Cleanup demo server code and add inheritable classes

Author: tkw1536

README.rst

@@ -43,6 +43,11 @@ arithmetic operations. To run the demo server, simply run::
   
    python examples/demo_server.py
 
+It furthermore contains a slightly more advanced server used within 
+the OpenDreamKit project. To use it, run:
+
+    python mitm/converting_server.py
+
 
 Client
 ------

examples/demo_server.py

@@ -1,15 +1,13 @@
-import socket
-from six.moves import socketserver
 import logging
+
+from six.moves import socketserver
+
 from openmath import openmath as om, convert as conv
 
-from scscp.client import TimeoutError, CONNECTED
-from scscp.server import SCSCPServer
-from scscp.scscp import SCSCPQuit, SCSCPProtocolError
 from scscp import scscp
+from scscp.socketserver import SCSCPServerRequestHandler, SCSCPSocketServer, CD_SCSCP2
 
 # Supported functions
-CD_SCSCP2 = ['get_service_description', 'get_allowed_heads', 'is_allowed_head']
 CD_ARITH1 = {
     'abs'         : abs,
     'unary_minus' : lambda x  : -x,
@@ -20,61 +18,13 @@
     'power'       : lambda x,y: x**y,
 }
 
-class SCSCPRequestHandler(socketserver.BaseRequestHandler):
-    def setup(self):
-        self.server.log.info("New connection from %s:%d" % self.client_address)
-        self.log = self.server.log.getChild(self.client_address[0])
-        self.scscp = SCSCPServer(self.request, self.server.name,
-                                     self.server.version, logger=self.log)
+class DemoServerRequestHandler(SCSCPServerRequestHandler):
+    def handle_call(self, call, head):
+        if call.data.elem.cd == 'arith1' and head in CD_ARITH1:
+            args = [conv.to_python(a) for a in call.data.arguments]
+            return conv.to_openmath(CD_ARITH1[head](*args))
 
-    def handle(self):
-        self.scscp.accept()
-        while True:
-            try:
-                call = self.scscp.wait()
-            except TimeoutError:
-                continue
-            except SCSCPQuit as e:
-                self.log.info(e)
-                break
-            except ConnectionResetError:
-                self.log.info('Client closed unexpectedly.')
-                break
-            except SCSCPProtocolError as e:
-                self.log.info('SCSCP protocol error: %s.' % str(e))
-                self.log.info('Closing connection.')
-                self.scscp.quit()
-                break
-            self.handle_call(call)
-
-    def handle_call(self, call):
-        if (call.type != 'procedure_call'):
-            raise SCSCPProtocolError('Bad message from client: %s.' % call.type, om=call.om())
-        try:
-            head = call.data.elem.name
-            self.log.debug('Requested head: %s...' % head)
-            
-            if call.data.elem.cd == 'scscp2' and head in CD_SCSCP2:
-                res = getattr(self, head)(call.data)
-            elif call.data.elem.cd == 'arith1' and head in CD_ARITH1:
-                args = [conv.to_python(a) for a in call.data.arguments]
-                res = conv.to_openmath(CD_ARITH1[head](*args))
-            else:
-                self.log.debug('...head unknown.')
-                return self.scscp.terminated(call.id, om.OMError(
-                    om.OMSymbol('unhandled_symbol', cd='error'), [call.data.elem]))
-
-            strlog = str(res)
-            self.log.debug('...sending result: %s' % (strlog[:20] + ('...' if len(strlog) > 20 else '')))
-            return self.scscp.completed(call.id, res)
-        except (AttributeError, IndexError, TypeError):
-            self.log.debug('...client protocol error.')
-            return self.scscp.terminated(call.id, om.OMError(
-                om.OMSymbol('unexpected_symbol', cd='error'), [call.data]))
-        except Exception as e:
-            self.log.exception('Unhandled exception:')
-            return self.scscp.terminated(call.id, 'system_specific',
-                                             'Unhandled exception %s.' % str(e))
+        return super(SCSCPRequestHandler, self).handle_call(call, head)
 
     def get_allowed_heads(self, data):
         return scscp.symbol_set([om.OMSymbol(head, cd='scscp2') for head in CD_SCSCP2]
@@ -92,17 +42,14 @@ def get_service_description(self, data):
                                              self.server.version.decode(),
                                              self.server.description)
 
