ominfra 0.0.0.dev121__py3-none-any.whl → 0.0.0.dev123__py3-none-any.whl

ominfra/supervisor/signals.py

@@ -0,0 +1,52 @@
+# ruff: noqa: UP006 UP007
+import signal
+import typing as ta
+
+
+##
+
+
+_SIG_NAMES: ta.Optional[ta.Mapping[int, str]] = None
+
+
+def sig_name(sig: int) -> str:
+    global _SIG_NAMES
+    if _SIG_NAMES is None:
+        _SIG_NAMES = _init_sig_names()
+    return _SIG_NAMES.get(sig) or 'signal %d' % sig
+
+
+def _init_sig_names() -> ta.Dict[int, str]:
+    d = {}
+    for k, v in signal.__dict__.items():  # noqa
+        k_startswith = getattr(k, 'startswith', None)
+        if k_startswith is None:
+            continue
+        if k_startswith('SIG') and not k_startswith('SIG_'):
+            d[v] = k
+    return d
+
+
+##
+
+
+class SignalReceiver:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._signals_recvd: ta.List[int] = []
+
+    def receive(self, sig: int, frame: ta.Any) -> None:
+        if sig not in self._signals_recvd:
+            self._signals_recvd.append(sig)
+
+    def install(self, *sigs: int) -> None:
+        for sig in sigs:
+            signal.signal(sig, self.receive)
+
+    def get_signal(self) -> ta.Optional[int]:
+        if self._signals_recvd:
+            sig = self._signals_recvd.pop(0)
+        else:
+            sig = None
+        return sig

ominfra/supervisor/states.py

@@ -1,29 +1,10 @@
-# ruff: noqa: UP006
-import typing as ta
-
-from omlish.lite.check import check_not_none
-
-
-ProcessState = int  # ta.TypeAlias
-SupervisorState = int  # ta.TypeAlias
-
-
-##
-
-
-def _names_by_code(states: ta.Any) -> ta.Dict[int, str]:
-    d = {}
-    for name in states.__dict__:
-        if not name.startswith('__'):
-            code = getattr(states, name)
-            d[code] = name
-    return d
+import enum
 
 
 ##
 
 
-class ProcessStates:
+class ProcessState(enum.IntEnum):
     STOPPED = 0
     STARTING = 10
     RUNNING = 20
@@ -33,46 +14,44 @@ class ProcessStates:
     FATAL = 200
     UNKNOWN = 1000
 
+    @property
+    def stopped(self) -> bool:
+        return self in STOPPED_STATES
+
+    @property
+    def running(self) -> bool:
+        return self in RUNNING_STATES
+
+    @property
+    def signalable(self) -> bool:
+        return self in SIGNALABLE_STATES
+
 
 STOPPED_STATES = (
-    ProcessStates.STOPPED,
-    ProcessStates.EXITED,
-    ProcessStates.FATAL,
-    ProcessStates.UNKNOWN,
+    ProcessState.STOPPED,
+    ProcessState.EXITED,
+    ProcessState.FATAL,
+    ProcessState.UNKNOWN,
 )
 
 RUNNING_STATES = (
-    ProcessStates.RUNNING,
-    ProcessStates.BACKOFF,
-    ProcessStates.STARTING,
+    ProcessState.RUNNING,
+    ProcessState.BACKOFF,
+    ProcessState.STARTING,
 )
 
-SIGNALLABLE_STATES = (
-    ProcessStates.RUNNING,
-    ProcessStates.STARTING,
-    ProcessStates.STOPPING,
+SIGNALABLE_STATES = (
+    ProcessState.RUNNING,
+    ProcessState.STARTING,
+    ProcessState.STOPPING,
 )
 
 
-_process_states_by_code = _names_by_code(ProcessStates)
-
-
-def get_process_state_description(code: ProcessState) -> str:
-    return check_not_none(_process_states_by_code.get(code))
-
-
 ##
 
 
-class SupervisorStates:
+class SupervisorState(enum.IntEnum):
     FATAL = 2
     RUNNING = 1
     RESTARTING = 0
     SHUTDOWN = -1
-
-
-_supervisor_states_by_code = _names_by_code(SupervisorStates)
-
-
-def get_supervisor_state_description(code: SupervisorState) -> str:
-    return check_not_none(_supervisor_states_by_code.get(code))

ominfra/supervisor/supervisor.py

@@ -8,28 +8,83 @@ from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check_not_none
 from omlish.lite.logs import log
 
-from .compat import ExitNow
-from .compat import as_string
-from .compat import decode_wait_status
-from .compat import signame
 from .configs import ProcessGroupConfig
 from .context import ServerContext
 from .dispatchers import Dispatcher
-from .events import EVENT_CALLBACKS
 from .events import TICK_EVENTS
-from .events import ProcessGroupAddedEvent
-from .events import ProcessGroupRemovedEvent
+from .events import EventCallbacks
 from .events import SupervisorRunningEvent
 from .events import SupervisorStoppingEvent
-from .process import ProcessGroup
+from .groups import ProcessGroup
+from .groups import ProcessGroups
+from .poller import Poller
 from .process import Subprocess
+from .signals import SignalReceiver
+from .signals import sig_name
 from .states import SupervisorState
-from .states import SupervisorStates
-from .states import get_process_state_description
+from .utils import ExitNow
+from .utils import as_string
+from .utils import decode_wait_status
+from .utils import timeslice
 
 
-def timeslice(period: int, when: float) -> int:
-    return int(when - (when % period))
+##
+
+
+class SignalHandler:
+    def __init__(
+            self,
+            *,
+            context: ServerContext,
+            signal_receiver: SignalReceiver,
+            process_groups: ProcessGroups,
+    ) -> None:
+        super().__init__()
+
+        self._context = context
+        self._signal_receiver = signal_receiver
+        self._process_groups = process_groups
+
+    def set_signals(self) -> None:
+        self._signal_receiver.install(
+            signal.SIGTERM,
+            signal.SIGINT,
+            signal.SIGQUIT,
+            signal.SIGHUP,
+            signal.SIGCHLD,
+            signal.SIGUSR2,
+        )
+
+    def handle_signals(self) -> None:
+        sig = self._signal_receiver.get_signal()
+        if not sig:
+            return
+
+        if sig in (signal.SIGTERM, signal.SIGINT, signal.SIGQUIT):
+            log.warning('received %s indicating exit request', sig_name(sig))
+            self._context.set_state(SupervisorState.SHUTDOWN)
+
+        elif sig == signal.SIGHUP:
+            if self._context.state == SupervisorState.SHUTDOWN:
+                log.warning('ignored %s indicating restart request (shutdown in progress)', sig_name(sig))  # noqa
+            else:
+                log.warning('received %s indicating restart request', sig_name(sig))  # noqa
+                self._context.set_state(SupervisorState.RESTARTING)
+
+        elif sig == signal.SIGCHLD:
+            log.debug('received %s indicating a child quit', sig_name(sig))
+
+        elif sig == signal.SIGUSR2:
+            log.info('received %s indicating log reopen request', sig_name(sig))
+
+            for group in self._process_groups:
+                group.reopen_logs()
+
+        else:
+            log.debug('received %s indicating nothing', sig_name(sig))
+
+
+##
 
 
 @dc.dataclass(frozen=True)
@@ -41,25 +96,26 @@ class ProcessGroupFactory:
 
 
 class Supervisor:
-
     def __init__(
             self,
-            context: ServerContext,
             *,
-            process_group_factory: ta.Optional[ProcessGroupFactory] = None,
+            context: ServerContext,
+            poller: Poller,
+            process_groups: ProcessGroups,
+            signal_handler: SignalHandler,
+            event_callbacks: EventCallbacks,
+            process_group_factory: ProcessGroupFactory,
     ) -> None:
         super().__init__()
 
         self._context = context
-
-        if process_group_factory is None:
-            def make_process_group(config: ProcessGroupConfig) -> ProcessGroup:
-                return ProcessGroup(config, self._context)
-            process_group_factory = ProcessGroupFactory(make_process_group)
+        self._poller = poller
+        self._process_groups = process_groups
+        self._signal_handler = signal_handler
+        self._event_callbacks = event_callbacks
         self._process_group_factory = process_group_factory
 
         self._ticks: ta.Dict[int, float] = {}
-        self._process_groups: ta.Dict[str, ProcessGroup] = {}  # map of process group name to process group object
         self._stop_groups: ta.Optional[ta.List[ProcessGroup]] = None  # list used for priority ordered shutdown
         self._stopping = False  # set after we detect that we are handling a stop request
         self._last_shutdown_report = 0.  # throttle for delayed process error reports at stop
@@ -82,7 +138,7 @@ class Supervisor:
 
     def diff_to_active(self) -> DiffToActive:
         new = self._context.config.groups or []
-        cur = [group.config for group in self._process_groups.values()]
+        cur = [group.config for group in self._process_groups]
 
         curdict = dict(zip([cfg.name for cfg in cur], cur))
         newdict = dict(zip([cfg.name for cfg in new], new))
@@ -95,38 +151,35 @@ class Supervisor:
         return Supervisor.DiffToActive(added, changed, removed)
 
     def add_process_group(self, config: ProcessGroupConfig) -> bool:
-        name = config.name
-        if name in self._process_groups:
+        if self._process_groups.get(config.name) is not None:
             return False
 
-        group = self._process_groups[name] = self._process_group_factory(config)
+        group = self._process_group_factory(config)
         group.after_setuid()
 
-        EVENT_CALLBACKS.notify(ProcessGroupAddedEvent(name))
+        self._process_groups.add(group)
+
         return True
 
     def remove_process_group(self, name: str) -> bool:
         if self._process_groups[name].get_unstopped_processes():
             return False
 
-        self._process_groups[name].before_remove()
-
-        del self._process_groups[name]
+        self._process_groups.remove(name)
 
-        EVENT_CALLBACKS.notify(ProcessGroupRemovedEvent(name))
         return True
 
     def get_process_map(self) -> ta.Dict[int, Dispatcher]:
         process_map = {}
-        for group in self._process_groups.values():
+        for group in self._process_groups:
             process_map.update(group.get_dispatchers())
         return process_map
 
     def shutdown_report(self) -> ta.List[Subprocess]:
         unstopped: ta.List[Subprocess] = []
 
-        for group in self._process_groups.values():
-            unstopped.extend(group.get_unstopped_processes())
+        for group in self._process_groups:
+            unstopped.extend(group.get_unstopped_processes())  # type: ignore
 
         if unstopped:
             # throttle 'waiting for x to die' reports
@@ -137,8 +190,7 @@ class Supervisor:
                 log.info('waiting for %s to die', namestr)
                 self._last_shutdown_report = now
                 for proc in unstopped:
-                    state = get_process_state_description(proc.get_state())
-                    log.debug('%s state: %s', proc.config.name, state)
+                    log.debug('%s state: %s', proc.config.name, proc.get_state().name)
 
         return unstopped
 
@@ -169,16 +221,16 @@ class Supervisor:
             *,
             callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
     ) -> None:
-        self._process_groups = {}  # clear
+        self._process_groups.clear()
         self._stop_groups = None  # clear
 
-        EVENT_CALLBACKS.clear()
+        self._event_callbacks.clear()
 
         try:
             for config in self._context.config.groups or []:
                 self.add_process_group(config)
 
-            self._context.set_signals()
+            self._signal_handler.set_signals()
 
             if not self._context.config.nodaemon and self._context.first:
                 self._context.daemonize()
@@ -186,7 +238,7 @@ class Supervisor:
             # writing pid file needs to come *after* daemonizing or pid will be wrong
             self._context.write_pidfile()
 
-            EVENT_CALLBACKS.notify(SupervisorRunningEvent())
+            self._event_callbacks.notify(SupervisorRunningEvent())
 
             while True:
                 if callback is not None and not callback(self):
@@ -202,10 +254,10 @@ class Supervisor:
     def _run_once(self) -> None:
         self._poll()
         self._reap()
-        self._handle_signal()
+        self._signal_handler.handle_signals()
         self._tick()
 
-        if self._context.state < SupervisorStates.RUNNING:
+        if self._context.state < SupervisorState.RUNNING:
             self._ordered_stop_groups_phase_2()
 
     def _ordered_stop_groups_phase_1(self) -> None:
@@ -228,15 +280,15 @@ class Supervisor:
         combined_map = {}
         combined_map.update(self.get_process_map())
 
-        pgroups = list(self._process_groups.values())
+        pgroups = list(self._process_groups)
         pgroups.sort()
 
-        if self._context.state < SupervisorStates.RUNNING:
+        if self._context.state < SupervisorState.RUNNING:
             if not self._stopping:
                 # first time, set the stopping flag, do a notification and set stop_groups
                 self._stopping = True
                 self._stop_groups = pgroups[:]
-                EVENT_CALLBACKS.notify(SupervisorStoppingEvent())
+                self._event_callbacks.notify(SupervisorStoppingEvent())
 
             self._ordered_stop_groups_phase_1()
 
@@ -246,12 +298,12 @@ class Supervisor:
 
         for fd, dispatcher in combined_map.items():
             if dispatcher.readable():
-                self._context.poller.register_readable(fd)
+                self._poller.register_readable(fd)
             if dispatcher.writable():
-                self._context.poller.register_writable(fd)
+                self._poller.register_writable(fd)
 
         timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
-        r, w = self._context.poller.poll(timeout)
+        r, w = self._poller.poll(timeout)
 
         for fd in r:
             if fd in combined_map:
@@ -260,7 +312,7 @@ class Supervisor:
                     log.debug('read event caused by %r', dispatcher)
                     dispatcher.handle_read_event()
                     if not dispatcher.readable():
-                        self._context.poller.unregister_readable(fd)
+                        self._poller.unregister_readable(fd)
                 except ExitNow:
                     raise
                 except Exception:  # noqa
@@ -270,7 +322,7 @@ class Supervisor:
                 # time, which may cause 100% cpu usage
                 log.debug('unexpected read event from fd %r', fd)
                 try:
-                    self._context.poller.unregister_readable(fd)
+                    self._poller.unregister_readable(fd)
                 except Exception:  # noqa
                     pass
 
@@ -281,7 +333,7 @@ class Supervisor:
                     log.debug('write event caused by %r', dispatcher)
                     dispatcher.handle_write_event()
                     if not dispatcher.writable():
-                        self._context.poller.unregister_writable(fd)
+                        self._poller.unregister_writable(fd)
                 except ExitNow:
                     raise
                 except Exception:  # noqa
@@ -289,7 +341,7 @@ class Supervisor:
             else:
                 log.debug('unexpected write event from fd %r', fd)
                 try:
-                    self._context.poller.unregister_writable(fd)
+                    self._poller.unregister_writable(fd)
                 except Exception:  # noqa
                     pass
 
@@ -316,34 +368,6 @@ class Supervisor:
             # keep reaping until no more kids to reap, but don't recurse infinitely
             self._reap(once=False, depth=depth + 1)
 
-    def _handle_signal(self) -> None:
-        sig = self._context.get_signal()
-        if not sig:
-            return
-
-        if sig in (signal.SIGTERM, signal.SIGINT, signal.SIGQUIT):
-            log.warning('received %s indicating exit request', signame(sig))
-            self._context.set_state(SupervisorStates.SHUTDOWN)
-
-        elif sig == signal.SIGHUP:
-            if self._context.state == SupervisorStates.SHUTDOWN:
-                log.warning('ignored %s indicating restart request (shutdown in progress)', signame(sig))  # noqa
-            else:
-                log.warning('received %s indicating restart request', signame(sig))  # noqa
-                self._context.set_state(SupervisorStates.RESTARTING)
-
-        elif sig == signal.SIGCHLD:
-            log.debug('received %s indicating a child quit', signame(sig))
-
-        elif sig == signal.SIGUSR2:
-            log.info('received %s indicating log reopen request', signame(sig))
-            # self._context.reopen_logs()
-            for group in self._process_groups.values():
-                group.reopen_logs()
-
-        else:
-            log.debug('received %s indicating nothing', signame(sig))
-
     def _tick(self, now: ta.Optional[float] = None) -> None:
         """Send one or more 'tick' events when the timeslice related to the period for the event type rolls over"""
 
@@ -352,7 +376,7 @@ class Supervisor:
             now = time.time()
 
         for event in TICK_EVENTS:
-            period = event.period  # type: ignore
+            period = event.period
 
             last_tick = self._ticks.get(period)
             if last_tick is None:
@@ -362,4 +386,4 @@ class Supervisor:
             this_tick = timeslice(period, now)
             if this_tick != last_tick:
                 self._ticks[period] = this_tick
-                EVENT_CALLBACKS.notify(event(this_tick, self))
+                self._event_callbacks.notify(event(this_tick, self))

ominfra/supervisor/types.py

@@ -1,9 +1,12 @@
-# ruff: noqa: UP006
+# ruff: noqa: UP006 UP007
 import abc
+import functools
 import typing as ta
 
 from .configs import ProcessConfig
+from .configs import ProcessGroupConfig
 from .configs import ServerConfig
+from .states import ProcessState
 from .states import SupervisorState
 
 
@@ -27,12 +30,8 @@ class AbstractServerContext(abc.ABC):
     def pid_history(self) -> ta.Dict[int, 'AbstractSubprocess']:
         raise NotImplementedError
 
-    @property
-    @abc.abstractmethod
-    def inherited_fds(self) -> ta.FrozenSet[int]:
-        raise NotImplementedError
-
 
+@functools.total_ordering
 class AbstractSubprocess(abc.ABC):
     @property
     @abc.abstractmethod
@@ -44,6 +43,12 @@ class AbstractSubprocess(abc.ABC):
     def config(self) -> ProcessConfig:
         raise NotImplementedError
 
+    def __lt__(self, other):
+        return self.config.priority < other.config.priority
+
+    def __eq__(self, other):
+        return self.config.priority == other.config.priority
+
     @property
     @abc.abstractmethod
     def context(self) -> AbstractServerContext:
@@ -52,3 +57,49 @@ class AbstractSubprocess(abc.ABC):
     @abc.abstractmethod
     def finish(self, sts: int) -> None:
         raise NotImplementedError
+
+    @abc.abstractmethod
+    def remove_logs(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def reopen_logs(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def stop(self) -> ta.Optional[str]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def give_up(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def transition(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_state(self) -> ProcessState:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def create_auto_child_logs(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # dict[int, Dispatcher]
+        raise NotImplementedError
+
+
+@functools.total_ordering
+class AbstractProcessGroup(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def config(self) -> ProcessGroupConfig:
+        raise NotImplementedError
+
+    def __lt__(self, other):
+        return self.config.priority < other.config.priority
+
+    def __eq__(self, other):
+        return self.config.priority == other.config.priority