baseimage-tutorial-framework/lib/tfw/networking/server/tfw_server.py

# Copyright (C) 2018 Avatao.com Innovative Learning Kft.
# All Rights Reserved. See LICENSE file for details.

from collections import defaultdict

from tornado.web import Application

from tfw.networking import MessageSender
from tfw.networking.event_handlers import ServerUplinkConnector
from tfw.networking.server import EventHandlerConnector
from tfw.config.logs import logging
from .zmq_websocket_handler import ZMQWebSocketProxy

LOG = logging.getLogger(__name__)


class TFWServer:
    def __init__(self, fsm_type):
        self._fsm = fsm_type()
        self._fsm_updater = FSMUpdater(self._fsm)
        self._fsm_manager = FSMManager(self._fsm)
        self._fsm.subscribe_callback(self._fsm_updater.update)
        self._event_handler_connector = EventHandlerConnector()

        self.application = Application(
            [(r'/ws', ZMQWebSocketProxy, {'make_response': self.make_response,
                                          'proxy_filter': self.proxy_filter,
                                          'event_handler_connector': self._event_handler_connector})]
        )
        #self.controller_responder = ControllerResponder(self.fsm) TODO: add this once controller stuff is resolved

    @property
    def fsm(self):
        return self._fsm

    @property
    def fsm_manager(self):
        return self._fsm_manager

    def make_response(self, message):
        trigger = message.get('trigger', '')
        try:
            self._fsm_manager.trigger(trigger, message)
        except AttributeError:
            LOG.debug('FSM failed to execute nonexistent trigger: "%s"', trigger)
        message['FSMUpdate'] = self._fsm_updater.get_fsm_state_and_transitions()
        return message

    def proxy_filter(self, message):
        # pylint: disable=unused-argument,no-self-use
        return True

    def listen(self, port):
        self.application.listen(port)


class FSMManager:
    def __init__(self, fsm):
        self._fsm = fsm
        self.trigger_predicates = defaultdict(list)
        self.messenge_sender = MessageSender()

    @property
    def fsm(self):
        return self._fsm

    def trigger(self, trigger, message):
        predicate_results = []
        for predicate in self.trigger_predicates[trigger]:
            success, message = predicate(message)
            predicate_results.append(success)
            self.messenge_sender.send('FSM', message)

        if all(predicate_results):
            try:
                self.fsm.trigger(trigger, message=message)
            except AttributeError:
                LOG.debug('FSM failed to execute nonexistent trigger: "%s"', trigger)

    def subscribe_predicate(self, trigger, *predicates):
        self.trigger_predicates[trigger].extend(predicates)

    def unsubscribe_predicate(self, trigger, *predicates):
        self.trigger_predicates[trigger] = [predicate for predicate in self.trigger_predicates[trigger]
                                            not in predicates]


class FSMUpdater:
    def __init__(self, fsm):
        self.fsm = fsm
        self.uplink = ServerUplinkConnector()

    def update(self, kwargs_dict):
        # pylint: disable=unused-argument
        self.uplink.send(*self.generate_fsm_update())

    def generate_fsm_update(self):
        key = 'FSMUpdate'
        response = {'data': self.get_fsm_state_and_transitions()}
        return key, response

    def get_fsm_state_and_transitions(self):
        state = self.fsm.state
        valid_transitions = [{'trigger': trigger} for trigger in self.fsm.machine.get_triggers(self.fsm.state)]
        return {'current_state': state, 'valid_transitions': valid_transitions}