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

ominfra/scripts/supervisor.py

@@ -95,7 +95,7 @@ TomlParseFloat = ta.Callable[[str], ta.Any]
 TomlKey = ta.Tuple[str, ...]
 TomlPos = int  # ta.TypeAlias
 
-# ../collections.py
+# ../utils/collections.py
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
@@ -952,168 +952,6 @@ 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
-
-
-class Automatic:
-    pass
-
-
-class Syslog:
-    """TODO deprecated; remove this special 'syslog' filename in the future"""
-
-
-LOGFILE_NONES = ('none', 'off', None)
-LOGFILE_AUTOS = (Automatic, 'auto')
-LOGFILE_SYSLOGS = (Syslog, 'syslog')
-
-
-def logfile_name(val):
-    if hasattr(val, 'lower'):
-        coerced = val.lower()
-    else:
-        coerced = val
-
-    if coerced in LOGFILE_NONES:
-        return None
-    elif coerced in LOGFILE_AUTOS:
-        return Automatic
-    elif coerced in LOGFILE_SYSLOGS:
-        return Syslog
-    else:
-        return existing_dirpath(val)
-
-
-##
-
-
-def octal_type(arg: ta.Union[str, int]) -> int:
-    if isinstance(arg, int):
-        return arg
-    try:
-        return int(arg, 8)
-    except (TypeError, ValueError):
-        raise ValueError(f'{arg} can not be converted to an octal type')  # noqa
-
-
-def existing_directory(v: str) -> str:
-    nv = os.path.expanduser(v)
-    if os.path.isdir(nv):
-        return nv
-    raise ValueError(f'{v} is not an existing directory')
-
-
-def existing_dirpath(v: str) -> str:
-    nv = os.path.expanduser(v)
-    dir = os.path.dirname(nv)  # noqa
-    if not dir:
-        # relative pathname with no directory component
-        return nv
-    if os.path.isdir(dir):
-        return nv
-    raise ValueError(f'The directory named as part of the path {v} does not exist')
-
-
-def logging_level(value: ta.Union[str, int]) -> int:
-    if isinstance(value, int):
-        return value
-    s = str(value).lower()
-    level = logging.getLevelNamesMapping().get(s.upper())
-    if level is None:
-        raise ValueError(f'bad logging level name {value!r}')
-    return level
-
-
-class SuffixMultiplier:
-    # d is a dictionary of suffixes to integer multipliers.  If no suffixes match, default is the multiplier.  Matches
-    # are case insensitive.  Return values are in the fundamental unit.
-    def __init__(self, d, default=1):
-        super().__init__()
-        self._d = d
-        self._default = default
-        # all keys must be the same size
-        self._keysz = None
-        for k in d:
-            if self._keysz is None:
-                self._keysz = len(k)
-            elif self._keysz != len(k):  # type: ignore
-                raise ValueError(k)
-
-    def __call__(self, v: ta.Union[str, int]) -> int:
-        if isinstance(v, int):
-            return v
-        v = v.lower()
-        for s, m in self._d.items():
-            if v[-self._keysz:] == s:  # type: ignore
-                return int(v[:-self._keysz]) * m  # type: ignore
-        return int(v) * self._default
-
-
-byte_size = SuffixMultiplier({
-    'kb': 1024,
-    'mb': 1024 * 1024,
-    'gb': 1024 * 1024 * 1024,
-})
-
-
-class RestartWhenExitUnexpected:
-    pass
-
-
-class RestartUnconditionally:
-    pass
-
-
 ########################################
 # ../exceptions.py
 
@@ -1208,67 +1046,6 @@ def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
     return None
 
 
-########################################
-# ../signals.py
-
-
-##
-
-
-_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_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 sig_name(num: int) -> str:
-    if (sig := _SIGS_BY_NUM.get(num)) is not None:
-        return sig.name
-    return f'signal {sig}'
-
-
-##
-
-
-class SignalReceiver:
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._signals_recvd: ta.List[int] = []
-
-    def receive(self, sig: int, frame: ta.Any = None) -> None:
-        if sig not in self._signals_recvd:
-            self._signals_recvd.append(sig)
-
-    def install(self, *sigs: int) -> None:
-        for sig in sigs:
-            signal.signal(sig, self.receive)
-
-    def get_signal(self) -> ta.Optional[int]:
-        if self._signals_recvd:
-            sig = self._signals_recvd.pop(0)
-        else:
-            sig = None
-        return sig
-
-
 ########################################
 # ../states.py
 
@@ -1330,67 +1107,310 @@ class SupervisorState(enum.IntEnum):
 
 
 ########################################
-# ../users.py
+# ../utils/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 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 __len__(self) -> int:
+        return len(self._by_key)
 
+    def __contains__(self, key: K) -> bool:
+        return key in self._by_key
 
-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 __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 gid_for_uid(uid: int) -> int:
-    pwrec = pwd.getpwuid(uid)
-    return pwrec[3]
+    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
 
-@dc.dataclass(frozen=True)
-class User:
-    name: str
-    uid: int
-    gid: int
+    @property
+    def _by_key(self) -> ta.Mapping[K, V]:
+        return self.__by_key
 
+    @abc.abstractmethod
+    def _key(self, v: V) -> K:
+        raise NotImplementedError
+
+
+########################################
+# ../utils/diag.py
+
+
+def compact_traceback() -> ta.Tuple[
+    ta.Tuple[str, str, int],
+    ta.Type[BaseException],
+    BaseException,
+    types.TracebackType,
+]:
+    t, v, tb = sys.exc_info()
+    if not tb:
+        raise RuntimeError('No traceback')
+
+    tbinfo = []
+    while tb:
+        tbinfo.append((
+            tb.tb_frame.f_code.co_filename,
+            tb.tb_frame.f_code.co_name,
+            str(tb.tb_lineno),
+        ))
+        tb = tb.tb_next
+
+    # just to be safe
+    del tb
+
+    file, function, line = tbinfo[-1]
+    info = ' '.join(['[%s|%s|%s]' % x for x in tbinfo])  # noqa
+    return (file, function, line), t, v, info  # type: ignore
+
+
+########################################
+# ../utils/fs.py
+
+
+def try_unlink(path: str) -> bool:
+    try:
+        os.unlink(path)
+    except OSError:
+        return False
+    return True
+
+
+def mktempfile(suffix: str, prefix: str, dir: str) -> str:  # noqa
+    fd, filename = tempfile.mkstemp(suffix, prefix, dir)
+    os.close(fd)
+    return filename
+
+
+def get_path() -> ta.Sequence[str]:
+    """Return a list corresponding to $PATH, or a default."""
+
+    path = ['/bin', '/usr/bin', '/usr/local/bin']
+    if 'PATH' in os.environ:
+        p = os.environ['PATH']
+        if p:
+            path = p.split(os.pathsep)
+    return path
+
+
+def check_existing_dir(v: str) -> str:
+    nv = os.path.expanduser(v)
+    if os.path.isdir(nv):
+        return nv
+    raise ValueError(f'{v} is not an existing directory')
+
+
+def check_path_with_existing_dir(v: str) -> str:
+    nv = os.path.expanduser(v)
+    dir = os.path.dirname(nv)  # noqa
+    if not dir:
+        # relative pathname with no directory component
+        return nv
+    if os.path.isdir(dir):
+        return nv
+    raise ValueError(f'The directory named as part of the path {v} does not exist')
+
+
+########################################
+# ../utils/ostypes.py
+
+
+Fd = ta.NewType('Fd', int)
+Pid = ta.NewType('Pid', int)
+Rc = ta.NewType('Rc', int)
+
+Uid = ta.NewType('Uid', int)
+Gid = ta.NewType('Gid', int)
+
+
+########################################
+# ../utils/signals.py
+
+
+##
+
+
+_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_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 sig_name(num: int) -> str:
+    if (sig := _SIGS_BY_NUM.get(num)) is not None:
+        return sig.name
+    return f'signal {sig}'
+
+
+##
+
+
+class SignalReceiver:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._signals_recvd: ta.List[int] = []
+
+    def receive(self, sig: int, frame: ta.Any = None) -> None:
+        if sig not in self._signals_recvd:
+            self._signals_recvd.append(sig)
+
+    def install(self, *sigs: int) -> None:
+        for sig in sigs:
+            signal.signal(sig, self.receive)
+
+    def get_signal(self) -> ta.Optional[int]:
+        if self._signals_recvd:
+            sig = self._signals_recvd.pop(0)
+        else:
+            sig = None
+        return sig
+
+
+########################################
+# ../utils/strings.py
+
+
+##
+
+
+def as_bytes(s: ta.Union[str, bytes], encoding: str = 'utf8') -> bytes:
+    if isinstance(s, bytes):
+        return s
+    else:
+        return s.encode(encoding)
+
+
+@ta.overload
+def find_prefix_at_end(haystack: str, needle: str) -> int:
+    ...
+
+
+@ta.overload
+def find_prefix_at_end(haystack: bytes, needle: bytes) -> int:
+    ...
+
+
+def find_prefix_at_end(haystack, needle):
+    l = len(needle) - 1
+    while l and not haystack.endswith(needle[:l]):
+        l -= 1
+    return l
+
+
+##
+
+
+ANSI_ESCAPE_BEGIN = b'\x1b['
+ANSI_TERMINATORS = (b'H', b'f', b'A', b'B', b'C', b'D', b'R', b's', b'u', b'J', b'K', b'h', b'l', b'p', b'm')
+
+
+def strip_escapes(s: bytes) -> bytes:
+    """Remove all ANSI color escapes from the given string."""
+
+    result = b''
+    show = 1
+    i = 0
+    l = len(s)
+    while i < l:
+        if show == 0 and s[i:i + 1] in ANSI_TERMINATORS:
+            show = 1
+        elif show:
+            n = s.find(ANSI_ESCAPE_BEGIN, i)
+            if n == -1:
+                return result + s[i:]
+            else:
+                result = result + s[i:n]
+                i = n
+                show = 0
+        i += 1
+    return result
+
+
+##
+
+
+class SuffixMultiplier:
+    # d is a dictionary of suffixes to integer multipliers.  If no suffixes match, default is the multiplier.  Matches
+    # are case insensitive.  Return values are in the fundamental unit.
+    def __init__(self, d, default=1):
+        super().__init__()
+        self._d = d
+        self._default = default
+        # all keys must be the same size
+        self._keysz = None
+        for k in d:
+            if self._keysz is None:
+                self._keysz = len(k)
+            elif self._keysz != len(k):  # type: ignore
+                raise ValueError(k)
+
+    def __call__(self, v: ta.Union[str, int]) -> int:
+        if isinstance(v, int):
+            return v
+        v = v.lower()
+        for s, m in self._d.items():
+            if v[-self._keysz:] == s:  # type: ignore
+                return int(v[:-self._keysz]) * m  # type: ignore
+        return int(v) * self._default
 
