ominfra 0.0.0.dev118__py3-none-any.whl → 0.0.0.dev120__py3-none-any.whl

ominfra/supervisor/__main__.py

@@ -1,4 +1,4 @@
 if __name__ == '__main__':
-    from .supervisor import main
+    from .main import main
 
     main()

ominfra/supervisor/context.py

@@ -2,7 +2,6 @@
 import errno
 import fcntl
 import grp
-import logging
 import os
 import pwd
 import re
@@ -12,6 +11,8 @@ import stat
 import typing as ta
 import warnings
 
+from omlish.lite.logs import log
+
 from .compat import SignalReceiver
 from .compat import close_fd
 from .compat import mktempfile
@@ -23,6 +24,7 @@ from .datatypes import name_to_uid
 from .exceptions import NoPermissionError
 from .exceptions import NotExecutableError
 from .exceptions import NotFoundError
+from .poller import BasePoller
 from .poller import Poller
 from .states import SupervisorState
 from .states import SupervisorStates
@@ -30,41 +32,47 @@ from .types import AbstractServerContext
 from .types import AbstractSubprocess
 
 
-log = logging.getLogger(__name__)
-
-
 class ServerContext(AbstractServerContext):
-    first = False
-    test = False
-
-    ##
-
-    def __init__(self, config: ServerConfig) -> None:
+    def __init__(
+            self,
+            config: ServerConfig,
+            *,
+            epoch: int = 0,
+    ) -> None:
         super().__init__()
 
         self._config = config
+        self._epoch = epoch
 
         self._pid_history: ta.Dict[int, AbstractSubprocess] = {}
         self._state: SupervisorState = SupervisorStates.RUNNING
 
-        self.signal_receiver = SignalReceiver()
+        self._signal_receiver = SignalReceiver()
 
-        self.poller = Poller()
+        self._poller: BasePoller = Poller()
 
-        if self.config.user is not None:
-            uid = name_to_uid(self.config.user)
-            self.uid = uid
-            self.gid = gid_for_uid(uid)
+        if config.user is not None:
+            uid = name_to_uid(config.user)
+            self._uid: ta.Optional[int] = uid
+            self._gid: ta.Optional[int] = gid_for_uid(uid)
         else:
-            self.uid = None
-            self.gid = None
+            self._uid = None
+            self._gid = None
 
-        self.unlink_pidfile = False
+        self._unlink_pidfile = False
 
     @property
     def config(self) -> ServerConfig:
         return self._config
 
+    @property
+    def epoch(self) -> int:
+        return self._epoch
+
+    @property
+    def first(self) -> bool:
+        return not self._epoch
+
     @property
     def state(self) -> SupervisorState:
         return self._state
@@ -72,17 +80,26 @@ class ServerContext(AbstractServerContext):
     def set_state(self, state: SupervisorState) -> None:
         self._state = state
 
+    @property
+    def poller(self) -> BasePoller:
+        return self._poller
+
     @property
     def pid_history(self) -> ta.Dict[int, AbstractSubprocess]:
         return self._pid_history
 
-    uid: ta.Optional[int]
-    gid: ta.Optional[int]
+    @property
+    def uid(self) -> ta.Optional[int]:
+        return self._uid
+
+    @property
+    def gid(self) -> ta.Optional[int]:
+        return self._gid
 
     ##
 
     def set_signals(self) -> None:
-        self.signal_receiver.install(
+        self._signal_receiver.install(
             signal.SIGTERM,
             signal.SIGINT,
             signal.SIGQUIT,
@@ -193,7 +210,7 @@ class ServerContext(AbstractServerContext):
                     ))
 
     def cleanup(self) -> None:
-        if self.unlink_pidfile:
+        if self._unlink_pidfile:
             try_unlink(self.config.pidfile)
         self.poller.close()
 
@@ -246,6 +263,7 @@ class ServerContext(AbstractServerContext):
             # Parent
             log.debug('supervisord forked; parent exiting')
             real_exit(0)
+
         # Child
         log.info('daemonizing the supervisord process')
         if self.config.directory:
@@ -255,11 +273,15 @@ class ServerContext(AbstractServerContext):
                 log.critical("can't chdir into %r: %s", self.config.directory, err)
             else:
                 log.info('set current directory: %r', self.config.directory)
+
         os.dup2(0, os.open('/dev/null', os.O_RDONLY))
         os.dup2(1, os.open('/dev/null', os.O_WRONLY))
         os.dup2(2, os.open('/dev/null', os.O_WRONLY))
+
         os.setsid()
+
         os.umask(self.config.umask)
+
         # XXX Stevens, in his Advanced Unix book, section 13.3 (page 417) recommends calling umask(0) and closing unused
         # file descriptors.  In his Network Programming book, he additionally recommends ignoring SIGHUP and forking
         # again after the setsid() call, for obscure SVR4 reasons.
