ominfra 0.0.0.dev128__py3-none-any.whl → 0.0.0.dev129__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -1494,6 +1494,30 @@ def check_not_equal(l: T, r: T) -> T:
     return l
 
 
+def check_is(l: T, r: T) -> T:
+    if l is not r:
+        raise ValueError(l, r)
+    return l
+
+
+def check_is_not(l: T, r: ta.Any) -> T:
+    if l is r:
+        raise ValueError(l, r)
+    return l
+
+
+def check_in(v: T, c: ta.Container[T]) -> T:
+    if v not in c:
+        raise ValueError(v, c)
+    return v
+
+
+def check_not_in(v: T, c: ta.Container[T]) -> T:
+    if v in c:
+        raise ValueError(v, c)
+    return v
+
+
 def check_single(vs: ta.Iterable[T]) -> T:
     [v] = vs
     return v
@@ -2604,6 +2628,11 @@ class HttpRequestParser:
 
 ########################################
 # ../../../omlish/lite/inject.py
+"""
+TODO:
+ - recursion detection
+ - bind empty array
+"""
 
 
 ###
@@ -2703,7 +2732,7 @@ class InjectorError(Exception):
     pass
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class InjectorKeyError(InjectorError):
     key: InjectorKey
 
@@ -2711,16 +2740,18 @@ class InjectorKeyError(InjectorError):
     name: ta.Optional[str] = None
 
 
-@dc.dataclass(frozen=True)
 class UnboundInjectorKeyError(InjectorKeyError):
     pass
 
 
-@dc.dataclass(frozen=True)
 class DuplicateInjectorKeyError(InjectorKeyError):
     pass
 
 
+class CyclicDependencyInjectorKeyError(InjectorKeyError):
+    pass
+
+
 ###
 # keys
 
@@ -3054,22 +3085,65 @@ class _Injector(Injector):
         if _INJECTOR_INJECTOR_KEY in self._pfm:
             raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
 
+        self.__cur_req: ta.Optional[_Injector._Request] = None
+
+    class _Request:
+        def __init__(self, injector: '_Injector') -> None:
+            super().__init__()
+            self._injector = injector
+            self._provisions: ta.Dict[InjectorKey, Maybe] = {}
+            self._seen_keys: ta.Set[InjectorKey] = set()
+
+        def handle_key(self, key: InjectorKey) -> Maybe[Maybe]:
+            try:
+                return Maybe.just(self._provisions[key])
+            except KeyError:
+                pass
+            if key in self._seen_keys:
+                raise CyclicDependencyInjectorKeyError(key)
+            self._seen_keys.add(key)
+            return Maybe.empty()
+
+        def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
+            check_in(key, self._seen_keys)
+            check_not_in(key, self._provisions)
+            self._provisions[key] = mv
+            return mv
+
+    @contextlib.contextmanager
+    def _current_request(self) -> ta.Generator[_Request, None, None]:
+        if (cr := self.__cur_req) is not None:
+            yield cr
+            return
+
+        cr = self._Request(self)
+        try:
+            self.__cur_req = cr
+            yield cr
+        finally:
+            self.__cur_req = None
+
     def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
         key = as_injector_key(key)
 
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
+        cr: _Injector._Request
+        with self._current_request() as cr:
+            if (rv := cr.handle_key(key)).present:
+                return rv.must()
+
+            if key == _INJECTOR_INJECTOR_KEY:
+                return cr.handle_provision(key, Maybe.just(self))
 
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
+            fn = self._pfm.get(key)
+            if fn is not None:
+                return cr.handle_provision(key, Maybe.just(fn(self)))
 
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
+            if self._p is not None:
+                pv = self._p.try_provide(key)
+                if pv is not None:
+                    return cr.handle_provision(key, Maybe.empty())
 
-        return Maybe.empty()
+            return cr.handle_provision(key, Maybe.empty())
 
     def provide(self, key: ta.Any) -> ta.Any:
         v = self.try_provide(key)
