ominfra 0.0.0.dev124__py3-none-any.whl → 0.0.0.dev125__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -4,6 +4,34 @@
 # @omlish-script
 # @omlish-amalg-output ../supervisor/main.py
 # ruff: noqa: N802 UP006 UP007 UP012 UP036
+# Supervisor is licensed under the following license:
+#
+#  A copyright notice accompanies this license document that identifies the copyright holders.
+#
+#  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+#  following conditions are met:
+#
+#  1. Redistributions in source code must retain the accompanying copyright notice, this list of conditions, and the
+#     following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the accompanying copyright notice, this list of conditions, and the
+#     following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+#  3. Names of the copyright holders must not be used to endorse or promote products derived from this software without
+#     prior written permission from the copyright holders.
+#
+#  4. If any files are modified, you must cause the modified files to carry prominent notices stating that you changed
+#     the files and the date of any change.
+#
+#  Disclaimer
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
+#   NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+#   EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+#   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+#   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+#   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import abc
 import base64
 import collections.abc
@@ -74,6 +102,9 @@ T = ta.TypeVar('T')
 SocketAddress = ta.Any
 SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
 
+# ../events.py
+EventCallback = ta.Callable[['Event'], None]
+
 # ../../../omlish/lite/http/parsing.py
 HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
 
@@ -92,12 +123,6 @@ HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']
 # ../../../omlish/lite/http/coroserver.py
 CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
 
-# ../context.py
-ServerEpoch = ta.NewType('ServerEpoch', int)
-
-# ../process.py
-InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
-
 
 ########################################
 # ../../../omdev/toml/parser.py
@@ -1537,6 +1562,18 @@ class SocketHandler(abc.ABC):
         raise NotImplementedError
 
 
+########################################
+# ../../../omlish/lite/typing.py
+
+
+@dc.dataclass(frozen=True)
+class Func(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)
+
+
 ########################################
 # ../events.py
 
@@ -1551,9 +1588,6 @@ class Event(abc.ABC):  # noqa
 ##
 
 
-EventCallback = ta.Callable[['Event'], None]
-
-
 class EventCallbacks:
     def __init__(self) -> None:
         super().__init__()
@@ -2398,7 +2432,13 @@ class HttpRequestParser:
 
 @dc.dataclass(frozen=True)
 class InjectorKey(ta.Generic[T]):
-    cls: InjectorKeyCls
+    # Before PEP-560 typing.Generic was a metaclass with a __new__ that takes a 'cls' arg, so instantiating a dataclass
+    # with kwargs (such as through dc.replace) causes `TypeError: __new__() got multiple values for argument 'cls'`.
+    # See:
+    #  - https://github.com/python/cpython/commit/d911e40e788fb679723d78b6ea11cabf46caed5a
+    #  - https://gist.github.com/wrmsr/4468b86efe9f373b6b114bfe85b98fd3
+    cls_: InjectorKeyCls
+
     tag: ta.Any = None
     array: bool = False
 
@@ -2519,14 +2559,14 @@ class FnInjectorProvider(InjectorProvider):
 
 @dc.dataclass(frozen=True)
 class CtorInjectorProvider(InjectorProvider):
-    cls: type
+    cls_: type
 
     def __post_init__(self) -> None:
-        check_isinstance(self.cls, type)
+        check_isinstance(self.cls_, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
-            return i.inject(self.cls)
+            return i.inject(self.cls_)
 
         return pfn
 
@@ -2675,19 +2715,42 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 # inspection
 
 
-_INJECTION_SIGNATURE_CACHE: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKeyDictionary()
+# inspect.signature(eval_str=True) was added in 3.10 and we have to support 3.8, so we have to get_type_hints to eval
+# str annotations *in addition to* getting the signature for parameter information.
+class _InjectionInspection(ta.NamedTuple):
+    signature: inspect.Signature
+    type_hints: ta.Mapping[str, ta.Any]
+
 
+_INJECTION_INSPECTION_CACHE: ta.MutableMapping[ta.Any, _InjectionInspection] = weakref.WeakKeyDictionary()
 
-def _injection_signature(obj: ta.Any) -> inspect.Signature:
+
+def _do_injection_inspect(obj: ta.Any) -> _InjectionInspection:
+    uw = obj
+    while True:
+        if isinstance(uw, functools.partial):
+            uw = uw.func
+        else:
+            if (uw2 := inspect.unwrap(uw)) is uw:
+                break
+            uw = uw2
+
+    return _InjectionInspection(
+        inspect.signature(obj),
+        ta.get_type_hints(uw),
+    )
+
+
+def _injection_inspect(obj: ta.Any) -> _InjectionInspection:
     try:
-        return _INJECTION_SIGNATURE_CACHE[obj]
+        return _INJECTION_INSPECTION_CACHE[obj]
     except TypeError:
-        return inspect.signature(obj)
+        return _do_injection_inspect(obj)
     except KeyError:
         pass
-    sig = inspect.signature(obj)
-    _INJECTION_SIGNATURE_CACHE[obj] = sig
-    return sig
+    insp = _do_injection_inspect(obj)
+    _INJECTION_INSPECTION_CACHE[obj] = insp
+    return insp
 
 
 class InjectionKwarg(ta.NamedTuple):
@@ -2708,20 +2771,20 @@ def build_injection_kwargs_target(
         skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
         raw_optional: bool = False,
 ) -> InjectionKwargsTarget:
-    sig = _injection_signature(obj)
+    insp = _injection_inspect(obj)
 
     seen: ta.Set[InjectorKey] = set(map(as_injector_key, skip_kwargs)) if skip_kwargs is not None else set()
     kws: ta.List[InjectionKwarg] = []
-    for p in list(sig.parameters.values())[skip_args:]:
+    for p in list(insp.signature.parameters.values())[skip_args:]:
         if p.annotation is inspect.Signature.empty:
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
             continue
 
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
-            raise TypeError(sig)
+            raise TypeError(insp)
 
-        ann = p.annotation
+        ann = insp.type_hints.get(p.name, p.annotation)
         if (
                 not raw_optional and
                 is_optional_alias(ann)
@@ -2746,6 +2809,66 @@ def build_injection_kwargs_target(
     )
 
 
+###
+# injector
+
+
+_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
+
+
+class _Injector(Injector):
+    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
+        super().__init__()
+
+        self._bs = check_isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
+
+        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
+
+        if _INJECTOR_INJECTOR_KEY in self._pfm:
+            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
+
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        key = as_injector_key(key)
+
+        if key == _INJECTOR_INJECTOR_KEY:
+            return Maybe.just(self)
+
+        fn = self._pfm.get(key)
+        if fn is not None:
+            return Maybe.just(fn(self))
+
+        if self._p is not None:
+            pv = self._p.try_provide(key)
+            if pv is not None:
+                return Maybe.empty()
+
+        return Maybe.empty()
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        v = self.try_provide(key)
+        if v.present:
+            return v.must()
+        raise UnboundInjectorKeyError(key)
+
+    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(obj)
+        ret: ta.Dict[str, ta.Any] = {}
+        for kw in kt.kwargs:
+            if kw.has_default:
+                if not (mv := self.try_provide(kw.key)).present:
+                    continue
+                v = mv.must()
+            else:
+                v = self.provide(kw.key)
+            ret[kw.name] = v
+        return ret
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        kws = self.provide_kwargs(obj)
+        return obj(**kws)
+
+
 ###
 # binder
 
@@ -2795,7 +2918,7 @@ class InjectorBinder:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         if obj is None or obj is inspect.Parameter.empty:
             raise TypeError(obj)
         if isinstance(obj, cls._BANNED_BIND_TYPES):
@@ -2825,8 +2948,8 @@ class InjectorBinder:
         elif cls._is_fn(obj) and not has_to:
             to_fn = obj
             if key is None:
-                sig = _injection_signature(obj)
-                key_cls = check_valid_injector_key_cls(sig.return_annotation)
+                insp = _injection_inspect(obj)
+                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
                 key = InjectorKey(key_cls)
         else:
             if to_const is not None:
@@ -2878,67 +3001,21 @@ class InjectorBinder:
 
 
 ###
-# injector
-
-
-_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
-
-
-class _Injector(Injector):
-    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
-        super().__init__()
-
-        self._bs = check_isinstance(bs, InjectorBindings)
-        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
-
-        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
-
-        if _INJECTOR_INJECTOR_KEY in self._pfm:
-            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
-
-    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
-        key = as_injector_key(key)
-
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
-
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
-
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
-
-        return Maybe.empty()
-
-    def provide(self, key: ta.Any) -> ta.Any:
-        v = self.try_provide(key)
-        if v.present:
-            return v.must()
-        raise UnboundInjectorKeyError(key)
+# injection helpers
 
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
-        kt = build_injection_kwargs_target(obj)
-        ret: ta.Dict[str, ta.Any] = {}
-        for kw in kt.kwargs:
-            if kw.has_default:
-                if not (mv := self.try_provide(kw.key)).present:
-                    continue
-                v = mv.must()
-            else:
-                v = self.provide(kw.key)
-            ret[kw.name] = v
-        return ret
 
-    def inject(self, obj: ta.Any) -> ta.Any:
-        kws = self.provide_kwargs(obj)
-        return obj(**kws)
+def make_injector_factory(
+        factory_cls: ta.Any,
+        factory_fn: ta.Callable[..., T],
+) -> ta.Callable[..., Func[T]]:
+    def outer(injector: Injector) -> factory_cls:
+        def inner(*args, **kwargs):
+            return injector.inject(functools.partial(factory_fn, *args, **kwargs))
+        return Func(inner)
+    return outer
 
 
-###
-# injection helpers
+##
 
 
 class Injection:
@@ -2969,6 +3046,12 @@ class Injection:
     def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
+    # injector
+
+    @classmethod
+    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), p)
+
     # binder
 
     @classmethod