@@ -274,7 +296,7 @@ class ServerContext(AbstractServerContext):
         return logfile
 
     def get_signal(self) -> ta.Optional[int]:
-        return self.signal_receiver.get_signal()
+        return self._signal_receiver.get_signal()
 
     def write_pidfile(self) -> None:
         pid = os.getpid()
@@ -284,7 +306,7 @@ class ServerContext(AbstractServerContext):
         except OSError:
             log.critical('could not write pidfile %s', self.config.pidfile)
         else:
-            self.unlink_pidfile = True
+            self._unlink_pidfile = True
             log.info('supervisord started with pid %s', pid)
 
 
@@ -337,11 +359,14 @@ def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
             os.setgroups(groups)
         except OSError:
             return 'Could not set groups of effective user'
+
     try:
         os.setgid(gid)
     except OSError:
         return 'Could not set group id of effective user'
+
     os.setuid(uid)
+
     return None
 
 

ominfra/supervisor/dispatchers.py

@@ -5,21 +5,20 @@ import logging
 import os
 import typing as ta
 
+from omlish.lite.logs import log
+
 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 EVENT_CALLBACKS
 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:
@@ -176,16 +175,16 @@ class OutputDispatcher(Dispatcher):
             # )
 
     def remove_logs(self):
-        for log in (self._normal_log, self._capture_log):
-            if log is not None:
-                for handler in log.handlers:
+        for l in (self._normal_log, self._capture_log):
+            if l is not None:
+                for handler in l.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:
+        for l in (self._normal_log, self._capture_log):
+            if l is not None:
+                for handler in l.handlers:
                     handler.reopen()  # type: ignore
 
     def _log(self, data):
@@ -208,10 +207,10 @@ class OutputDispatcher(Dispatcher):
 
             if self._channel == 'stdout':
                 if self._stdout_events_enabled:
-                    notify_event(ProcessLogStdoutEvent(self._process, self._process.pid, data))
+                    EVENT_CALLBACKS.notify(ProcessLogStdoutEvent(self._process, self._process.pid, data))
 
             elif self._stderr_events_enabled:
-                notify_event(ProcessLogStderrEvent(self._process, self._process.pid, data))
+                EVENT_CALLBACKS.notify(ProcessLogStderrEvent(self._process, self._process.pid, data))
 
     def record_output(self):
         if self._capture_log is None:
@@ -262,7 +261,7 @@ class OutputDispatcher(Dispatcher):
                 channel = self._channel
                 procname = self._process.config.name
                 event = self.event_type(self._process, self._process.pid, data)
-                notify_event(event)
+                EVENT_CALLBACKS.notify(event)
 
                 log.debug('%r %s emitted a comm event', procname, channel)
                 for handler in self._capture_log.handlers:

ominfra/supervisor/events.py

@@ -29,12 +29,9 @@ class EventCallbacks:
 
 EVENT_CALLBACKS = EventCallbacks()
 
-notify_event = EVENT_CALLBACKS.notify
-clear_events = EVENT_CALLBACKS.clear
-
 
 class Event(abc.ABC):  # noqa
-    """Abstract event type """
+    """Abstract event type."""
 
 
 class ProcessLogEvent(Event, abc.ABC):
@@ -114,7 +111,7 @@ class RemoteCommunicationEvent(Event):
 
 
 class SupervisorStateChangeEvent(Event):
-    """ Abstract class """
+    """Abstract class."""
 
     def payload(self):
         return ''
@@ -136,7 +133,7 @@ class EventRejectedEvent:  # purposely does not subclass Event
 
 
 class ProcessStateEvent(Event):
-    """ Abstract class, never raised directly """
+    """Abstract class, never raised directly."""
     frm = None
     to = None
 
@@ -225,7 +222,7 @@ class ProcessGroupRemovedEvent(ProcessGroupEvent):
 
 
 class TickEvent(Event):
-    """ Abstract """
+    """Abstract."""
 
     def __init__(self, when, supervisord):
         super().__init__()

ominfra/supervisor/main.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# ruff: noqa: UP006 UP007
+# @omlish-amalg ../scripts/supervisor.py
+import itertools
+import json
+import typing as ta
+
+from omlish.lite.journald import journald_log_handler_factory
+from omlish.lite.logs import configure_standard_logging
+from omlish.lite.marshal import unmarshal_obj
+
+from .compat import ExitNow
+from .configs import ServerConfig
+from .context import ServerContext
+from .states import SupervisorStates
+from .supervisor import Supervisor
+
+
+def main(
+        argv: ta.Optional[ta.Sequence[str]] = None,
+        *,
+        no_logging: bool = False,
+) -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('config_file', metavar='config-file')
+    parser.add_argument('--no-journald', action='store_true')
+    args = parser.parse_args(argv)
+
+    #
+
+    if not (cf := args.config_file):
+        raise RuntimeError('No config file specified')
+
+    if not no_logging:
+        configure_standard_logging(
+            'INFO',
+            handler_factory=journald_log_handler_factory if not args.no_journald else None,
+        )
+
+    #
+
+    # if we hup, restart by making a new Supervisor()
+    for epoch in itertools.count():
+        with open(cf) as f:
+            config_src = f.read()
+
+        config_dct = json.loads(config_src)
+        config: ServerConfig = unmarshal_obj(config_dct, ServerConfig)
+
+        context = ServerContext(
+            config,
+            epoch=epoch,
+        )
+
+        supervisor = Supervisor(context)
+        try:
+            supervisor.main()
+        except ExitNow:
+            pass
+
+        if context.state < SupervisorStates.RESTARTING:
+            break
+
+
+if __name__ == '__main__':
+    main()

ominfra/supervisor/poller.py

@@ -1,13 +1,11 @@
 # ruff: noqa: UP006 UP007
 import abc
 import errno
-import logging
 import select
 import sys
 import typing as ta
 
-
-log = logging.getLogger(__name__)
+from omlish.lite.logs import log
 
 
 class BasePoller(abc.ABC):

ominfra/supervisor/process.py

@@ -1,14 +1,15 @@
 # ruff: noqa: UP006 UP007
 import errno
 import functools
-import logging
-import os
+import os.path
 import shlex
 import signal
 import time
 import traceback
 import typing as ta
 
+from omlish.lite.logs import log
+
 from .compat import as_bytes
 from .compat import as_string
 from .compat import close_fd
@@ -29,6 +30,7 @@ from .datatypes import RestartUnconditionally
 from .dispatchers import Dispatcher
 from .dispatchers import InputDispatcher
 from .dispatchers import OutputDispatcher
+from .events import EVENT_CALLBACKS
 from .events import EventRejectedEvent
 from .events import ProcessCommunicationEvent
 from .events import ProcessCommunicationStderrEvent
@@ -42,7 +44,6 @@ from .events import ProcessStateStartingEvent
 from .events import ProcessStateStoppedEvent
 from .events import ProcessStateStoppingEvent
 from .events import ProcessStateUnknownEvent
-from .events import notify_event
 from .exceptions import BadCommandError
 from .exceptions import ProcessError
 from .states import STOPPED_STATES
@@ -54,9 +55,6 @@ from .types import AbstractServerContext
 from .types import AbstractSubprocess
 
 
-log = logging.getLogger(__name__)
-
-
 @functools.total_ordering
 class Subprocess(AbstractSubprocess):
     """A class to manage a subprocess."""
@@ -209,7 +207,7 @@ class Subprocess(AbstractSubprocess):
         event_class = self.event_map.get(new_state)
         if event_class is not None:
             event = event_class(self, old_state, expected)
-            notify_event(event)
+            EVENT_CALLBACKS.notify(event)
 
         return True
 
@@ -326,6 +324,7 @@ class Subprocess(AbstractSubprocess):
             os.dup2(self._pipes['child_stdout'], 2)
         else:
             os.dup2(self._pipes['child_stderr'], 2)
+        # FIXME: leave debugger fds
         for i in range(3, self.context.config.minfds):
             close_fd(i)
 
@@ -361,7 +360,7 @@ class Subprocess(AbstractSubprocess):
             cwd = self.config.directory
             try:
                 if cwd is not None:
-                    os.chdir(cwd)
+                    os.chdir(os.path.expanduser(cwd))
             except OSError as why:
                 code = errno.errorcode.get(why.args[0], why.args[0])
                 msg = f"couldn't chdir to {cwd}: {code}\n"
@@ -417,7 +416,7 @@ class Subprocess(AbstractSubprocess):
         return self.kill(self.config.stopsignal)
 
     def stop_report(self) -> None:
-        """ Log a 'waiting for x to stop' message with throttling. """
+        """Log a 'waiting for x to stop' message with throttling."""
         if self.state == ProcessStates.STOPPING:
             now = time.time()
 
@@ -547,7 +546,7 @@ class Subprocess(AbstractSubprocess):
         return None
 
     def finish(self, sts: int) -> None:
-        """ The process was reaped and we need to report and manage its state """
+        """The process was reaped and we need to report and manage its state."""
 
         self.drain()
 
@@ -628,7 +627,7 @@ class Subprocess(AbstractSubprocess):
         # system that this event was rejected so it can be processed again.
         if self.event is not None:
             # Note: this should only be true if we were in the BUSY state when finish() was called.
-            notify_event(EventRejectedEvent(self, self.event))  # type: ignore
+            EVENT_CALLBACKS.notify(EventRejectedEvent(self, self.event))  # type: ignore
             self.event = None
 
     def set_uid(self) -> ta.Optional[str]: