ominfra 0.0.0.dev127__py3-none-any.whl → 0.0.0.dev128__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
 
@@ -1209,7 +1047,206 @@ def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
 
 
 ########################################
-# ../signals.py
+# ../states.py
+
+
+##
+
+
+class ProcessState(enum.IntEnum):
+    STOPPED = 0
+    STARTING = 10
+    RUNNING = 20
+    BACKOFF = 30
+    STOPPING = 40
+    EXITED = 100
+    FATAL = 200
+    UNKNOWN = 1000
+
+    @property
+    def stopped(self) -> bool:
+        return self in STOPPED_STATES
+
+    @property
+    def running(self) -> bool:
+        return self in RUNNING_STATES
+
+    @property
+    def signalable(self) -> bool:
+        return self in SIGNALABLE_STATES
+
+
+STOPPED_STATES = (
+    ProcessState.STOPPED,
+    ProcessState.EXITED,
+    ProcessState.FATAL,
+    ProcessState.UNKNOWN,
+)
+
+RUNNING_STATES = (
+    ProcessState.RUNNING,
+    ProcessState.BACKOFF,
+    ProcessState.STARTING,
+)
+
+SIGNALABLE_STATES = (
+    ProcessState.RUNNING,
+    ProcessState.STARTING,
+    ProcessState.STOPPING,
+)
+
+
+##
+
+
+class SupervisorState(enum.IntEnum):
+    FATAL = 2
+    RUNNING = 1
+    RESTARTING = 0
+    SHUTDOWN = -1
+
+
+########################################
+# ../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 __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
+
+
+########################################
+# ../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
 
 
 ##
@@ -1270,127 +1307,110 @@ class SignalReceiver:
 
 
 ########################################
-# ../states.py
+# ../utils/strings.py
 
 
 ##
 
 
-class ProcessState(enum.IntEnum):
-    STOPPED = 0
-    STARTING = 10
-    RUNNING = 20
-    BACKOFF = 30
-    STOPPING = 40
-    EXITED = 100
-    FATAL = 200
-    UNKNOWN = 1000
-
-    @property
-    def stopped(self) -> bool:
-        return self in STOPPED_STATES
-
-    @property
-    def running(self) -> bool:
-        return self in RUNNING_STATES
-
-    @property
-    def signalable(self) -> bool:
-        return self in SIGNALABLE_STATES
-
-
-STOPPED_STATES = (
-    ProcessState.STOPPED,
-    ProcessState.EXITED,
-    ProcessState.FATAL,
-    ProcessState.UNKNOWN,
-)
-
-RUNNING_STATES = (
-    ProcessState.RUNNING,
-    ProcessState.BACKOFF,
-    ProcessState.STARTING,
-)
-
-SIGNALABLE_STATES = (
-    ProcessState.RUNNING,
-    ProcessState.STARTING,
-    ProcessState.STOPPING,
-)
-
-
-##
+def as_bytes(s: ta.Union[str, bytes], encoding: str = 'utf8') -> bytes:
+    if isinstance(s, bytes):
+        return s
+    else:
+        return s.encode(encoding)
 
 
-class SupervisorState(enum.IntEnum):
-    FATAL = 2
-    RUNNING = 1
-    RESTARTING = 0
-    SHUTDOWN = -1
+@ta.overload
+def find_prefix_at_end(haystack: str, needle: str) -> int:
+    ...
 
 
-########################################
-# ../users.py
+@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
 
 
-def name_to_uid(name: str) -> int:
-    try:
-        uid = int(name)
-    except ValueError:
-        try:
-            pwdrec = pwd.getpwnam(name)
-        except KeyError:
-            raise ValueError(f'Invalid user name {name}')  # noqa
-        uid = pwdrec[2]
-    else:
-        try:
-            pwd.getpwuid(uid)  # check if uid is valid
-        except KeyError:
-            raise ValueError(f'Invalid user id {name}')  # noqa
-    return uid
+##
 
 
-def name_to_gid(name: str) -> int:
-    try:
-        gid = int(name)
-    except ValueError:
-        try:
-            grprec = grp.getgrnam(name)
-        except KeyError:
-            raise ValueError(f'Invalid group name {name}')  # noqa
-        gid = grprec[2]
-    else:
-        try:
-            grp.getgrgid(gid)  # check if gid is valid
-        except KeyError:
-            raise ValueError(f'Invalid group id {name}')  # noqa
-    return gid
+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 gid_for_uid(uid: int) -> int:
-    pwrec = pwd.getpwuid(uid)
-    return pwrec[3]
+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
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class User:
-    name: str
-    uid: int
-    gid: int
+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
 
 
 ########################################
@@ -2032,112 +2052,64 @@ def get_event_name_by_type(requested):
 
 
 ########################################
-# ../setup.py
-
-
-##
-
-
-SupervisorUser = ta.NewType('SupervisorUser', User)
+# ../utils/fds.py
 
 
-##
+class PipeFds(ta.NamedTuple):
+    r: Fd
+    w: Fd
 
 
-class DaemonizeListener(abc.ABC):  # noqa
-    def before_daemonize(self) -> None:  # noqa
-        pass
+def make_pipe() -> PipeFds:
+    return PipeFds(*os.pipe())  # type: ignore
 
-    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
-
-
-##
-
-
-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
+# ../utils/os.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
-
-
-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 +2120,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)}'
@@ -2156,114 +2129,77 @@ def decode_wait_status(sts: int) -> ta.Tuple[int, str]:
             iscore = os.WCOREDUMP(sts)
         else:
             iscore = bool(sts & 0x80)
-        if iscore:
-            msg += ' (core dumped)'
-        return -1, msg
-    else:
-        msg = 'unknown termination cause 0x%04x' % sts  # noqa
-        return -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
-
-
-def try_unlink(path: str) -> bool:
-    try:
-        os.unlink(path)
-    except OSError:
-        return False
-    return True
-
-
-def close_fd(fd: int) -> bool:
-    try:
-        os.close(fd)
-    except OSError:
-        return False
-    return True
-
-
-def is_fd_open(fd: int) -> bool:
-    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
-
+        if iscore:
+            msg += ' (core dumped)'
+        return Rc(-1), msg
 
-##
+    else:
+        msg = 'unknown termination cause 0x%04x' % sts  # noqa
+        return Rc(-1), msg
 
 
-def get_path() -> ta.Sequence[str]:
-    """Return a list corresponding to $PATH, or a default."""
+########################################
+# ../utils/users.py
 
-    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)))
 
+def name_to_uid(name: str) -> Uid:
+    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(uid)
 
-##
 
+def name_to_gid(name: str) -> Gid:
+    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(gid)
 
-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 gid_for_uid(uid: Uid) -> Gid:
+    pwrec = pwd.getpwuid(uid)
+    return Gid(pwrec[3])
 
-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
+##
 
 
-##
+@dc.dataclass(frozen=True)
+class User:
+    name: str
+    uid: Uid
+    gid: Gid
 
 
-def timeslice(period: int, when: float) -> int:
-    return int(when - (when % period))
+def get_user(name: str) -> User:
+    return User(
+        name=name,
+        uid=(uid := name_to_uid(name)),
+        gid=gid_for_uid(uid),
+    )
 
 
 ########################################
@@ -4288,19 +4224,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,56 +4246,268 @@ 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]] = {
-        'child_stdin': None,
-        'stdin': None,
+    pipes: ta.Dict[str, ta.Optional[Fd]] = {
+        'child_stdin': None,
+        'stdin': None,
+
+        'stdout': None,
+        'child_stdout': None,
+
+        'stderr': None,
+        'child_stderr': None,
+    }
+
+    try:
+        pipes['child_stdin'], pipes['stdin'] = make_pipe()
+        pipes['stdout'], pipes['child_stdout'] = make_pipe()
+
+        if stderr:
+            pipes['stderr'], pipes['child_stderr'] = make_pipe()
+
+        for fd in (
+                pipes['stdout'],
+                pipes['stderr'],
+                pipes['stdin'],
+        ):
+            if fd is not None:
+                flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NDELAY
+                fcntl.fcntl(fd, fcntl.F_SETFL, flags)
+
+        return ProcessPipes(**pipes)
+
+    except OSError:
+        for fd in pipes.values():
+            if fd is not None:
+                close_fd(fd)
+
+        raise
+
+
+def close_pipes(pipes: ProcessPipes) -> None:
+    close_parent_pipes(pipes)
+    close_child_pipes(pipes)
+
+
+def close_parent_pipes(pipes: ProcessPipes) -> None:
+    for fd in pipes.parent_fds():
+        close_fd(fd)
+
+
+def close_child_pipes(pipes: ProcessPipes) -> None:
+    for fd in pipes.child_fds():
+        close_fd(fd)
+
+
+########################################
+# ../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
 
-        'stdout': None,
-        'child_stdout': None,
+    processes: ta.Optional[ta.Sequence[ProcessConfig]] = None
 
-        'stderr': None,
-        'child_stderr': None,
-    }
 
-    try:
-        pipes['child_stdin'], pipes['stdin'] = os.pipe()
-        pipes['stdout'], pipes['child_stdout'] = os.pipe()
+@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
 
-        if stderr:
-            pipes['stderr'], pipes['child_stderr'] = os.pipe()
+    groups: ta.Optional[ta.Sequence[ProcessGroupConfig]] = None
 
-        for fd in (
-                pipes['stdout'],
-                pipes['stderr'],
-                pipes['stdin'],
-        ):
-            if fd is not None:
-                flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NDELAY
-                fcntl.fcntl(fd, fcntl.F_SETFL, flags)
+    @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,
+        )
 
-        return ProcessPipes(**pipes)
 
-    except OSError:
-        for fd in pipes.values():
-            if fd is not None:
-                close_fd(fd)
+##
 
-        raise
+
+def prepare_process_group_config(dct: ConfigMapping) -> ConfigMapping:
+    out = dict(dct)
+    out['processes'] = build_config_named_children(out.get('processes'))
+    return out
 
 
-def close_pipes(pipes: ProcessPipes) -> None:
-    close_parent_pipes(pipes)
-    close_child_pipes(pipes)
+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 close_parent_pipes(pipes: ProcessPipes) -> None:
-    for fd in pipes.parent_fds():
-        close_fd(fd)
+##
 
 
-def close_child_pipes(pipes: ProcessPipes) -> None:
-    for fd in pipes.child_fds():
-        close_fd(fd)
+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
 
 
 ########################################
@@ -4371,23 +4519,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 +4552,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 +4598,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 +4633,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 +4661,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 +4693,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 +4743,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
@@ -5351,11 +5348,6 @@ 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
-
 
 ##
 
@@ -5373,7 +5365,7 @@ class Dispatcher(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def fd(self) -> int:
+    def fd(self) -> Fd:
         raise NotImplementedError
 
     @property
@@ -5451,7 +5443,7 @@ class Process(ConfigPriorityOrdered, abc.ABC):
 
     @property
     @abc.abstractmethod
-    def pid(self) -> int:
+    def pid(self) -> Pid:
         raise NotImplementedError
 
     #
@@ -5462,7 +5454,7 @@ class Process(ConfigPriorityOrdered, abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def finish(self, sts: int) -> None:
+    def finish(self, sts: Rc) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -5546,7 +5538,6 @@ class ServerContextImpl(ServerContext):
         self._poller = poller
         self._epoch = epoch
 
-        self._pid_history: ta.Dict[int, Process] = {}
         self._state: SupervisorState = SupervisorState.RUNNING
 
     @property
@@ -5568,13 +5559,9 @@ class ServerContextImpl(ServerContext):
     def set_state(self, state: SupervisorState) -> None:
         self._state = state
 
-    @property
-    def pid_history(self) -> ta.Dict[int, Process]:
-        return self._pid_history
-
     #
 
-    def waitpid(self) -> ta.Tuple[ta.Optional[int], ta.Optional[int]]:
+    def waitpid(self) -> ta.Tuple[ta.Optional[Pid], ta.Optional[Rc]]:
         # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
         # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
         # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
@@ -5590,7 +5577,7 @@ class ServerContextImpl(ServerContext):
             if code == errno.EINTR:
                 log.debug('EINTR during reap')
             pid, sts = None, None
-        return pid, sts
+        return pid, sts  # type: ignore
 
     def get_auto_child_log_name(self, name: str, identifier: str, channel: str) -> str:
         prefix = f'{name}-{channel}---{identifier}-'
@@ -5606,8 +5593,8 @@ class ServerContextImpl(ServerContext):
 # ../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
 
     #
@@ -5643,7 +5630,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
             self,
             process: Process,
             channel: str,
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
     ) -> None:
@@ -5672,7 +5659,7 @@ class BaseDispatcherImpl(Dispatcher, abc.ABC):
         return self._channel
 
     @property
-    def fd(self) -> int:
+    def fd(self) -> Fd:
         return self._fd
 
     @property
@@ -5706,7 +5693,7 @@ class OutputDispatcherImpl(BaseDispatcherImpl, OutputDispatcher):
             self,
             process: Process,
             event_type: ta.Type[ProcessCommunicationEvent],
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
     ) -> None:
@@ -5916,7 +5903,7 @@ class InputDispatcherImpl(BaseDispatcherImpl, InputDispatcher):
             self,
             process: Process,
             channel: str,
-            fd: int,
+            fd: Fd,
             *,
             event_callbacks: EventCallbacks,
     ) -> None:
@@ -6110,7 +6097,7 @@ class ProcessGroupImpl(ProcessGroup):
 
 
 ########################################
-# ../processes.py
+# ../process.py
 
 
 ##
@@ -6123,7 +6110,7 @@ class ProcessStateError(RuntimeError):
 ##
 
 
-class PidHistory(ta.Dict[int, Process]):
+class PidHistory(ta.Dict[Pid, Process]):
     pass
 
 
@@ -6351,7 +6338,7 @@ class SupervisorSetupImpl(SupervisorSetup):
         if pid != 0:
             # Parent
             log.debug('supervisord forked; parent exiting')
-            real_exit(0)
+            real_exit(Rc(0))
 
         # Child
         log.info('daemonizing the supervisord process')
@@ -6380,7 +6367,7 @@ class SupervisorSetupImpl(SupervisorSetup):
 
 @dc.dataclass(frozen=True)
 class SpawnedProcess:
-    pid: int
+    pid: Pid
     pipes: ProcessPipes
     dispatchers: Dispatchers
 
@@ -6409,6 +6396,17 @@ class ProcessSpawning:
 ##
 
 
+class ExitNow(Exception):  # noqa
+    pass
+
+
+def timeslice(period: int, when: float) -> int:
+    return int(when - (when % period))
+
+
+##
+
+
 class SignalHandler:
     def __init__(
             self,
@@ -6543,7 +6541,7 @@ class Supervisor:
             # 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]
+                names = [p.config.name for p in unstopped]
                 namestr = ', '.join(names)
                 log.info('waiting for %s to die', namestr)
                 self._last_shutdown_report = now
@@ -6736,7 +6734,7 @@ class Supervisor:
 
 
 ########################################
-# ../processesimpl.py
+# ../processimpl.py
 
 
 class ProcessSpawningFactory(Func1[Process, ProcessSpawning]):
@@ -6774,7 +6772,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,7 +6786,7 @@ 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
 
     #
@@ -6811,7 +6809,7 @@ class ProcessImpl(Process):
         return self._group
 
     @property
-    def pid(self) -> int:
+    def pid(self) -> Pid:
         return self._pid
 
     #
@@ -6830,11 +6828,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(
@@ -6957,7 +6953,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 +6973,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 +6997,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 +7006,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 +7039,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 +7056,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 +7066,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 +7085,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 +7093,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 +7103,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 +7119,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,14 +7138,14 @@ 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([])
@@ -7190,7 +7183,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 +7192,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 +7225,15 @@ class ProcessImpl(Process):
 # ../spawningimpl.py
 
 
-class OutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], int, OutputDispatcher]):
+class OutputDispatcherFactory(Func3[Process, ta.Type[ProcessCommunicationEvent], Fd, OutputDispatcher]):
     pass
 
 
-class InputDispatcherFactory(Func3[Process, str, int, InputDispatcher]):
+class InputDispatcherFactory(Func3[Process, str, Fd, InputDispatcher]):
     pass
 
 
-InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[Fd])
 
 
 ##
@@ -7312,7 +7304,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:
@@ -7491,7 +7483,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 +7500,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: