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

ominfra/scripts/supervisor.py

@@ -95,6 +95,10 @@ TomlParseFloat = ta.Callable[[str], ta.Any]
 TomlKey = ta.Tuple[str, ...]
 TomlPos = int  # ta.TypeAlias
 
+# ../collections.py
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
 # ../../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 
@@ -102,6 +106,11 @@ T = ta.TypeVar('T')
 SocketAddress = ta.Any
 SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
 
+# ../../../omlish/lite/typing.py
+A0 = ta.TypeVar('A0')
+A1 = ta.TypeVar('A1')
+A2 = ta.TypeVar('A2')
+
 # ../events.py
 EventCallback = ta.Callable[['Event'], None]
 
@@ -109,6 +118,7 @@ EventCallback = ta.Callable[['Event'], None]
 HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
 
 # ../../../omlish/lite/inject.py
+U = ta.TypeVar('U')
 InjectorKeyCls = ta.Union[type, ta.NewType]
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
 InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
@@ -942,6 +952,55 @@ def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
     return safe_parse_float
 
 
+########################################
+# ../collections.py
+
+
+class KeyedCollectionAccessors(abc.ABC, ta.Generic[K, V]):
+    @property
+    @abc.abstractmethod
+    def _by_key(self) -> ta.Mapping[K, V]:
+        raise NotImplementedError
+
+    def __iter__(self) -> ta.Iterator[V]:
+        return iter(self._by_key.values())
+
+    def __len__(self) -> int:
+        return len(self._by_key)
+
+    def __contains__(self, key: K) -> bool:
+        return key in self._by_key
+
+    def __getitem__(self, key: K) -> V:
+        return self._by_key[key]
+
+    def get(self, key: K, default: ta.Optional[V] = None) -> ta.Optional[V]:
+        return self._by_key.get(key, default)
+
+    def items(self) -> ta.Iterator[ta.Tuple[K, V]]:
+        return iter(self._by_key.items())
+
+
+class KeyedCollection(KeyedCollectionAccessors[K, V]):
+    def __init__(self, items: ta.Iterable[V]) -> None:
+        super().__init__()
+
+        by_key: ta.Dict[K, V] = {}
+        for v in items:
+            if (k := self._key(v)) in by_key:
+                raise KeyError(f'key {k} of {v} already registered by {by_key[k]}')
+            by_key[k] = v
+        self.__by_key = by_key
+
+    @property
+    def _by_key(self) -> ta.Mapping[K, V]:
+        return self.__by_key
+
+    @abc.abstractmethod
+    def _key(self, v: V) -> K:
+        raise NotImplementedError
+
+
 ########################################
 # ../datatypes.py
 
@@ -975,43 +1034,7 @@ def logfile_name(val):
         return existing_dirpath(val)
 
 
-def name_to_uid(name: str) -> int:
-    try:
-        uid = int(name)
-    except ValueError:
-        try:
-            pwdrec = pwd.getpwnam(name)
-        except KeyError:
-            raise ValueError(f'Invalid user name {name}')  # noqa
-        uid = pwdrec[2]
-    else:
-        try:
-            pwd.getpwuid(uid)  # check if uid is valid
-        except KeyError:
-            raise ValueError(f'Invalid user id {name}')  # noqa
-    return uid
-
-
-def name_to_gid(name: str) -> int:
-    try:
-        gid = int(name)
-    except ValueError:
-        try:
-            grprec = grp.getgrnam(name)
-        except KeyError:
-            raise ValueError(f'Invalid group name {name}')  # noqa
-        gid = grprec[2]
-    else:
-        try:
-            grp.getgrgid(gid)  # check if gid is valid
-        except KeyError:
-            raise ValueError(f'Invalid group id {name}')  # noqa
-    return gid
-
-
-def gid_for_uid(uid: int) -> int:
-    pwrec = pwd.getpwuid(uid)
-    return pwrec[3]
+##
 
 
 def octal_type(arg: ta.Union[str, int]) -> int:
@@ -1083,29 +1106,6 @@ byte_size = SuffixMultiplier({
 })
 
 
-# all valid signal numbers
-SIGNUMS = [getattr(signal, k) for k in dir(signal) if k.startswith('SIG')]
-
-
-def signal_number(value: ta.Union[int, str]) -> int:
-    try:
-        num = int(value)
-
-    except (ValueError, TypeError):
-        name = value.strip().upper()  # type: ignore
-        if not name.startswith('SIG'):
-            name = f'SIG{name}'
-
-        num = getattr(signal, name, None)  # type: ignore
-        if num is None:
-            raise ValueError(f'value {value!r} is not a valid signal name')  # noqa
-
-    if num not in SIGNUMS:
-        raise ValueError(f'value {value!r} is not a valid signal number')
-
-    return num
-
-
 class RestartWhenExitUnexpected:
     pass
 
@@ -1144,6 +1144,70 @@ class NoPermissionError(ProcessError):
     """
 
 
+########################################
+# ../privileges.py
+
+
+def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
+    """
+    Drop privileges to become the specified user, which may be a username or uid.  Called for supervisord startup
+    and when spawning subprocesses.  Returns None on success or a string error message if privileges could not be
+    dropped.
+    """
+
+    if user is None:
+        return 'No user specified to setuid to!'
+
+    # get uid for user, which can be a number or username
+    try:
+        uid = int(user)
+    except ValueError:
+        try:
+            pwrec = pwd.getpwnam(user)  # type: ignore
+        except KeyError:
+            return f"Can't find username {user!r}"
+        uid = pwrec[2]
+    else:
+        try:
+            pwrec = pwd.getpwuid(uid)
+        except KeyError:
+            return f"Can't find uid {uid!r}"
+
+    current_uid = os.getuid()
+
+    if current_uid == uid:
+        # do nothing and return successfully if the uid is already the current one.  this allows a supervisord
+        # running as an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in
+        # it.
+        return None
+
+    if current_uid != 0:
+        return "Can't drop privilege as nonroot user"
+
+    gid = pwrec[3]
+    if hasattr(os, 'setgroups'):
+        user = pwrec[0]
+        groups = [grprec[2] for grprec in grp.getgrall() if user in grprec[3]]
+
+        # always put our primary gid first in this list, otherwise we can lose group info since sometimes the first
+        # group in the setgroups list gets overwritten on the subsequent setgid call (at least on freebsd 9 with
+        # python 2.7 - this will be safe though for all unix /python version combos)
+        groups.insert(0, gid)
+        try:
+            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
+
+
 ########################################
 # ../signals.py
 
@@ -1151,25 +1215,33 @@ class NoPermissionError(ProcessError):
 ##
 
 
-_SIG_NAMES: ta.Optional[ta.Mapping[int, str]] = None
+_SIGS_BY_NUM: ta.Mapping[int, signal.Signals] = {s.value: s for s in signal.Signals}
+_SIGS_BY_NAME: ta.Mapping[str, signal.Signals] = {s.name: s for s in signal.Signals}
 
 
-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 sig_num(value: ta.Union[int, str]) -> int:
+    try:
+        num = int(value)
 
+    except (ValueError, TypeError):
+        name = value.strip().upper()  # type: ignore
+        if not name.startswith('SIG'):
+            name = f'SIG{name}'
+
+        if (sn := _SIGS_BY_NAME.get(name)) is None:
+            raise ValueError(f'value {value!r} is not a valid signal name')  # noqa
+        num = sn
+
+    if num not in _SIGS_BY_NUM:
+        raise ValueError(f'value {value!r} is not a valid signal number')
+
+    return num
 
-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
+
+def sig_name(num: int) -> str:
+    if (sig := _SIGS_BY_NUM.get(num)) is not None:
+        return sig.name
+    return f'signal {sig}'
 
 
 ##
@@ -1181,7 +1253,7 @@ class SignalReceiver:
 
         self._signals_recvd: ta.List[int] = []
 
-    def receive(self, sig: int, frame: ta.Any) -> None:
+    def receive(self, sig: int, frame: ta.Any = None) -> None:
         if sig not in self._signals_recvd:
             self._signals_recvd.append(sig)
 
@@ -1257,6 +1329,70 @@ class SupervisorState(enum.IntEnum):
     SHUTDOWN = -1
 
 
+########################################
+# ../users.py
+
+
+##
+
+
+def name_to_uid(name: str) -> int:
+    try:
+        uid = int(name)
+    except ValueError:
+        try:
+            pwdrec = pwd.getpwnam(name)
+        except KeyError:
+            raise ValueError(f'Invalid user name {name}')  # noqa
+        uid = pwdrec[2]
+    else:
+        try:
+            pwd.getpwuid(uid)  # check if uid is valid
+        except KeyError:
+            raise ValueError(f'Invalid user id {name}')  # noqa
+    return uid
+
+
+def name_to_gid(name: str) -> int:
+    try:
+        gid = int(name)
+    except ValueError:
+        try:
+            grprec = grp.getgrnam(name)
+        except KeyError:
+            raise ValueError(f'Invalid group name {name}')  # noqa
+        gid = grprec[2]
+    else:
+        try:
+            grp.getgrgid(gid)  # check if gid is valid
+        except KeyError:
+            raise ValueError(f'Invalid group id {name}')  # noqa
+    return gid
+
+
+def gid_for_uid(uid: int) -> int:
+    pwrec = pwd.getpwuid(uid)
+    return pwrec[3]
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class User:
+    name: str
+    uid: int
+    gid: int
+
+
+def get_user(name: str) -> User:
+    return User(
+        name=name,
+        uid=(uid := name_to_uid(name)),
+        gid=gid_for_uid(uid),
+    )
+
+
 ########################################
 # ../../../omlish/lite/cached.py
 
@@ -1566,14 +1702,50 @@ class SocketHandler(abc.ABC):
 # ../../../omlish/lite/typing.py
 
 
+##
+# A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+
+
 @dc.dataclass(frozen=True)
-class Func(ta.Generic[T]):
+class AnyFunc(ta.Generic[T]):
     fn: ta.Callable[..., T]
 
     def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
         return self.fn(*args, **kwargs)
 
 
+@dc.dataclass(frozen=True)
+class Func0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        return self.fn()
+
+
+@dc.dataclass(frozen=True)
+class Func1(ta.Generic[A0, T]):
+    fn: ta.Callable[[A0], T]
+
+    def __call__(self, a0: A0) -> T:
+        return self.fn(a0)
+
+
+@dc.dataclass(frozen=True)
+class Func2(ta.Generic[A0, A1, T]):
+    fn: ta.Callable[[A0, A1], T]
+
+    def __call__(self, a0: A0, a1: A1) -> T:
+        return self.fn(a0, a1)
+
+
+@dc.dataclass(frozen=True)
+class Func3(ta.Generic[A0, A1, A2, T]):
+    fn: ta.Callable[[A0, A1, A2], T]
+
+    def __call__(self, a0: A0, a1: A1, a2: A2) -> T:
+        return self.fn(a0, a1, a2)
+
+
 ########################################
 # ../events.py
 
@@ -1860,37 +2032,74 @@ def get_event_name_by_type(requested):
 
 
 ########################################
-# ../utils.py
+# ../setup.py
 
 
 ##
 
 
-def as_bytes(s: ta.Union[str, bytes], encoding: str = 'utf8') -> bytes:
-    if isinstance(s, bytes):
-        return s
-    else:
-        return s.encode(encoding)
+SupervisorUser = ta.NewType('SupervisorUser', User)
 
 
-def as_string(s: ta.Union[str, bytes], encoding: str = 'utf8') -> str:
-    if isinstance(s, str):
-        return s
-    else:
-        return s.decode(encoding)
+##
 
 
-def find_prefix_at_end(haystack: bytes, needle: bytes) -> int:
-    l = len(needle) - 1
-    while l and not haystack.endswith(needle[:l]):
-        l -= 1
-    return l
+class DaemonizeListener(abc.ABC):  # noqa
+    def before_daemonize(self) -> None:  # noqa
+        pass
 
+    def after_daemonize(self) -> None:  # noqa
+        pass
 
-##
 
+DaemonizeListeners = ta.NewType('DaemonizeListeners', ta.Sequence[DaemonizeListener])
 
-def compact_traceback() -> ta.Tuple[
+
+##
+
+
+class SupervisorSetup(abc.ABC):
+    @abc.abstractmethod
+    def setup(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def cleanup(self) -> None:
+        raise NotImplementedError
+
+
+########################################
+# ../utils.py
+
+
+##
+
+
+def as_bytes(s: ta.Union[str, bytes], encoding: str = 'utf8') -> bytes:
+    if isinstance(s, bytes):
+        return s
+    else:
+        return s.encode(encoding)
+
+
+def as_string(s: ta.Union[str, bytes], encoding: str = 'utf8') -> str:
+    if isinstance(s, str):
+        return s
+    else:
+        return s.decode(encoding)
+
+
+def find_prefix_at_end(haystack: bytes, needle: bytes) -> int:
+    l = len(needle) - 1
+    while l and not haystack.endswith(needle[:l]):
+        l -= 1
+    return l
+
+
+##
+
+
+def compact_traceback() -> ta.Tuple[
     ta.Tuple[str, str, int],
     ta.Type[BaseException],
     BaseException,
@@ -2059,6 +2268,41 @@ def timeslice(period: int, when: float) -> int:
 
 ########################################
 # ../../../omlish/lite/http/parsing.py
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
+# alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
 
 
 ##
@@ -2489,11 +2733,23 @@ class Injector(abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+    def provide_kwargs(
+            self,
+            obj: ta.Any,
+            *,
+            skip_args: int = 0,
+            skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+    ) -> ta.Mapping[str, ta.Any]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def inject(self, obj: ta.Any) -> ta.Any:
+    def inject(
+            self,
+            obj: ta.Any,
+            *,
+            args: ta.Optional[ta.Sequence[ta.Any]] = None,
+            kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Any:
         raise NotImplementedError
 
     def __getitem__(
@@ -2507,8 +2763,12 @@ class Injector(abc.ABC):
 # exceptions
 
 
+class InjectorError(Exception):
+    pass
+
+
 @dc.dataclass(frozen=True)
-class InjectorKeyError(Exception):
+class InjectorKeyError(InjectorError):
     key: InjectorKey
 
     source: ta.Any = None
@@ -2715,29 +2975,49 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 # inspection
 
 
-# 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]
+    args_offset: int
 
 
 _INJECTION_INSPECTION_CACHE: ta.MutableMapping[ta.Any, _InjectionInspection] = weakref.WeakKeyDictionary()
 
 
 def _do_injection_inspect(obj: ta.Any) -> _InjectionInspection:
-    uw = obj
+    tgt = obj
+    if isinstance(tgt, type) and tgt.__init__ is not object.__init__:  # type: ignore[misc]
+        # Python 3.8's inspect.signature can't handle subclasses overriding __new__, always generating *args/**kwargs.
+        #  - https://bugs.python.org/issue40897
+        #  - https://github.com/python/cpython/commit/df7c62980d15acd3125dfbd81546dad359f7add7
+        tgt = tgt.__init__  # type: ignore[misc]
+        has_generic_base = True
+    else:
+        has_generic_base = False
+
+    # 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.
+    uw = tgt
+    has_partial = False
     while True:
         if isinstance(uw, functools.partial):
+            has_partial = True
             uw = uw.func
         else:
             if (uw2 := inspect.unwrap(uw)) is uw:
                 break
             uw = uw2
 
+    if has_generic_base and has_partial:
+        raise InjectorError(
+            'Injector inspection does not currently support both a typing.Generic base and a functools.partial: '
+            f'{obj}',
+        )
+
     return _InjectionInspection(
-        inspect.signature(obj),
+        inspect.signature(tgt),
         ta.get_type_hints(uw),
+        1 if has_generic_base else 0,
     )
 
 
@@ -2768,14 +3048,23 @@ def build_injection_kwargs_target(
         obj: ta.Any,
         *,
         skip_args: int = 0,
-        skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+        skip_kwargs: ta.Optional[ta.Iterable[str]] = None,
         raw_optional: bool = False,
 ) -> InjectionKwargsTarget:
     insp = _injection_inspect(obj)
 
-    seen: ta.Set[InjectorKey] = set(map(as_injector_key, skip_kwargs)) if skip_kwargs is not None else set()
+    params = list(insp.signature.parameters.values())
+
+    skip_names: ta.Set[str] = set()
+    if skip_kwargs is not None:
+        skip_names.update(check_not_isinstance(skip_kwargs, str))
+
+    seen: ta.Set[InjectorKey] = set()
     kws: ta.List[InjectionKwarg] = []
-    for p in list(insp.signature.parameters.values())[skip_args:]:
+    for p in params[insp.args_offset + skip_args:]:
+        if p.name in skip_names:
+            continue
+
         if p.annotation is inspect.Signature.empty:
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
@@ -2784,6 +3073,7 @@ def build_injection_kwargs_target(
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
             raise TypeError(insp)
 
+        # 3.8 inspect.signature doesn't eval_str but typing.get_type_hints does, so prefer that.
         ann = insp.type_hints.get(p.name, p.annotation)
         if (
                 not raw_optional and
@@ -2851,8 +3141,19 @@ class _Injector(Injector):
             return v.must()
         raise UnboundInjectorKeyError(key)
 
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
-        kt = build_injection_kwargs_target(obj)
+    def provide_kwargs(
+            self,
+            obj: ta.Any,
+            *,
+            skip_args: int = 0,
+            skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+    ) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(
+            obj,
+            skip_args=skip_args,
+            skip_kwargs=skip_kwargs,
+        )
+
         ret: ta.Dict[str, ta.Any] = {}
         for kw in kt.kwargs:
             if kw.has_default:
@@ -2864,9 +3165,24 @@ class _Injector(Injector):
             ret[kw.name] = v
         return ret
 
-    def inject(self, obj: ta.Any) -> ta.Any:
-        kws = self.provide_kwargs(obj)
-        return obj(**kws)
+    def inject(
+            self,
+            obj: ta.Any,
+            *,
+            args: ta.Optional[ta.Sequence[ta.Any]] = None,
+            kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Any:
+        provided = self.provide_kwargs(
+            obj,
+            skip_args=len(args) if args is not None else 0,
+            skip_kwargs=kwargs if kwargs is not None else None,
+        )
+
+        return obj(
+            *(args if args is not None else ()),
+            **(kwargs if kwargs is not None else {}),
+            **provided,
+        )
 
 
 ###
@@ -3005,16 +3321,42 @@ class InjectorBinder:
 
 
 def make_injector_factory(
-        factory_cls: ta.Any,
-        factory_fn: ta.Callable[..., T],
-) -> ta.Callable[..., Func[T]]:
-    def outer(injector: Injector) -> factory_cls:
+        fn: ta.Callable[..., T],
+        cls: U,
+        ann: ta.Any = None,
+) -> ta.Callable[..., U]:
+    if ann is None:
+        ann = cls
+
+    def outer(injector: Injector) -> ann:
         def inner(*args, **kwargs):
-            return injector.inject(functools.partial(factory_fn, *args, **kwargs))
-        return Func(inner)
+            return injector.inject(fn, args=args, kwargs=kwargs)
+        return cls(inner)  # type: ignore
+
     return outer
 
 
+def make_injector_array_type(
+        ele: ta.Union[InjectorKey, InjectorKeyCls],
+        cls: U,
+        ann: ta.Any = None,
+) -> ta.Callable[..., U]:
+    if isinstance(ele, InjectorKey):
+        if not ele.array:
+            raise InjectorError('Provided key must be array', ele)
+        key = ele
+    else:
+        key = dc.replace(as_injector_key(ele), array=True)
+
+    if ann is None:
+        ann = cls
+
+    def inner(injector: Injector) -> ann:
+        return cls(injector.provide(key))  # type: ignore[operator]
+
+    return inner
+
+
 ##
 
 
@@ -3049,8 +3391,8 @@ class Injection:
     # injector
 
     @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
-        return _Injector(as_injector_bindings(*args), p)
+    def create_injector(cls, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), parent)
 
     # binder
 
@@ -3090,10 +3432,20 @@ class Injection:
     @classmethod
     def bind_factory(
             cls,
-            factory_cls: ta.Any,
-            factory_fn: ta.Callable[..., T],
+            fn: ta.Callable[..., T],
+            cls_: U,
+            ann: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_factory(fn, cls_, ann))
+
+    @classmethod
+    def bind_array_type(
+            cls,
+            ele: ta.Union[InjectorKey, InjectorKeyCls],
+            cls_: U,
+            ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_factory(factory_cls, factory_fn))
+        return cls.bind(make_injector_array_type(ele, cls_, ann))
 
 
 inj = Injection
@@ -3344,7 +3696,7 @@ class StandardLogFormatter(logging.Formatter):
             return ct.strftime(datefmt)  # noqa
         else:
             t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)
+            return '%s.%03d' % (t, record.msecs)  # noqa
 
 
 ##
@@ -3930,11 +4282,91 @@ def build_config_named_children(
     return lst
 
 
+########################################
+# ../pipes.py
+
+
+@dc.dataclass(frozen=True)
+class ProcessPipes:
+    child_stdin: ta.Optional[int] = None
+    stdin: ta.Optional[int] = None
+
+    stdout: ta.Optional[int] = None
+    child_stdout: ta.Optional[int] = None
+
+    stderr: ta.Optional[int] = None
+    child_stderr: ta.Optional[int] = None
+
+    def child_fds(self) -> ta.List[int]:
+        return [fd for fd in [self.child_stdin, self.child_stdout, self.child_stderr] if fd is not None]
+
+    def parent_fds(self) -> ta.List[int]:
+        return [fd for fd in [self.stdin, self.stdout, self.stderr] if fd is not None]
+
+
+def make_process_pipes(stderr=True) -> ProcessPipes:
+    """
+    Create pipes for parent to child stdin/stdout/stderr communications.  Open fd in non-blocking mode so we can
+    read them in the mainloop without blocking.  If stderr is False, don't create a pipe for stderr.
+    """
+
+    pipes: ta.Dict[str, ta.Optional[int]] = {
+        'child_stdin': None,
+        'stdin': None,
+
+        'stdout': None,
+        'child_stdout': None,
+
+        'stderr': None,
+        'child_stderr': None,
+    }
+
+    try:
+        pipes['child_stdin'], pipes['stdin'] = os.pipe()
+        pipes['stdout'], pipes['child_stdout'] = os.pipe()
+
+        if stderr:
+            pipes['stderr'], pipes['child_stderr'] = os.pipe()
+
+        for fd in (
+                pipes['stdout'],
+                pipes['stderr'],
+                pipes['stdin'],
+        ):
+            if fd is not None:
+                flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NDELAY
+                fcntl.fcntl(fd, fcntl.F_SETFL, flags)
+
+        return ProcessPipes(**pipes)
+
+    except OSError:
+        for fd in pipes.values():
+            if fd is not None:
+                close_fd(fd)
+
+        raise
+
+
+def close_pipes(pipes: ProcessPipes) -> None:
+    close_parent_pipes(pipes)
+    close_child_pipes(pipes)
+
+
+def close_parent_pipes(pipes: ProcessPipes) -> None:
+    for fd in pipes.parent_fds():
+        close_fd(fd)
+
+
+def close_child_pipes(pipes: ProcessPipes) -> None:
+    for fd in pipes.child_fds():
+        close_fd(fd)
+
+
 ########################################
 # ../poller.py
 
 
-class Poller(abc.ABC):
+class Poller(DaemonizeListener, abc.ABC):
     def __init__(self) -> None:
         super().__init__()
 
@@ -4152,8 +4584,9 @@ else:
 
 def get_poller_impl() -> ta.Type[Poller]:
     if (
-            sys.platform == 'darwin' or sys.platform.startswith('freebsd') and
-            hasattr(select, 'kqueue') and KqueuePoller is not None
+            (sys.platform == 'darwin' or sys.platform.startswith('freebsd')) and
+            hasattr(select, 'kqueue') and
+            KqueuePoller is not None
     ):
         return KqueuePoller
     elif hasattr(select, 'poll'):
@@ -4877,6 +5310,32 @@ class CoroHttpServerSocketHandler(SocketHandler):
 # ../types.py
 
 
+##
+
+
+ServerEpoch = ta.NewType('ServerEpoch', int)
+
+
+##
+
+
+@functools.total_ordering
+class ConfigPriorityOrdered(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def config(self) -> ta.Any:
+        raise NotImplementedError
+
+    def __lt__(self, other):
+        return self.config.priority < other.config.priority
+
+    def __eq__(self, other):
+        return self.config.priority == other.config.priority
+
+
+##
+
+
 class ServerContext(abc.ABC):
     @property
     @abc.abstractmethod
@@ -4898,114 +5357,166 @@ class ServerContext(abc.ABC):
         raise NotImplementedError
 
 
-# class Dispatcher(abc.ABC):
-#     pass
-#
-#
-# class OutputDispatcher(Dispatcher, abc.ABC):
-#     pass
-#
-#
-# class InputDispatcher(Dispatcher, abc.ABC):
-#     pass
+##
 
 
-@functools.total_ordering
-class Process(abc.ABC):
+class Dispatcher(abc.ABC):
     @property
     @abc.abstractmethod
-    def pid(self) -> int:
+    def process(self) -> 'Process':
         raise NotImplementedError
 
     @property
     @abc.abstractmethod
-    def config(self) -> ProcessConfig:
+    def channel(self) -> str:
         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) -> ServerContext:
+    def fd(self) -> int:
         raise NotImplementedError
 
+    @property
     @abc.abstractmethod
-    def finish(self, sts: int) -> None:
+    def closed(self) -> bool:
         raise NotImplementedError
 
+    #
+
     @abc.abstractmethod
-    def remove_logs(self) -> None:
+    def close(self) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def reopen_logs(self) -> None:
+    def handle_error(self) -> None:
         raise NotImplementedError
 
+    #
+
     @abc.abstractmethod
-    def stop(self) -> ta.Optional[str]:
+    def readable(self) -> bool:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def give_up(self) -> None:
+    def writable(self) -> bool:
         raise NotImplementedError
 
+    #
+
+    def handle_read_event(self) -> None:
+        raise TypeError
+
+    def handle_write_event(self) -> None:
+        raise TypeError
+
+
+class OutputDispatcher(Dispatcher, abc.ABC):
     @abc.abstractmethod
-    def transition(self) -> None:
+    def remove_logs(self) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get_state(self) -> ProcessState:
+    def reopen_logs(self) -> None:
         raise NotImplementedError
 
+
+class InputDispatcher(Dispatcher, abc.ABC):
     @abc.abstractmethod
-    def create_auto_child_logs(self) -> None:
+    def write(self, chars: ta.Union[bytes, str]) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # Dispatcher]:
+    def flush(self) -> None:
         raise NotImplementedError
 
 
-@functools.total_ordering
-class ProcessGroup(abc.ABC):
+##
+
+
+class Process(ConfigPriorityOrdered, abc.ABC):
     @property
     @abc.abstractmethod
-    def config(self) -> ProcessGroupConfig:
+    def name(self) -> str:
         raise NotImplementedError
 
-    def __lt__(self, other):
-        return self.config.priority < other.config.priority
+    @property
+    @abc.abstractmethod
+    def config(self) -> ProcessConfig:
+        raise NotImplementedError
 
-    def __eq__(self, other):
-        return self.config.priority == other.config.priority
+    @property
+    @abc.abstractmethod
+    def group(self) -> 'ProcessGroup':
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def pid(self) -> int:
+        raise NotImplementedError
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def context(self) -> ServerContext:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def finish(self, sts: int) -> 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 stop_all(self) -> None:
+    def get_state(self) -> ProcessState:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def after_setuid(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_dispatchers(self) -> 'Dispatchers':
         raise NotImplementedError
 
+
+##
+
+
+class ProcessGroup(
+    ConfigPriorityOrdered,
+    KeyedCollectionAccessors[str, Process],
+    abc.ABC,
+):
     @property
     @abc.abstractmethod
     def name(self) -> str:
         raise NotImplementedError
 
+    @property
     @abc.abstractmethod
-    def before_remove(self) -> None:
+    def config(self) -> ProcessGroupConfig:
         raise NotImplementedError
 
+    @property
     @abc.abstractmethod
-    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # Dispatcher]:
+    def by_name(self) -> ta.Mapping[str, Process]:
         raise NotImplementedError
 
+    #
+
     @abc.abstractmethod
-    def reopen_logs(self) -> None:
+    def stop_all(self) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -5013,7 +5524,7 @@ class ProcessGroup(abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def after_setuid(self) -> None:
+    def before_remove(self) -> None:
         raise NotImplementedError
 
 
@@ -5021,9 +5532,6 @@ class ProcessGroup(abc.ABC):
 # ../context.py
 
 
-ServerEpoch = ta.NewType('ServerEpoch', int)
-
-
 class ServerContextImpl(ServerContext):
     def __init__(
             self,
@@ -5041,16 +5549,6 @@ class ServerContextImpl(ServerContext):
         self._pid_history: ta.Dict[int, Process] = {}
         self._state: SupervisorState = SupervisorState.RUNNING
 
-        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._unlink_pidfile = False
-
     @property
     def config(self) -> ServerConfig:
         return self._config
@@ -5074,15 +5572,7 @@ class ServerContextImpl(ServerContext):
     def pid_history(self) -> ta.Dict[int, Process]:
         return self._pid_history
 
-    @property
-    def uid(self) -> ta.Optional[int]:
-        return self._uid
-
-    @property
-    def gid(self) -> ta.Optional[int]:
-        return self._gid
-
-    ##
+    #
 
     def waitpid(self) -> ta.Tuple[ta.Optional[int], ta.Optional[int]]:
         # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
@@ -5102,386 +5592,108 @@ class ServerContextImpl(ServerContext):
             pid, sts = None, None
         return pid, sts
 
-    def set_uid_or_exit(self) -> None:
-        """
-        Set the uid of the supervisord process.  Called during supervisord startup only.  No return value.  Exits the
-        process via usage() if privileges could not be dropped.
-        """
+    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
 
-        if self.uid is None:
-            if os.getuid() == 0:
-                warnings.warn(
-                    'Supervisor is running as root.  Privileges were not dropped because no user is specified in the '
-                    'config file.  If you intend to run as root, you can set user=root in the config file to avoid '
-                    'this message.',
-                )
-        else:
-            msg = drop_privileges(self.uid)
-            if msg is None:
-                log.info('Set uid to user %s succeeded', self.uid)
-            else:  # failed to drop privileges
-                raise RuntimeError(msg)
 
-    def set_rlimits_or_exit(self) -> None:
-        """
-        Set the rlimits of the supervisord process.  Called during supervisord startup only.  No return value.  Exits
-        the process via usage() if any rlimits could not be set.
-        """
+########################################
+# ../dispatchers.py
 
-        limits = []
 
-        if hasattr(resource, 'RLIMIT_NOFILE'):
-            limits.append({
-                'msg': (
-                    'The minimum number of file descriptors required to run this process is %(min_limit)s as per the '
-                    '"minfds" command-line argument or config file setting. The current environment will only allow '
-                    'you to open %(hard)s file descriptors.  Either raise the number of usable file descriptors in '
-                    'your environment (see README.rst) or lower the minfds setting in the config file to allow the '
-                    'process to start.'
-                ),
-                'min': self.config.minfds,
-                'resource': resource.RLIMIT_NOFILE,
-                'name': 'RLIMIT_NOFILE',
-            })
+class Dispatchers(KeyedCollection[int, Dispatcher]):
+    def _key(self, v: Dispatcher) -> int:
+        return v.fd
 
-        if hasattr(resource, 'RLIMIT_NPROC'):
-            limits.append({
-                'msg': (
-                    'The minimum number of available processes required to run this program is %(min_limit)s as per '
-                    'the "minprocs" command-line argument or config file setting. The current environment will only '
-                    'allow you to open %(hard)s processes.  Either raise the number of usable processes in your '
-                    'environment (see README.rst) or lower the minprocs setting in the config file to allow the '
-                    'program to start.'
-                ),
-                'min': self.config.minprocs,
-                'resource': resource.RLIMIT_NPROC,
-                'name': 'RLIMIT_NPROC',
-            })
+    #
 
-        for limit in limits:
-            min_limit = limit['min']
-            res = limit['resource']
-            msg = limit['msg']
-            name = limit['name']
+    def drain(self) -> None:
+        for d in self:
+            # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
+            # dispatcher (eg. call handle_listener_state_change for event listener processes)
+            if d.readable():
+                d.handle_read_event()
+            if d.writable():
+                d.handle_write_event()
 
-            soft, hard = resource.getrlimit(res)  # type: ignore
+    #
 
-            # -1 means unlimited
-            if soft < min_limit and soft != -1:  # type: ignore
-                if hard < min_limit and hard != -1:  # type: ignore
-                    # setrlimit should increase the hard limit if we are root, if not then setrlimit raises and we print
-                    # usage
-                    hard = min_limit  # type: ignore
+    def remove_logs(self) -> None:
+        for d in self:
+            if isinstance(d, OutputDispatcher):
+                d.remove_logs()
 
-                try:
-                    resource.setrlimit(res, (min_limit, hard))  # type: ignore
-                    log.info('Increased %s limit to %s', name, min_limit)
-                except (resource.error, ValueError):
-                    raise RuntimeError(msg % dict(  # type: ignore  # noqa
-                        min_limit=min_limit,
-                        res=res,
-                        name=name,
-                        soft=soft,
-                        hard=hard,
-                    ))
+    def reopen_logs(self) -> None:
+        for d in self:
+            if isinstance(d, OutputDispatcher):
+                d.reopen_logs()
 
-    def cleanup(self) -> None:
-        if self._unlink_pidfile:
-            try_unlink(self.config.pidfile)
-        self._poller.close()
 
-    def cleanup_fds(self) -> None:
-        # try to close any leaked file descriptors (for reload)
-        start = 5
-        os.closerange(start, self.config.minfds)
+########################################
+# ../dispatchersimpl.py
 
-    def clear_auto_child_logdir(self) -> None:
-        # must be called after realize()
-        child_logdir = self.config.child_logdir
-        fnre = re.compile(rf'.+?---{self.config.identifier}-\S+\.log\.?\d{{0,4}}')
-        try:
-            filenames = os.listdir(child_logdir)
-        except OSError:
-            log.warning('Could not clear child_log dir')
-            return
 
-        for filename in filenames:
-            if fnre.match(filename):
-                pathname = os.path.join(child_logdir, filename)
-                try:
-                    os.remove(pathname)
-                except OSError:
-                    log.warning('Failed to clean up %r', pathname)
+class BaseDispatcherImpl(Dispatcher, abc.ABC):
+    def __init__(
+            self,
+            process: Process,
+            channel: str,
+            fd: int,
+            *,
+            event_callbacks: EventCallbacks,
+    ) -> None:
+        super().__init__()
 
-    def daemonize(self) -> None:
-        self._poller.before_daemonize()
-        self._daemonize()
-        self._poller.after_daemonize()
+        self._process = process  # process which "owns" this dispatcher
+        self._channel = channel  # 'stderr' or 'stdout'
+        self._fd = fd
+        self._event_callbacks = event_callbacks
 
-    def _daemonize(self) -> None:
-        # To daemonize, we need to become the leader of our own session (process) group.  If we do not, signals sent to
-        # our parent process will also be sent to us.   This might be bad because signals such as SIGINT can be sent to
-        # our parent process during normal (uninteresting) operations such as when we press Ctrl-C in the parent
-        # terminal window to escape from a logtail command. To disassociate ourselves from our parent's session group we
-        # use os.setsid.  It means "set session id", which has the effect of disassociating a process from is current
-        # session and process group and setting itself up as a new session leader.
-        #
-        # Unfortunately we cannot call setsid if we're already a session group leader, so we use "fork" to make a copy
-        # of ourselves that is guaranteed to not be a session group leader.
-        #
-        # We also change directories, set stderr and stdout to null, and change our umask.
-        #
-        # This explanation was (gratefully) garnered from
-        # http://www.cems.uwe.ac.uk/~irjohnso/coursenotes/lrc/system/daemons/d3.htm
+        self._closed = False  # True if close() has been called
 
-        pid = os.fork()
-        if pid != 0:
-            # Parent
-            log.debug('supervisord forked; parent exiting')
-            real_exit(0)
+    #
 
-        # Child
-        log.info('daemonizing the supervisord process')
-        if self.config.directory:
-            try:
-                os.chdir(self.config.directory)
-            except OSError as err:
-                log.critical("can't chdir into %r: %s", self.config.directory, err)
-            else:
-                log.info('set current directory: %r', self.config.directory)
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__} at {id(self)} for {self._process} ({self._channel})>'
 
-        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()
+    @property
+    def process(self) -> Process:
+        return self._process
 
-        os.umask(self.config.umask)
+    @property
+    def channel(self) -> str:
+        return self._channel
 
-        # 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.
+    @property
+    def fd(self) -> int:
+        return self._fd
 
-    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
+    @property
+    def closed(self) -> bool:
+        return self._closed
 
-    def write_pidfile(self) -> None:
-        pid = os.getpid()
-        try:
-            with open(self.config.pidfile, 'w') as f:
-                f.write(f'{pid}\n')
-        except OSError:
-            log.critical('could not write pidfile %s', self.config.pidfile)
-        else:
-            self._unlink_pidfile = True
-            log.info('supervisord started with pid %s', pid)
+    #
 
+    def close(self) -> None:
+        if not self._closed:
+            log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
+            self._closed = True
 
-def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
-    """
-    Drop privileges to become the specified user, which may be a username or uid.  Called for supervisord startup
-    and when spawning subprocesses.  Returns None on success or a string error message if privileges could not be
-    dropped.
-    """
-
-    if user is None:
-        return 'No user specified to setuid to!'
-
-    # get uid for user, which can be a number or username
-    try:
-        uid = int(user)
-    except ValueError:
-        try:
-            pwrec = pwd.getpwnam(user)  # type: ignore
-        except KeyError:
-            return f"Can't find username {user!r}"
-        uid = pwrec[2]
-    else:
-        try:
-            pwrec = pwd.getpwuid(uid)
-        except KeyError:
-            return f"Can't find uid {uid!r}"
-
-    current_uid = os.getuid()
-
-    if current_uid == uid:
-        # do nothing and return successfully if the uid is already the current one.  this allows a supervisord
-        # running as an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in
-        # it.
-        return None
-
-    if current_uid != 0:
-        return "Can't drop privilege as nonroot user"
-
-    gid = pwrec[3]
-    if hasattr(os, 'setgroups'):
-        user = pwrec[0]
-        groups = [grprec[2] for grprec in grp.getgrall() if user in grprec[3]]
-
-        # always put our primary gid first in this list, otherwise we can lose group info since sometimes the first
-        # group in the setgroups list gets overwritten on the subsequent setgid call (at least on freebsd 9 with
-        # python 2.7 - this will be safe though for all unix /python version combos)
-        groups.insert(0, gid)
-        try:
-            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
-
-
-def make_pipes(stderr=True) -> ta.Mapping[str, int]:
-    """
-    Create pipes for parent to child stdin/stdout/stderr communications.  Open fd in non-blocking mode so we can
-    read them in the mainloop without blocking.  If stderr is False, don't create a pipe for stderr.
-    """
-
-    pipes: ta.Dict[str, ta.Optional[int]] = {
-        'child_stdin': None,
-        'stdin': None,
-        'stdout': None,
-        'child_stdout': None,
-        'stderr': None,
-        'child_stderr': None,
-    }
-
-    try:
-        stdin, child_stdin = os.pipe()
-        pipes['child_stdin'], pipes['stdin'] = stdin, child_stdin
-
-        stdout, child_stdout = os.pipe()
-        pipes['stdout'], pipes['child_stdout'] = stdout, child_stdout
-
-        if stderr:
-            stderr, child_stderr = os.pipe()
-            pipes['stderr'], pipes['child_stderr'] = stderr, child_stderr
-
-        for fd in (pipes['stdout'], pipes['stderr'], pipes['stdin']):
-            if fd is not None:
-                flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NDELAY
-                fcntl.fcntl(fd, fcntl.F_SETFL, flags)
-
-        return pipes  # type: ignore
-
-    except OSError:
-        for fd in pipes.values():
-            if fd is not None:
-                close_fd(fd)
-        raise
-
-
-def close_parent_pipes(pipes: ta.Mapping[str, int]) -> None:
-    for fdname in ('stdin', 'stdout', 'stderr'):
-        fd = pipes.get(fdname)
-        if fd is not None:
-            close_fd(fd)
-
-
-def close_child_pipes(pipes: ta.Mapping[str, int]) -> None:
-    for fdname in ('child_stdin', 'child_stdout', 'child_stderr'):
-        fd = pipes.get(fdname)
-        if fd is not None:
-            close_fd(fd)
-
-
-def check_execv_args(filename, argv, st) -> None:
-    if st is None:
-        raise NotFoundError(f"can't find command {filename!r}")
-
-    elif stat.S_ISDIR(st[stat.ST_MODE]):
-        raise NotExecutableError(f'command at {filename!r} is a directory')
-
-    elif not (stat.S_IMODE(st[stat.ST_MODE]) & 0o111):
-        raise NotExecutableError(f'command at {filename!r} is not executable')
-
-    elif not os.access(filename, os.X_OK):
-        raise NoPermissionError(f'no permission to run command {filename!r}')
-
-
-########################################
-# ../dispatchers.py
-
-
-class Dispatcher(abc.ABC):
-    def __init__(
-            self,
-            process: Process,
-            channel: str,
-            fd: int,
-            *,
-            event_callbacks: EventCallbacks,
-    ) -> None:
-        super().__init__()
-
-        self._process = process  # process which "owns" this dispatcher
-        self._channel = channel  # 'stderr' or 'stdout'
-        self._fd = fd
-        self._event_callbacks = event_callbacks
-
-        self._closed = False  # True if close() has been called
-
-    def __repr__(self) -> str:
-        return f'<{self.__class__.__name__} at {id(self)} for {self._process} ({self._channel})>'
-
-    @property
-    def process(self) -> Process:
-        return self._process
-
-    @property
-    def channel(self) -> str:
-        return self._channel
-
-    @property
-    def fd(self) -> int:
-        return self._fd
-
-    @property
-    def closed(self) -> bool:
-        return self._closed
-
-    @abc.abstractmethod
-    def readable(self) -> bool:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def writable(self) -> bool:
-        raise NotImplementedError
-
-    def handle_read_event(self) -> None:
-        raise TypeError
-
-    def handle_write_event(self) -> None:
-        raise TypeError
-
-    def handle_error(self) -> None:
-        nil, t, v, tbinfo = compact_traceback()
+    def handle_error(self) -> None:
+        nil, t, v, tbinfo = compact_traceback()
 
         log.critical('uncaptured python exception, closing channel %s (%s:%s %s)', repr(self), t, v, tbinfo)
         self.close()
 
-    def close(self) -> None:
-        if not self._closed:
-            log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
-            self._closed = True
 
-    def flush(self) -> None:  # noqa
-        pass
-
-
-class OutputDispatcher(Dispatcher):
+class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
     """
     Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
 