-def get_user(name: str) -> User:
-    return User(
-        name=name,
-        uid=(uid := name_to_uid(name)),
-        gid=gid_for_uid(uid),
-    )
+
+parse_bytes_size = SuffixMultiplier({
+    'kb': 1024,
+    'mb': 1024 * 1024,
+    'gb': 1024 * 1024 * 1024,
+})
+
+
+#
+
+
+def parse_octal(arg: ta.Union[str, int]) -> int:
+    if isinstance(arg, int):
+        return arg
+    try:
+        return int(arg, 8)
+    except (TypeError, ValueError):
+        raise ValueError(f'{arg} can not be converted to an octal type')  # noqa
 
 
 ########################################
@@ -1474,6 +1494,30 @@ def check_not_equal(l: T, r: T) -> T:
     return l
 
 
+def check_is(l: T, r: T) -> T:
+    if l is not r:
+        raise ValueError(l, r)
+    return l
+
+
+def check_is_not(l: T, r: ta.Any) -> T:
+    if l is r:
+        raise ValueError(l, r)
+    return l
+
+
+def check_in(v: T, c: ta.Container[T]) -> T:
+    if v not in c:
+        raise ValueError(v, c)
+    return v
+
+
+def check_not_in(v: T, c: ta.Container[T]) -> T:
+    if v in c:
+        raise ValueError(v, c)
+    return v
+
+
 def check_single(vs: ta.Iterable[T]) -> T:
     [v] = vs
     return v
@@ -2032,112 +2076,64 @@ def get_event_name_by_type(requested):
 
 
 ########################################
-# ../setup.py
-
-
-##
-
+# ../utils/fds.py
 
-SupervisorUser = ta.NewType('SupervisorUser', User)
 
+class PipeFds(ta.NamedTuple):
+    r: Fd
+    w: Fd
 
-##
 
+def make_pipe() -> PipeFds:
+    return PipeFds(*os.pipe())  # type: ignore
 
-class DaemonizeListener(abc.ABC):  # noqa
-    def before_daemonize(self) -> None:  # noqa
-        pass
-
-    def after_daemonize(self) -> None:  # noqa
-        pass
 
+def read_fd(fd: Fd) -> bytes:
+    try:
+        data = os.read(fd, 2 << 16)  # 128K
+    except OSError as why:
+        if why.args[0] not in (errno.EWOULDBLOCK, errno.EBADF, errno.EINTR):
+            raise
+        data = b''
+    return data
 
-DaemonizeListeners = ta.NewType('DaemonizeListeners', ta.Sequence[DaemonizeListener])
 
+def close_fd(fd: Fd) -> bool:
+    try:
+        os.close(fd)
+    except OSError:
+        return False
+    return True
 
-##
 
+def is_fd_open(fd: Fd) -> bool:
+    try:
+        n = os.dup(fd)
+    except OSError:
+        return False
+    os.close(n)
+    return True
 
-class SupervisorSetup(abc.ABC):
-    @abc.abstractmethod
-    def setup(self) -> None:
-        raise NotImplementedError
 
-    @abc.abstractmethod
-    def cleanup(self) -> None:
-        raise NotImplementedError
+def get_open_fds(limit: int) -> ta.FrozenSet[Fd]:
+    return frozenset(fd for i in range(limit) if is_fd_open(fd := Fd(i)))
 
 
 ########################################
-# ../utils.py
+# ../utils/os.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,
-    types.TracebackType,
-]:
-    t, v, tb = sys.exc_info()
-    if not tb:
-        raise RuntimeError('No traceback')
-
-    tbinfo = []
-    while tb:
-        tbinfo.append((
-            tb.tb_frame.f_code.co_filename,
-            tb.tb_frame.f_code.co_name,
-            str(tb.tb_lineno),
-        ))
-        tb = tb.tb_next
-
-    # just to be safe
-    del tb
-
-    file, function, line = tbinfo[-1]
-    info = ' '.join(['[%s|%s|%s]' % x for x in tbinfo])  # noqa
-    return (file, function, line), t, v, info  # type: ignore
-
-
-class ExitNow(Exception):  # noqa
-    pass
-
-
-def real_exit(code: int) -> None:
+def real_exit(code: Rc) -> None:
     os._exit(code)  # noqa
 
 
 ##
 
 
-def decode_wait_status(sts: int) -> ta.Tuple[int, str]:
+def decode_wait_status(sts: int) -> ta.Tuple[Rc, str]:
     """
     Decode the status returned by wait() or waitpid().
 
@@ -2148,7 +2144,8 @@ def decode_wait_status(sts: int) -> ta.Tuple[int, str]:
     if os.WIFEXITED(sts):
         es = os.WEXITSTATUS(sts) & 0xffff
         msg = f'exit status {es}'
-        return es, msg
+        return Rc(es), msg
+
     elif os.WIFSIGNALED(sts):
         sig = os.WTERMSIG(sts)
         msg = f'terminated by {sig_name(sig)}'
@@ -2158,112 +2155,75 @@ def decode_wait_status(sts: int) -> ta.Tuple[int, str]:
             iscore = bool(sts & 0x80)
         if iscore:
             msg += ' (core dumped)'
-        return -1, msg
+        return Rc(-1), msg
+
     else:
         msg = 'unknown termination cause 0x%04x' % sts  # noqa
-        return -1, msg
+        return Rc(-1), msg
 
 
-##
-
-
-def read_fd(fd: int) -> bytes:
-    try:
-        data = os.read(fd, 2 << 16)  # 128K
-    except OSError as why:
-        if why.args[0] not in (errno.EWOULDBLOCK, errno.EBADF, errno.EINTR):
-            raise
-        data = b''
-    return data
+########################################
+# ../utils/users.py
 
 
-def try_unlink(path: str) -> bool:
-    try:
-        os.unlink(path)
-    except OSError:
-        return False
-    return True
+##
 
 
-def close_fd(fd: int) -> bool:
+def name_to_uid(name: str) -> Uid:
     try:
-        os.close(fd)
-    except OSError:
-        return False
-    return True
+        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(uid)
 
 
-def is_fd_open(fd: int) -> bool:
+def name_to_gid(name: str) -> Gid:
     try:
-        n = os.dup(fd)
-    except OSError:
-        return False
-    os.close(n)
-    return True
-
-
-def get_open_fds(limit: int) -> ta.FrozenSet[int]:
-    return frozenset(filter(is_fd_open, range(limit)))
-
-
-def mktempfile(suffix: str, prefix: str, dir: str) -> str:  # noqa
-    fd, filename = tempfile.mkstemp(suffix, prefix, dir)
-    os.close(fd)
-    return filename
-
-
-##
-
-
-def get_path() -> ta.Sequence[str]:
-    """Return a list corresponding to $PATH, or a default."""
-
-    path = ['/bin', '/usr/bin', '/usr/local/bin']
-    if 'PATH' in os.environ:
-        p = os.environ['PATH']
-        if p:
-            path = p.split(os.pathsep)
-    return path
-
-
-def normalize_path(v: str) -> str:
-    return os.path.normpath(os.path.abspath(os.path.expanduser(v)))
-
-
-##
-
-
-ANSI_ESCAPE_BEGIN = b'\x1b['
-ANSI_TERMINATORS = (b'H', b'f', b'A', b'B', b'C', b'D', b'R', b's', b'u', b'J', b'K', b'h', b'l', b'p', b'm')
-
-
-def strip_escapes(s: bytes) -> bytes:
-    """Remove all ANSI color escapes from the given string."""
-
-    result = b''
-    show = 1
-    i = 0
-    l = len(s)
-    while i < l:
-        if show == 0 and s[i:i + 1] in ANSI_TERMINATORS:
-            show = 1
-        elif show:
-            n = s.find(ANSI_ESCAPE_BEGIN, i)
-            if n == -1:
-                return result + s[i:]
-            else:
-                result = result + s[i:n]
-                i = n
-                show = 0
-        i += 1
-    return result
+        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(gid)
+
+
+def gid_for_uid(uid: Uid) -> Gid:
+    pwrec = pwd.getpwuid(uid)
+    return Gid(pwrec[3])
 
 
 ##
 
 
-def timeslice(period: int, when: float) -> int:
-    return int(when - (when % period))
+@dc.dataclass(frozen=True)
+class User:
+    name: str
+    uid: Uid
+    gid: Gid
+
+
+def get_user(name: str) -> User:
+    return User(
+        name=name,
+        uid=(uid := name_to_uid(name)),
+        gid=gid_for_uid(uid),
+    )
 
 
 ########################################
@@ -2668,6 +2628,11 @@ class HttpRequestParser:
 
 ########################################
 # ../../../omlish/lite/inject.py
+"""
+TODO:
+ - recursion detection
+ - bind empty array
+"""
 
 
 ###
@@ -2767,7 +2732,7 @@ class InjectorError(Exception):
     pass
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class InjectorKeyError(InjectorError):
     key: InjectorKey
 
@@ -2775,16 +2740,18 @@ class InjectorKeyError(InjectorError):
     name: ta.Optional[str] = None
 
 
-@dc.dataclass(frozen=True)
 class UnboundInjectorKeyError(InjectorKeyError):
     pass
 
 
-@dc.dataclass(frozen=True)
 class DuplicateInjectorKeyError(InjectorKeyError):
     pass
 
 
+class CyclicDependencyInjectorKeyError(InjectorKeyError):
+    pass
+
+
 ###
 # keys
 
@@ -3118,22 +3085,65 @@ class _Injector(Injector):
         if _INJECTOR_INJECTOR_KEY in self._pfm:
             raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
 
+        self.__cur_req: ta.Optional[_Injector._Request] = None
+
+    class _Request:
+        def __init__(self, injector: '_Injector') -> None:
+            super().__init__()
+            self._injector = injector
+            self._provisions: ta.Dict[InjectorKey, Maybe] = {}
+            self._seen_keys: ta.Set[InjectorKey] = set()
+
+        def handle_key(self, key: InjectorKey) -> Maybe[Maybe]:
+            try:
+                return Maybe.just(self._provisions[key])
+            except KeyError:
+                pass
+            if key in self._seen_keys:
+                raise CyclicDependencyInjectorKeyError(key)
+            self._seen_keys.add(key)
+            return Maybe.empty()
+
+        def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
+            check_in(key, self._seen_keys)
+            check_not_in(key, self._provisions)
+            self._provisions[key] = mv
+            return mv
+
+    @contextlib.contextmanager
+    def _current_request(self) -> ta.Generator[_Request, None, None]:
+        if (cr := self.__cur_req) is not None:
+            yield cr
+            return
+
+        cr = self._Request(self)
+        try:
+            self.__cur_req = cr
+            yield cr
+        finally:
+            self.__cur_req = None
+
     def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
         key = as_injector_key(key)
 
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
+        cr: _Injector._Request
+        with self._current_request() as cr:
+            if (rv := cr.handle_key(key)).present:
+                return rv.must()
 
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
+            if key == _INJECTOR_INJECTOR_KEY:
+                return cr.handle_provision(key, Maybe.just(self))
 
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
+            fn = self._pfm.get(key)
+            if fn is not None:
+                return cr.handle_provision(key, Maybe.just(fn(self)))
 
-        return Maybe.empty()
+            if self._p is not None:
+                pv = self._p.try_provide(key)
+                if pv is not None:
+                    return cr.handle_provision(key, Maybe.empty())
+
+            return cr.handle_provision(key, Maybe.empty())
 
     def provide(self, key: ta.Any) -> ta.Any:
         v = self.try_provide(key)
@@ -4222,6 +4232,23 @@ def unmarshal_obj(o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
     return get_obj_marshaler(ty).unmarshal(o)
 
 
+########################################
+# ../../../omlish/lite/runtime.py
+
+
+@cached_nullary
+def is_debugger_attached() -> bool:
+    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+
+
+REQUIRED_PYTHON_VERSION = (3, 8)
+
+
+def check_runtime_version() -> None:
+    if sys.version_info < REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+
+
 ########################################
 # ../../configs.py
 
@@ -4288,19 +4315,19 @@ def build_config_named_children(
 
 @dc.dataclass(frozen=True)
 class ProcessPipes:
-    child_stdin: ta.Optional[int] = None
-    stdin: ta.Optional[int] = None
+    child_stdin: ta.Optional[Fd] = None
+    stdin: ta.Optional[Fd] = None
 
-    stdout: ta.Optional[int] = None
-    child_stdout: ta.Optional[int] = None
+    stdout: ta.Optional[Fd] = None
+    child_stdout: ta.Optional[Fd] = None
 
-    stderr: ta.Optional[int] = None
-    child_stderr: ta.Optional[int] = None
+    stderr: ta.Optional[Fd] = None
+    child_stderr: ta.Optional[Fd] = None
 
-    def child_fds(self) -> ta.List[int]:
+    def child_fds(self) -> ta.List[Fd]:
         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]:
+    def parent_fds(self) -> ta.List[Fd]:
         return [fd for fd in [self.stdin, self.stdout, self.stderr] if fd is not None]
 
 
@@ -4310,7 +4337,7 @@ def make_process_pipes(stderr=True) -> ProcessPipes:
     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]] = {
+    pipes: ta.Dict[str, ta.Optional[Fd]] = {
         'child_stdin': None,
         'stdin': None,
 
@@ -4322,11 +4349,11 @@ def make_process_pipes(stderr=True) -> ProcessPipes:
     }
 
     try:
-        pipes['child_stdin'], pipes['stdin'] = os.pipe()
-        pipes['stdout'], pipes['child_stdout'] = os.pipe()
+        pipes['child_stdin'], pipes['stdin'] = make_pipe()
+        pipes['stdout'], pipes['child_stdout'] = make_pipe()
 
         if stderr:
-            pipes['stderr'], pipes['child_stderr'] = os.pipe()
+            pipes['stderr'], pipes['child_stderr'] = make_pipe()
 
         for fd in (
                 pipes['stdout'],
@@ -4362,6 +4389,218 @@ def close_child_pipes(pipes: ProcessPipes) -> None:
         close_fd(fd)
 
 
+########################################
+# ../setup.py
+
+
+##
+
+
+SupervisorUser = ta.NewType('SupervisorUser', User)
+
+
+##
+
+
+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])
+
+
+##
+
+
+class SupervisorSetup(abc.ABC):
+    @abc.abstractmethod
+    def setup(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def cleanup(self) -> None:
+        raise NotImplementedError
+
+
+########################################
+# ../../../omlish/lite/http/handlers.py
+
+
+@dc.dataclass(frozen=True)
+class HttpHandlerRequest:
+    client_address: SocketAddress
+    method: str
+    path: str
+    headers: HttpHeaders
+    data: ta.Optional[bytes]
+
+
+@dc.dataclass(frozen=True)
+class HttpHandlerResponse:
+    status: ta.Union[http.HTTPStatus, int]
+
+    headers: ta.Optional[ta.Mapping[str, str]] = None
+    data: ta.Optional[bytes] = None
+    close_connection: ta.Optional[bool] = None
+
+
+class HttpHandlerError(Exception):
+    pass
+
+
+class UnsupportedMethodHttpHandlerError(Exception):
+    pass
+
+
+########################################
+# ../configs.py
+
+
+##
+
+
+class RestartWhenExitUnexpected:
+    pass
+
+
+class RestartUnconditionally:
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ProcessConfig:
+    name: str
+    command: str
+
+    uid: ta.Optional[int] = None
+    directory: ta.Optional[str] = None
+    umask: ta.Optional[int] = None
+    priority: int = 999
+
+    autostart: bool = True
+    autorestart: str = 'unexpected'
+
+    startsecs: int = 1
+    startretries: int = 3
+
+    numprocs: int = 1
+    numprocs_start: int = 0
+
+    @dc.dataclass(frozen=True)
+    class Log:
+        file: ta.Optional[str] = None
+        capture_maxbytes: ta.Optional[int] = None
+        events_enabled: bool = False
+        syslog: bool = False
+        backups: ta.Optional[int] = None
+        maxbytes: ta.Optional[int] = None
+
+    stdout: Log = Log()
+    stderr: Log = Log()
+
+    stopsignal: int = signal.SIGTERM
+    stopwaitsecs: int = 10
+    stopasgroup: bool = False
+
+    killasgroup: bool = False
+
+    exitcodes: ta.Sequence[int] = (0,)
+
+    redirect_stderr: bool = False
+
+    environment: ta.Optional[ta.Mapping[str, str]] = None
+
+
+@dc.dataclass(frozen=True)
+class ProcessGroupConfig:
+    name: str
+
+    priority: int = 999
+
+    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
+
+
+@dc.dataclass(frozen=True)
+class ServerConfig:
+    user: ta.Optional[str] = None
+    nodaemon: bool = False
+    umask: int = 0o22
+    directory: ta.Optional[str] = None
+    logfile: str = 'supervisord.log'
+    logfile_maxbytes: int = 50 * 1024 * 1024
+    logfile_backups: int = 10
+    loglevel: int = logging.INFO
+    pidfile: str = 'supervisord.pid'
+    identifier: str = 'supervisor'
+    child_logdir: str = '/dev/null'
+    minfds: int = 1024
+    minprocs: int = 200
+    nocleanup: bool = False
+    strip_ansi: bool = False
+    silent: bool = False
+
+    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = None
+
+    @classmethod
+    def new(
+            cls,
+            umask: ta.Union[int, str] = 0o22,
+            directory: ta.Optional[str] = None,
+            logfile: str = 'supervisord.log',
+            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
+            loglevel: ta.Union[int, str] = logging.INFO,
+            pidfile: str = 'supervisord.pid',
+            child_logdir: ta.Optional[str] = None,
+            **kwargs: ta.Any,
+    ) -> 'ServerConfig':
+        return cls(
+            umask=parse_octal(umask),
+            directory=check_existing_dir(directory) if directory is not None else None,
+            logfile=check_path_with_existing_dir(logfile),
+            logfile_maxbytes=parse_bytes_size(logfile_maxbytes),
+            loglevel=parse_logging_level(loglevel),
+            pidfile=check_path_with_existing_dir(pidfile),
+            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
+            **kwargs,
+        )
+
+
+##
+
+
+def prepare_process_group_config(dct: ConfigMapping) -> ConfigMapping:
+    out = dict(dct)
+    out['processes'] = build_config_named_children(out.get('processes'))
+    return out
+
+
+def prepare_server_config(dct: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, ta.Any]:
+    out = dict(dct)
+    group_dcts = build_config_named_children(out.get('groups'))
+    out['groups'] = [prepare_process_group_config(group_dct) for group_dct in group_dcts or []]
+    return out
+
+
+##
+
+
+def parse_logging_level(value: ta.Union[str, int]) -> int:
+    if isinstance(value, int):
+        return value
+    s = str(value).lower()
+    level = logging.getLevelNamesMapping().get(s.upper())
+    if level is None:
+        raise ValueError(f'bad logging level name {value!r}')
+    return level
+
+
 ########################################
 # ../poller.py
 
@@ -4371,23 +4610,23 @@ class Poller(DaemonizeListener, abc.ABC):
         super().__init__()
 
     @abc.abstractmethod
-    def register_readable(self, fd: int) -> None:
+    def register_readable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def register_writable(self, fd: int) -> None:
+    def register_writable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def unregister_readable(self, fd: int) -> None:
+    def unregister_readable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def unregister_writable(self, fd: int) -> None:
+    def unregister_writable(self, fd: Fd) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
         raise NotImplementedError
 
     def before_daemonize(self) -> None:  # noqa
@@ -4404,37 +4643,37 @@ class SelectPoller(Poller):
     def __init__(self) -> None:
         super().__init__()
 
-        self._readable: ta.Set[int] = set()
-        self._writable: ta.Set[int] = set()
+        self._readable: ta.Set[Fd] = set()
+        self._writable: ta.Set[Fd] = set()
 
-    def register_readable(self, fd: int) -> None:
+    def register_readable(self, fd: Fd) -> None:
         self._readable.add(fd)
 
-    def register_writable(self, fd: int) -> None:
+    def register_writable(self, fd: Fd) -> None:
         self._writable.add(fd)
 
-    def unregister_readable(self, fd: int) -> None:
+    def unregister_readable(self, fd: Fd) -> None:
         self._readable.discard(fd)
 
-    def unregister_writable(self, fd: int) -> None:
+    def unregister_writable(self, fd: Fd) -> None:
         self._writable.discard(fd)
 
     def unregister_all(self) -> None:
         self._readable.clear()
         self._writable.clear()
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
         try:
             r, w, x = select.select(
                 self._readable,
                 self._writable,
                 [], timeout,
             )
-        except OSError as err:
-            if err.args[0] == errno.EINTR:
+        except OSError as exc:
+            if exc.args[0] == errno.EINTR:
                 log.debug('EINTR encountered in poll')
                 return [], []
-            if err.args[0] == errno.EBADF:
+            if exc.args[0] == errno.EBADF:
                 log.debug('EBADF encountered in poll')
                 self.unregister_all()
                 return [], []
@@ -4450,30 +4689,30 @@ class PollPoller(Poller):
         super().__init__()
 
         self._poller = select.poll()
-        self._readable: set[int] = set()
-        self._writable: set[int] = set()
+        self._readable: set[Fd] = set()
+        self._writable: set[Fd] = set()
 
-    def register_readable(self, fd: int) -> None:
+    def register_readable(self, fd: Fd) -> None:
         self._poller.register(fd, self._READ)
         self._readable.add(fd)
 
-    def register_writable(self, fd: int) -> None:
+    def register_writable(self, fd: Fd) -> None:
         self._poller.register(fd, self._WRITE)
         self._writable.add(fd)
 
-    def unregister_readable(self, fd: int) -> None:
+    def unregister_readable(self, fd: Fd) -> None:
         self._readable.discard(fd)
         self._poller.unregister(fd)
         if fd in self._writable:
             self._poller.register(fd, self._WRITE)
 
-    def unregister_writable(self, fd: int) -> None:
+    def unregister_writable(self, fd: Fd) -> None:
         self._writable.discard(fd)
         self._poller.unregister(fd)
         if fd in self._readable:
             self._poller.register(fd, self._READ)
 
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
         fds = self._poll_fds(timeout)  # type: ignore
         readable, writable = [], []
         for fd, eventmask in fds:
@@ -4485,16 +4724,16 @@ class PollPoller(Poller):
                 writable.append(fd)
         return readable, writable
 
-    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[int, int]]:
+    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[Fd, Fd]]:
         try:
-            return self._poller.poll(timeout * 1000)
-        except OSError as err:
-            if err.args[0] == errno.EINTR:
+            return self._poller.poll(timeout * 1000)  # type: ignore
+        except OSError as exc:
+            if exc.args[0] == errno.EINTR:
                 log.debug('EINTR encountered in poll')
                 return []
             raise
 
-    def _ignore_invalid(self, fd: int, eventmask: int) -> bool:
+    def _ignore_invalid(self, fd: Fd, eventmask: int) -> bool:
         if eventmask & select.POLLNVAL:
             # POLLNVAL means `fd` value is invalid, not open. When a process quits it's `fd`s are closed so there is no
             # more reason to keep this `fd` registered If the process restarts it's `fd`s are registered again.
@@ -4513,30 +4752,30 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
             super().__init__()
 
             self._kqueue: ta.Optional[ta.Any] = select.kqueue()
-            self._readable: set[int] = set()
-            self._writable: set[int] = set()
+            self._readable: set[Fd] = set()
+            self._writable: set[Fd] = set()
 
-        def register_readable(self, fd: int) -> None:
+        def register_readable(self, fd: Fd) -> None:
             self._readable.add(fd)
             kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_ADD)
             self._kqueue_control(fd, kevent)
 
-        def register_writable(self, fd: int) -> None:
+        def register_writable(self, fd: Fd) -> None:
             self._writable.add(fd)
             kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_ADD)
             self._kqueue_control(fd, kevent)
 
-        def unregister_readable(self, fd: int) -> None:
+        def unregister_readable(self, fd: Fd) -> None:
             kevent = select.kevent(fd, filter=select.KQ_FILTER_READ, flags=select.KQ_EV_DELETE)
             self._readable.discard(fd)
             self._kqueue_control(fd, kevent)
 
-        def unregister_writable(self, fd: int) -> None:
+        def unregister_writable(self, fd: Fd) -> None:
             kevent = select.kevent(fd, filter=select.KQ_FILTER_WRITE, flags=select.KQ_EV_DELETE)
             self._writable.discard(fd)
             self._kqueue_control(fd, kevent)
 
-        def _kqueue_control(self, fd: int, kevent: 'select.kevent') -> None:
+        def _kqueue_control(self, fd: Fd, kevent: 'select.kevent') -> None:
             try:
                 self._kqueue.control([kevent], 0)  # type: ignore
             except OSError as error:
@@ -4545,7 +4784,7 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
                 else:
                     raise
 
-        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[int], ta.List[int]]:
+        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
             readable, writable = [], []  # type: ignore
 
             try:
@@ -4595,157 +4834,6 @@ def get_poller_impl() -> ta.Type[Poller]:
         return SelectPoller
 
 
-########################################
-# ../../../omlish/lite/http/handlers.py
-
-
-@dc.dataclass(frozen=True)
-class HttpHandlerRequest:
-    client_address: SocketAddress
-    method: str
-    path: str
-    headers: HttpHeaders
-    data: ta.Optional[bytes]
-
-
-@dc.dataclass(frozen=True)
-class HttpHandlerResponse:
-    status: ta.Union[http.HTTPStatus, int]
-
-    headers: ta.Optional[ta.Mapping[str, str]] = None
-    data: ta.Optional[bytes] = None
-    close_connection: ta.Optional[bool] = None
-
-
-class HttpHandlerError(Exception):
-    pass
-
-
-class UnsupportedMethodHttpHandlerError(Exception):
-    pass
-
-
-########################################
-# ../configs.py
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class ProcessConfig:
-    name: str
-    command: str
-
-    uid: ta.Optional[int] = None
-    directory: ta.Optional[str] = None
-    umask: ta.Optional[int] = None
-    priority: int = 999
-
-    autostart: bool = True
-    autorestart: str = 'unexpected'
-
-    startsecs: int = 1
-    startretries: int = 3
-
-    numprocs: int = 1
-    numprocs_start: int = 0
-
-    @dc.dataclass(frozen=True)
-    class Log:
-        file: ta.Optional[str] = None
-        capture_maxbytes: ta.Optional[int] = None
-        events_enabled: bool = False
-        syslog: bool = False
-        backups: ta.Optional[int] = None
-        maxbytes: ta.Optional[int] = None
-
-    stdout: Log = Log()
-    stderr: Log = Log()
-
-    stopsignal: int = signal.SIGTERM
-    stopwaitsecs: int = 10
-    stopasgroup: bool = False
-
-    killasgroup: bool = False
-
-    exitcodes: ta.Sequence[int] = (0,)
-
-    redirect_stderr: bool = False
-
-    environment: ta.Optional[ta.Mapping[str, str]] = None
-
-
-@dc.dataclass(frozen=True)
-class ProcessGroupConfig:
-    name: str
-
-    priority: int = 999
-
-    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
-
-
-@dc.dataclass(frozen=True)
-class ServerConfig:
-    user: ta.Optional[str] = None
-    nodaemon: bool = False
-    umask: int = 0o22
-    directory: ta.Optional[str] = None
-    logfile: str = 'supervisord.log'
-    logfile_maxbytes: int = 50 * 1024 * 1024
-    logfile_backups: int = 10
-    loglevel: int = logging.INFO
-    pidfile: str = 'supervisord.pid'
-    identifier: str = 'supervisor'
-    child_logdir: str = '/dev/null'
-    minfds: int = 1024
-    minprocs: int = 200
-    nocleanup: bool = False
-    strip_ansi: bool = False
-    silent: bool = False
-
-    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = None
-
-    @classmethod
-    def new(
-            cls,
-            umask: ta.Union[int, str] = 0o22,
-            directory: ta.Optional[str] = None,
-            logfile: str = 'supervisord.log',
-            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
-            loglevel: ta.Union[int, str] = logging.INFO,
-            pidfile: str = 'supervisord.pid',
-            child_logdir: ta.Optional[str] = None,
-            **kwargs: ta.Any,
-    ) -> 'ServerConfig':
-        return cls(
-            umask=octal_type(umask),
-            directory=existing_directory(directory) if directory is not None else None,
-            logfile=existing_dirpath(logfile),
-            logfile_maxbytes=byte_size(logfile_maxbytes),
-            loglevel=logging_level(loglevel),
-            pidfile=existing_dirpath(pidfile),
-            child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
-            **kwargs,
-        )
-
-
-##
-
-
-def prepare_process_group_config(dct: ConfigMapping) -> ConfigMapping:
-    out = dict(dct)
-    out['processes'] = build_config_named_children(out.get('processes'))
-    return out
-
-
-def prepare_server_config(dct: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, ta.Any]:
-    out = dict(dct)
-    group_dcts = build_config_named_children(out.get('groups'))
-    out['groups'] = [prepare_process_group_config(group_dct) for group_dct in group_dcts or []]
-    return out
-
-
 ########################################
 # ../../../omlish/lite/http/coroserver.py
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
@@ -5313,6 +5401,10 @@ class CoroHttpServerSocketHandler(SocketHandler):
 ##
 
 
+class ExitNow(Exception):  # noqa
+    pass
+
+
 ServerEpoch = ta.NewType('ServerEpoch', int)
 
 
@@ -5336,12 +5428,7 @@ class ConfigPriorityOrdered(abc.ABC):
 ##
 
 
-class ServerContext(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def config(self) -> ServerConfig:
-        raise NotImplementedError
-
+class SupervisorStateManager(abc.ABC):
     @property
     @abc.abstractmethod
     def state(self) -> SupervisorState:
@@ -5351,21 +5438,11 @@ class ServerContext(abc.ABC):
     def set_state(self, state: SupervisorState) -> None:
         raise NotImplementedError
 
-    @property
-    @abc.abstractmethod
-    def pid_history(self) -> ta.Dict[int, 'Process']:
-        raise NotImplementedError
-
 
 ##
 
 
 class Dispatcher(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def process(self) -> 'Process':
-        raise NotImplementedError
-
     @property
     @abc.abstractmethod
     def channel(self) -> str:
@@ -5373,7 +5450,7 @@ class Dispatcher(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def fd(self) -> int:
+    def fd(self) -> Fd:
         raise NotImplementedError
 
     @property
@@ -5409,8 +5486,32 @@ class Dispatcher(abc.ABC):
     def handle_write_event(self) -> None:
         raise TypeError
 
+    #
+
+    def handle_connect(self) -> None:
+        raise TypeError
+
+    def handle_close(self) -> None:
+        raise TypeError
+
+    def handle_accepted(self, sock, addr) -> None:
+        raise TypeError
+
+
+class HasDispatchers(abc.ABC):
+    @abc.abstractmethod
+    def get_dispatchers(self) -> 'Dispatchers':
+        raise NotImplementedError
+
+
+class ProcessDispatcher(Dispatcher, abc.ABC):
+    @property
+    @abc.abstractmethod
+    def process(self) -> 'Process':
+        raise NotImplementedError
 
-class OutputDispatcher(Dispatcher, abc.ABC):
+
+class ProcessOutputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
     def remove_logs(self) -> None:
         raise NotImplementedError
@@ -5420,7 +5521,7 @@ class OutputDispatcher(Dispatcher, abc.ABC):
         raise NotImplementedError
 
 
-class InputDispatcher(Dispatcher, abc.ABC):
+class ProcessInputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
     def write(self, chars: ta.Union[bytes, str]) -> None:
         raise NotImplementedError
@@ -5433,7 +5534,11 @@ class InputDispatcher(Dispatcher, abc.ABC):
 ##
 
 
-class Process(ConfigPriorityOrdered, abc.ABC):
+class Process(
+    ConfigPriorityOrdered,
+    HasDispatchers,
+    abc.ABC,
+):
     @property
     @abc.abstractmethod
     def name(self) -> str:
@@ -5451,18 +5556,13 @@ class Process(ConfigPriorityOrdered, abc.ABC):
 
     @property
     @abc.abstractmethod
-    def pid(self) -> int:
+    def pid(self) -> Pid:
         raise NotImplementedError
 
     #
 
-    @property
-    @abc.abstractmethod
-    def context(self) -> ServerContext:
-        raise NotImplementedError
-
     @abc.abstractmethod
-    def finish(self, sts: int) -> None:
+    def finish(self, sts: Rc) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -5477,18 +5577,15 @@ class Process(ConfigPriorityOrdered, abc.ABC):
     def transition(self) -> None:
         raise NotImplementedError
 
+    @property
     @abc.abstractmethod
-    def get_state(self) -> ProcessState:
+    def state(self) -> ProcessState:
         raise NotImplementedError
 
     @abc.abstractmethod
     def after_setuid(self) -> None:
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def get_dispatchers(self) -> 'Dispatchers':
-        raise NotImplementedError
-
 
 ##
 
@@ -5509,105 +5606,31 @@ class ProcessGroup(
         raise NotImplementedError
 
     @property
-    @abc.abstractmethod
-    def by_name(self) -> ta.Mapping[str, Process]:
-        raise NotImplementedError
-
-    #
-
-    @abc.abstractmethod
-    def stop_all(self) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def get_unstopped_processes(self) -> ta.List[Process]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def before_remove(self) -> None:
-        raise NotImplementedError
-
-
-########################################
-# ../context.py
-
-
-class ServerContextImpl(ServerContext):
-    def __init__(
-            self,
-            config: ServerConfig,
-            poller: Poller,
-            *,
-            epoch: ServerEpoch = ServerEpoch(0),
-    ) -> None:
-        super().__init__()
-
-        self._config = config
-        self._poller = poller
-        self._epoch = epoch
-
-        self._pid_history: ta.Dict[int, Process] = {}
-        self._state: SupervisorState = SupervisorState.RUNNING
-
-    @property
-    def config(self) -> ServerConfig:
-        return self._config
-
-    @property
-    def epoch(self) -> ServerEpoch:
-        return self._epoch
-
-    @property
-    def first(self) -> bool:
-        return not self._epoch
-
-    @property
-    def state(self) -> SupervisorState:
-        return self._state
-
-    def set_state(self, state: SupervisorState) -> None:
-        self._state = state
-
-    @property
-    def pid_history(self) -> ta.Dict[int, Process]:
-        return self._pid_history
+    @abc.abstractmethod
+    def by_name(self) -> ta.Mapping[str, Process]:
+        raise NotImplementedError
 
     #
 
-    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
-        # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
-        # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
-        # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
-        # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
-        # lying around.
-        try:
-            pid, sts = os.waitpid(-1, os.WNOHANG)
-        except OSError as exc:
-            code = exc.args[0]
-            if code not in (errno.ECHILD, errno.EINTR):
-                log.critical('waitpid error %r; a process may not be cleaned up properly', code)
-            if code == errno.EINTR:
-                log.debug('EINTR during reap')
-            pid, sts = None, None
-        return pid, sts
-
-    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
+    @abc.abstractmethod
+    def stop_all(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_unstopped_processes(self) -> ta.List[Process]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def before_remove(self) -> None:
+        raise NotImplementedError
 
 
 ########################################
 # ../dispatchers.py
 
 
-class Dispatchers(KeyedCollection[int, Dispatcher]):
-    def _key(self, v: Dispatcher) -> int:
+class Dispatchers(KeyedCollection[Fd, Dispatcher]):
+    def _key(self, v: Dispatcher) -> Fd:
         return v.fd
 
     #
@@ -5625,12 +5648,12 @@ class Dispatchers(KeyedCollection[int, Dispatcher]):
 
     def remove_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.remove_logs()
 
     def reopen_logs(self) -> None:
         for d in self:
-            if isinstance(d, OutputDispatcher):
+            if isinstance(d, ProcessOutputDispatcher):
                 d.reopen_logs()
 
 
@@ -5638,14 +5661,15 @@ class Dispatchers(KeyedCollection[int, Dispatcher]):
 # ../dispatchersimpl.py
 
 
-class BaseDispatcherImpl(Dispatcher, abc.ABC):
+class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
     def __init__(
             self,
             process: Process,
             channel: str,
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__()
 
@@ -5653,6 +5677,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         self._channel = channel  # 'stderr' or 'stdout'
         self._fd = fd
         self._event_callbacks = event_callbacks
+        self._server_config = server_config
 
         self._closed = False  # True if close() has been called
 
@@ -5672,7 +5697,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         return self._channel
 
     @property
-    def fd(self) -> int:
+    def fd(self) -> Fd:
         return self._fd
 
     @property
@@ -5693,7 +5718,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         self.close()
 
 
-class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
+class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispatcher):
     """
     Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
 