-class Server(socketserver.ThreadingMixIn, socketserver.TCPServer, object):
-    allow_reuse_address = True
-    
+class Server(SCSCPSocketServer):
     def __init__(self, host='localhost', port=26133,
                      logger=None, name=b'DemoServer', version=b'none',
                      description='Demo SCSCP server'):
-        super(Server, self).__init__((host, port), SCSCPRequestHandler)
-        self.log = logger or logging.getLogger(__name__)
-        self.name = name
-        self.version = version
-        self.description = description
+
+        super(Server, self).__init__(host=host, port=port, logger=logger or logging.getLogger(__name__), 
+            name=name, version=version, description=description, 
+            RequestHandlerClass=DemoServerRequestHandler)
 
 if __name__ == '__main__':
     logging.basicConfig(level=logging.DEBUG)

mitm/converting_server.py

@@ -9,73 +9,25 @@
 from scscp.scscp import SCSCPQuit, SCSCPProtocolError
 from scscp import scscp
 
+from scscp.socketserver import SCSCPServerRequestHandler, SCSCPSocketServer
+
 MitMBase = "http://opendreamkit.org/MitM"
 MitMCD = "computation"
 MitMEval = "sage_eval"
 
-class MitMRequestHandler(socketserver.BaseRequestHandler):
-    def __init__(self,converter, *kargs, **kwargs):
+class MitMRequestHandler(SCSCPServerRequestHandler):
+    def __init__(self, converter, *args, **kwargs):
+        super(MitMRequestHandler, self).__init__(*args, **kwargs)
         self.converter = converter
-        super(socketserver.BaseRequestHandler, self).__init__(*kargs, **kwargs)
 
-    def setup(self):
-        self.server.log.info("New connection from %s:%d" % self.client_address)
-        self.log = self.server.log.getChild(self.client_address[0])
-        self.scscp = SCSCPServer(self.request, self.server.name,
-                                     self.server.version, logger=self.log)
-        
-    # TODO: should be inherited from a to-be-written SCSCPRequestHandler class        
-    def handle(self):
-        self.scscp.accept()
-        while True:
-            try:
-                call = self.scscp.wait()
-            except TimeoutError:
-                continue
-            except SCSCPQuit as e:
-                self.log.info(e)
-                break
-            except ConnectionResetError:
-                self.log.info('Client closed unexpectedly.')
-                break
-            except SCSCPProtocolError as e:
-                self.log.info('SCSCP protocol error: %s.' % str(e))
-                self.log.info('Closing connection.')
-                self.scscp.quit()
-                break
-            self.handle_call(call)
-
-    # TODO: most of this should be inherited as well
-    def handle_call(self, call):
-        if (call.type != 'procedure_call'):
-            raise SCSCPProtocolError('Bad message from client: %s.' % call.type, om=call.om())
-        try:
-            head = call.data.elem.name
-            self.log.debug('Requested head: %s...' % head)
-            
-            if call.data.elem.cd == 'scscp2' and head in CD_SCSCP2:
-                res = getattr(self, head)(call.data)
-            elif self.data.elem.base == MitMBase and self.data.elem.cd == MitMCD and self.data.elem.name == MitMEval:
+    def handle_call(self, call, head):
+        if self.data.elem.base == MitMBase and self.data.elem.cd == MitMCD and self.data.elem.name == MitMEval:
                 # we take the one argument of MitMEval, import it (which triggers computation), and export it (i.e., the result of the computation)
                 obj = call.data.arguments[0]
                 objPy = self.converter.to_python(obj)
-                res = self.converter.to_openmath(objPy)
-            else:
-                self.log.debug('...head unknown.')
-                return self.scscp.terminated(call.id, om.OMError(
-                    om.OMSymbol('unhandled_symbol', cd='error'), [call.data.elem]))
-
-            strlog = str(res)
-            self.log.debug('...sending result: %s' % (strlog[:20] + ('...' if len(strlog) > 20 else '')))
-            return self.scscp.completed(call.id, res)
-        except (AttributeError, IndexError, TypeError):
-            self.log.debug('...client protocol error.')
-            return self.scscp.terminated(call.id, om.OMError(
-                om.OMSymbol('unexpected_symbol', cd='error'), [call.data]))
-        except Exception as e:
-            self.log.exception('Unhandled exception:')
-            return self.scscp.terminated(call.id, 'system_specific',
-                                             'Unhandled exception %s.' % str(e))
+                return self.converter.to_openmath(objPy)
+        
+        return super(MitMRequestHandler, self).handle_call(call, head)
 
     def get_allowed_heads(self, data):
         return scscp.symbol_set([om.OMSymbol(base = MitMEval, cd = MitMCD, name = MitMEval)], cdnames=[MitMCD, 'scscp1'])
@@ -90,27 +42,27 @@ def get_service_description(self, data):
                                              self.server.version.decode(),
                                              self.server.description)
 
-class MitMSCSCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer, object):
-    allow_reuse_address = True
-    
+class MitMSCSCPServer(SCSCPSocketServer):
     def __init__(self, openmath_converter, host='localhost', port=26133,
                      logger=None, name=b'MitM Server', version=b'none',
                      description='MitM SCSCP server'):
-        # ThreadingMixIn expects a class as constructor argument, so we have to build one that knows about the converter
+        
+        # build a converter class
         class ReqHandler(MitMRequestHandler):
             def __init__(self, *args, **kwargs):
                 super(MitMRequestHandler,self).__init__(openmath_converter, *args, **kwargs)
-        super(MitMSCSCPServer, self).__init__((host, port), ReqHandler)
-        self.log = logger or logging.getLogger(__name__)
-        self.name = name
-        self.version = version
-        self.description = description
+        
+        super(MitMSCSCPServer, self).__init__(host=host, port=port, 
+            logger=logger or logging.getLogger(__name__), name=name, version=version, 
+            description=description, RequestHandlerClass=ReqHandler)
 
 if __name__ == '__main__':
     logging.basicConfig(level=logging.DEBUG)
     logger = logging.getLogger('demo_server')
+
     conv = MitMConverter()
     srv = MitMSCSCPServer(conv, logger=logger)
+    
     try:
         srv.serve_forever()
     except KeyboardInterrupt:

scscp/client.py

@@ -1,7 +1,6 @@
 import logging
 from pexpect import fdpexpect, TIMEOUT, EOF
 from openmath import encoder, decoder
-from . import scscp
 from .scscp import SCSCPConnectionError, SCSCPQuit, SCSCPCancel, SCSCPProcedureMessage
 from .processing_instruction import ProcessingInstruction as PI, OrderedProcessingInstruction as OPI
 

scscp/scscp.py

@@ -17,6 +17,8 @@ class SCSCPProtocolError(SCSCPError):
     def __init__(self, msg, om=None):
         super(SCSCPProtocolError, self).__init__(msg)
         self.om = om
+class SCSCPUnknownHead(SCSCPError):
+    pass
 
 ### SCSCP1 content dictionary
 

scscp/server.py

@@ -2,13 +2,15 @@
 from .client import SCSCPPeer, SCSCPPeerOM, _assert_status, INITIALIZED, CONNECTED
 from .scscp import SCSCPConnectionError, SCSCPProcedureMessage
 
+
 class SCSCPServerBase(SCSCPPeer):
     """
     A simple SCSCP synchronous server, with no understanding of OpenMath.
     """
-    
+
     def __init__(self, socket, name, version, id=None, timeout=30, logger=None):
-        super(SCSCPServerBase, self).__init__(socket, timeout, logger, me="Server", you="Client")
+        super(SCSCPServerBase, self).__init__(
+            socket, timeout, logger, me="Server", you="Client")
         self._name = name
         self._version = version
         self._id = id or str(uuid.uuid1()).encode()
@@ -17,22 +19,23 @@ def __init__(self, socket, name, version, id=None, timeout=30, logger=None):
     def accept(self, timeout=None):
         """ SCSCP handshake """
         self._send_ordered_PI('', [('service_name', self._name), ('service_version', self._version),
-                                       ('service_id', self._id), ('scscp_versions', b'1.3')])
-        
+                                   ('service_id', self._id), ('scscp_versions', b'1.3')])
+
         pi = self._get_next_PI([''], timeout=timeout)
         if pi.attrs.get('version') != b'1.3':
             self.quit()
             raise SCSCPConnectionError("Client sent unexpected response.", pi)
-        
+
         self._send_PI(version=b'1.3')
 
         self.status = CONNECTED
 
-        
+
 class SCSCPServer(SCSCPServerBase, SCSCPPeerOM):
     """
     A simple SCSCP synchronous server.
     """
+
     def wait(self, timeout=-1):
         return SCSCPProcedureMessage.from_om(self.receive(timeout))