@@ -5495,13 +5707,14 @@ class OutputDispatcher(Dispatcher):
             process: Process,
             event_type: ta.Type[ProcessCommunicationEvent],
             fd: int,
-            **kwargs: ta.Any,
+            *,
+            event_callbacks: EventCallbacks,
     ) -> None:
         super().__init__(
             process,
             event_type.channel,
             fd,
-            **kwargs,
+            event_callbacks=event_callbacks,
         )
 
         self._event_type = event_type
@@ -5698,19 +5911,20 @@ class OutputDispatcher(Dispatcher):
             self.close()
 
 
-class InputDispatcher(Dispatcher):
+class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
     def __init__(
             self,
             process: Process,
             channel: str,
             fd: int,
-            **kwargs: ta.Any,
+            *,
+            event_callbacks: EventCallbacks,
     ) -> None:
         super().__init__(
             process,
             channel,
             fd,
-            **kwargs,
+            event_callbacks=event_callbacks,
         )
 
         self._input_buffer = b''
@@ -5747,58 +5961,133 @@ class InputDispatcher(Dispatcher):
 # ../groups.py
 
 
-##
+class ProcessGroupManager(KeyedCollectionAccessors[str, ProcessGroup]):
+    def __init__(
+            self,
+            *,
+            event_callbacks: EventCallbacks,
+    ) -> None:
+        super().__init__()
+
+        self._event_callbacks = event_callbacks
+
+        self._by_name: ta.Dict[str, ProcessGroup] = {}
+
+    @property
+    def _by_key(self) -> ta.Mapping[str, ProcessGroup]:
+        return self._by_name
+
+    #
+
+    def all_processes(self) -> ta.Iterator[Process]:
+        for g in self:
+            yield from g
+
+    #
+
+    def add(self, group: ProcessGroup) -> None:
+        if (name := group.name) in self._by_name:
+            raise KeyError(f'Process group already exists: {name}')
+
+        self._by_name[name] = group
 
+        self._event_callbacks.notify(ProcessGroupAddedEvent(name))
+
+    def remove(self, name: str) -> None:
+        group = self._by_name[name]
+
+        group.before_remove()
+
+        del self._by_name[name]
+
+        self._event_callbacks.notify(ProcessGroupRemovedEvent(name))
+
+    def clear(self) -> None:
+        # FIXME: events?
+        self._by_name.clear()
+
+    #
 
-ProcessFactory = ta.NewType('ProcessFactory', Func[Process])  # (config: ProcessConfig, group: ProcessGroup)
+    class Diff(ta.NamedTuple):
+        added: ta.List[ProcessGroupConfig]
+        changed: ta.List[ProcessGroupConfig]
+        removed: ta.List[ProcessGroupConfig]
+
+    def diff(self, new: ta.Sequence[ProcessGroupConfig]) -> Diff:
+        cur = [group.config for group in self]
+
+        cur_by_name = {cfg.name: cfg for cfg in cur}
+        new_by_name = {cfg.name: cfg for cfg in new}
+
+        added = [cand for cand in new if cand.name not in cur_by_name]
+        removed = [cand for cand in cur if cand.name not in new_by_name]
+        changed = [cand for cand in new if cand != cur_by_name.get(cand.name, cand)]
+
+        return ProcessGroupManager.Diff(
+            added,
+            changed,
+            removed,
+        )
+
+
+########################################
+# ../groupsimpl.py
+
+
+class ProcessFactory(Func2[ProcessConfig, ProcessGroup, Process]):
+    pass
 
 
 class ProcessGroupImpl(ProcessGroup):
     def __init__(
             self,
             config: ProcessGroupConfig,
-            context: ServerContext,
             *,
             process_factory: ProcessFactory,
     ):
         super().__init__()
 
         self._config = config
-        self._context = context
         self._process_factory = process_factory
 
-        self._processes = {}
+        by_name: ta.Dict[str, Process] = {}
         for pconfig in self._config.processes or []:
-            process = self._process_factory(pconfig, self)
-            self._processes[pconfig.name] = process
+            p = check_isinstance(self._process_factory(pconfig, self), Process)
+            if p.name in by_name:
+                raise KeyError(f'name {p.name} of process {p} already registered by {by_name[p.name]}')
+            by_name[pconfig.name] = p
+        self._by_name = by_name
 
     @property
-    def config(self) -> ProcessGroupConfig:
-        return self._config
+    def _by_key(self) -> ta.Mapping[str, Process]:
+        return self._by_name
+
+    #
+
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__} instance at {id(self)} named {self._config.name}>'
+
+    #
 
     @property
     def name(self) -> str:
         return self._config.name
 
     @property
-    def context(self) -> ServerContext:
-        return self._context
+    def config(self) -> ProcessGroupConfig:
+        return self._config
 
-    def __repr__(self):
-        # repr can't return anything other than a native string, but the name might be unicode - a problem on Python 2.
-        name = self._config.name
-        return f'<{self.__class__.__name__} instance at {id(self)} named {name}>'
+    @property
+    def by_name(self) -> ta.Mapping[str, Process]:
+        return self._by_name
 
-    def remove_logs(self) -> None:
-        for process in self._processes.values():
-            process.remove_logs()
+    #
 
-    def reopen_logs(self) -> None:
-        for process in self._processes.values():
-            process.reopen_logs()
+    def get_unstopped_processes(self) -> ta.List[Process]:
+        return [x for x in self if not x.get_state().stopped]
 
     def stop_all(self) -> None:
