ominfra 0.0.0.dev76__py3-none-any.whl → 0.0.0.dev78__py3-none-any.whl

ominfra/supervisor/dispatchers.py

@@ -0,0 +1,307 @@
+# ruff: noqa: UP007
+import abc
+import errno
+import logging
+import os
+import typing as ta
+
+from .compat import as_bytes
+from .compat import compact_traceback
+from .compat import find_prefix_at_end
+from .compat import readfd
+from .compat import strip_escapes
+from .configs import ProcessConfig
+from .events import ProcessLogStderrEvent
+from .events import ProcessLogStdoutEvent
+from .events import notify_event
+from .types import AbstractSubprocess
+
+
+log = logging.getLogger(__name__)
+
+
+class Dispatcher(abc.ABC):
+
+    def __init__(self, process: AbstractSubprocess, channel: str, fd: int) -> None:
+        super().__init__()
+
+        self._process = process  # process which "owns" this dispatcher
+        self._channel = channel  # 'stderr' or 'stdout'
+        self._fd = fd
+        self._closed = False  # True if close() has been called
+
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__} at {id(self)} for {self._process} ({self._channel})>'
+
+    @property
+    def process(self) -> AbstractSubprocess:
+        return self._process
+
+    @property
+    def channel(self) -> str:
+        return self._channel
+
+    @property
+    def fd(self) -> int:
+        return self._fd
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    @abc.abstractmethod
+    def readable(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def writable(self) -> bool:
+        raise NotImplementedError
+
+    def handle_read_event(self) -> None:
+        raise TypeError
+
+    def handle_write_event(self) -> None:
+        raise TypeError
+
+    def handle_error(self) -> None:
+        nil, t, v, tbinfo = compact_traceback()
+
+        log.critical('uncaptured python exception, closing channel %s (%s:%s %s)', repr(self), t, v, tbinfo)
+        self.close()
+
+    def close(self) -> None:
+        if not self._closed:
+            log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
+            self._closed = True
+
+    def flush(self) -> None:  # noqa
+        pass
+
+
+class OutputDispatcher(Dispatcher):
+    """
+    Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
+
+    - capture output sent within <!--XSUPERVISOR:BEGIN--> and <!--XSUPERVISOR:END--> tags and signal a
+      ProcessCommunicationEvent by calling notify_event(event).
+    - route the output to the appropriate log handlers as specified in the config.
+    """
+
+    def __init__(self, process: AbstractSubprocess, event_type, fd):
+        """
+        Initialize the dispatcher.
+
+        `event_type` should be one of ProcessLogStdoutEvent or ProcessLogStderrEvent
+        """
+        super().__init__(process, event_type.channel, fd)
+        self.event_type = event_type
+
+        self.lc: ProcessConfig.Log = getattr(process.config, self._channel)
+
+        self._init_normal_log()
+        self._init_capture_log()
+
+        self._child_log = self._normal_log
+
+        self._capture_mode = False  # are we capturing process event data
+        self._output_buffer = b''  # data waiting to be logged
+
+        # all code below is purely for minor speedups
+        begin_token = self.event_type.BEGIN_TOKEN
+        end_token = self.event_type.END_TOKEN
+        self.begin_token_data = (begin_token, len(begin_token))
+        self.end_token_data = (end_token, len(end_token))
+        self.main_log_level = logging.DEBUG
+        config = self._process.config
+        self.log_to_main_log = process.context.config.loglevel <= self.main_log_level
+        self.stdout_events_enabled = config.stdout.events_enabled
+        self.stderr_events_enabled = config.stderr.events_enabled
+
+    _child_log: ta.Optional[logging.Logger]  # the current logger (normal_log or capture_log)
+    _normal_log: ta.Optional[logging.Logger]  # the "normal" (non-capture) logger
+    _capture_log: ta.Optional[logging.Logger]  # the logger used while we're in capture_mode
+
+    def _init_normal_log(self) -> None:
+        """
+        Configure the "normal" (non-capture) log for this channel of this process. Sets self.normal_log if logging is
+        enabled.
+        """
+        config = self._process.config  # noqa
+        channel = self._channel  # noqa
+
+        logfile = self.lc.file
+        maxbytes = self.lc.maxbytes  # noqa
+        backups = self.lc.backups  # noqa
+        to_syslog = self.lc.syslog
+
+        if logfile or to_syslog:
+            self._normal_log = logging.getLogger(__name__)
+
+        # if logfile:
+        #     loggers.handle_file(
+        #         self.normal_log,
+        #         filename=logfile,
+        #         fmt='%(message)s',
+        #         rotating=bool(maxbytes),  # optimization
+        #         maxbytes=maxbytes,
+        #         backups=backups,
+        #     )
+        #
+        # if to_syslog:
+        #     loggers.handle_syslog(
+        #         self.normal_log,
+        #         fmt=config.name + ' %(message)s',
+        #     )
+
+    def _init_capture_log(self) -> None:
+        """
+        Configure the capture log for this process.  This log is used to temporarily capture output when special output
+        is detected. Sets self.capture_log if capturing is enabled.
+        """
+        capture_maxbytes = self.lc.capture_maxbytes
+        if capture_maxbytes:
+            self._capture_log = logging.getLogger(__name__)
+            # loggers.handle_boundIO(
+            #     self._capture_log,
+            #     fmt='%(message)s',
+            #     maxbytes=capture_maxbytes,
+            # )
+
+    def remove_logs(self):
+        for log in (self._normal_log, self._capture_log):
+            if log is not None:
+                for handler in log.handlers:
+                    handler.remove()  # type: ignore
+                    handler.reopen()  # type: ignore
+
+    def reopen_logs(self):
+        for log in (self._normal_log, self._capture_log):
+            if log is not None:
+                for handler in log.handlers:
+                    handler.reopen()  # type: ignore
+
+    def _log(self, data):
+        if data:
+            if self._process.context.config.strip_ansi:
+                data = strip_escapes(data)
+            if self._child_log:
+                self._child_log.info(data)
+            if self.log_to_main_log:
+                if not isinstance(data, bytes):
+                    text = data
+                else:
+                    try:
+                        text = data.decode('utf-8')
+                    except UnicodeDecodeError:
+                        text = f'Undecodable: {data!r}'
+                log.log(self.main_log_level, '%r %s output:\n%s', self._process.config.name, self._channel, text)  # noqa
+            if self._channel == 'stdout':
+                if self.stdout_events_enabled:
+                    notify_event(ProcessLogStdoutEvent(self._process, self._process.pid, data))
+            elif self.stderr_events_enabled:
+                notify_event(ProcessLogStderrEvent(self._process, self._process.pid, data))
+
+    def record_output(self):
+        if self._capture_log is None:
+            # shortcut trying to find capture data
+            data = self._output_buffer
+            self._output_buffer = b''
+            self._log(data)
+            return
+
+        if self._capture_mode:
+            token, tokenlen = self.end_token_data
+        else:
+            token, tokenlen = self.begin_token_data
+
+        if len(self._output_buffer) <= tokenlen:
+            return  # not enough data
+
+        data = self._output_buffer
+        self._output_buffer = b''
+
+        try:
+            before, after = data.split(token, 1)
+        except ValueError:
+            after = None
+            index = find_prefix_at_end(data, token)
+            if index:
+                self._output_buffer = self._output_buffer + data[-index:]
+                data = data[:-index]
+            self._log(data)
+        else:
+            self._log(before)
+            self.toggle_capture_mode()
+            self._output_buffer = after  # type: ignore
+
+        if after:
+            self.record_output()
+
+    def toggle_capture_mode(self):
+        self._capture_mode = not self._capture_mode
+
+        if self._capture_log is not None:
+            if self._capture_mode:
+                self._child_log = self._capture_log
+            else:
+                for handler in self._capture_log.handlers:
+                    handler.flush()
+                data = self._capture_log.getvalue()  # type: ignore
+                channel = self._channel
+                procname = self._process.config.name
+                event = self.event_type(self._process, self._process.pid, data)
+                notify_event(event)
+
+                log.debug('%r %s emitted a comm event', procname, channel)
+                for handler in self._capture_log.handlers:
+                    handler.remove()  # type: ignore
+                    handler.reopen()  # type: ignore
+                self._child_log = self._normal_log
+
+    def writable(self) -> bool:
+        return False
+
+    def readable(self) -> bool:
+        if self._closed:
+            return False
+        return True
+
+    def handle_read_event(self) -> None:
+        data = readfd(self._fd)
+        self._output_buffer += data
+        self.record_output()
+        if not data:
+            # if we get no data back from the pipe, it means that the child process has ended.  See
+            # mail.python.org/pipermail/python-dev/2004-August/046850.html
+            self.close()
+
+
+class InputDispatcher(Dispatcher):
+
+    def __init__(self, process: AbstractSubprocess, channel: str, fd: int) -> None:
+        super().__init__(process, channel, fd)
+        self._input_buffer = b''
+
+    def writable(self) -> bool:
+        if self._input_buffer and not self._closed:
+            return True
+        return False
+
+    def readable(self) -> bool:
+        return False
+
+    def flush(self) -> None:
+        # other code depends on this raising EPIPE if the pipe is closed
+        sent = os.write(self._fd, as_bytes(self._input_buffer))
+        self._input_buffer = self._input_buffer[sent:]
+
+    def handle_write_event(self) -> None:
+        if self._input_buffer:
+            try:
+                self.flush()
+            except OSError as why:
+                if why.args[0] == errno.EPIPE:
+                    self._input_buffer = b''
+                    self.close()
+                else:
+                    raise

ominfra/supervisor/events.py

@@ -0,0 +1,304 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from .compat import as_string
+from .states import get_process_state_description
+
+
+class EventCallbacks:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._callbacks: ta.List[ta.Tuple[type, ta.Callable]] = []
+
+    def subscribe(self, type, callback):  # noqa
+        self._callbacks.append((type, callback))
+
+    def unsubscribe(self, type, callback):  # noqa
+        self._callbacks.remove((type, callback))
+
+    def notify(self, event):
+        for type, callback in self._callbacks:  # noqa
+            if isinstance(event, type):
+                callback(event)
+
+    def clear(self):
+        self._callbacks[:] = []
+
+
+EVENT_CALLBACKS = EventCallbacks()
+
+notify_event = EVENT_CALLBACKS.notify
+clear_events = EVENT_CALLBACKS.clear
+
+
+class Event:
+    """Abstract event type """
+
+
+class ProcessLogEvent(Event):
+    """Abstract"""
+    channel: ta.Optional[str] = None
+
+    def __init__(self, process, pid, data):
+        super().__init__()
+        self.process = process
+        self.pid = pid
+        self.data = data
+
+    def payload(self):
+        groupname = ''
+        if self.process.group is not None:
+            groupname = self.process.group.config.name
+        try:
+            data = as_string(self.data)
+        except UnicodeDecodeError:
+            data = f'Undecodable: {self.data!r}'
+        fmt = as_string('processname:%s groupname:%s pid:%s channel:%s\n%s')
+        result = fmt % (
+            as_string(self.process.config.name),
+            as_string(groupname),
+            self.pid,
+            as_string(self.channel),  # type: ignore
+            data,
+        )
+        return result
+
+
+class ProcessLogStdoutEvent(ProcessLogEvent):
+    channel = 'stdout'
+
+
+class ProcessLogStderrEvent(ProcessLogEvent):
+    channel = 'stderr'
+
+
+class ProcessCommunicationEvent(Event):
+    """ Abstract """
+    # event mode tokens
+    BEGIN_TOKEN = b'<!--XSUPERVISOR:BEGIN-->'
+    END_TOKEN = b'<!--XSUPERVISOR:END-->'
+
+    def __init__(self, process, pid, data):
+        super().__init__()
+        self.process = process
+        self.pid = pid
+        self.data = data
+
+    def payload(self):
+        groupname = ''
+        if self.process.group is not None:
+            groupname = self.process.group.config.name
+        try:
+            data = as_string(self.data)
+        except UnicodeDecodeError:
+            data = f'Undecodable: {self.data!r}'
+        return f'processname:{self.process.config.name} groupname:{groupname} pid:{self.pid}\n{data}'
+
+
+class ProcessCommunicationStdoutEvent(ProcessCommunicationEvent):
+    channel = 'stdout'
+
+
+class ProcessCommunicationStderrEvent(ProcessCommunicationEvent):
+    channel = 'stderr'
+
+
+class RemoteCommunicationEvent(Event):
+    def __init__(self, type, data):  # noqa
+        super().__init__()
+        self.type = type
+        self.data = data
+
+    def payload(self):
+        return f'type:{self.type}\n{self.data}'
+
+
+class SupervisorStateChangeEvent(Event):
+    """ Abstract class """
+
+    def payload(self):
+        return ''
+
+
+class SupervisorRunningEvent(SupervisorStateChangeEvent):
+    pass
+
+
+class SupervisorStoppingEvent(SupervisorStateChangeEvent):
+    pass
+
+
+class EventRejectedEvent:  # purposely does not subclass Event
+    def __init__(self, process, event):
+        super().__init__()
+        self.process = process
+        self.event = event
+
+
+class ProcessStateEvent(Event):
+    """ Abstract class, never raised directly """
+    frm = None
+    to = None
+
+    def __init__(self, process, from_state, expected=True):
+        super().__init__()
+        self.process = process
+        self.from_state = from_state
+        self.expected = expected
+        # we eagerly render these so if the process pid, etc changes beneath
+        # us, we stash the values at the time the event was sent
+        self.extra_values = self.get_extra_values()
+
+    def payload(self):
+        groupname = ''
+        if self.process.group is not None:
+            groupname = self.process.group.config.name
+        l = [
+            ('processname', self.process.config.name),
+            ('groupname', groupname),
+            ('from_state', get_process_state_description(self.from_state)),
+        ]
+        l.extend(self.extra_values)
+        s = ' '.join([f'{name}:{val}' for name, val in l])
+        return s
+
+    def get_extra_values(self):
+        return []
+
+
+class ProcessStateFatalEvent(ProcessStateEvent):
+    pass
+
+
+class ProcessStateUnknownEvent(ProcessStateEvent):
+    pass
+
+
+class ProcessStateStartingOrBackoffEvent(ProcessStateEvent):
+    def get_extra_values(self):
+        return [('tries', int(self.process.backoff))]
+
+
+class ProcessStateBackoffEvent(ProcessStateStartingOrBackoffEvent):
+    pass
+
+
+class ProcessStateStartingEvent(ProcessStateStartingOrBackoffEvent):
+    pass
+
+
+class ProcessStateExitedEvent(ProcessStateEvent):
+    def get_extra_values(self):
+        return [('expected', int(self.expected)), ('pid', self.process.pid)]
+
+
+class ProcessStateRunningEvent(ProcessStateEvent):
+    def get_extra_values(self):
+        return [('pid', self.process.pid)]
+
+
+class ProcessStateStoppingEvent(ProcessStateEvent):
+    def get_extra_values(self):
+        return [('pid', self.process.pid)]
+
+
+class ProcessStateStoppedEvent(ProcessStateEvent):
+    def get_extra_values(self):
+        return [('pid', self.process.pid)]
+
+
+class ProcessGroupEvent(Event):
+    def __init__(self, group):
+        super().__init__()
+        self.group = group
+
+    def payload(self):
+        return f'groupname:{self.group}\n'
+
+
+class ProcessGroupAddedEvent(ProcessGroupEvent):
+    pass
+
+
+class ProcessGroupRemovedEvent(ProcessGroupEvent):
+    pass
+
+
+class TickEvent(Event):
+    """ Abstract """
+
+    def __init__(self, when, supervisord):
+        super().__init__()
+        self.when = when
+        self.supervisord = supervisord
+
+    def payload(self):
+        return f'when:{self.when}'
+
+
+class Tick5Event(TickEvent):
+    period = 5
+
+
+class Tick60Event(TickEvent):
+    period = 60
+
+
+class Tick3600Event(TickEvent):
+    period = 3600
+
+
+TICK_EVENTS = [  # imported elsewhere
+    Tick5Event,
+    Tick60Event,
+    Tick3600Event,
+]
+
+
+class EventTypes:
+    EVENT = Event  # abstract
+
+    PROCESS_STATE = ProcessStateEvent  # abstract
+    PROCESS_STATE_STOPPED = ProcessStateStoppedEvent
+    PROCESS_STATE_EXITED = ProcessStateExitedEvent
+    PROCESS_STATE_STARTING = ProcessStateStartingEvent
+    PROCESS_STATE_STOPPING = ProcessStateStoppingEvent
+    PROCESS_STATE_BACKOFF = ProcessStateBackoffEvent
+    PROCESS_STATE_FATAL = ProcessStateFatalEvent
+    PROCESS_STATE_RUNNING = ProcessStateRunningEvent
+    PROCESS_STATE_UNKNOWN = ProcessStateUnknownEvent
+
+    PROCESS_COMMUNICATION = ProcessCommunicationEvent  # abstract
+    PROCESS_COMMUNICATION_STDOUT = ProcessCommunicationStdoutEvent
+    PROCESS_COMMUNICATION_STDERR = ProcessCommunicationStderrEvent
+
+    PROCESS_LOG = ProcessLogEvent
+    PROCESS_LOG_STDOUT = ProcessLogStdoutEvent
+    PROCESS_LOG_STDERR = ProcessLogStderrEvent
+
+    REMOTE_COMMUNICATION = RemoteCommunicationEvent
+
+    SUPERVISOR_STATE_CHANGE = SupervisorStateChangeEvent  # abstract
+    SUPERVISOR_STATE_CHANGE_RUNNING = SupervisorRunningEvent
+    SUPERVISOR_STATE_CHANGE_STOPPING = SupervisorStoppingEvent
+
+    TICK = TickEvent  # abstract
+    TICK_5 = Tick5Event
+    TICK_60 = Tick60Event
+    TICK_3600 = Tick3600Event
+
+    PROCESS_GROUP = ProcessGroupEvent  # abstract
+    PROCESS_GROUP_ADDED = ProcessGroupAddedEvent
+    PROCESS_GROUP_REMOVED = ProcessGroupRemovedEvent
+
+
+def get_event_name_by_type(requested):
+    for name, typ in EventTypes.__dict__.items():
+        if typ is requested:
+            return name
+    return None
+
+
+def register(name, event):
+    setattr(EventTypes, name, event)

ominfra/supervisor/exceptions.py

@@ -0,0 +1,22 @@
+class ProcessError(Exception):
+    """ Specialized exceptions used when attempting to start a process """
+
+
+class BadCommandError(ProcessError):
+    """ Indicates the command could not be parsed properly. """
+
+
+class NotExecutableError(ProcessError):
+    """ Indicates that the filespec cannot be executed because its path
+    resolves to a file which is not executable, or which is a directory. """
+
+
+class NotFoundError(ProcessError):
+    """ Indicates that the filespec cannot be executed because it could not be found """
+
+
+class NoPermissionError(ProcessError):
+    """
+    Indicates that the file cannot be executed because the supervisor process does not possess the appropriate UNIX
+    filesystem permission to execute the file.
+    """