Initial import of the Python EKS library with example and test code.

Author: Oliver Simon

README.md

@@ -0,0 +1,6 @@
+# Python EKS Library
+
+## Usage
+
+See example code in demo.py. Hostname needs to be set, port is 2444 by default.
+You need to implement a callback class to receive notitications from the eks library.

demo.py

@@ -0,0 +1,42 @@
+from eks import EKSConnector, EKSCallback
+import datetime, time
+
+class EKSConnectorMock(EKSConnector):
+
+    def __init__ (self, callback, host, port=2444):
+        super(EKSConnectorMock, self).__init__(callback, host, port)
+        self.expiration_date = datetime.datetime.now() + datetime.timedelta(seconds=5)
+        self.is_active = False
+
+    def read_key_state(self, callback): # override networking
+        now = datetime.datetime.now()
+
+        if self.is_active:
+            callback.did_insert_key()
+            callback.did_read_key("12345678")
+        else:
+            callback.did_remove_key()
+
+        if now > self.expiration_date:
+            self.is_active = not self.is_active
+            self.expiration_date = datetime.datetime.now() + datetime.timedelta(seconds=5)
+
+class MyEKSCallback(EKSCallback):
+
+    def did_insert_key(self):
+        print "did insert key"
+
+    def did_remove_key(self):
+        print "did remove key"
+
+    def did_read_key(self, data):
+        print "did read key: %s" % data
+
+callback = MyEKSCallback()
+eks = EKSConnector("127.0.0.1", 2444)
+
+print "single call: "
+eks.read_key_state(callback)
+
+print "\npermanent call: "
+eks.start_listening(callback)

eks.py

@@ -0,0 +1,118 @@
+import socket, threading, time
+
+
+class EKSResponse:
+    def __init__(self, command, status, payload):
+        self.command = command
+        self.status = status
+        self.payload = payload
+
+    def __eq__(self, other):
+        if other == None:
+            return False
+        return self.command == other.command \
+                and self.status == other.status \
+                and self.payload == other.payload
+
+
+class EKSConnector(object):
+
+    def __init__ (self, host, port=2444, timeout=5):
+        self.host = host
+        self.port = port
+        self.poll_interval = 1
+        self.socket_timeout = timeout
+
+
+    def __poll(self):
+        last_response = None
+        while self.polling_enabled:
+            self.read_key_state(self.callback)
+            time.sleep(self.poll_interval)
+
+
+    def __send_to_socket(self, msg):
+        bytes_sent = self.eks_socket.send(msg)
+        return bytes_sent
+
+
+    def __read_from_socket(self):
+        chunks = []
+        bytes_recd = 0
+        msglen = 123
+        command = ''
+        status = -1
+        start = 0
+        length = 0
+
+        while bytes_recd < msglen:
+            chunk = self.eks_socket.recv(1)
+            if chunk == '':
+                raise RuntimeError("socket connection broken")
+            chunks.append(chunk.encode("hex"))
+
+            if bytes_recd == 0:
+                msglen = ord(chunk)
+            if bytes_recd == 1:
+                command += chunk
+            if bytes_recd == 2:
+                command += chunk
+            if bytes_recd == 6:
+                status = ord(chunk)
+
+            bytes_recd = bytes_recd + len(chunk)
+            
+        payload = ''.join(chunks[8:len(chunks)])
+        return EKSResponse(command, status, payload)
+
+
+    def read_key_state(self, callback):
+        self.eks_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.eks_socket.settimeout(self.socket_timeout)
+        self.eks_socket.connect((self.host, self.port))
+        
+        response = self.__read_from_socket()
+        self.__handle_response(response, callback)
+
+        if response.command == "Ek" and response.status == 1:
+            self.__send_to_socket("\x07TL\x01\x01\x73\x09")
+            response = self.__read_from_socket()    
+            self.__handle_response(response, callback)
+        
+        self.eks_socket.close()
+        return response
+
+
+    def start_listening(self, callback, interval=1):
+        self.polling_enabled = True
+        self.callback = callback
+        self.poll_interval = interval
+        self.__poll()
+
+
+    def stop_listening(self):
+        self.polling_enabled = False
+
+
+    def __handle_response(self, response, callback):
+        if response.command == "Ek":
+            if response.status == 1:
+                callback.did_insert_key()
+            elif response.status == 2:   
+                callback.did_remove_key()
+            elif response.status == 3:
+                raise RuntimeError
+        elif response.command == "RL":
+            callback.did_read_key(response.payload)
+
+
+class EKSCallback: #abstract
+
+    def did_insert_key(self):
+        raise NotImplementedError
+
+    def did_remove_key(self):
+        raise NotImplementedError
+
+    def did_read_key(self, data):
+        raise NotImplementedError

test.py

@@ -0,0 +1,91 @@
+import socket
+import time
+
+class Response:
+    def __init__(self, status, payload):
+        self.status = status
+        self.payload = payload
+
+class mysocket:
+    '''demonstration class only
+      - coded for clarity, not efficiency
+    '''
+
+    def __init__(self, sock=None):
+        if sock is None:
+            self.sock = socket.socket(
+                socket.AF_INET, socket.SOCK_STREAM)
+        else:
+            self.sock = sock
+
+    def connect(self, host, port):
+        self.sock.connect((host, port))
+
+    def close(self):
+        self.sock.close()
+
+    def mysend(self, msg):
+        bytes_sent = self.sock.send(msg)
+        return bytes_sent
+        # totalsent = 0
+        # while totalsent < len(msg):
+        #     sent = self.sock.send(msg[totalsent:])
+        #     if sent == 0:
+        #         raise RuntimeError("socket connection broken")
+        #     totalsent = totalsent + sent
+
+    def myreceive(self):
+        chunks = []
+        bytes_recd = 0
+        msglen = 123
+        command = ''
+        status = -1
+
+        while bytes_recd < msglen:
+            chunk = self.sock.recv(1)
+            if chunk == '':
+                raise RuntimeError("socket connection broken")
+            chunks.append(chunk)
+
+            if bytes_recd == 0:
+                msglen = ord(chunk)
+            if bytes_recd == 1:
+                command += chunk
+            if bytes_recd == 2:
+                command += chunk
+            if bytes_recd == 6:
+                status = ord(chunk)
+
+            bytes_recd = bytes_recd + len(chunk)
+            # print "(" + str(bytes_recd) + ") \t" + str(ord(chunk)) + "\t" + str(msglen)
+
+
+        # if bytes_recd > 3:
+        # print command + "/" + str(status)
+        # print ''.join(chunks)
+        if command == "Ek":
+            if status == 1:
+                return Response("EKS_KEY_IN", None)
+            if status == 2:
+                return Response("EKS_KEY_OUT", None)
+            if status == 3:
+                return Response("EKS_KEY_OTHER", None)
+        else:
+            return Response(command, ''.join(chunks))
+
+
+mysock = mysocket()
+mysock.connect("127.0.0.1", 2444)
+status = ''
+while True:
+    mysock.mysend("\x07Ek\x01\x00\x00\x00")
+    new_status = mysock.myreceive()
+    if new_status != status:
+        print 'new status'
+        status = new_status
+        print new_status
+        print status
+
+    if status == "EKS_KEY_IN":
+        mysock.mysend("\x07TL\x01\x00\x00\x74")
+        print mysock.myreceive()