-        processes = list(self._processes.values())
+        processes = list(self._by_name.values())
         processes.sort()
         processes.reverse()  # stop in desc priority order
 
@@ -5816,84 +6105,642 @@ class ProcessGroupImpl(ProcessGroup):
                 # BACKOFF -> FATAL
                 proc.give_up()
 
-    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]:
-        dispatchers: dict = {}
-        for process in self._processes.values():
-            dispatchers.update(process.get_dispatchers())
-        return dispatchers
-
     def before_remove(self) -> None:
         pass
 
-    def transition(self) -> None:
-        for proc in self._processes.values():
-            proc.transition()
 
-    def after_setuid(self) -> None:
-        for proc in self._processes.values():
-            proc.create_auto_child_logs()
+########################################
+# ../processes.py
 
 
 ##
 
 
-class ProcessGroups:
-    def __init__(
-            self,
-            *,
-            event_callbacks: EventCallbacks,
-    ) -> None:
-        super().__init__()
+class ProcessStateError(RuntimeError):
+    pass
 
+
+##
+
+
+class PidHistory(ta.Dict[int, Process]):
+    pass
+
+
+########################################
+# ../setupimpl.py
+
+
+##
+
+
+class SupervisorSetupImpl(SupervisorSetup):
+    def __init__(
+            self,
+            *,
+            config: ServerConfig,
+            user: ta.Optional[SupervisorUser] = None,
+            epoch: ServerEpoch = ServerEpoch(0),
+            daemonize_listeners: DaemonizeListeners = DaemonizeListeners([]),
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+        self._user = user
+        self._epoch = epoch
+        self._daemonize_listeners = daemonize_listeners
+
+    #
+
+    @property
+    def first(self) -> bool:
+        return not self._epoch
+
+    #
+
+    @cached_nullary
+    def setup(self) -> None:
+        if not self.first:
+            # prevent crash on libdispatch-based systems, at least for the first request
+            self._cleanup_fds()
+
+        self._set_uid_or_exit()
+
+        if self.first:
+            self._set_rlimits_or_exit()
+
+        # this sets the options.logger object delay logger instantiation until after setuid
+        if not self._config.nocleanup:
+            # clean up old automatic logs
+            self._clear_auto_child_logdir()
+
+        if not self._config.nodaemon and self.first:
+            self._daemonize()
+
+        # writing pid file needs to come *after* daemonizing or pid will be wrong
+        self._write_pidfile()
+
+    @cached_nullary
+    def cleanup(self) -> None:
+        self._cleanup_pidfile()
+
+    #
+
+    def _cleanup_fds(self) -> None:
+        # try to close any leaked file descriptors (for reload)
+        start = 5
+        os.closerange(start, self._config.minfds)
+
+    #
+
+    def _set_uid_or_exit(self) -> None:
+        """
+        Set the uid of the supervisord process.  Called during supervisord startup only.  No return value.  Exits the
+        process via usage() if privileges could not be dropped.
+        """
+
+        if self._user is None:
+            if os.getuid() == 0:
+                warnings.warn(
+                    'Supervisor is running as root.  Privileges were not dropped because no user is specified in the '
+                    'config file.  If you intend to run as root, you can set user=root in the config file to avoid '
+                    'this message.',
+                )
+        else:
+            msg = drop_privileges(self._user.uid)
+            if msg is None:
+                log.info('Set uid to user %s succeeded', self._user.uid)
+            else:  # failed to drop privileges
+                raise RuntimeError(msg)
+
+    #
+
+    def _set_rlimits_or_exit(self) -> None:
+        """
+        Set the rlimits of the supervisord process.  Called during supervisord startup only.  No return value.  Exits
+        the process via usage() if any rlimits could not be set.
+        """
+
+        limits = []
+
+        if hasattr(resource, 'RLIMIT_NOFILE'):
+            limits.append({
+                'msg': (
+                    'The minimum number of file descriptors required to run this process is %(min_limit)s as per the '
+                    '"minfds" command-line argument or config file setting. The current environment will only allow '
+                    'you to open %(hard)s file descriptors.  Either raise the number of usable file descriptors in '
+                    'your environment (see README.rst) or lower the minfds setting in the config file to allow the '
+                    'process to start.'
+                ),
+                'min': self._config.minfds,
+                'resource': resource.RLIMIT_NOFILE,
+                'name': 'RLIMIT_NOFILE',
+            })
+
+        if hasattr(resource, 'RLIMIT_NPROC'):
+            limits.append({
+                'msg': (
+                    'The minimum number of available processes required to run this program is %(min_limit)s as per '
+                    'the "minprocs" command-line argument or config file setting. The current environment will only '
+                    'allow you to open %(hard)s processes.  Either raise the number of usable processes in your '
+                    'environment (see README.rst) or lower the minprocs setting in the config file to allow the '
+                    'program to start.'
+                ),
+                'min': self._config.minprocs,
+                'resource': resource.RLIMIT_NPROC,
+                'name': 'RLIMIT_NPROC',
+            })
+
+        for limit in limits:
+            min_limit = limit['min']
+            res = limit['resource']
+            msg = limit['msg']
+            name = limit['name']
+
+            soft, hard = resource.getrlimit(res)  # type: ignore
+
+            # -1 means unlimited
+            if soft < min_limit and soft != -1:  # type: ignore
+                if hard < min_limit and hard != -1:  # type: ignore
+                    # setrlimit should increase the hard limit if we are root, if not then setrlimit raises and we print
+                    # usage
+                    hard = min_limit  # type: ignore
+
+                try:
+                    resource.setrlimit(res, (min_limit, hard))  # type: ignore
+                    log.info('Increased %s limit to %s', name, min_limit)
+                except (resource.error, ValueError):
+                    raise RuntimeError(msg % dict(  # type: ignore  # noqa
+                        min_limit=min_limit,
+                        res=res,
+                        name=name,
+                        soft=soft,
+                        hard=hard,
+                    ))
+
+    #
+
+    _unlink_pidfile = False
+
+    def _write_pidfile(self) -> None:
+        pid = os.getpid()
+        try:
+            with open(self._config.pidfile, 'w') as f:
+                f.write(f'{pid}\n')
+        except OSError:
+            log.critical('could not write pidfile %s', self._config.pidfile)
+        else:
+            self._unlink_pidfile = True
+            log.info('supervisord started with pid %s', pid)
+
+    def _cleanup_pidfile(self) -> None:
+        if self._unlink_pidfile:
+            try_unlink(self._config.pidfile)
+
+    #
+
+    def _clear_auto_child_logdir(self) -> None:
+        # must be called after realize()
+        child_logdir = self._config.child_logdir
+        if child_logdir == '/dev/null':
+            return
+
+        fnre = re.compile(rf'.+?---{self._config.identifier}-\S+\.log\.?\d{{0,4}}')
+        try:
+            filenames = os.listdir(child_logdir)
+        except OSError:
+            log.warning('Could not clear child_log dir')
+            return
+
+        for filename in filenames:
+            if fnre.match(filename):
+                pathname = os.path.join(child_logdir, filename)
+                try:
+                    os.remove(pathname)
+                except OSError:
+                    log.warning('Failed to clean up %r', pathname)
+
+    #
+
+    def _daemonize(self) -> None:
+        for dl in self._daemonize_listeners:
+            dl.before_daemonize()
+
+        self._do_daemonize()
+
+        for dl in self._daemonize_listeners:
+            dl.after_daemonize()
+
+    def _do_daemonize(self) -> None:
+        # To daemonize, we need to become the leader of our own session (process) group.  If we do not, signals sent to
+        # our parent process will also be sent to us.   This might be bad because signals such as SIGINT can be sent to
+        # our parent process during normal (uninteresting) operations such as when we press Ctrl-C in the parent
+        # terminal window to escape from a logtail command. To disassociate ourselves from our parent's session group we
+        # use os.setsid.  It means "set session id", which has the effect of disassociating a process from is current
+        # session and process group and setting itself up as a new session leader.
+        #
+        # Unfortunately we cannot call setsid if we're already a session group leader, so we use "fork" to make a copy
+        # of ourselves that is guaranteed to not be a session group leader.
+        #
+        # We also change directories, set stderr and stdout to null, and change our umask.
+        #
+        # This explanation was (gratefully) garnered from
+        # http://www.cems.uwe.ac.uk/~irjohnso/coursenotes/lrc/system/daemons/d3.htm
+
+        pid = os.fork()
+        if pid != 0:
+            # Parent
+            log.debug('supervisord forked; parent exiting')
+            real_exit(0)
+
+        # Child
+        log.info('daemonizing the supervisord process')
+        if self._config.directory:
+            try:
+                os.chdir(self._config.directory)
+            except OSError as err:
+                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))
+
+        # 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.
+        os.setsid()
+        os.umask(self._config.umask)
+
+
+########################################
+# ../spawning.py
+
+
+@dc.dataclass(frozen=True)
+class SpawnedProcess:
+    pid: int
+    pipes: ProcessPipes
+    dispatchers: Dispatchers
+
+
+class ProcessSpawnError(RuntimeError):
+    pass
+
+
+class ProcessSpawning:
+    @property
+    @abc.abstractmethod
+    def process(self) -> Process:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
+        raise NotImplementedError
+
+
+########################################
+# ../supervisor.py
+
+
+##
+
+
+class SignalHandler:
+    def __init__(
+            self,
+            *,
+            context: ServerContextImpl,
+            signal_receiver: SignalReceiver,
+            process_groups: ProcessGroupManager,
+    ) -> 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 p in self._process_groups.all_processes():
+                for d in p.get_dispatchers():
+                    if isinstance(d, OutputDispatcher):
+                        d.reopen_logs()
+
+        else:
+            log.debug('received %s indicating nothing', sig_name(sig))
+
+
+##
+
+
+class ProcessGroupFactory(Func1[ProcessGroupConfig, ProcessGroup]):
+    pass
+
+
+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__()
+
+        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
+
+    #
+
+    @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)
 
-        self._by_name: ta.Dict[str, ProcessGroup] = {}
+        return True
 
-    def get(self, name: str) -> ta.Optional[ProcessGroup]:
-        return self._by_name.get(name)
+    def remove_process_group(self, name: str) -> bool:
+        if self._process_groups[name].get_unstopped_processes():
+            return False
 
-    def __getitem__(self, name: str) -> ProcessGroup:
-        return self._by_name[name]
+        self._process_groups.remove(name)
 
-    def __len__(self) -> int:
-        return len(self._by_name)
+        return True
 
-    def __iter__(self) -> ta.Iterator[ProcessGroup]:
-        return iter(self._by_name.values())
+    #
 
-    def all(self) -> ta.Mapping[str, ProcessGroup]:
-        return self._by_name
+    def shutdown_report(self) -> ta.List[Process]:
+        unstopped: ta.List[Process] = []
 
-    def add(self, group: ProcessGroup) -> None:
-        if (name := group.name) in self._by_name:
-            raise KeyError(f'Process group already exists: {name}')
+        for group in self._process_groups:
+            unstopped.extend(group.get_unstopped_processes())
 
-        self._by_name[name] = group
+        if unstopped:
+            # throttle 'waiting for x to die' reports
+            now = time.time()
+            if now > (self._last_shutdown_report + 3):  # every 3 secs
+                names = [as_string(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)
 
-        self._event_callbacks.notify(ProcessGroupAddedEvent(name))
+        return unstopped
 
-    def remove(self, name: str) -> None:
-        group = self._by_name[name]
+    #
 
-        group.before_remove()
+    def main(self, **kwargs: ta.Any) -> None:
+        self._setup.setup()
+        try:
+            self.run(**kwargs)
+        finally:
+            self._setup.cleanup()
 
-        del self._by_name[name]
+    def run(
+            self,
+            *,
+            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
+    ) -> None:
+        self._process_groups.clear()
+        self._stop_groups = None  # clear
 
-        self._event_callbacks.notify(ProcessGroupRemovedEvent(name))
+        self._event_callbacks.clear()
 
-    def clear(self) -> None:
-        # FIXME: events?
-        self._by_name.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()
+
+    #
+
+    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))
 
 
 ########################################