@@ -4158,6 +4232,23 @@ def unmarshal_obj(o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
     return get_obj_marshaler(ty).unmarshal(o)
 
 
+########################################
+# ../../../omlish/lite/runtime.py
+
+
+@cached_nullary
+def is_debugger_attached() -> bool:
+    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+
+
+REQUIRED_PYTHON_VERSION = (3, 8)
+
+
+def check_runtime_version() -> None:
+    if sys.version_info < REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+
+
 ########################################
 # ../../configs.py
 
@@ -5310,6 +5401,10 @@ class CoroHttpServerSocketHandler(SocketHandler):
 ##
 
 
+class ExitNow(Exception):  # noqa
+    pass
+
+
 ServerEpoch = ta.NewType('ServerEpoch', int)
 
 
@@ -5333,12 +5428,7 @@ class ConfigPriorityOrdered(abc.ABC):
 ##
 
 
-class ServerContext(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def config(self) -> ServerConfig:
-        raise NotImplementedError
-
+class SupervisorStateManager(abc.ABC):
     @property
     @abc.abstractmethod
     def state(self) -> SupervisorState:
@@ -5353,11 +5443,6 @@ class ServerContext(abc.ABC):
 
 
 class Dispatcher(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def process(self) -> 'Process':
-        raise NotImplementedError
-
     @property
     @abc.abstractmethod
     def channel(self) -> str:
@@ -5401,8 +5486,32 @@ class Dispatcher(abc.ABC):
     def handle_write_event(self) -> None:
         raise TypeError
 
+    #
+
+    def handle_connect(self) -> None:
+        raise TypeError
+
+    def handle_close(self) -> None:
+        raise TypeError
+
+    def handle_accepted(self, sock, addr) -> None:
+        raise TypeError
+
+
+class HasDispatchers(abc.ABC):
+    @abc.abstractmethod
+    def get_dispatchers(self) -> 'Dispatchers':
+        raise NotImplementedError
+
 
-class OutputDispatcher(Dispatcher, abc.ABC):
+class ProcessDispatcher(Dispatcher, abc.ABC):
+    @property
+    @abc.abstractmethod
+    def process(self) -> 'Process':
+        raise NotImplementedError
+
+
+class ProcessOutputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
     def remove_logs(self) -> None:
         raise NotImplementedError
@@ -5412,7 +5521,7 @@ class OutputDispatcher(Dispatcher, abc.ABC):
         raise NotImplementedError
 
 
-class InputDispatcher(Dispatcher, abc.ABC):
+class ProcessInputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
     def write(self, chars: ta.Union[bytes, str]) -> None:
         raise NotImplementedError
@@ -5425,7 +5534,11 @@ class InputDispatcher(Dispatcher, abc.ABC):
 ##
 
 
-class Process(ConfigPriorityOrdered, abc.ABC):
+class Process(
+    ConfigPriorityOrdered,
+    HasDispatchers,
+    abc.ABC,
+):
     @property
     @abc.abstractmethod
     def name(self) -> str:
@@ -5448,11 +5561,6 @@ class Process(ConfigPriorityOrdered, abc.ABC):
 
     #
 
-    @property
-    @abc.abstractmethod
-    def context(self) -> ServerContext:
-        raise NotImplementedError
-
     @abc.abstractmethod
     def finish(self, sts: Rc) -> None:
         raise NotImplementedError
@@ -5469,18 +5577,15 @@ class Process(ConfigPriorityOrdered, abc.ABC):
     def transition(self) -> None:
         raise NotImplementedError
 
+    @property
     @abc.abstractmethod
-    def get_state(self) -> ProcessState:
+    def state(self) -> ProcessState:
         raise NotImplementedError
 
     @abc.abstractmethod
     def after_setuid(self) -> None:
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def get_dispatchers(self) -> 'Dispatchers':
-        raise NotImplementedError
-
 
 ##
 
@@ -5520,75 +5625,6 @@ class ProcessGroup(
         raise NotImplementedError
 
 
-########################################
-# ../context.py
-
-
-class ServerContextImpl(ServerContext):
-    def __init__(
-            self,
-            config: ServerConfig,
-            poller: Poller,
-            *,
-            epoch: ServerEpoch = ServerEpoch(0),
-    ) -> None:
-        super().__init__()
-
-        self._config = config
-        self._poller = poller
-        self._epoch = epoch
-
-        self._state: SupervisorState = SupervisorState.RUNNING
-
-    @property
-    def config(self) -> ServerConfig:
-        return self._config
-
-    @property
-    def epoch(self) -> ServerEpoch:
-        return self._epoch
-
-    @property
-    def first(self) -> bool:
-        return not self._epoch
-
-    @property
-    def state(self) -> SupervisorState:
-        return self._state
-
-    def set_state(self, state: SupervisorState) -> None:
-        self._state = state
-
-    #
-
-    def waitpid(self) -> ta.Tuple[ta.Optional[Pid], ta.Optional[Rc]]:
-        # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
-        # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
-        # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
-        # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
-        # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
-        # lying around.
-        try:
-            pid, sts = os.waitpid(-1, os.WNOHANG)
-        except OSError as exc:
-            code = exc.args[0]
-            if code not in (errno.ECHILD, errno.EINTR):
-                log.critical('waitpid error %r; a process may not be cleaned up properly', code)
-            if code == errno.EINTR:
-                log.debug('EINTR during reap')
-            pid, sts = None, None
-        return pid, sts  # type: ignore
-
-    def get_auto_child_log_name(self, name: str, identifier: str, channel: str) -> str:
-        prefix = f'{name}-{channel}---{identifier}-'
-        logfile = mktempfile(
-            suffix='.log',
-            prefix=prefix,
-            dir=self.config.child_logdir,
-        )
-        return logfile
-
-
 ########################################
 # ../dispatchers.py
 
@@ -5612,12 +5648,12 @@ class Dispatchers(KeyedCollection[Fd, Dispatcher]):
 
     def remove_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.remove_logs()
 
     def reopen_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.reopen_logs()
 
 
@@ -5625,7 +5661,7 @@ class Dispatchers(KeyedCollection[Fd, Dispatcher]):
 # ../dispatchersimpl.py
 
 
-class BaseDispatcherImpl(Dispatcher, abc.ABC):
+class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
     def __init__(
             self,
             process: Process,
@@ -5633,6 +5669,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__()
 
@@ -5640,6 +5677,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         self._channel = channel  # 'stderr' or 'stdout'
         self._fd = fd
         self._event_callbacks = event_callbacks
+        self._server_config = server_config
 
         self._closed = False  # True if close() has been called
 
@@ -5680,7 +5718,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         self.close()
 
 
-class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
+class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispatcher):
     """
     Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
 
@@ -5696,12 +5734,14 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             event_type.channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._event_type = event_type
@@ -5725,11 +5765,10 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
 
         self._main_log_level = logging.DEBUG
 
-        self._log_to_main_log = process.context.config.loglevel <= self._main_log_level
+        self._log_to_main_log = self._server_config.loglevel <= self._main_log_level
 
-        config = self._process.config
-        self._stdout_events_enabled = config.stdout.events_enabled
-        self._stderr_events_enabled = config.stderr.events_enabled
+        self._stdout_events_enabled = self._process.config.stdout.events_enabled
+        self._stderr_events_enabled = self._process.config.stderr.events_enabled
 
     _child_log: ta.Optional[logging.Logger] = None  # the current logger (normal_log or capture_log)
     _normal_log: ta.Optional[logging.Logger] = None  # the "normal" (non-capture) logger
@@ -5800,7 +5839,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
         if not data:
             return
 
-        if self._process.context.config.strip_ansi:
+        if self._server_config.strip_ansi:
             data = strip_escapes(as_bytes(data))
 
         if self._child_log:
@@ -5898,7 +5937,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             self.close()
 
 
-class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
+class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatcher):
     def __init__(
             self,
             process: Process,
@@ -5906,12 +5945,14 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
             fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._input_buffer = b''
@@ -6071,7 +6112,7 @@ class ProcessGroupImpl(ProcessGroup):
     #
 
     def get_unstopped_processes(self) -> ta.List[Process]:
-        return [x for x in self if not x.get_state().stopped]
+        return [x for x in self if not x.state.stopped]
 
     def stop_all(self) -> None:
         processes = list(self._by_name.values())
@@ -6079,7 +6120,7 @@ class ProcessGroupImpl(ProcessGroup):
         processes.reverse()  # stop in desc priority order
 
         for proc in processes:
-            state = proc.get_state()
+            state = proc.state
             if state == ProcessState.RUNNING:
                 # RUNNING -> STOPPING
                 proc.stop()
@@ -6362,62 +6403,99 @@ class SupervisorSetupImpl(SupervisorSetup):
 
 
 ########################################
-# ../spawning.py
-
-
-@dc.dataclass(frozen=True)
-class SpawnedProcess:
-    pid: Pid
-    pipes: ProcessPipes
-    dispatchers: Dispatchers
-
-
-class ProcessSpawnError(RuntimeError):
-    pass
-
+# ../io.py
 
-class ProcessSpawning:
-    @property
-    @abc.abstractmethod
-    def process(self) -> Process:
-        raise NotImplementedError
 
-    #
+##
 
-    @abc.abstractmethod
-    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
-        raise NotImplementedError
 
+class IoManager:
+    def __init__(
+            self,
+            *,
+            poller: Poller,
+            process_groups: ProcessGroupManager,
+    ) -> None:
+        super().__init__()
 
-########################################
-# ../supervisor.py
+        self._poller = poller
+        self._process_groups = process_groups
 
+    def get_dispatchers(self) -> Dispatchers:
+        return Dispatchers(
+            d
+            for p in self._process_groups.all_processes()
+            for d in p.get_dispatchers()
+        )
 
-##
+    def poll(self) -> None:
+        dispatchers = self.get_dispatchers()
 
+        for fd, dispatcher in dispatchers.items():
+            if dispatcher.readable():
+                self._poller.register_readable(fd)
+            if dispatcher.writable():
+                self._poller.register_writable(fd)
 
-class ExitNow(Exception):  # noqa
-    pass
+        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
+        r, w = self._poller.poll(timeout)
 
+        for fd in r:
+            if fd in dispatchers:
+                try:
+                    dispatcher = dispatchers[fd]
+                    log.debug('read event caused by %r', dispatcher)
+                    dispatcher.handle_read_event()
+                    if not dispatcher.readable():
+                        self._poller.unregister_readable(fd)
+                except ExitNow:
+                    raise
+                except Exception:  # noqa
+                    dispatchers[fd].handle_error()
+            else:
+                # if the fd is not in combined map, we should unregister it. otherwise, it will be polled every
+                # time, which may cause 100% cpu usage
+                log.debug('unexpected read event from fd %r', fd)
+                try:
+                    self._poller.unregister_readable(fd)
+                except Exception:  # noqa
+                    pass
 
-def timeslice(period: int, when: float) -> int:
-    return int(when - (when % period))
+        for fd in w:
+            if fd in dispatchers:
+                try:
+                    dispatcher = dispatchers[fd]
+                    log.debug('write event caused by %r', dispatcher)
+                    dispatcher.handle_write_event()
+                    if not dispatcher.writable():
+                        self._poller.unregister_writable(fd)
+                except ExitNow:
+                    raise
+                except Exception:  # noqa
+                    dispatchers[fd].handle_error()
+            else:
+                log.debug('unexpected write event from fd %r', fd)
+                try:
+                    self._poller.unregister_writable(fd)
+                except Exception:  # noqa
+                    pass
 
 
-##
+########################################
+# ../signals.py
 
 
 class SignalHandler:
     def __init__(
             self,
             *,
-            context: ServerContextImpl,
+            states: SupervisorStateManager,
             signal_receiver: SignalReceiver,
             process_groups: ProcessGroupManager,
     ) -> None:
         super().__init__()
 
-        self._context = context
+        self._states = states
         self._signal_receiver = signal_receiver
         self._process_groups = process_groups
 
@@ -6438,14 +6516,14 @@ class SignalHandler:
 
         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)
+            self._states.set_state(SupervisorState.SHUTDOWN)
 
         elif sig == signal.SIGHUP:
-            if self._context.state == SupervisorState.SHUTDOWN:
+            if self._states.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)
+                self._states.set_state(SupervisorState.RESTARTING)
 
         elif sig == signal.SIGCHLD:
             log.debug('received %s indicating a child quit', sig_name(sig))
@@ -6455,282 +6533,39 @@ class SignalHandler:
 
             for p in self._process_groups.all_processes():
                 for d in p.get_dispatchers():
-                    if isinstance(d, OutputDispatcher):
+                    if isinstance(d, ProcessOutputDispatcher):
                         d.reopen_logs()
 
         else:
             log.debug('received %s indicating nothing', sig_name(sig))
 
 
-##
+########################################
+# ../spawning.py
 
 
-class ProcessGroupFactory(Func1[ProcessGroupConfig, ProcessGroup]):
-    pass
+@dc.dataclass(frozen=True)
+class SpawnedProcess:
+    pid: Pid
+    pipes: ProcessPipes
+    dispatchers: Dispatchers
 
 
-class Supervisor:
-    def __init__(
-            self,
-            *,
-            context: ServerContextImpl,
-            poller: Poller,
-            process_groups: ProcessGroupManager,
-            signal_handler: SignalHandler,
-            event_callbacks: EventCallbacks,
-            process_group_factory: ProcessGroupFactory,
-            pid_history: PidHistory,
-            setup: SupervisorSetup,
-    ) -> None:
-        super().__init__()
+class ProcessSpawnError(RuntimeError):
+    pass
 
-        self._context = context
-        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._pid_history = pid_history
-        self._setup = setup
-
-        self._ticks: ta.Dict[int, float] = {}
-        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
-
-    #
 
+class ProcessSpawning:
     @property
-    def context(self) -> ServerContextImpl:
-        return self._context
-
-    def get_state(self) -> SupervisorState:
-        return self._context.state
-
-    #
-
-    def add_process_group(self, config: ProcessGroupConfig) -> bool:
-        if self._process_groups.get(config.name) is not None:
-            return False
-
-        group = check_isinstance(self._process_group_factory(config), ProcessGroup)
-        for process in group:
-            process.after_setuid()
-
-        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.remove(name)
-
-        return True
-
-    #
-
-    def shutdown_report(self) -> ta.List[Process]:
-        unstopped: ta.List[Process] = []
-
-        for group in self._process_groups:
-            unstopped.extend(group.get_unstopped_processes())
-
-        if unstopped:
-            # throttle 'waiting for x to die' reports
-            now = time.time()
-            if now > (self._last_shutdown_report + 3):  # every 3 secs
-                names = [p.config.name for p in unstopped]
-                namestr = ', '.join(names)
-                log.info('waiting for %s to die', namestr)
-                self._last_shutdown_report = now
-                for proc in unstopped:
-                    log.debug('%s state: %s', proc.config.name, proc.get_state().name)
-
-        return unstopped
-
-    #
-
-    def main(self, **kwargs: ta.Any) -> None:
-        self._setup.setup()
-        try:
-            self.run(**kwargs)
-        finally:
-            self._setup.cleanup()
-
-    def run(
-            self,
-            *,
-            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
-    ) -> None:
-        self._process_groups.clear()
-        self._stop_groups = None  # clear
-
-        self._event_callbacks.clear()
-
-        try:
-            for config in self._context.config.groups or []:
-                self.add_process_group(config)
-
-            self._signal_handler.set_signals()
-
-            self._event_callbacks.notify(SupervisorRunningEvent())
-
-            while True:
-                if callback is not None and not callback(self):
-                    break
-
-                self._run_once()
-
-        finally:
-            self._poller.close()
+    @abc.abstractmethod
+    def process(self) -> Process:
+        raise NotImplementedError
 
     #
 
-    def _run_once(self) -> None:
-        self._poll()
-        self._reap()
-        self._signal_handler.handle_signals()
-        self._tick()
-
-        if self._context.state < SupervisorState.RUNNING:
-            self._ordered_stop_groups_phase_2()
-
-    def _ordered_stop_groups_phase_1(self) -> None:
-        if self._stop_groups:
-            # stop the last group (the one with the "highest" priority)
-            self._stop_groups[-1].stop_all()
-
-    def _ordered_stop_groups_phase_2(self) -> None:
-        # after phase 1 we've transitioned and reaped, let's see if we can remove the group we stopped from the
-        # stop_groups queue.
-        if self._stop_groups:
-            # pop the last group (the one with the "highest" priority)
-            group = self._stop_groups.pop()
-            if group.get_unstopped_processes():
-                # if any processes in the group aren't yet in a stopped state, we're not yet done shutting this group
-                # down, so push it back on to the end of the stop group queue
-                self._stop_groups.append(group)
-
-    def get_dispatchers(self) -> Dispatchers:
-        return Dispatchers(
-            d
-            for p in self._process_groups.all_processes()
-            for d in p.get_dispatchers()
-        )
-
-    def _poll(self) -> None:
-        dispatchers = self.get_dispatchers()
-
-        sorted_groups = list(self._process_groups)
-        sorted_groups.sort()
-
-        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 = sorted_groups[:]
-                self._event_callbacks.notify(SupervisorStoppingEvent())
-
-            self._ordered_stop_groups_phase_1()
-
-            if not self.shutdown_report():
-                # if there are no unstopped processes (we're done killing everything), it's OK to shutdown or reload
-                raise ExitNow
-
-        for fd, dispatcher in dispatchers.items():
-            if dispatcher.readable():
-                self._poller.register_readable(fd)
-            if dispatcher.writable():
-                self._poller.register_writable(fd)
-
-        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
-        r, w = self._poller.poll(timeout)
-
-        for fd in r:
-            if fd in dispatchers:
-                try:
-                    dispatcher = dispatchers[fd]
-                    log.debug('read event caused by %r', dispatcher)
-                    dispatcher.handle_read_event()
-                    if not dispatcher.readable():
-                        self._poller.unregister_readable(fd)
-                except ExitNow:
-                    raise
-                except Exception:  # noqa
-                    dispatchers[fd].handle_error()
-            else:
-                # if the fd is not in combined map, we should unregister it. otherwise, it will be polled every
-                # time, which may cause 100% cpu usage
-                log.debug('unexpected read event from fd %r', fd)
-                try:
-                    self._poller.unregister_readable(fd)
-                except Exception:  # noqa
-                    pass
-
-        for fd in w:
-            if fd in dispatchers:
-                try:
-                    dispatcher = dispatchers[fd]
-                    log.debug('write event caused by %r', dispatcher)
-                    dispatcher.handle_write_event()
-                    if not dispatcher.writable():
-                        self._poller.unregister_writable(fd)
-                except ExitNow:
-                    raise
-                except Exception:  # noqa
-                    dispatchers[fd].handle_error()
-            else:
-                log.debug('unexpected write event from fd %r', fd)
-                try:
-                    self._poller.unregister_writable(fd)
-                except Exception:  # noqa
-                    pass
-
-        for group in sorted_groups:
-            for process in group:
-                process.transition()
-
-    def _reap(self, *, once: bool = False, depth: int = 0) -> None:
-        if depth >= 100:
-            return
-
-        pid, sts = self._context.waitpid()
-        if not pid:
-            return
-
-        process = self._pid_history.get(pid, None)
-        if process is None:
-            _, msg = decode_wait_status(check_not_none(sts))
-            log.info('reaped unknown pid %s (%s)', pid, msg)
-        else:
-            process.finish(check_not_none(sts))
-            del self._pid_history[pid]
-
-        if not once:
-            # keep reaping until no more kids to reap, but don't recurse infinitely
-            self._reap(once=False, depth=depth + 1)
-
-    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"""
-
-        if now is None:
-            # now won't be None in unit tests
-            now = time.time()
-
-        for event in TICK_EVENTS:
-            period = event.period
-
-            last_tick = self._ticks.get(period)
-            if last_tick is None:
-                # we just started up
-                last_tick = self._ticks[period] = timeslice(period, now)
-
-            this_tick = timeslice(period, now)
-            if this_tick != last_tick:
-                self._ticks[period] = this_tick
-                self._event_callbacks.notify(event(this_tick, self))
+    @abc.abstractmethod
+    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
+        raise NotImplementedError
 
 
 ########################################
@@ -6752,7 +6587,7 @@ class ProcessImpl(Process):
             config: ProcessConfig,
             group: ProcessGroup,
             *,
-            context: ServerContext,
+            supervisor_states: SupervisorStateManager,
             event_callbacks: EventCallbacks,
             process_spawning_factory: ProcessSpawningFactory,
     ) -> None:
@@ -6761,7 +6596,7 @@ class ProcessImpl(Process):
         self._config = config
         self._group = group
 
-        self._context = context
+        self._supervisor_states = supervisor_states
         self._event_callbacks = event_callbacks
 
         self._spawning = process_spawning_factory(self)
@@ -6792,7 +6627,7 @@ class ProcessImpl(Process):
     #
 
     def __repr__(self) -> str:
-        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self.get_state().name}>'
+        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self._state.name}>'
 
     #
 
@@ -6814,10 +6649,6 @@ class ProcessImpl(Process):
 
     #
 
-    @property
-    def context(self) -> ServerContext:
-        return self._context
-
     @property
     def state(self) -> ProcessState:
         return self._state
@@ -6880,7 +6711,7 @@ class ProcessImpl(Process):
         if stdin_fd is None:
             raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
-        dispatcher = check_isinstance(self._dispatchers[stdin_fd], InputDispatcher)
+        dispatcher = check_isinstance(self._dispatchers[stdin_fd], ProcessInputDispatcher)
         if dispatcher.closed:
             raise OSError(errno.EPIPE, "Process' stdin channel is closed")
 
@@ -7150,9 +6981,6 @@ class ProcessImpl(Process):
         self._pipes = ProcessPipes()
         self._dispatchers = Dispatchers([])
 
-    def get_state(self) -> ProcessState:
-        return self._state
-
     def transition(self) -> None:
         now = time.time()
         state = self._state
@@ -7161,7 +6989,7 @@ class ProcessImpl(Process):
 
         logger = log
 
-        if self.context.state > SupervisorState.RESTARTING:
+        if self._supervisor_states.state > SupervisorState.RESTARTING:
             # dont start any processes if supervisor is shutting down
             if state == ProcessState.EXITED:
                 if self._config.autorestart:
@@ -7225,11 +7053,11 @@ class ProcessImpl(Process):
 # ../spawningimpl.py
 
 
-class OutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], Fd, OutputDispatcher]):
+class ProcessOutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], Fd, ProcessOutputDispatcher]):
     pass
 
 
-class InputDispatcherFactory(Func3[Process, str, Fd, InputDispatcher]):
+class ProcessInputDispatcherFactory(Func3[Process, str, Fd, ProcessInputDispatcher]):
     pass
 
 
@@ -7247,8 +7075,8 @@ class ProcessSpawningImpl(ProcessSpawning):
             server_config: ServerConfig,
             pid_history: PidHistory,
 
-            output_dispatcher_factory: OutputDispatcherFactory,
-            input_dispatcher_factory: InputDispatcherFactory,
+            output_dispatcher_factory: ProcessOutputDispatcherFactory,
+            input_dispatcher_factory: ProcessInputDispatcherFactory,
 
             inherited_fds: ta.Optional[InheritedFds] = None,
     ) -> None:
@@ -7388,21 +7216,21 @@ class ProcessSpawningImpl(ProcessSpawning):
                 self.process,
                 ProcessCommunicationStdoutEvent,
                 pipes.stdout,
-            ), OutputDispatcher))
+            ), ProcessOutputDispatcher))
 
         if pipes.stderr is not None:
             dispatchers.append(check_isinstance(self._output_dispatcher_factory(
                 self.process,
                 ProcessCommunicationStderrEvent,
                 pipes.stderr,
-            ), OutputDispatcher))
+            ), ProcessOutputDispatcher))
 
         if pipes.stdin is not None:
             dispatchers.append(check_isinstance(self._input_dispatcher_factory(
                 self.process,
                 'stdin',
                 pipes.stdin,
-            ), InputDispatcher))
+            ), ProcessInputDispatcher))
 
         return Dispatchers(dispatchers)
 
@@ -7531,6 +7359,278 @@ def check_execv_args(
         raise NoPermissionError(f'No permission to run command {exe!r}')
 
 
+########################################
+# ../supervisor.py
+
+
+##
+
+
+def timeslice(period: int, when: float) -> int:
+    return int(when - (when % period))
+
+
+##
+
+
+class SupervisorStateManagerImpl(SupervisorStateManager):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._state: SupervisorState = SupervisorState.RUNNING
+
+    @property
+    def state(self) -> SupervisorState:
+        return self._state
+
+    def set_state(self, state: SupervisorState) -> None:
+        self._state = state
+
+
+##
+
+
+class ProcessGroupFactory(Func1[ProcessGroupConfig, ProcessGroup]):
+    pass
+
+
+class Supervisor:
+    def __init__(
+            self,
+            *,
+            config: ServerConfig,
+            poller: Poller,
+            process_groups: ProcessGroupManager,
+            signal_handler: SignalHandler,
+            event_callbacks: EventCallbacks,
+            process_group_factory: ProcessGroupFactory,
+            pid_history: PidHistory,
+            setup: SupervisorSetup,
+            states: SupervisorStateManager,
+            io: IoManager,
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+        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._pid_history = pid_history
+        self._setup = setup
+        self._states = states
+        self._io = io
+
+        self._ticks: ta.Dict[int, float] = {}
+        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
+
+    #
+
+    @property
+    def state(self) -> SupervisorState:
+        return self._states.state
+
+    #
+
+    def add_process_group(self, config: ProcessGroupConfig) -> bool:
+        if self._process_groups.get(config.name) is not None:
+            return False
+
+        group = check_isinstance(self._process_group_factory(config), ProcessGroup)
+        for process in group:
+            process.after_setuid()
+
+        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.remove(name)
+
+        return True
+
+    #
+
+    def shutdown_report(self) -> ta.List[Process]:
+        unstopped: ta.List[Process] = []
+
+        for group in self._process_groups:
+            unstopped.extend(group.get_unstopped_processes())
+
+        if unstopped:
+            # throttle 'waiting for x to die' reports
+            now = time.time()
+            if now > (self._last_shutdown_report + 3):  # every 3 secs
+                names = [p.config.name for p in unstopped]
+                namestr = ', '.join(names)
+                log.info('waiting for %s to die', namestr)
+                self._last_shutdown_report = now
+                for proc in unstopped:
+                    log.debug('%s state: %s', proc.config.name, proc.state.name)
+
+        return unstopped
+
+    #
+
+    def main(self, **kwargs: ta.Any) -> None:
+        self._setup.setup()
+        try:
+            self.run(**kwargs)
+        finally:
+            self._setup.cleanup()
+
+    def run(
+            self,
+            *,
+            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
+    ) -> None:
+        self._process_groups.clear()
+        self._stop_groups = None  # clear
+
+        self._event_callbacks.clear()
+
+        try:
+            for config in self._config.groups or []:
+                self.add_process_group(config)
+
+            self._signal_handler.set_signals()
+
+            self._event_callbacks.notify(SupervisorRunningEvent())
+
+            while True:
+                if callback is not None and not callback(self):
+                    break
+
+                self._run_once()
+
+        finally:
+            self._poller.close()
+
+    #
+
+    def _run_once(self) -> None:
+        self._poll()
+        self._reap()
+        self._signal_handler.handle_signals()
+        self._tick()
+
+        if self._states.state < SupervisorState.RUNNING:
+            self._ordered_stop_groups_phase_2()
+
+    def _ordered_stop_groups_phase_1(self) -> None:
+        if self._stop_groups:
+            # stop the last group (the one with the "highest" priority)
+            self._stop_groups[-1].stop_all()
+
+    def _ordered_stop_groups_phase_2(self) -> None:
+        # after phase 1 we've transitioned and reaped, let's see if we can remove the group we stopped from the
+        # stop_groups queue.
+        if self._stop_groups:
+            # pop the last group (the one with the "highest" priority)
+            group = self._stop_groups.pop()
+            if group.get_unstopped_processes():
+                # if any processes in the group aren't yet in a stopped state, we're not yet done shutting this group
+                # down, so push it back on to the end of the stop group queue
+                self._stop_groups.append(group)
+
+    def _poll(self) -> None:
+        sorted_groups = list(self._process_groups)
+        sorted_groups.sort()
+
+        if self._states.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 = sorted_groups[:]
+                self._event_callbacks.notify(SupervisorStoppingEvent())
+
+            self._ordered_stop_groups_phase_1()
+
+            if not self.shutdown_report():
+                # if there are no unstopped processes (we're done killing everything), it's OK to shutdown or reload
+                raise ExitNow
+
+        self._io.poll()
+
+        for group in sorted_groups:
+            for process in group:
+                process.transition()
+
+    def _reap(self, *, once: bool = False, depth: int = 0) -> None:
+        if depth >= 100:
+            return
+
+        wp = waitpid()
+        if wp is None or not wp.pid:
+            return
+
+        process = self._pid_history.get(wp.pid, None)
+        if process is None:
+            _, msg = decode_wait_status(wp.sts)
+            log.info('reaped unknown pid %s (%s)', wp.pid, msg)
+        else:
+            process.finish(wp.sts)
+            del self._pid_history[wp.pid]
+
+        if not once:
+            # keep reaping until no more kids to reap, but don't recurse infinitely
+            self._reap(once=False, depth=depth + 1)
+
+    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"""
+
+        if now is None:
+            # now won't be None in unit tests
+            now = time.time()
+
+        for event in TICK_EVENTS:
+            period = event.period
+
+            last_tick = self._ticks.get(period)
+            if last_tick is None:
+                # we just started up
+                last_tick = self._ticks[period] = timeslice(period, now)
+
+            this_tick = timeslice(period, now)
+            if this_tick != last_tick:
+                self._ticks[period] = this_tick
+                self._event_callbacks.notify(event(this_tick, self))
+
+
+##
+
+
+class WaitedPid(ta.NamedTuple):
+    pid: Pid
+    sts: Rc
+
+
+def waitpid() -> ta.Optional[WaitedPid]:
+    # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
+    # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
+    # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
+    # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
+    # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
+    # lying around.
+    try:
+        pid, sts = os.waitpid(-1, os.WNOHANG)
+    except OSError as exc:
+        code = exc.args[0]
+        if code not in (errno.ECHILD, errno.EINTR):
+            log.critical('waitpid error %r; a process may not be cleaned up properly', code)
+        if code == errno.EINTR:
+            log.debug('EINTR during reap')
+        return None
+    else:
+        return WaitedPid(pid, sts)  # type: ignore
+
+
 ########################################
 # ../inject.py
 
@@ -7551,17 +7651,21 @@ def bind_server(
 
         inj.bind(DaemonizeListener, array=True, to_key=Poller),
 
-        inj.bind(ServerContextImpl, singleton=True),
-        inj.bind(ServerContext, to_key=ServerContextImpl),
-
         inj.bind(EventCallbacks, singleton=True),
 
         inj.bind(SignalReceiver, singleton=True),
 
+        inj.bind(IoManager, singleton=True),
+
         inj.bind(SignalHandler, singleton=True),
+
         inj.bind(ProcessGroupManager, singleton=True),
+
         inj.bind(Supervisor, singleton=True),
 
+        inj.bind(SupervisorStateManagerImpl, singleton=True),
+        inj.bind(SupervisorStateManager, to_key=SupervisorStateManagerImpl),
+
         inj.bind(PidHistory()),
 
         inj.bind_factory(ProcessGroupImpl, ProcessGroupFactory),
@@ -7569,8 +7673,8 @@ def bind_server(
 
         inj.bind_factory(ProcessSpawningImpl, ProcessSpawningFactory),
 
-        inj.bind_factory(OutputDispatcherImpl, OutputDispatcherFactory),
-        inj.bind_factory(InputDispatcherImpl, InputDispatcherFactory),
+        inj.bind_factory(ProcessOutputDispatcherImpl, ProcessOutputDispatcherFactory),
+        inj.bind_factory(ProcessInputDispatcherImpl, ProcessInputDispatcherFactory),
     ]
 
     #
@@ -7627,7 +7731,7 @@ def main(
     if not no_logging:
         configure_standard_logging(
             'INFO',
-            handler_factory=journald_log_handler_factory if not args.no_journald else None,
+            handler_factory=journald_log_handler_factory if not (args.no_journald or is_debugger_attached()) else None,
         )
 
     #
@@ -7650,7 +7754,6 @@ def main(
             inherited_fds=inherited_fds,
         ))
 
-        context = injector[ServerContextImpl]
         supervisor = injector[Supervisor]
 
         try:
@@ -7658,7 +7761,7 @@ def main(
         except ExitNow:
             pass
 
-        if context.state < SupervisorState.RESTARTING:
+        if supervisor.state < SupervisorState.RESTARTING:
             break