Refactor project structure

src/app/app.py

@@ -4,10 +4,10 @@ import zmq
 from tornado.web import Application
 from tornado.ioloop import IOLoop
 
-from config import WEB_PORT
-from config.logs import logging
+from tfw.config import WEB_PORT
+from tfw.config.logs import logging
 log = logging.getLogger(__name__)
-from handlers import FSMManagingSocketHandler
+from tfw.networking.zmq_websocket_handler import FSMManagingSocketHandler
 from sql_injection_fsm import SQLInjectionFSM
 
 

src/app/event_handler_connector.py

@@ -1,44 +0,0 @@
-import zmq
-from zmq.eventloop import ioloop
-from zmq.eventloop.zmqstream import ZMQStream
-
-from config import PUBLISHER_PORT, RECEIVER_PORT
-from config.logs import logging
-log = logging.getLogger(__name__)
-from util import parse_anchor_from_message, ZMQConnectorBase
-
-
-ioloop.install()
-
-
-class EventHandlerDownlinkConnector(ZMQConnectorBase):
-    def __init__(self, zmq_context=None):
-        super(EventHandlerDownlinkConnector, self).__init__(zmq_context)
-        self._zmq_pull_socket = self._zmq_context.socket(zmq.PULL)
-        self._zmq_pull_stream = ZMQStream(self._zmq_pull_socket)
-        address = 'tcp://*:{}'.format(RECEIVER_PORT)
-        self._zmq_pull_socket.bind(address)
-        log.debug('Pull socket bound to {}'.format(address))
-
-
-class EventHandlerUplinkConnector(ZMQConnectorBase):
-    def __init__(self, zmq_context=None):
-        super(EventHandlerUplinkConnector, self).__init__(zmq_context)
-        self._zmq_pub_socket = self._zmq_context.socket(zmq.PUB)
-        address = 'tcp://*:{}'.format(PUBLISHER_PORT)
-        self._zmq_pub_socket.bind(address)
-        log.debug('Pub socket bound to {}'.format(address))
-
-
-class EventHandlerConnector(EventHandlerDownlinkConnector, EventHandlerUplinkConnector):
-    def __init__(self, zmq_context=None):
-        super(EventHandlerConnector, self).__init__(zmq_context)
-
-    def register_callback(self, callback):
-        self._zmq_pull_stream.on_recv(callback)
-
-    def send_message(self, message: str, anchor: str = None):
-        if not anchor:
-            anchor = parse_anchor_from_message(message)
-        encoded_message = [part.encode('utf-8') for part in (anchor, message)]
-        self._zmq_pub_socket.send_multipart(encoded_message)

src/app/fsm_base.py

@@ -1,23 +0,0 @@
-from transitions import Machine
-
-
-class FSMBase:
-    states, transitions = [], []
-
-    def __init__(self, initial: str = None):
-        self.message_handlers = []
-        self.machine = Machine(model=self,
-                               states=self.states,
-                               transitions=self.transitions,
-                               initial=initial or self.states[0],
-                               send_event=True,
-                               ignore_invalid_triggers=True,
-                               after_state_change='forward_message')
-
-    def forward_message(self, event_data):
-        message = event_data.kwargs.get('message')
-        for msghandler in self.message_handlers:
-            msghandler(message)
-
-    def subscribe_message_handler(self, msghandler):
-        self.message_handlers.append(msghandler)

src/app/handlers/__init__.py

@@ -1 +0,0 @@
-from .zmq_websocket_handler import FSMManagingSocketHandler

src/app/handlers/zmq_websocket_handler.py

@@ -1,61 +0,0 @@
-import json
-from tornado.websocket import WebSocketHandler
-from util import parse_anchor_from_message
-
-from event_handler_connector import EventHandlerConnector
-from config.logs import logging
-log = logging.getLogger(__name__)
-
-
-class ZMQWebSocketHandler(WebSocketHandler):
-    _event_handler_connector = EventHandlerConnector() #----.
-    # TODO: investigate thread safety!    <-----------------'
-    # ZMQ sockets shared between several WebSocketHandler instances
-    # http://pyzmq.readthedocs.io/en/latest/morethanbindings.html#thread-safety
-    def __init__(self, application, request, **kwargs):
-        super().__init__(application, request, **kwargs)
-
-    def open(self, *args, **kwargs):
-        log.debug('WebSocket connection initiated')
-        self._event_handler_connector.register_callback(self.zmq_callback)
-
-    def zmq_callback(self, msg_parts):
-        anchor, data = msg_parts
-        log.debug('Received on pull socket: {}'.format(data.decode()))
-        self.write_message(data.decode())
-
-    def on_message(self, message):
-        log.debug('Received on WebSocket: {}'.format(message))
-        self.send_message(*self.make_response(message))
-
-    def make_response(self, message):
-        raise NotImplementedError
-
-    def send_message(self, message: str, anchor: str = None):
-        self._event_handler_connector.send_message(message, anchor)
-
-    def on_close(self):
-        pass
-
-    # much secure, very cors, wow
-    def check_origin(self, origin):
-        return True
-
-
-class FSMManagingSocketHandler(ZMQWebSocketHandler):
-    def __init__(self, FSM, application, request, **kwargs):
-        super().__init__(application, request, **kwargs)
-        self.fsm = FSM()
-        self.fsm.subscribe_message_handler(self.handle_fsm_message)
-
-    def handle_fsm_message(self, message):
-        self._event_handler_connector.send_message(message)
-
-    def make_response(self, message):
-        self.fsm.trigger(parse_anchor_from_message(message), message=message)
-        anchor = 'FSMUpdate'
-        response = {'anchor': anchor,
-                    'data': {'current_state': self.fsm.state,
-                             'valid_transitions':
-                                 [{'trigger': trigger} for trigger in self.fsm.machine.get_triggers()]}}
-        return json.dumps(response), anchor

src/app/sql_injection_fsm.py

@@ -1,4 +1,4 @@
-from fsm_base import FSMBase
+from tfw.fsm_base import FSMBase
 
 
 class SQLInjectionFSM(FSMBase):