-# ../process.py
+# ../processesimpl.py
 
 
-InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+class ProcessSpawningFactory(Func1[Process, ProcessSpawning]):
+    pass
 
 
 ##
@@ -5909,19 +6756,22 @@ class ProcessImpl(Process):
             *,
             context: ServerContext,
             event_callbacks: EventCallbacks,
-
-            inherited_fds: ta.Optional[InheritedFds] = None,
+            process_spawning_factory: ProcessSpawningFactory,
     ) -> None:
         super().__init__()
 
         self._config = config
         self._group = group
+
         self._context = context
         self._event_callbacks = event_callbacks
-        self._inherited_fds = InheritedFds(frozenset(inherited_fds or []))
 
-        self._dispatchers: ta.Dict[int, Dispatcher] = {}
-        self._pipes: ta.Dict[str, int] = {}
+        self._spawning = process_spawning_factory(self)
+
+        #
+
+        self._dispatchers = Dispatchers([])
+        self._pipes = ProcessPipes()
 
         self._state = ProcessState.STOPPED
         self._pid = 0  # 0 when not running
@@ -5938,144 +6788,47 @@ class ProcessImpl(Process):
 
         self._backoff = 0  # backoff counter (to startretries)
 
-        self._exitstatus: ta.Optional[int] = None  # status attached to dead process by finish()
-        self._spawn_err: ta.Optional[str] = None  # error message attached by spawn() if any
-
-    @property
-    def pid(self) -> int:
-        return self._pid
-
-    @property
-    def group(self) -> ProcessGroup:
-        return self._group
-
-    @property
-    def config(self) -> ProcessConfig:
-        return self._config
-
-    @property
-    def context(self) -> ServerContext:
-        return self._context
-
-    @property
-    def state(self) -> ProcessState:
-        return self._state
-
-    @property
-    def backoff(self) -> int:
-        return self._backoff
-
-    def get_dispatchers(self) -> ta.Mapping[int, Dispatcher]:
-        return self._dispatchers
-
-    def remove_logs(self) -> None:
-        for dispatcher in self._dispatchers.values():
-            if hasattr(dispatcher, 'remove_logs'):
-                dispatcher.remove_logs()
-
-    def reopen_logs(self) -> None:
-        for dispatcher in self._dispatchers.values():
-            if hasattr(dispatcher, 'reopen_logs'):
-                dispatcher.reopen_logs()
-
-    def drain(self) -> None:
-        for dispatcher in self._dispatchers.values():
-            # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
-            # dispatcher (eg. call handle_listener_state_change for event listener processes)
-            if dispatcher.readable():
-                dispatcher.handle_read_event()
-            if dispatcher.writable():
-                dispatcher.handle_write_event()
-
-    def write(self, chars: ta.Union[bytes, str]) -> None:
-        if not self.pid or self._killing:
-            raise OSError(errno.EPIPE, 'Process already closed')
-
-        stdin_fd = self._pipes['stdin']
-        if stdin_fd is None:
-            raise OSError(errno.EPIPE, 'Process has no stdin channel')
-
-        dispatcher = check_isinstance(self._dispatchers[stdin_fd], InputDispatcher)
-        if dispatcher.closed:
-            raise OSError(errno.EPIPE, "Process' stdin channel is closed")
-
-        dispatcher.write(chars)
-        dispatcher.flush()  # this must raise EPIPE if the pipe is closed
-
-    def _get_execv_args(self) -> ta.Tuple[str, ta.Sequence[str]]:
-        """
-        Internal: turn a program name into a file name, using $PATH, make sure it exists / is executable, raising a
-        ProcessError if not
-        """
-
-        try:
-            commandargs = shlex.split(self._config.command)
-        except ValueError as e:
-            raise BadCommandError(f"can't parse command {self._config.command!r}: {e}")  # noqa
+        self._exitstatus: ta.Optional[int] = None  # status attached to dead process by finish()
+        self._spawn_err: ta.Optional[str] = None  # error message attached by spawn() if any
 
-        if commandargs:
-            program = commandargs[0]
-        else:
-            raise BadCommandError('command is empty')
+    #
 
-        if '/' in program:
-            filename = program
-            try:
-                st = os.stat(filename)
-            except OSError:
-                st = None
+    def __repr__(self) -> str:
+        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self.get_state().name}>'
 
-        else:
-            path = get_path()
-            found = None
-            st = None
-            for dir in path:  # noqa
-                found = os.path.join(dir, program)
-                try:
-                    st = os.stat(found)
-                except OSError:
-                    pass
-                else:
-                    break
-            if st is None:
-                filename = program
-            else:
-                filename = found  # type: ignore
+    #
 
-        # check_execv_args will raise a ProcessError if the execv args are bogus, we break it out into a separate
-        # options method call here only to service unit tests
-        check_execv_args(filename, commandargs, st)
+    @property
+    def name(self) -> str:
+        return self._config.name
+
+    @property
+    def config(self) -> ProcessConfig:
+        return self._config
 
-        return filename, commandargs
+    @property
+    def group(self) -> ProcessGroup:
+        return self._group
 
-    def change_state(self, new_state: ProcessState, expected: bool = True) -> bool:
-        old_state = self._state
-        if new_state is old_state:
-            return False
+    @property
+    def pid(self) -> int:
+        return self._pid
 
-        self._state = new_state
-        if new_state == ProcessState.BACKOFF:
-            now = time.time()
-            self._backoff += 1
-            self._delay = now + self._backoff
+    #
 
-        event_class = PROCESS_STATE_EVENT_MAP.get(new_state)
-        if event_class is not None:
-            event = event_class(self, old_state, expected)
-            self._event_callbacks.notify(event)
+    @property
+    def context(self) -> ServerContext:
+        return self._context
 
-        return True
+    @property
+    def state(self) -> ProcessState:
+        return self._state
 
-    def _check_in_state(self, *states: ProcessState) -> None:
-        if self._state not in states:
-            current_state = self._state.name
-            allowable_states = ' '.join(s.name for s in states)
-            process_name = as_string(self._config.name)
-            raise RuntimeError('Assertion failed for %s: %s not in %s' % (process_name, current_state, allowable_states))  # noqa
+    @property
+    def backoff(self) -> int:
+        return self._backoff
 
-    def _record_spawn_err(self, msg: str) -> None:
-        self._spawn_err = msg
-        log.info('_spawn_err: %s', msg)
+    #
 
     def spawn(self) -> ta.Optional[int]:
         process_name = as_string(self._config.name)
@@ -6084,6 +6837,13 @@ class ProcessImpl(Process):
             log.warning('process \'%s\' already running', process_name)
             return None
 
+        self.check_in_state(
+            ProcessState.EXITED,
+            ProcessState.FATAL,
+            ProcessState.BACKOFF,
+            ProcessState.STOPPED,
+        )
+
         self._killing = False
         self._spawn_err = None
         self._exitstatus = None
@@ -6092,183 +6852,73 @@ class ProcessImpl(Process):
 
         self._last_start = time.time()
 
-        self._check_in_state(
-            ProcessState.EXITED,
-            ProcessState.FATAL,
-            ProcessState.BACKOFF,
-            ProcessState.STOPPED,
-        )
-
         self.change_state(ProcessState.STARTING)
 
         try:
-            filename, argv = self._get_execv_args()
-        except ProcessError as what:
-            self._record_spawn_err(what.args[0])
-            self._check_in_state(ProcessState.STARTING)
-            self.change_state(ProcessState.BACKOFF)
-            return None
-
-        try:
-            self._dispatchers, self._pipes = self._make_dispatchers()  # type: ignore
-        except OSError as why:
-            code = why.args[0]
-            if code == errno.EMFILE:
-                # too many file descriptors open
-                msg = f"too many open files to spawn '{process_name}'"
-            else:
-                msg = f"unknown error making dispatchers for '{process_name}': {errno.errorcode.get(code, code)}"
-            self._record_spawn_err(msg)
-            self._check_in_state(ProcessState.STARTING)
-            self.change_state(ProcessState.BACKOFF)
-            return None
-
-        try:
-            pid = os.fork()
-        except OSError as why:
-            code = why.args[0]
-            if code == errno.EAGAIN:
-                # process table full
-                msg = f'Too many processes in process table to spawn \'{process_name}\''
-            else:
-                msg = f'unknown error during fork for \'{process_name}\': {errno.errorcode.get(code, code)}'
-            self._record_spawn_err(msg)
-            self._check_in_state(ProcessState.STARTING)
+            sp = self._spawning.spawn()
+        except ProcessSpawnError as err:
+            log.exception('Spawn error')
+            self._spawn_err = err.args[0]
+            self.check_in_state(ProcessState.STARTING)
             self.change_state(ProcessState.BACKOFF)
-            close_parent_pipes(self._pipes)
-            close_child_pipes(self._pipes)
-            return None
-
-        if pid != 0:
-            return self._spawn_as_parent(pid)
-
-        else:
-            self._spawn_as_child(filename, argv)
             return None
 
-    def _make_dispatchers(self) -> ta.Tuple[ta.Mapping[int, Dispatcher], ta.Mapping[str, int]]:
-        use_stderr = not self._config.redirect_stderr
-
-        p = make_pipes(use_stderr)
-        stdout_fd, stderr_fd, stdin_fd = p['stdout'], p['stderr'], p['stdin']
+        log.info("Spawned: '%s' with pid %s", self.name, sp.pid)
 
-        dispatchers: ta.Dict[int, Dispatcher] = {}
+        self._pid = sp.pid
+        self._pipes = sp.pipes
+        self._dispatchers = sp.dispatchers
 
-        dispatcher_kw = dict(
-            event_callbacks=self._event_callbacks,
-        )
+        self._delay = time.time() + self.config.startsecs
 
-        etype: ta.Type[ProcessCommunicationEvent]
-        if stdout_fd is not None:
-            etype = ProcessCommunicationStdoutEvent
-            dispatchers[stdout_fd] = OutputDispatcher(
-                self,
-                etype,
-                stdout_fd,
-                **dispatcher_kw,
-            )
+        return sp.pid
 
-        if stderr_fd is not None:
-            etype = ProcessCommunicationStderrEvent
-            dispatchers[stderr_fd] = OutputDispatcher(
-                self,
-                etype,
-                stderr_fd,
-                **dispatcher_kw,
-            )
+    def get_dispatchers(self) -> Dispatchers:
+        return self._dispatchers
 
-        if stdin_fd is not None:
-            dispatchers[stdin_fd] = InputDispatcher(
-                self,
-                'stdin',
-                stdin_fd,
-                **dispatcher_kw,
-            )
+    def write(self, chars: ta.Union[bytes, str]) -> None:
+        if not self.pid or self._killing:
+            raise OSError(errno.EPIPE, 'Process already closed')
 
-        return dispatchers, p
+        stdin_fd = self._pipes.stdin
+        if stdin_fd is None:
+            raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
-    def _spawn_as_parent(self, pid: int) -> int:
-        # Parent
-        self._pid = pid
-        close_child_pipes(self._pipes)
-        log.info('spawned: \'%s\' with pid %s', as_string(self._config.name), pid)
-        self._spawn_err = None
-        self._delay = time.time() + self._config.startsecs
-        self.context.pid_history[pid] = self
-        return pid
-
-    def _prepare_child_fds(self) -> None:
-        os.dup2(self._pipes['child_stdin'], 0)
-        os.dup2(self._pipes['child_stdout'], 1)
-        if self._config.redirect_stderr:
-            os.dup2(self._pipes['child_stdout'], 2)
-        else:
-            os.dup2(self._pipes['child_stderr'], 2)
+        dispatcher = check_isinstance(self._dispatchers[stdin_fd], InputDispatcher)
+        if dispatcher.closed:
+            raise OSError(errno.EPIPE, "Process' stdin channel is closed")
 
-        for i in range(3, self.context.config.minfds):
-            if i in self._inherited_fds:
-                continue
-            close_fd(i)
+        dispatcher.write(chars)
+        dispatcher.flush()  # this must raise EPIPE if the pipe is closed
 