@@ -5706,15 +5731,17 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             self,
             process: Process,
             event_type: ta.Type[ProcessCommunicationEvent],
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             event_type.channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._event_type = event_type
@@ -5738,11 +5765,10 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
 
         self._main_log_level = logging.DEBUG
 
-        self._log_to_main_log = process.context.config.loglevel <= self._main_log_level
+        self._log_to_main_log = self._server_config.loglevel <= self._main_log_level
 
-        config = self._process.config
-        self._stdout_events_enabled = config.stdout.events_enabled
-        self._stderr_events_enabled = config.stderr.events_enabled
+        self._stdout_events_enabled = self._process.config.stdout.events_enabled
+        self._stderr_events_enabled = self._process.config.stderr.events_enabled
 
     _child_log: ta.Optional[logging.Logger] = None  # the current logger (normal_log or capture_log)
     _normal_log: ta.Optional[logging.Logger] = None  # the "normal" (non-capture) logger
@@ -5813,7 +5839,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
         if not data:
             return
 
-        if self._process.context.config.strip_ansi:
+        if self._server_config.strip_ansi:
             data = strip_escapes(as_bytes(data))
 
         if self._child_log:
@@ -5911,20 +5937,22 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             self.close()
 
 
-class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
+class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatcher):
     def __init__(
             self,
             process: Process,
             channel: str,
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__(
             process,
             channel,
             fd,
             event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
         self._input_buffer = b''
@@ -6084,7 +6112,7 @@ class ProcessGroupImpl(ProcessGroup):
     #
 
     def get_unstopped_processes(self) -> ta.List[Process]:
-        return [x for x in self if not x.get_state().stopped]
+        return [x for x in self if not x.state.stopped]
 
     def stop_all(self) -> None:
         processes = list(self._by_name.values())
@@ -6092,7 +6120,7 @@ class ProcessGroupImpl(ProcessGroup):
         processes.reverse()  # stop in desc priority order
 
         for proc in processes:
-            state = proc.get_state()
+            state = proc.state
             if state == ProcessState.RUNNING:
                 # RUNNING -> STOPPING
                 proc.stop()
@@ -6110,7 +6138,7 @@ class ProcessGroupImpl(ProcessGroup):
 
 
 ########################################
-# ../processes.py
+# ../process.py
 
 
 ##
@@ -6123,7 +6151,7 @@ class ProcessStateError(RuntimeError):
 ##
 
 
-class PidHistory(ta.Dict[int, Process]):
+class PidHistory(ta.Dict[Pid, Process]):
     pass
 
 
@@ -6272,348 +6300,126 @@ class SupervisorSetupImpl(SupervisorSetup):
                 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)
+                        res=res,
+                        name=name,
+                        soft=soft,
+                        hard=hard,
+                    ))
 