@@ -2986,7 +3069,7 @@ class Injection:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         return InjectorBinder.bind(
             obj,
 
@@ -3002,11 +3085,15 @@ class Injection:
             singleton=singleton,
         )
 
-    # injector
+    # helpers
 
     @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
-        return _Injector(as_injector_bindings(*args), p)
+    def bind_factory(
+            cls,
+            factory_cls: ta.Any,
+            factory_fn: ta.Callable[..., T],
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_factory(factory_cls, factory_fn))
 
 
 inj = Injection
@@ -4790,7 +4877,7 @@ class CoroHttpServerSocketHandler(SocketHandler):
 # ../types.py
 
 
-class AbstractServerContext(abc.ABC):
+class ServerContext(abc.ABC):
     @property
     @abc.abstractmethod
     def config(self) -> ServerConfig:
@@ -4807,12 +4894,24 @@ class AbstractServerContext(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def pid_history(self) -> ta.Dict[int, 'AbstractSubprocess']:
+    def pid_history(self) -> ta.Dict[int, 'Process']:
         raise NotImplementedError
 
 
+# class Dispatcher(abc.ABC):
+#     pass
+#
+#
+# class OutputDispatcher(Dispatcher, abc.ABC):
+#     pass
+#
+#
+# class InputDispatcher(Dispatcher, abc.ABC):
+#     pass
+
+
 @functools.total_ordering
-class AbstractSubprocess(abc.ABC):
+class Process(abc.ABC):
     @property
     @abc.abstractmethod
     def pid(self) -> int:
@@ -4831,7 +4930,7 @@ class AbstractSubprocess(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def context(self) -> AbstractServerContext:
+    def context(self) -> ServerContext:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -4867,12 +4966,12 @@ class AbstractSubprocess(abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # dict[int, Dispatcher]
+    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # Dispatcher]:
         raise NotImplementedError
 
 
 @functools.total_ordering
-class AbstractProcessGroup(abc.ABC):
+class ProcessGroup(abc.ABC):
     @property
     @abc.abstractmethod
     def config(self) -> ProcessGroupConfig:
@@ -4884,12 +4983,48 @@ class AbstractProcessGroup(abc.ABC):
     def __eq__(self, other):
         return self.config.priority == other.config.priority
 
+    @abc.abstractmethod
+    def transition(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def stop_all(self) -> None:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def before_remove(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # Dispatcher]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def reopen_logs(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_unstopped_processes(self) -> ta.List[Process]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def after_setuid(self) -> None:
+        raise NotImplementedError
+
 
 ########################################
 # ../context.py
 
 
-class ServerContext(AbstractServerContext):
+ServerEpoch = ta.NewType('ServerEpoch', int)
+
+
+class ServerContextImpl(ServerContext):
     def __init__(
             self,
             config: ServerConfig,
@@ -4903,7 +5038,7 @@ class ServerContext(AbstractServerContext):
         self._poller = poller
         self._epoch = epoch
 
-        self._pid_history: ta.Dict[int, AbstractSubprocess] = {}
+        self._pid_history: ta.Dict[int, Process] = {}
         self._state: SupervisorState = SupervisorState.RUNNING
 
         if config.user is not None:
@@ -4936,7 +5071,7 @@ class ServerContext(AbstractServerContext):
         self._state = state
 
     @property
-    def pid_history(self) -> ta.Dict[int, AbstractSubprocess]:
+    def pid_history(self) -> ta.Dict[int, Process]:
         return self._pid_history
 
     @property
@@ -5283,7 +5418,7 @@ def check_execv_args(filename, argv, st) -> None:
 class Dispatcher(abc.ABC):
     def __init__(
             self,
-            process: AbstractSubprocess,
+            process: Process,
             channel: str,
             fd: int,
             *,
@@ -5302,7 +5437,7 @@ class Dispatcher(abc.ABC):
         return f'<{self.__class__.__name__} at {id(self)} for {self._process} ({self._channel})>'
 
     @property
-    def process(self) -> AbstractSubprocess:
+    def process(self) -> Process:
         return self._process
 
     @property
@@ -5357,7 +5492,7 @@ class OutputDispatcher(Dispatcher):
 
     def __init__(
             self,
-            process: AbstractSubprocess,
+            process: Process,
             event_type: ta.Type[ProcessCommunicationEvent],
             fd: int,
             **kwargs: ta.Any,
@@ -5566,7 +5701,7 @@ class OutputDispatcher(Dispatcher):
 class InputDispatcher(Dispatcher):
     def __init__(
             self,
-            process: AbstractSubprocess,
+            process: Process,
             channel: str,
             fd: int,
             **kwargs: ta.Any,
@@ -5615,31 +5750,26 @@ class InputDispatcher(Dispatcher):
 ##
 
 
-@dc.dataclass(frozen=True)
-class SubprocessFactory:
-    fn: ta.Callable[[ProcessConfig, AbstractProcessGroup], AbstractSubprocess]
+ProcessFactory = ta.NewType('ProcessFactory', Func[Process])  # (config: ProcessConfig, group: ProcessGroup)
 
-    def __call__(self, config: ProcessConfig, group: AbstractProcessGroup) -> AbstractSubprocess:
-        return self.fn(config, group)
 
-
-class ProcessGroup(AbstractProcessGroup):
+class ProcessGroupImpl(ProcessGroup):
     def __init__(
             self,
             config: ProcessGroupConfig,
             context: ServerContext,
             *,
-            subprocess_factory: SubprocessFactory,
+            process_factory: ProcessFactory,
     ):
         super().__init__()
 
         self._config = config
         self._context = context
-        self._subprocess_factory = subprocess_factory
+        self._process_factory = process_factory
 
         self._processes = {}
         for pconfig in self._config.processes or []:
-            process = self._subprocess_factory(pconfig, self)
+            process = self._process_factory(pconfig, self)
             self._processes[pconfig.name] = process
 
     @property
@@ -5651,7 +5781,7 @@ class ProcessGroup(AbstractProcessGroup):
         return self._config.name
 
     @property
-    def context(self) -> AbstractServerContext:
+    def context(self) -> ServerContext:
         return self._context
 
     def __repr__(self):
@@ -5686,7 +5816,7 @@ class ProcessGroup(AbstractProcessGroup):
                 # BACKOFF -> FATAL
                 proc.give_up()
 
-    def get_unstopped_processes(self) -> ta.List[AbstractSubprocess]:
+    def get_unstopped_processes(self) -> ta.List[Process]:
         return [x for x in self._processes.values() if not x.get_state().stopped]
 
     def get_dispatchers(self) -> ta.Dict[int, Dispatcher]:
@@ -5763,18 +5893,21 @@ class ProcessGroups:
 # ../process.py
 
 
+InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+
+
 ##
 
 
-class Subprocess(AbstractSubprocess):
+class ProcessImpl(Process):
     """A class to manage a subprocess."""
 
     def __init__(
             self,
             config: ProcessConfig,
-            group: AbstractProcessGroup,
+            group: ProcessGroup,
             *,
-            context: AbstractServerContext,
+            context: ServerContext,
             event_callbacks: EventCallbacks,
 
             inherited_fds: ta.Optional[InheritedFds] = None,
@@ -5813,7 +5946,7 @@ class Subprocess(AbstractSubprocess):
         return self._pid
 
     @property
-    def group(self) -> AbstractProcessGroup:
+    def group(self) -> ProcessGroup:
         return self._group
 
     @property
@@ -5821,7 +5954,7 @@ class Subprocess(AbstractSubprocess):
         return self._config
 
     @property
-    def context(self) -> AbstractServerContext:
+    def context(self) -> ServerContext:
         return self._context
 
     @property
@@ -6468,7 +6601,7 @@ class SignalHandler:
     def __init__(
             self,
             *,
-            context: ServerContext,
+            context: ServerContextImpl,
             signal_receiver: SignalReceiver,
             process_groups: ProcessGroups,
     ) -> None:
@@ -6520,19 +6653,14 @@ class SignalHandler:
 ##
 
 
-@dc.dataclass(frozen=True)
-class ProcessGroupFactory:
-    fn: ta.Callable[[ProcessGroupConfig], ProcessGroup]
-
-    def __call__(self, config: ProcessGroupConfig) -> ProcessGroup:
-        return self.fn(config)
+ProcessGroupFactory = ta.NewType('ProcessGroupFactory', Func[ProcessGroup])  # (config: ProcessGroupConfig)
 
 
 class Supervisor:
     def __init__(
             self,
             *,
-            context: ServerContext,
+            context: ServerContextImpl,
             poller: Poller,
             process_groups: ProcessGroups,
             signal_handler: SignalHandler,
@@ -6556,7 +6684,7 @@ class Supervisor:
     #
 
     @property
-    def context(self) -> ServerContext:
+    def context(self) -> ServerContextImpl:
         return self._context
 
     def get_state(self) -> SupervisorState:
@@ -6603,16 +6731,16 @@ class Supervisor:
         return True
 
     def get_process_map(self) -> ta.Dict[int, Dispatcher]:
-        process_map = {}
+        process_map: ta.Dict[int, Dispatcher] = {}
         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] = []
+    def shutdown_report(self) -> ta.List[Process]:
+        unstopped: ta.List[Process] = []
 
         for group in self._process_groups:
-            unstopped.extend(group.get_unstopped_processes())  # type: ignore
+            unstopped.extend(group.get_unstopped_processes())
 
         if unstopped:
             # throttle 'waiting for x to die' reports
@@ -6840,8 +6968,8 @@ def bind_server(
 
         inj.bind(get_poller_impl(), key=Poller, singleton=True),
 
-        inj.bind(ServerContext, singleton=True),
-        inj.bind(AbstractServerContext, to_key=ServerContext),
+        inj.bind(ServerContextImpl, singleton=True),
+        inj.bind(ServerContext, to_key=ServerContextImpl),
 
         inj.bind(EventCallbacks, singleton=True),
 
@@ -6850,21 +6978,10 @@ def bind_server(
         inj.bind(SignalHandler, singleton=True),
         inj.bind(ProcessGroups, singleton=True),
         inj.bind(Supervisor, singleton=True),
-    ]
 
-    #
-
-    def make_process_group_factory(injector: Injector) -> ProcessGroupFactory:
-        def inner(group_config: ProcessGroupConfig) -> ProcessGroup:
-            return injector.inject(functools.partial(ProcessGroup, group_config))
-        return ProcessGroupFactory(inner)
-    lst.append(inj.bind(make_process_group_factory))
-
-    def make_subprocess_factory(injector: Injector) -> SubprocessFactory:
-        def inner(process_config: ProcessConfig, group: AbstractProcessGroup) -> AbstractSubprocess:
-            return injector.inject(functools.partial(Subprocess, process_config, group))
-        return SubprocessFactory(inner)
-    lst.append(inj.bind(make_subprocess_factory))
+        inj.bind_factory(ProcessGroupFactory, ProcessGroupImpl),
+        inj.bind_factory(ProcessFactory, ProcessImpl),
+    ]
 
     #
 
@@ -6933,7 +7050,7 @@ def main(
             inherited_fds=inherited_fds,
         ))
 
-        context = injector[ServerContext]
+        context = injector[ServerContextImpl]
         supervisor = injector[Supervisor]
 
         try: