Simplify package structure

tfw/components/process_management/__init__.py

@@ -0,0 +1,2 @@
+from .process_handler import ProcessHandler
+from .process_log_handler import ProcessLogHandler

tfw/components/process_management/log_inotify_observer.py

@@ -0,0 +1,45 @@
+import logging
+
+from tfw.internals.networking import Scope
+from tfw.internals.inotify import InotifyObserver
+
+from .supervisor import ProcessLogManager
+
+
+class LogInotifyObserver(InotifyObserver, ProcessLogManager):
+    def __init__(self, server_connector, supervisor_uri, process_name, log_tail=0):
+        self._prevent_log_recursion()
+        self._server_connector = server_connector
+        self._process_name = process_name
+        self.log_tail = log_tail
+        self._procinfo = None
+        ProcessLogManager.__init__(self, supervisor_uri)
+        InotifyObserver.__init__(self, self._get_logfiles())
+
+    @staticmethod
+    def _prevent_log_recursion():
+        # This is done to prevent inotify event logs triggering themselves (infinite log recursion)
+        logging.getLogger('watchdog.observers.inotify_buffer').propagate = False
+
+    def _get_logfiles(self):
+        self._procinfo = self.supervisor.getProcessInfo(self._process_name)
+        return self._procinfo['stdout_logfile'], self._procinfo['stderr_logfile']
+
+    @property
+    def process_name(self):
+        return self._process_name
+
+    @process_name.setter
+    def process_name(self, process_name):
+        self._process_name = process_name
+        self.paths = self._get_logfiles()
+
+    def on_modified(self, event):
+        self._server_connector.send_message({
+            'key': 'processlog',
+            'data': {
+                'command': 'new_log',
+                'stdout': self.read_stdout(self.process_name, tail=self.log_tail),
+                'stderr': self.read_stderr(self.process_name, tail=self.log_tail)
+            }
+        }, Scope.BROADCAST)

tfw/components/process_management/process_handler.py

@@ -0,0 +1,54 @@
+import logging
+from xmlrpc.client import Fault as SupervisorFault
+
+from tfw.internals.networking import Scope
+
+from .supervisor import ProcessManager, ProcessLogManager
+
+
+LOG = logging.getLogger(__name__)
+
+
+class ProcessHandler(ProcessManager, ProcessLogManager):
+    keys = ['processmanager']
+    """
+    Event handler that can manage processes managed by supervisor.
+
+    This EventHandler accepts messages that have a data['command'] key specifying
+    a command to be executed.
+    Every message must contain a data['process_name'] field with the name of the
+    process to manage. This is the name specified in supervisor config files like so:
+    [program:someprogram]
+
+    Commands available: start, stop, restart, readlog
+    (the names are as self-documenting as it gets)
+    """
+    def __init__(self, *, supervisor_uri, log_tail=0):
+        ProcessManager.__init__(self, supervisor_uri)
+        ProcessLogManager.__init__(self, supervisor_uri)
+        self.log_tail = log_tail
+        self.commands = {
+            'start': self.start_process,
+            'stop': self.stop_process,
+            'restart': self.restart_process
+        }
+
+    def handle_event(self, message, server_connector):
+        try:
+            data = message['data']
+            try:
+                self.commands[data['command']](data['process_name'])
+            except SupervisorFault as fault:
+                message['data']['error'] = fault.faultString
+            finally:
+                message['data']['stdout'] = self.read_stdout(
+                    data['process_name'],
+                    self.log_tail
+                )
+                message['data']['stderr'] = self.read_stderr(
+                    data['process_name'],
+                    self.log_tail
+                )
+            server_connector.send_message(message, scope=Scope.WEBSOCKET)
+        except KeyError:
+            LOG.error('IGNORING MESSAGE: Invalid message received: %s', message)

tfw/components/process_management/process_log_handler.py

@@ -0,0 +1,69 @@
+import logging
+
+from .log_inotify_observer import LogInotifyObserver
+
+
+LOG = logging.getLogger(__name__)
+
+
+class ProcessLogHandler:
+    keys = ['logmonitor']
+    """
+    Monitors the output of a supervisor process (stdout, stderr) and
+    sends the results to the frontend.
+
+    Accepts messages that have a data['command'] key specifying
+    a command to be executed.
+
+    The API of each command is documented in their respective handler.
+    """
+    def __init__(self, *, process_name, supervisor_uri, log_tail=0):
+        self.server_connector = None
+        self.process_name = process_name
+        self._supervisor_uri = supervisor_uri
+        self._initial_log_tail = log_tail
+        self._monitor = None
+
+        self.command_handlers = {
+            'process_name': self.handle_process_name,
+            'log_tail':     self.handle_log_tail
+        }
+
+    def start(self):
+        self._monitor = LogInotifyObserver(
+            server_connector=self.server_connector,
+            supervisor_uri=self._supervisor_uri,
+            process_name=self.process_name,
+            log_tail=self._initial_log_tail
+        )
+        self._monitor.start()
+
+    def handle_event(self, message, _):
+        try:
+            data = message['data']
+            self.command_handlers[data['command']](data)
+        except KeyError:
+            LOG.error('IGNORING MESSAGE: Invalid message received: %s', message)
+
+    def handle_process_name(self, data):
+        """
+        Changes the monitored process.
+
+        :param data: TFW message data containing 'value'
+                     (name of the process to monitor)
+        """
+        self._monitor.process_name = data['value']
+
+    def handle_log_tail(self, data):
+        """
+        Sets tail length of the log the monitor will send
+        to the frontend (the monitor will send back the last
+        'value' characters of the log).
+
+        :param data: TFW message data containing 'value'
+                     (new tail length)
+        """
+        self._monitor.log_tail = data['value']
+
+    def cleanup(self):
+        self._monitor.stop()

tfw/components/process_management/supervisor.py

@@ -0,0 +1,36 @@
+from os import remove
+from contextlib import suppress
+import xmlrpc.client
+from xmlrpc.client import Fault as SupervisorFault
+
+
+class SupervisorBase:
+    def __init__(self, supervisor_uri):
+        self.supervisor = xmlrpc.client.ServerProxy(supervisor_uri).supervisor
+
+
+class ProcessManager(SupervisorBase):
+    def stop_process(self, process_name):
+        with suppress(SupervisorFault):
+            self.supervisor.stopProcess(process_name)
+
+    def start_process(self, process_name):
+        self.supervisor.startProcess(process_name)
+
+    def restart_process(self, process_name):
+        self.stop_process(process_name)
+        self.start_process(process_name)
+
+
+class ProcessLogManager(SupervisorBase):
+    def read_stdout(self, process_name, tail=0):
+        return self.supervisor.readProcessStdoutLog(process_name, -tail, 0)
+
+    def read_stderr(self, process_name, tail=0):
+        return self.supervisor.readProcessStderrLog(process_name, -tail, 0)
+
+    def clear_logs(self, process_name):
+        for logfile in ('stdout_logfile', 'stderr_logfile'):
+            with suppress(FileNotFoundError):
+                remove(self.supervisor.getProcessInfo(process_name)[logfile])
+        self.supervisor.clearProcessLogs(process_name)