-        return True
+    #
 
-    def remove_process_group(self, name: str) -> bool:
-        if self._process_groups[name].get_unstopped_processes():
-            return False
+    _unlink_pidfile = False
 
-        self._process_groups.remove(name)
+    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)
 
-        return True
+    def _cleanup_pidfile(self) -> None:
+        if self._unlink_pidfile:
+            try_unlink(self._config.pidfile)
 
     #
 
-    def shutdown_report(self) -> ta.List[Process]:
-        unstopped: ta.List[Process] = []
-
-        for group in self._process_groups:
-            unstopped.extend(group.get_unstopped_processes())
+    def _clear_auto_child_logdir(self) -> None:
+        # must be called after realize()
+        child_logdir = self._config.child_logdir
+        if child_logdir == '/dev/null':
+            return
 
-        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)
+        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
 
-        return unstopped
+        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 main(self, **kwargs: ta.Any) -> None:
-        self._setup.setup()
-        try:
-            self.run(**kwargs)
-        finally:
-            self._setup.cleanup()
+    def _daemonize(self) -> None:
+        for dl in self._daemonize_listeners:
+            dl.before_daemonize()
 
-    def run(
-            self,
-            *,
-            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
-    ) -> None:
-        self._process_groups.clear()
-        self._stop_groups = None  # clear
+        self._do_daemonize()
 
-        self._event_callbacks.clear()
+        for dl in self._daemonize_listeners:
+            dl.after_daemonize()
 
-        try:
-            for config in self._context.config.groups or []:
-                self.add_process_group(config)
+    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
 
-            self._signal_handler.set_signals()
+        pid = os.fork()
+        if pid != 0:
+            # Parent
+            log.debug('supervisord forked; parent exiting')
+            real_exit(Rc(0))
 
-            self._event_callbacks.notify(SupervisorRunningEvent())
+        # 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)
 
-            while True:
-                if callback is not None and not callback(self):
-                    break
+        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))
 
-                self._run_once()
+        # 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)
 
-        finally:
-            self._poller.close()
 
-    #
+########################################
+# ../io.py
 
-    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)
+class IoManager:
+    def __init__(
+            self,
+            *,
+            poller: Poller,
+            process_groups: ProcessGroupManager,
+    ) -> None:
+        super().__init__()
+
+        self._poller = poller
+        self._process_groups = process_groups
 
     def get_dispatchers(self) -> Dispatchers:
         return Dispatchers(
@@ -6622,25 +6428,9 @@ class Supervisor:
             for d in p.get_dispatchers()
         )
 
-    def _poll(self) -> None:
+    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)
@@ -6690,53 +6480,96 @@ class Supervisor:
                 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
+########################################
+# ../signals.py
+
+
+class SignalHandler:
+    def __init__(
+            self,
+            *,
+            states: SupervisorStateManager,
+            signal_receiver: SignalReceiver,
+            process_groups: ProcessGroupManager,
+    ) -> None:
+        super().__init__()
+
+        self._states = states
+        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,
+        )
 
-        pid, sts = self._context.waitpid()
-        if not pid:
+    def handle_signals(self) -> None:
+        sig = self._signal_receiver.get_signal()
+        if not sig:
             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)
+        if sig in (signal.SIGTERM, signal.SIGINT, signal.SIGQUIT):
+            log.warning('received %s indicating exit request', sig_name(sig))
+            self._states.set_state(SupervisorState.SHUTDOWN)
+
+        elif sig == signal.SIGHUP:
+            if self._states.state == SupervisorState.SHUTDOWN:
+                log.warning('ignored %s indicating restart request (shutdown in progress)', sig_name(sig))  # noqa
+            else:
+                log.warning('received %s indicating restart request', sig_name(sig))  # noqa
+                self._states.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, ProcessOutputDispatcher):
+                        d.reopen_logs()
+
         else:
-            process.finish(check_not_none(sts))
-            del self._pid_history[pid]
+            log.debug('received %s indicating nothing', sig_name(sig))
 
-        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"""
+########################################
+# ../spawning.py
 
-        if now is None:
-            # now won't be None in unit tests
-            now = time.time()
 
-        for event in TICK_EVENTS:
-            period = event.period
+@dc.dataclass(frozen=True)
+class SpawnedProcess:
+    pid: Pid
+    pipes: ProcessPipes
+    dispatchers: Dispatchers
 
-            last_tick = self._ticks.get(period)
-            if last_tick is None:
-                # we just started up
-                last_tick = self._ticks[period] = timeslice(period, now)
 
-            this_tick = timeslice(period, now)
-            if this_tick != last_tick:
-                self._ticks[period] = this_tick
-                self._event_callbacks.notify(event(this_tick, self))
+class ProcessSpawnError(RuntimeError):
+    pass
+
+
+class ProcessSpawning:
+    @property
+    @abc.abstractmethod
+    def process(self) -> Process:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
+        raise NotImplementedError
 
 
 ########################################
-# ../processesimpl.py
+# ../processimpl.py
 
 
 class ProcessSpawningFactory(Func1[Process, ProcessSpawning]):
@@ -6754,7 +6587,7 @@ class ProcessImpl(Process):
             config: ProcessConfig,
             group: ProcessGroup,
             *,
-            context: ServerContext,
+            supervisor_states: SupervisorStateManager,
             event_callbacks: EventCallbacks,
             process_spawning_factory: ProcessSpawningFactory,
     ) -> None:
@@ -6763,7 +6596,7 @@ class ProcessImpl(Process):
         self._config = config
         self._group = group
 
-        self._context = context
+        self._supervisor_states = supervisor_states
         self._event_callbacks = event_callbacks
 
         self._spawning = process_spawning_factory(self)
@@ -6774,7 +6607,7 @@ class ProcessImpl(Process):
         self._pipes = ProcessPipes()
 
         self._state = ProcessState.STOPPED
-        self._pid = 0  # 0 when not running
+        self._pid = Pid(0)  # 0 when not running
 
         self._last_start = 0.  # Last time the subprocess was started; 0 if never
         self._last_stop = 0.  # Last time the subprocess was stopped; 0 if never
@@ -6788,13 +6621,13 @@ class ProcessImpl(Process):
 
         self._backoff = 0  # backoff counter (to startretries)
 
-        self._exitstatus: ta.Optional[int] = None  # status attached to dead process by finish()
+        self._exitstatus: ta.Optional[Rc] = None  # status attached to dead process by finish()
         self._spawn_err: ta.Optional[str] = None  # error message attached by spawn() if any
 
     #
 
     def __repr__(self) -> str:
-        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self.get_state().name}>'
+        return f'<Subprocess at {id(self)} with name {self._config.name} in state {self._state.name}>'
 
     #
 
@@ -6811,15 +6644,11 @@ class ProcessImpl(Process):
         return self._group
 
     @property
-    def pid(self) -> int:
+    def pid(self) -> Pid:
         return self._pid
 
     #
 
-    @property
-    def context(self) -> ServerContext:
-        return self._context
-
     @property
     def state(self) -> ProcessState:
         return self._state
@@ -6830,11 +6659,9 @@ class ProcessImpl(Process):
 
     #
 
-    def spawn(self) -> ta.Optional[int]:
-        process_name = as_string(self._config.name)
-
+    def spawn(self) -> ta.Optional[Pid]:
         if self.pid:
-            log.warning('process \'%s\' already running', process_name)
+            log.warning('process \'%s\' already running', self.name)
             return None
 
         self.check_in_state(
@@ -6884,7 +6711,7 @@ class ProcessImpl(Process):
         if stdin_fd is None:
             raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
-        dispatcher = check_isinstance(self._dispatchers[stdin_fd], InputDispatcher)
+        dispatcher = check_isinstance(self._dispatchers[stdin_fd], ProcessInputDispatcher)
         if dispatcher.closed:
             raise OSError(errno.EPIPE, "Process' stdin channel is closed")
 
@@ -6957,7 +6784,7 @@ class ProcessImpl(Process):
             self._check_and_adjust_for_system_clock_rollback(now)
 
             if now > (self._last_stop_report + 2):  # every 2 seconds
-                log.info('waiting for %s to stop', as_string(self._config.name))
+                log.info('waiting for %s to stop', self.name)
                 self._last_stop_report = now
 
     def give_up(self) -> None:
@@ -6977,18 +6804,17 @@ class ProcessImpl(Process):
         """
         now = time.time()
 
-        process_name = as_string(self._config.name)
         # If the process is in BACKOFF and we want to stop or kill it, then BACKOFF -> STOPPED.  This is needed because
         # if startretries is a large number and the process isn't starting successfully, the stop request would be
         # blocked for a long time waiting for the retries.
         if self._state == ProcessState.BACKOFF:
-            log.debug('Attempted to kill %s, which is in BACKOFF state.', process_name)
+            log.debug('Attempted to kill %s, which is in BACKOFF state.', self.name)
             self.change_state(ProcessState.STOPPED)
             return None
 
         args: tuple
         if not self.pid:
-            fmt, args = "attempted to kill %s with sig %s but it wasn't running", (process_name, sig_name(sig))
+            fmt, args = "attempted to kill %s with sig %s but it wasn't running", (self.name, sig_name(sig))
             log.debug(fmt, *args)
             return fmt % args
 
@@ -7002,7 +6828,7 @@ class ProcessImpl(Process):
         if killasgroup:
             as_group = 'process group '
 
-        log.debug('killing %s (pid %s) %s with signal %s', process_name, self.pid, as_group, sig_name(sig))
+        log.debug('killing %s (pid %s) %s with signal %s', self.name, self.pid, as_group, sig_name(sig))
 
         # RUNNING/STARTING/STOPPING -> STOPPING
         self._killing = True
@@ -7011,24 +6837,24 @@ class ProcessImpl(Process):
         self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
         self.change_state(ProcessState.STOPPING)
 
-        pid = self.pid
+        kpid = int(self.pid)
         if killasgroup:
             # send to the whole process group instead
-            pid = -self.pid
+            kpid = -kpid
 
         try:
             try:
-                os.kill(pid, sig)
+                os.kill(kpid, sig)
             except OSError as exc:
                 if exc.errno == errno.ESRCH:
-                    log.debug('unable to signal %s (pid %s), it probably just exited on its own: %s', process_name, self.pid, str(exc))  # noqa
+                    log.debug('unable to signal %s (pid %s), it probably just exited on its own: %s', self.name, self.pid, str(exc))  # noqa
                     # we could change the state here but we intentionally do not.  we will do it during normal SIGCHLD
                     # processing.
                     return None
                 raise
         except Exception:  # noqa
             tb = traceback.format_exc()
-            fmt, args = 'unknown problem killing %s (%s):%s', (process_name, self.pid, tb)
+            fmt, args = 'unknown problem killing %s (%s):%s', (self.name, self.pid, tb)
             log.critical(fmt, *args)
             self.change_state(ProcessState.UNKNOWN)
             self._killing = False
@@ -7044,14 +6870,13 @@ class ProcessImpl(Process):
         Return None if the signal was sent, or an error message string if an error occurred or if the subprocess is not
         running.
         """
-        process_name = as_string(self._config.name)
         args: tuple
         if not self.pid:
-            fmt, args = "attempted to send %s sig %s but it wasn't running", (process_name, sig_name(sig))
+            fmt, args = "Attempted to send %s sig %s but it wasn't running", (self.name, sig_name(sig))
             log.debug(fmt, *args)
             return fmt % args
 
-        log.debug('sending %s (pid %s) sig %s', process_name, self.pid, sig_name(sig))
+        log.debug('sending %s (pid %s) sig %s', self.name, self.pid, sig_name(sig))
 
         self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
 
@@ -7062,7 +6887,7 @@ class ProcessImpl(Process):
                 if exc.errno == errno.ESRCH:
                     log.debug(
                         'unable to signal %s (pid %s), it probably just now exited on its own: %s',
-                        process_name,
+                        self.name,
                         self.pid,
                         str(exc),
                     )
@@ -7072,14 +6897,14 @@ class ProcessImpl(Process):
                 raise
         except Exception:  # noqa
             tb = traceback.format_exc()
-            fmt, args = 'unknown problem sending sig %s (%s):%s', (process_name, self.pid, tb)
+            fmt, args = 'unknown problem sending sig %s (%s):%s', (self.name, self.pid, tb)
             log.critical(fmt, *args)
             self.change_state(ProcessState.UNKNOWN)
             return fmt % args
 
         return None
 
-    def finish(self, sts: int) -> None:
+    def finish(self, sts: Rc) -> None:
         """The process was reaped and we need to report and manage its state."""
 
         self._dispatchers.drain()
@@ -7091,7 +6916,6 @@ class ProcessImpl(Process):
         self._check_and_adjust_for_system_clock_rollback(now)
 
         self._last_stop = now
-        process_name = as_string(self._config.name)
 
         if now > self._last_start:
             too_quickly = now - self._last_start < self._config.startsecs
@@ -7100,7 +6924,7 @@ class ProcessImpl(Process):
             log.warning(
                 "process '%s' (%s) last_start time is in the future, don't know how long process was running so "
                 "assuming it did not exit too quickly",
-                process_name,
+                self.name,
                 self.pid,
             )
 
@@ -7110,9 +6934,9 @@ class ProcessImpl(Process):
             # likely the result of a stop request implies STOPPING -> STOPPED
             self._killing = False
             self._delay = 0
-            self._exitstatus = es
+            self._exitstatus = Rc(es)
 
-            fmt, args = 'stopped: %s (%s)', (process_name, msg)
+            fmt, args = 'stopped: %s (%s)', (self.name, msg)
             self.check_in_state(ProcessState.STOPPING)
             self.change_state(ProcessState.STOPPED)
             if exit_expected:
@@ -7126,7 +6950,7 @@ class ProcessImpl(Process):
             self._spawn_err = 'Exited too quickly (process log may have details)'
             self.check_in_state(ProcessState.STARTING)
             self.change_state(ProcessState.BACKOFF)
-            log.warning('exited: %s (%s)', process_name, msg + '; not expected')
+            log.warning('exited: %s (%s)', self.name, msg + '; not expected')
 
         else:
             # this finish was not the result of a stop request, the program was in the RUNNING state but exited implies
@@ -7145,21 +6969,18 @@ class ProcessImpl(Process):
             if exit_expected:
                 # expected exit code
                 self.change_state(ProcessState.EXITED, expected=True)
-                log.info('exited: %s (%s)', process_name, msg + '; expected')
+                log.info('exited: %s (%s)', self.name, msg + '; expected')
             else:
                 # unexpected exit code
                 self._spawn_err = f'Bad exit code {es}'
                 self.change_state(ProcessState.EXITED, expected=False)
-                log.warning('exited: %s (%s)', process_name, msg + '; not expected')
+                log.warning('exited: %s (%s)', self.name, msg + '; not expected')
 
-        self._pid = 0
+        self._pid = Pid(0)
         close_parent_pipes(self._pipes)
         self._pipes = ProcessPipes()
         self._dispatchers = Dispatchers([])
 
-    def get_state(self) -> ProcessState:
-        return self._state
-
     def transition(self) -> None:
         now = time.time()
         state = self._state
@@ -7168,7 +6989,7 @@ class ProcessImpl(Process):
 
         logger = log
 
-        if self.context.state > SupervisorState.RESTARTING:
+        if self._supervisor_states.state > SupervisorState.RESTARTING:
             # dont start any processes if supervisor is shutting down
             if state == ProcessState.EXITED:
                 if self._config.autorestart:
@@ -7190,7 +7011,6 @@ class ProcessImpl(Process):
                         # BACKOFF -> STARTING
                         self.spawn()
 
-        process_name = as_string(self._config.name)
         if state == ProcessState.STARTING:
             if now - self._last_start > self._config.startsecs:
                 # STARTING -> RUNNING if the proc has started successfully and it has stayed up for at least
@@ -7200,21 +7020,21 @@ class ProcessImpl(Process):
                 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)
+                logger.info('success: %s %s', self.name, msg)
 
         if state == ProcessState.BACKOFF:
             if self._backoff > self._config.startretries:
                 # BACKOFF -> FATAL if the proc has exceeded its number of retries
                 self.give_up()
                 msg = ('entered FATAL state, too many start retries too quickly')
-                logger.info('gave up: %s %s', process_name, msg)
+                logger.info('gave up: %s %s', self.name, msg)
 
         elif state == ProcessState.STOPPING:
             time_left = self._delay - now
             if time_left <= 0:
                 # kill processes which are taking too long to stop with a final sigkill.  if this doesn't kill it, the
                 # process will be stuck in the STOPPING state forever.
-                log.warning('killing \'%s\' (%s) with SIGKILL', process_name, self.pid)
+                log.warning('killing \'%s\' (%s) with SIGKILL', self.name, self.pid)
                 self.kill(signal.SIGKILL)
 
     def after_setuid(self) -> None:
@@ -7233,15 +7053,15 @@ class ProcessImpl(Process):
 # ../spawningimpl.py
 
 
-class OutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], int, OutputDispatcher]):
+class ProcessOutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], Fd, ProcessOutputDispatcher]):
     pass
 
 
-class InputDispatcherFactory(Func3[Process, str, int, InputDispatcher]):
+class ProcessInputDispatcherFactory(Func3[Process, str, Fd, ProcessInputDispatcher]):
     pass
 
 
-InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[Fd])
 
 
 ##
@@ -7255,8 +7075,8 @@ class ProcessSpawningImpl(ProcessSpawning):
             server_config: ServerConfig,
             pid_history: PidHistory,
 
-            output_dispatcher_factory: OutputDispatcherFactory,
-            input_dispatcher_factory: InputDispatcherFactory,
+            output_dispatcher_factory: ProcessOutputDispatcherFactory,
+            input_dispatcher_factory: ProcessInputDispatcherFactory,
 
             inherited_fds: ta.Optional[InheritedFds] = None,
     ) -> None:
@@ -7312,7 +7132,7 @@ class ProcessSpawningImpl(ProcessSpawning):
             raise ProcessSpawnError(f"Unknown error making dispatchers for '{self.process.name}': {exc}") from exc
 
         try:
-            pid = os.fork()
+            pid = Pid(os.fork())
         except OSError as exc:
             code = exc.args[0]
             if code == errno.EAGAIN:
@@ -7396,21 +7216,21 @@ class ProcessSpawningImpl(ProcessSpawning):
                 self.process,
                 ProcessCommunicationStdoutEvent,
                 pipes.stdout,
-            ), OutputDispatcher))
+            ), ProcessOutputDispatcher))
 
         if pipes.stderr is not None:
             dispatchers.append(check_isinstance(self._output_dispatcher_factory(
                 self.process,
                 ProcessCommunicationStderrEvent,
                 pipes.stderr,
-            ), OutputDispatcher))
+            ), ProcessOutputDispatcher))
 
         if pipes.stdin is not None:
             dispatchers.append(check_isinstance(self._input_dispatcher_factory(
                 self.process,
                 'stdin',
                 pipes.stdin,
-            ), InputDispatcher))
+            ), ProcessInputDispatcher))
 
         return Dispatchers(dispatchers)
 
@@ -7491,7 +7311,7 @@ class ProcessSpawningImpl(ProcessSpawning):
 
         finally:
             os.write(2, as_bytes('supervisor: child process was not spawned\n'))
-            real_exit(127)  # exit process with code for spawn failure
+            real_exit(Rc(127))  # exit process with code for spawn failure
 
         raise RuntimeError('Unreachable')
 
@@ -7508,7 +7328,7 @@ class ProcessSpawningImpl(ProcessSpawning):
         for i in range(3, self._server_config.minfds):
             if i in self._inherited_fds:
                 continue
-            close_fd(i)
+            close_fd(Fd(i))
 
     def _set_uid(self) -> ta.Optional[str]:
         if self.config.uid is None:
@@ -7539,6 +7359,278 @@ def check_execv_args(
         raise NoPermissionError(f'No permission to run command {exe!r}')
 
 
+########################################
+# ../supervisor.py
+
+
+##
+
+
+def timeslice(period: int, when: float) -> int:
+    return int(when - (when % period))
+
+
+##
+
+
+class SupervisorStateManagerImpl(SupervisorStateManager):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._state: SupervisorState = SupervisorState.RUNNING
+
+    @property
+    def state(self) -> SupervisorState:
+        return self._state
+
+    def set_state(self, state: SupervisorState) -> None:
+        self._state = state
+
+
+##
+
+
+class ProcessGroupFactory(Func1[ProcessGroupConfig, ProcessGroup]):
+    pass
+
+
+class Supervisor:
+    def __init__(
+            self,
+            *,
+            config: ServerConfig,
+            poller: Poller,
+            process_groups: ProcessGroupManager,
+            signal_handler: SignalHandler,
+            event_callbacks: EventCallbacks,
+            process_group_factory: ProcessGroupFactory,
+            pid_history: PidHistory,
+            setup: SupervisorSetup,
+            states: SupervisorStateManager,
+            io: IoManager,
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+        self._poller = poller
+        self._process_groups = process_groups
+        self._signal_handler = signal_handler
+        self._event_callbacks = event_callbacks
+        self._process_group_factory = process_group_factory
+        self._pid_history = pid_history
+        self._setup = setup
+        self._states = states
+        self._io = io
+
+        self._ticks: ta.Dict[int, float] = {}
+        self._stop_groups: ta.Optional[ta.List[ProcessGroup]] = None  # list used for priority ordered shutdown
+        self._stopping = False  # set after we detect that we are handling a stop request
+        self._last_shutdown_report = 0.  # throttle for delayed process error reports at stop
+
+    #
+
+    @property
+    def state(self) -> SupervisorState:
+        return self._states.state
+
+    #
+
+    def add_process_group(self, config: ProcessGroupConfig) -> bool:
+        if self._process_groups.get(config.name) is not None:
+            return False
+
+        group = check_isinstance(self._process_group_factory(config), ProcessGroup)
+        for process in group:
+            process.after_setuid()
+
+        self._process_groups.add(group)
+
+        return True
+
+    def remove_process_group(self, name: str) -> bool:
+        if self._process_groups[name].get_unstopped_processes():
+            return False
+
+        self._process_groups.remove(name)
+
+        return True
+
+    #
+
+    def shutdown_report(self) -> ta.List[Process]:
+        unstopped: ta.List[Process] = []
+
+        for group in self._process_groups:
+            unstopped.extend(group.get_unstopped_processes())
+
+        if unstopped:
+            # throttle 'waiting for x to die' reports
+            now = time.time()
+            if now > (self._last_shutdown_report + 3):  # every 3 secs
+                names = [p.config.name for p in unstopped]
+                namestr = ', '.join(names)
+                log.info('waiting for %s to die', namestr)
+                self._last_shutdown_report = now
+                for proc in unstopped:
+                    log.debug('%s state: %s', proc.config.name, proc.state.name)
+
+        return unstopped
+
+    #
+
+    def main(self, **kwargs: ta.Any) -> None:
+        self._setup.setup()
+        try:
+            self.run(**kwargs)
+        finally:
+            self._setup.cleanup()
+
+    def run(
+            self,
+            *,
+            callback: ta.Optional[ta.Callable[['Supervisor'], bool]] = None,
+    ) -> None:
+        self._process_groups.clear()
+        self._stop_groups = None  # clear
+
+        self._event_callbacks.clear()
+
+        try:
+            for config in self._config.groups or []:
+                self.add_process_group(config)
+
+            self._signal_handler.set_signals()
+
+            self._event_callbacks.notify(SupervisorRunningEvent())
+
+            while True:
+                if callback is not None and not callback(self):
+                    break
+
+                self._run_once()
+
+        finally:
+            self._poller.close()
+
+    #
+
+    def _run_once(self) -> None:
+        self._poll()
+        self._reap()
+        self._signal_handler.handle_signals()
+        self._tick()
+
+        if self._states.state < SupervisorState.RUNNING:
+            self._ordered_stop_groups_phase_2()
+
+    def _ordered_stop_groups_phase_1(self) -> None:
+        if self._stop_groups:
+            # stop the last group (the one with the "highest" priority)
+            self._stop_groups[-1].stop_all()
+
+    def _ordered_stop_groups_phase_2(self) -> None:
+        # after phase 1 we've transitioned and reaped, let's see if we can remove the group we stopped from the
+        # stop_groups queue.
+        if self._stop_groups:
+            # pop the last group (the one with the "highest" priority)
+            group = self._stop_groups.pop()
+            if group.get_unstopped_processes():
+                # if any processes in the group aren't yet in a stopped state, we're not yet done shutting this group
+                # down, so push it back on to the end of the stop group queue
+                self._stop_groups.append(group)
+
+    def _poll(self) -> None:
+        sorted_groups = list(self._process_groups)
+        sorted_groups.sort()
+
+        if self._states.state < SupervisorState.RUNNING:
+            if not self._stopping:
+                # first time, set the stopping flag, do a notification and set stop_groups
+                self._stopping = True
+                self._stop_groups = sorted_groups[:]
+                self._event_callbacks.notify(SupervisorStoppingEvent())
+
+            self._ordered_stop_groups_phase_1()
+
+            if not self.shutdown_report():
+                # if there are no unstopped processes (we're done killing everything), it's OK to shutdown or reload
+                raise ExitNow
+
+        self._io.poll()
+
+        for group in sorted_groups:
+            for process in group:
+                process.transition()
+
+    def _reap(self, *, once: bool = False, depth: int = 0) -> None:
+        if depth >= 100:
+            return
+
+        wp = waitpid()
+        if wp is None or not wp.pid:
+            return
+
+        process = self._pid_history.get(wp.pid, None)
+        if process is None:
+            _, msg = decode_wait_status(wp.sts)
+            log.info('reaped unknown pid %s (%s)', wp.pid, msg)
+        else:
+            process.finish(wp.sts)
+            del self._pid_history[wp.pid]
+
+        if not once:
+            # keep reaping until no more kids to reap, but don't recurse infinitely
+            self._reap(once=False, depth=depth + 1)
+
+    def _tick(self, now: ta.Optional[float] = None) -> None:
+        """Send one or more 'tick' events when the timeslice related to the period for the event type rolls over"""
+
+        if now is None:
+            # now won't be None in unit tests
+            now = time.time()
+
+        for event in TICK_EVENTS:
+            period = event.period
+
+            last_tick = self._ticks.get(period)
+            if last_tick is None:
+                # we just started up
+                last_tick = self._ticks[period] = timeslice(period, now)
+
+            this_tick = timeslice(period, now)
+            if this_tick != last_tick:
+                self._ticks[period] = this_tick
+                self._event_callbacks.notify(event(this_tick, self))
+
+
+##
+
+
+class WaitedPid(ta.NamedTuple):
+    pid: Pid
+    sts: Rc
+
+
+def waitpid() -> ta.Optional[WaitedPid]:
+    # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
+    # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
+    # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
+    # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
+    # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
+    # lying around.
+    try:
+        pid, sts = os.waitpid(-1, os.WNOHANG)
+    except OSError as exc:
+        code = exc.args[0]
+        if code not in (errno.ECHILD, errno.EINTR):
+            log.critical('waitpid error %r; a process may not be cleaned up properly', code)
+        if code == errno.EINTR:
+            log.debug('EINTR during reap')
+        return None
+    else:
+        return WaitedPid(pid, sts)  # type: ignore
+
+
 ########################################
 # ../inject.py
 
@@ -7559,17 +7651,21 @@ def bind_server(
 
         inj.bind(DaemonizeListener, array=True, to_key=Poller),
 
-        inj.bind(ServerContextImpl, singleton=True),
-        inj.bind(ServerContext, to_key=ServerContextImpl),
-
         inj.bind(EventCallbacks, singleton=True),
 
         inj.bind(SignalReceiver, singleton=True),
 
+        inj.bind(IoManager, singleton=True),
+
         inj.bind(SignalHandler, singleton=True),
+
         inj.bind(ProcessGroupManager, singleton=True),
+
         inj.bind(Supervisor, singleton=True),
 
+        inj.bind(SupervisorStateManagerImpl, singleton=True),
+        inj.bind(SupervisorStateManager, to_key=SupervisorStateManagerImpl),
+
         inj.bind(PidHistory()),
 
         inj.bind_factory(ProcessGroupImpl, ProcessGroupFactory),
@@ -7577,8 +7673,8 @@ def bind_server(
 
         inj.bind_factory(ProcessSpawningImpl, ProcessSpawningFactory),
 
-        inj.bind_factory(OutputDispatcherImpl, OutputDispatcherFactory),
-        inj.bind_factory(InputDispatcherImpl, InputDispatcherFactory),
+        inj.bind_factory(ProcessOutputDispatcherImpl, ProcessOutputDispatcherFactory),
+        inj.bind_factory(ProcessInputDispatcherImpl, ProcessInputDispatcherFactory),
     ]
 
     #
@@ -7635,7 +7731,7 @@ def main(
     if not no_logging:
         configure_standard_logging(
             'INFO',
-            handler_factory=journald_log_handler_factory if not args.no_journald else None,
+            handler_factory=journald_log_handler_factory if not (args.no_journald or is_debugger_attached()) else None,
         )
 
     #
@@ -7658,7 +7754,6 @@ def main(
             inherited_fds=inherited_fds,
         ))
 
-        context = injector[ServerContextImpl]
         supervisor = injector[Supervisor]
 
         try:
@@ -7666,7 +7761,7 @@ def main(
         except ExitNow:
             pass
 
-        if context.state < SupervisorState.RESTARTING:
+        if supervisor.state < SupervisorState.RESTARTING:
             break