-    def _spawn_as_child(self, filename: str, argv: ta.Sequence[str]) -> None:
-        try:
-            # prevent child from receiving signals sent to the parent by calling os.setpgrp to create a new process
-            # group for the child; this prevents, for instance, the case of child processes being sent a SIGINT when
-            # running supervisor in foreground mode and Ctrl-C in the terminal window running supervisord is pressed.
-            # Presumably it also prevents HUP, etc received by supervisord from being sent to children.
-            os.setpgrp()
+    #
 
-            self._prepare_child_fds()
-            # sending to fd 2 will put this output in the stderr log
+    def change_state(self, new_state: ProcessState, expected: bool = True) -> bool:
+        old_state = self._state
+        if new_state is old_state:
+            return False
 
-            # set user
-            setuid_msg = self.set_uid()
-            if setuid_msg:
-                uid = self._config.uid
-                msg = f"couldn't setuid to {uid}: {setuid_msg}\n"
-                os.write(2, as_bytes('supervisor: ' + msg))
-                return  # finally clause will exit the child process
+        self._state = new_state
+        if new_state == ProcessState.BACKOFF:
+            now = time.time()
+            self._backoff += 1
+            self._delay = now + self._backoff
 
-            # set environment
-            env = os.environ.copy()
-            env['SUPERVISOR_ENABLED'] = '1'
-            env['SUPERVISOR_PROCESS_NAME'] = self._config.name
-            if self._group:
-                env['SUPERVISOR_GROUP_NAME'] = self._group.config.name
-            if self._config.environment is not None:
-                env.update(self._config.environment)
-
-            # change directory
-            cwd = self._config.directory
-            try:
-                if cwd is not None:
-                    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"
-                os.write(2, as_bytes('supervisor: ' + msg))
-                return  # finally clause will exit the child process
+        event_class = PROCESS_STATE_EVENT_MAP.get(new_state)
+        if event_class is not None:
+            event = event_class(self, old_state, expected)
+            self._event_callbacks.notify(event)
 
-            # set umask, then execve
-            try:
-                if self._config.umask is not None:
-                    os.umask(self._config.umask)
-                os.execve(filename, list(argv), env)
-            except OSError as why:
-                code = errno.errorcode.get(why.args[0], why.args[0])
-                msg = f"couldn't exec {argv[0]}: {code}\n"
-                os.write(2, as_bytes('supervisor: ' + msg))
-            except Exception:  # noqa
-                (file, fun, line), t, v, tbinfo = compact_traceback()
-                error = f'{t}, {v}: file: {file} line: {line}'
-                msg = f"couldn't exec {filename}: {error}\n"
-                os.write(2, as_bytes('supervisor: ' + msg))
+        return True
 
-            # this point should only be reached if execve failed. the finally clause will exit the child process.
+    def check_in_state(self, *states: ProcessState) -> None:
+        if self._state not in states:
+            raise ProcessStateError(
+                f'Check failed for {self._config.name}: '
+                f'{self._state.name} not in {" ".join(s.name for s in states)}',
+            )
 
-        finally:
-            os.write(2, as_bytes('supervisor: child process was not spawned\n'))
-            real_exit(127)  # exit process with code for spawn failure
+    #
 
     def _check_and_adjust_for_system_clock_rollback(self, test_time):
         """
@@ -6314,7 +6964,7 @@ class ProcessImpl(Process):
         self._delay = 0
         self._backoff = 0
         self._system_stop = True
-        self._check_in_state(ProcessState.BACKOFF)
+        self.check_in_state(ProcessState.BACKOFF)
         self.change_state(ProcessState.FATAL)
 
     def kill(self, sig: int) -> ta.Optional[str]:
@@ -6358,7 +7008,7 @@ class ProcessImpl(Process):
         self._killing = True
         self._delay = now + self._config.stopwaitsecs
         # we will already be in the STOPPING state if we're doing a SIGKILL as a result of overrunning stopwaitsecs
-        self._check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
+        self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
         self.change_state(ProcessState.STOPPING)
 
         pid = self.pid
@@ -6403,7 +7053,7 @@ class ProcessImpl(Process):
 
         log.debug('sending %s (pid %s) sig %s', process_name, self.pid, sig_name(sig))
 
-        self._check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
+        self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
 
         try:
             try:
@@ -6432,7 +7082,7 @@ class ProcessImpl(Process):
     def finish(self, sts: int) -> None:
         """The process was reaped and we need to report and manage its state."""
 
-        self.drain()
+        self._dispatchers.drain()
 
         es, msg = decode_wait_status(sts)
 
@@ -6463,7 +7113,7 @@ class ProcessImpl(Process):
             self._exitstatus = es
 
             fmt, args = 'stopped: %s (%s)', (process_name, msg)
-            self._check_in_state(ProcessState.STOPPING)
+            self.check_in_state(ProcessState.STOPPING)
             self.change_state(ProcessState.STOPPED)
             if exit_expected:
                 log.info(fmt, *args)
@@ -6474,7 +7124,7 @@ class ProcessImpl(Process):
             # the program did not stay up long enough to make it to RUNNING implies STARTING -> BACKOFF
             self._exitstatus = None
             self._spawn_err = 'Exited too quickly (process log may have details)'
-            self._check_in_state(ProcessState.STARTING)
+            self.check_in_state(ProcessState.STARTING)
             self.change_state(ProcessState.BACKOFF)
             log.warning('exited: %s (%s)', process_name, msg + '; not expected')
 
@@ -6490,7 +7140,7 @@ class ProcessImpl(Process):
             if self._state == ProcessState.STARTING:
                 self.change_state(ProcessState.RUNNING)
 
-            self._check_in_state(ProcessState.RUNNING)
+            self.check_in_state(ProcessState.RUNNING)
 
             if exit_expected:
                 # expected exit code
@@ -6504,19 +7154,8 @@ class ProcessImpl(Process):
 
         self._pid = 0
         close_parent_pipes(self._pipes)
-        self._pipes = {}
-        self._dispatchers = {}
-
-    def set_uid(self) -> ta.Optional[str]:
-        if self._config.uid is None:
-            return None
-        msg = drop_privileges(self._config.uid)
-        return msg
-
-    def __repr__(self) -> str:
-        # repr can't return anything other than a native string, but the name might be unicode - a problem on Python 2.
-        name = self._config.name
-        return f'<Subprocess at {id(self)} with name {name} in state {self.get_state().name}>'
+        self._pipes = ProcessPipes()
+        self._dispatchers = Dispatchers([])
 
     def get_state(self) -> ProcessState:
         return self._state
@@ -6558,7 +7197,7 @@ class ProcessImpl(Process):
                 # proc.config.startsecs,
                 self._delay = 0
                 self._backoff = 0
-                self._check_in_state(ProcessState.STARTING)
+                self.check_in_state(ProcessState.STARTING)
                 self.change_state(ProcessState.RUNNING)
                 msg = ('entered RUNNING state, process has stayed up for > than %s seconds (startsecs)' % self._config.startsecs)  # noqa
                 logger.info('success: %s %s', process_name, msg)
@@ -6578,7 +7217,7 @@ class ProcessImpl(Process):
                 log.warning('killing \'%s\' (%s) with SIGKILL', process_name, self.pid)
                 self.kill(signal.SIGKILL)
 
-    def create_auto_child_logs(self) -> None:
+    def after_setuid(self) -> None:
         # temporary logfiles which are erased at start time
         # get_autoname = self.context.get_auto_child_log_name  # noqa
         # sid = self.context.config.identifier  # noqa
@@ -6591,372 +7230,319 @@ class ProcessImpl(Process):
 
 
 ########################################
-# ../supervisor.py
-
-
-##
-
-
-class SignalHandler:
-    def __init__(
-            self,
-            *,
-            context: ServerContextImpl,
-            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
+# ../spawningimpl.py
 
-        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)
+class OutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], int, OutputDispatcher]):
+    pass
 
-        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))
+class InputDispatcherFactory(Func3[Process, str, int, InputDispatcher]):
+    pass
 
-            for group in self._process_groups:
-                group.reopen_logs()
 
-        else:
-            log.debug('received %s indicating nothing', sig_name(sig))
+InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
 
 
 ##
 
 
-ProcessGroupFactory = ta.NewType('ProcessGroupFactory', Func[ProcessGroup])  # (config: ProcessGroupConfig)
-
-
-class Supervisor:
+class ProcessSpawningImpl(ProcessSpawning):
     def __init__(
             self,
+            process: Process,
             *,
-            context: ServerContextImpl,
-            poller: Poller,
-            process_groups: ProcessGroups,
-            signal_handler: SignalHandler,
-            event_callbacks: EventCallbacks,
-            process_group_factory: ProcessGroupFactory,
-    ) -> None:
-        super().__init__()
-
-        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._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 context(self) -> ServerContextImpl:
-        return self._context
-
-    def get_state(self) -> SupervisorState:
-        return self._context.state
+            server_config: ServerConfig,
+            pid_history: PidHistory,
 
-    #
-
-    class DiffToActive(ta.NamedTuple):
-        added: ta.List[ProcessGroupConfig]
-        changed: ta.List[ProcessGroupConfig]
-        removed: ta.List[ProcessGroupConfig]
-
-    def diff_to_active(self) -> DiffToActive:
-        new = self._context.config.groups or []
-        cur = [group.config for group in self._process_groups]
+            output_dispatcher_factory: OutputDispatcherFactory,
+            input_dispatcher_factory: InputDispatcherFactory,
 
-        curdict = dict(zip([cfg.name for cfg in cur], cur))
-        newdict = dict(zip([cfg.name for cfg in new], new))
+            inherited_fds: ta.Optional[InheritedFds] = None,
+    ) -> None:
+        super().__init__()
 
-        added = [cand for cand in new if cand.name not in curdict]
-        removed = [cand for cand in cur if cand.name not in newdict]
+        self._process = process
 
-        changed = [cand for cand in new if cand != curdict.get(cand.name, cand)]
+        self._server_config = server_config
+        self._pid_history = pid_history
 
-        return Supervisor.DiffToActive(added, changed, removed)
+        self._output_dispatcher_factory = output_dispatcher_factory
+        self._input_dispatcher_factory = input_dispatcher_factory
 
-    def add_process_group(self, config: ProcessGroupConfig) -> bool:
-        if self._process_groups.get(config.name) is not None:
-            return False
+        self._inherited_fds = InheritedFds(frozenset(inherited_fds or []))
 
-        group = self._process_group_factory(config)
-        group.after_setuid()
+    #
 
-        self._process_groups.add(group)
+    @property
+    def process(self) -> Process:
+        return self._process
 
-        return True
+    @property
+    def config(self) -> ProcessConfig:
+        return self._process.config
 
-    def remove_process_group(self, name: str) -> bool:
-        if self._process_groups[name].get_unstopped_processes():
-            return False
+    @property
+    def group(self) -> ProcessGroup:
+        return self._process.group
 
-        self._process_groups.remove(name)
+    #
 
-        return True
+    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
+        try:
+            exe, argv = self._get_execv_args()
+        except ProcessError as exc:
+            raise ProcessSpawnError(exc.args[0]) from exc
 
-    def get_process_map(self) -> ta.Dict[int, Dispatcher]:
-        process_map: ta.Dict[int, Dispatcher] = {}
-        for group in self._process_groups:
-            process_map.update(group.get_dispatchers())
-        return process_map
+        try:
+            pipes = make_process_pipes(not self.config.redirect_stderr)
+        except OSError as exc:
+            code = exc.args[0]
+            if code == errno.EMFILE:
+                # too many file descriptors open
+                msg = f"Too many open files to spawn '{self.process.name}'"
+            else:
+                msg = f"Unknown error making pipes for '{self.process.name}': {errno.errorcode.get(code, code)}"
+            raise ProcessSpawnError(msg) from exc
 
-    def shutdown_report(self) -> ta.List[Process]:
-        unstopped: ta.List[Process] = []
+        try:
+            dispatchers = self._make_dispatchers(pipes)
+        except Exception as exc:  # noqa
+            close_pipes(pipes)
+            raise ProcessSpawnError(f"Unknown error making dispatchers for '{self.process.name}': {exc}") from exc
 
-        for group in self._process_groups:
-            unstopped.extend(group.get_unstopped_processes())
+        try:
+            pid = os.fork()
+        except OSError as exc:
+            code = exc.args[0]
+            if code == errno.EAGAIN:
+                # process table full
+                msg = f"Too many processes in process table to spawn '{self.process.name}'"
+            else:
+                msg = f"Unknown error during fork for '{self.process.name}': {errno.errorcode.get(code, code)}"
+            err = ProcessSpawnError(msg)
+            close_pipes(pipes)
+            raise err from exc
 
-        if unstopped:
-            # throttle 'waiting for x to die' reports
-            now = time.time()
-            if now > (self._last_shutdown_report + 3):  # every 3 secs
-                names = [as_string(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)
+        if pid != 0:
+            sp = SpawnedProcess(
+                pid,
+                pipes,
+                dispatchers,
+            )
+            self._spawn_as_parent(sp)
+            return sp
 
-        return unstopped
+        else:
+            self._spawn_as_child(
+                exe,
+                argv,
+                pipes,
+            )
+            raise RuntimeError('Unreachable')  # noqa
 
-    #
+    def _get_execv_args(self) -> ta.Tuple[str, ta.Sequence[str]]:
+        """
+        Internal: turn a program name into a file name, using $PATH, make sure it exists / is executable, raising a
+        ProcessError if not
+        """
 
-    def main(self) -> None:
-        self.setup()
-        self.run()
+        try:
+            args = shlex.split(self.config.command)
+        except ValueError as e:
+            raise BadCommandError(f"Can't parse command {self.config.command!r}: {e}")  # noqa
 
-    @cached_nullary
-    def setup(self) -> None:
-        if not self._context.first:
-            # prevent crash on libdispatch-based systems, at least for the first request
-            self._context.cleanup_fds()
+        if args:
+            program = args[0]
+        else:
+            raise BadCommandError('Command is empty')
 
-        self._context.set_uid_or_exit()
+        if '/' in program:
+            exe = program
+            try:
+                st = os.stat(exe)
+            except OSError:
+                st = None
 
-        if self._context.first:
-            self._context.set_rlimits_or_exit()
+        else:
+            path = get_path()
+            found = None
+            st = None
+            for dir in path:  # noqa
+                found = os.path.join(dir, program)
+                try:
+                    st = os.stat(found)
+                except OSError:
+                    pass
+                else:
+                    break
 
-        # this sets the options.logger object delay logger instantiation until after setuid
-        if not self._context.config.nocleanup:
-            # clean up old automatic logs
-            self._context.clear_auto_child_logdir()
+            if st is None:
+                exe = program
+            else:
+                exe = found  # type: ignore
 
-    def run(
-            self,
-            *,
-            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
-    ) -> None:
-        self._process_groups.clear()
-        self._stop_groups = None  # clear
+        # check_execv_args will raise a ProcessError if the execv args are bogus, we break it out into a separate
+        # options method call here only to service unit tests
+        check_execv_args(exe, args, st)
+
+        return exe, args
+
+    def _make_dispatchers(self, pipes: ProcessPipes) -> Dispatchers:
+        dispatchers: ta.List[Dispatcher] = []
+
+        if pipes.stdout is not None:
+            dispatchers.append(check_isinstance(self._output_dispatcher_factory(
+                self.process,
+                ProcessCommunicationStdoutEvent,
+                pipes.stdout,
+            ), OutputDispatcher))
+
+        if pipes.stderr is not None:
+            dispatchers.append(check_isinstance(self._output_dispatcher_factory(
+                self.process,
+                ProcessCommunicationStderrEvent,
+                pipes.stderr,
+            ), OutputDispatcher))
+
+        if pipes.stdin is not None:
+            dispatchers.append(check_isinstance(self._input_dispatcher_factory(
+                self.process,
+                'stdin',
+                pipes.stdin,
+            ), InputDispatcher))
 
-        self._event_callbacks.clear()
+        return Dispatchers(dispatchers)
 
-        try:
-            for config in self._context.config.groups or []:
-                self.add_process_group(config)
+    #
 
-            self._signal_handler.set_signals()
+    def _spawn_as_parent(self, sp: SpawnedProcess) -> None:
+        close_child_pipes(sp.pipes)
 
-            if not self._context.config.nodaemon and self._context.first:
-                self._context.daemonize()
+        self._pid_history[sp.pid] = self.process
 
-            # writing pid file needs to come *after* daemonizing or pid will be wrong
-            self._context.write_pidfile()
+    #
 
-            self._event_callbacks.notify(SupervisorRunningEvent())
+    def _spawn_as_child(
+            self,
+            exe: str,
+            argv: ta.Sequence[str],
+            pipes: ProcessPipes,
+    ) -> ta.NoReturn:
+        try:
+            # Prevent child from receiving signals sent to the parent by calling os.setpgrp to create a new process
+            # group for the child. This prevents, for instance, the case of child processes being sent a SIGINT when
+            # running supervisor in foreground mode and Ctrl-C in the terminal window running supervisord is pressed.
+            # Presumably it also prevents HUP, etc. received by supervisord from being sent to children.
+            os.setpgrp()
 
-            while True:
-                if callback is not None and not callback(self):
-                    break
+            #
 
-                self._run_once()
+            # After preparation sending to fd 2 will put this output in the stderr log.
+            self._prepare_child_fds(pipes)
 
-        finally:
-            self._context.cleanup()
+            #
 
-    #
+            setuid_msg = self._set_uid()
+            if setuid_msg:
+                uid = self.config.uid
+                msg = f"Couldn't setuid to {uid}: {setuid_msg}\n"
+                os.write(2, as_bytes('supervisor: ' + msg))
+                raise RuntimeError(msg)
 
-    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()
+            env = os.environ.copy()
+            env['SUPERVISOR_ENABLED'] = '1'
+            env['SUPERVISOR_PROCESS_NAME'] = self.process.name
+            if self.group:
+                env['SUPERVISOR_GROUP_NAME'] = self.group.name
+            if self.config.environment is not None:
+                env.update(self.config.environment)
 
-    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)
+            cwd = self.config.directory
+            try:
+                if cwd is not None:
+                    os.chdir(os.path.expanduser(cwd))
+            except OSError as exc:
+                code = errno.errorcode.get(exc.args[0], exc.args[0])
+                msg = f"Couldn't chdir to {cwd}: {code}\n"
+                os.write(2, as_bytes('supervisor: ' + msg))
+                raise RuntimeError(msg) from exc
 
-    def _poll(self) -> None:
-        combined_map = {}
-        combined_map.update(self.get_process_map())
+            #
 
-        pgroups = list(self._process_groups)
-        pgroups.sort()
+            try:
+                if self.config.umask is not None:
+                    os.umask(self.config.umask)
+                os.execve(exe, list(argv), env)
 
-        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[:]
-                self._event_callbacks.notify(SupervisorStoppingEvent())
+            except OSError as exc:
+                code = errno.errorcode.get(exc.args[0], exc.args[0])
+                msg = f"Couldn't exec {argv[0]}: {code}\n"
+                os.write(2, as_bytes('supervisor: ' + msg))
 
-            self._ordered_stop_groups_phase_1()
+            except Exception:  # noqa
+                (file, fun, line), t, v, tb = compact_traceback()
+                msg = f"Couldn't exec {exe}: {t}, {v}: file: {file} line: {line}\n"
+                os.write(2, as_bytes('supervisor: ' + msg))
 
-            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
+        finally:
+            os.write(2, as_bytes('supervisor: child process was not spawned\n'))
+            real_exit(127)  # exit process with code for spawn failure
 
-        for fd, dispatcher in combined_map.items():
-            if dispatcher.readable():
-                self._poller.register_readable(fd)
-            if dispatcher.writable():
-                self._poller.register_writable(fd)
+        raise RuntimeError('Unreachable')
 
-        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
-        r, w = self._poller.poll(timeout)
+    def _prepare_child_fds(self, pipes: ProcessPipes) -> None:
+        os.dup2(check_not_none(pipes.child_stdin), 0)
 
-        for fd in r:
-            if fd in combined_map:
-                try:
-                    dispatcher = combined_map[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
-                    combined_map[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
+        os.dup2(check_not_none(pipes.child_stdout), 1)
 
-        for fd in w:
-            if fd in combined_map:
-                try:
-                    dispatcher = combined_map[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
-                    combined_map[fd].handle_error()
-            else:
-                log.debug('unexpected write event from fd %r', fd)
-                try:
-                    self._poller.unregister_writable(fd)
-                except Exception:  # noqa
-                    pass
+        if self.config.redirect_stderr:
+            os.dup2(check_not_none(pipes.child_stdout), 2)
+        else:
+            os.dup2(check_not_none(pipes.child_stderr), 2)
 
-        for group in pgroups:
-            group.transition()
+        for i in range(3, self._server_config.minfds):
+            if i in self._inherited_fds:
+                continue
+            close_fd(i)
 
-    def _reap(self, *, once: bool = False, depth: int = 0) -> None:
-        if depth >= 100:
-            return
+    def _set_uid(self) -> ta.Optional[str]:
+        if self.config.uid is None:
+            return None
 
-        pid, sts = self._context.waitpid()
-        if not pid:
-            return
+        msg = drop_privileges(self.config.uid)
+        return msg
 
-        process = self._context.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._context.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()
+def check_execv_args(
+        exe: str,
+        argv: ta.Sequence[str],
+        st: ta.Optional[os.stat_result],
+) -> None:
+    if st is None:
+        raise NotFoundError(f"Can't find command {exe!r}")
 
-        for event in TICK_EVENTS:
-            period = event.period
+    elif stat.S_ISDIR(st[stat.ST_MODE]):
+        raise NotExecutableError(f'Command at {exe!r} is a directory')
 
-            last_tick = self._ticks.get(period)
-            if last_tick is None:
-                # we just started up
-                last_tick = self._ticks[period] = timeslice(period, now)
+    elif not (stat.S_IMODE(st[stat.ST_MODE]) & 0o111):
+        raise NotExecutableError(f'Command at {exe!r} is not executable')
 
-            this_tick = timeslice(period, now)
-            if this_tick != last_tick:
-                self._ticks[period] = this_tick
-                self._event_callbacks.notify(event(this_tick, self))
+    elif not os.access(exe, os.X_OK):
+        raise NoPermissionError(f'No permission to run command {exe!r}')
 
 
 ########################################
 # ../inject.py
 
 
-##
-
-
 def bind_server(
         config: ServerConfig,
         *,
@@ -6966,7 +7552,12 @@ def bind_server(
     lst: ta.List[InjectorBindingOrBindings] = [
         inj.bind(config),
 
-        inj.bind(get_poller_impl(), key=Poller, singleton=True),
+        inj.bind_array_type(DaemonizeListener, DaemonizeListeners),
+
+        inj.bind(SupervisorSetupImpl, singleton=True),
+        inj.bind(SupervisorSetup, to_key=SupervisorSetupImpl),
+
+        inj.bind(DaemonizeListener, array=True, to_key=Poller),
 
         inj.bind(ServerContextImpl, singleton=True),
         inj.bind(ServerContext, to_key=ServerContextImpl),
@@ -6976,11 +7567,18 @@ def bind_server(
         inj.bind(SignalReceiver, singleton=True),
 
         inj.bind(SignalHandler, singleton=True),
-        inj.bind(ProcessGroups, singleton=True),
+        inj.bind(ProcessGroupManager, singleton=True),
         inj.bind(Supervisor, singleton=True),
 
-        inj.bind_factory(ProcessGroupFactory, ProcessGroupImpl),
-        inj.bind_factory(ProcessFactory, ProcessImpl),
+        inj.bind(PidHistory()),
+
+        inj.bind_factory(ProcessGroupImpl, ProcessGroupFactory),
+        inj.bind_factory(ProcessImpl, ProcessFactory),
+
+        inj.bind_factory(ProcessSpawningImpl, ProcessSpawningFactory),
+
+        inj.bind_factory(OutputDispatcherImpl, OutputDispatcherFactory),
+        inj.bind_factory(InputDispatcherImpl, InputDispatcherFactory),
     ]
 
     #
@@ -6992,6 +7590,16 @@ def bind_server(
 
     #
 
+    if config.user is not None:
+        user = get_user(config.user)
+        lst.append(inj.bind(user, key=SupervisorUser))
+
+    #
+
+    lst.append(inj.bind(get_poller_impl(), key=Poller, singleton=True))
+
+    #
+
     return inj.as_bindings(*lst)