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

ominfra/scripts/supervisor.py

@@ -3,7 +3,7 @@
 # @omlish-lite
 # @omlish-script
 # @omlish-amalg-output ../supervisor/main.py
-# ruff: noqa: N802 UP006 UP007 UP012 UP036
+# ruff: noqa: N802 U006 UP006 UP007 UP012 UP036
 # Supervisor is licensed under the following license:
 #
 #  A copyright notice accompanies this license document that identifies the copyright holders.
@@ -90,47 +90,50 @@ if sys.version_info < (3, 8):
 ########################################
 
 
-# ../../../omdev/toml/parser.py
+# ../../omdev/toml/parser.py
 TomlParseFloat = ta.Callable[[str], ta.Any]
 TomlKey = ta.Tuple[str, ...]
 TomlPos = int  # ta.TypeAlias
 
-# ../utils/collections.py
+# utils/collections.py
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
-# ../../../omlish/lite/cached.py
+# ../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 
-# ../../../omlish/lite/socket.py
+# ../../omlish/lite/check.py
+SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+
+# ../../omlish/lite/socket.py
 SocketAddress = ta.Any
 SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
 
-# ../../../omlish/lite/typing.py
+# ../../omlish/lite/typing.py
 A0 = ta.TypeVar('A0')
 A1 = ta.TypeVar('A1')
 A2 = ta.TypeVar('A2')
 
-# ../events.py
+# events.py
 EventCallback = ta.Callable[['Event'], None]
 
-# ../../../omlish/lite/http/parsing.py
+# ../../omlish/lite/http/parsing.py
 HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
 
-# ../../../omlish/lite/inject.py
+# ../../omlish/lite/inject.py
 U = ta.TypeVar('U')
 InjectorKeyCls = ta.Union[type, ta.NewType]
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
 InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
 InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 
-# ../../configs.py
+# ../configs.py
 ConfigMapping = ta.Mapping[str, ta.Any]
 
-# ../../../omlish/lite/http/handlers.py
+# ../../omlish/lite/http/handlers.py
 HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']
 
-# ../../../omlish/lite/http/coroserver.py
+# ../../omlish/lite/http/coroserver.py
 CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
 
 
@@ -988,9 +991,8 @@ class NoPermissionError(ProcessError):
 
 def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
     """
-    Drop privileges to become the specified user, which may be a username or uid.  Called for supervisord startup
-    and when spawning subprocesses.  Returns None on success or a string error message if privileges could not be
-    dropped.
+    Drop privileges to become the specified user, which may be a username or uid. Called for supervisord startup and
+    when spawning subprocesses. Returns None on success or a string error message if privileges could not be dropped.
     """
 
     if user is None:
@@ -1014,9 +1016,8 @@ def drop_privileges(user: ta.Union[int, str, None]) -> ta.Optional[str]:
     current_uid = os.getuid()
 
     if current_uid == uid:
-        # do nothing and return successfully if the uid is already the current one.  this allows a supervisord
-        # running as an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in
-        # it.
+        # do nothing and return successfully if the uid is already the current one. this allows a supervisord running as
+        # an unprivileged user "foo" to start a process where the config has "user=foo" (same user) in it.
         return None
 
     if current_uid != 0:
@@ -1370,8 +1371,8 @@ def strip_escapes(s: bytes) -> bytes:
 
 
 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.
+    # 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
@@ -1523,6 +1524,228 @@ def check_single(vs: ta.Iterable[T]) -> T:
     return v
 
 
+def check_empty(v: SizedT) -> SizedT:
+    if len(v):
+        raise ValueError(v)
+    return v
+
+
+def check_non_empty(v: SizedT) -> SizedT:
+    if not len(v):
+        raise ValueError(v)
+    return v
+
+
+########################################
+# ../../../omlish/lite/fdio/pollers.py
+
+
+##
+
+
+class FdIoPoller(abc.ABC):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._readable: ta.Set[int] = set()
+        self._writable: ta.Set[int] = set()
+
+    #
+
+    def close(self) -> None:  # noqa
+        pass
+
+    def reopen(self) -> None:  # noqa
+        pass
+
+    #
+
+    @property
+    @ta.final
+    def readable(self) -> ta.AbstractSet[int]:
+        return self._readable
+
+    @property
+    @ta.final
+    def writable(self) -> ta.AbstractSet[int]:
+        return self._writable
+
+    #
+
+    @ta.final
+    def register_readable(self, fd: int) -> bool:
+        if fd in self._readable:
+            return False
+        self._readable.add(fd)
+        self._register_readable(fd)
+        return True
+
+    @ta.final
+    def register_writable(self, fd: int) -> bool:
+        if fd in self._writable:
+            return False
+        self._writable.add(fd)
+        self._register_writable(fd)
+        return True
+
+    @ta.final
+    def unregister_readable(self, fd: int) -> bool:
+        if fd not in self._readable:
+            return False
+        self._readable.discard(fd)
+        self._unregister_readable(fd)
+        return True
+
+    @ta.final
+    def unregister_writable(self, fd: int) -> bool:
+        if fd not in self._writable:
+            return False
+        self._writable.discard(fd)
+        self._unregister_writable(fd)
+        return True
+
+    #
+
+    def _register_readable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _register_writable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _unregister_readable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _unregister_writable(self, fd: int) -> None:  # noqa
+        pass
+
+    #
+
+    def update(
+            self,
+            r: ta.AbstractSet[int],
+            w: ta.AbstractSet[int],
+    ) -> None:
+        for f in r - self._readable:
+            self.register_readable(f)
+        for f in w - self._writable:
+            self.register_writable(f)
+        for f in self._readable - r:
+            self.unregister_readable(f)
+        for f in self._writable - w:
+            self.unregister_writable(f)
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class PollResult:
+        r: ta.Sequence[int] = ()
+        w: ta.Sequence[int] = ()
+
+        inv: ta.Sequence[int] = ()
+
+        msg: ta.Optional[str] = None
+        exc: ta.Optional[BaseException] = None
+
+    @abc.abstractmethod
+    def poll(self, timeout: ta.Optional[float]) -> PollResult:
+        raise NotImplementedError
+
+
+##
+
+
+class SelectFdIoPoller(FdIoPoller):
+    def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+        try:
+            r, w, x = select.select(
+                self._readable,
+                self._writable,
+                [],
+                timeout,
+            )
+
+        except OSError as exc:
+            if exc.errno == errno.EINTR:
+                return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+            elif exc.errno == errno.EBADF:
+                return FdIoPoller.PollResult(msg='EBADF encountered in poll', exc=exc)
+            else:
+                raise
+
+        return FdIoPoller.PollResult(r, w)
+
+
+##
+
+
+PollFdIoPoller: ta.Optional[ta.Type[FdIoPoller]]
+if hasattr(select, 'poll'):
+
+    class _PollFdIoPoller(FdIoPoller):
+        def __init__(self) -> None:
+            super().__init__()
+
+            self._poller = select.poll()
+
+        #
+
+        _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
+        _WRITE = select.POLLOUT
+
+        def _register_readable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _register_writable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _unregister_readable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _unregister_writable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _update_registration(self, fd: int) -> None:
+            r = fd in self._readable
+            w = fd in self._writable
+            if r or w:
+                self._poller.register(fd, (self._READ if r else 0) | (self._WRITE if w else 0))
+            else:
+                self._poller.unregister(fd)
+
+        #
+
+        def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+            polled: ta.List[ta.Tuple[int, int]]
+            try:
+                polled = self._poller.poll(timeout * 1000 if timeout is not None else None)
+
+            except OSError as exc:
+                if exc.errno == errno.EINTR:
+                    return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                else:
+                    raise
+
+            r: ta.List[int] = []
+            w: ta.List[int] = []
+            inv: ta.List[int] = []
+            for fd, mask in polled:
+                if mask & select.POLLNVAL:
+                    self._poller.unregister(fd)
+                    self._readable.discard(fd)
+                    self._writable.discard(fd)
+                    inv.append(fd)
+                    continue
+                if mask & self._READ:
+                    r.append(fd)
+                if mask & self._WRITE:
+                    w.append(fd)
+            return FdIoPoller.PollResult(r, w, inv=inv)
+
+    PollFdIoPoller = _PollFdIoPoller
+else:
+    PollFdIoPoller = None
+
+
 ########################################
 # ../../../omlish/lite/http/versions.py
 
@@ -1742,6 +1965,73 @@ class SocketHandler(abc.ABC):
         raise NotImplementedError
 
 
+########################################
+# ../../../omlish/lite/strings.py
+
+
+##
+
+
+def camel_case(name: str, lower: bool = False) -> str:
+    if not name:
+        return ''
+    s = ''.join(map(str.capitalize, name.split('_')))  # noqa
+    if lower:
+        s = s[0].lower() + s[1:]
+    return s
+
+
+def snake_case(name: str) -> str:
+    uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
+    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
+
+
+##
+
+
+def is_dunder(name: str) -> bool:
+    return (
+        name[:2] == name[-2:] == '__' and
+        name[2:3] != '_' and
+        name[-3:-2] != '_' and
+        len(name) > 4
+    )
+
+
+def is_sunder(name: str) -> bool:
+    return (
+        name[0] == name[-1] == '_' and
+        name[1:2] != '_' and
+        name[-2:-1] != '_' and
+        len(name) > 2
+    )
+
+
+##
+
+
+def attr_repr(obj: ta.Any, *attrs: str) -> str:
+    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
+
+
+##
+
+
+FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
+
+
+def format_num_bytes(num_bytes: int) -> str:
+    for i, suffix in enumerate(FORMAT_NUM_BYTES_SUFFIXES):
+        value = num_bytes / 1024 ** i
+        if num_bytes < 1024 ** (i + 1):
+            if value.is_integer():
+                return f'{int(value)}{suffix}'
+            else:
+                return f'{value:.2f}{suffix}'
+
+    return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
+
+
 ########################################
 # ../../../omlish/lite/typing.py
 
@@ -2138,7 +2428,7 @@ def decode_wait_status(sts: int) -> ta.Tuple[Rc, str]:
     Decode the status returned by wait() or waitpid().
 
     Return a tuple (exitstatus, message) where exitstatus is the exit status, or -1 if the process was killed by a
-    signal; and message is a message telling what happened.  It is the caller's responsibility to display the message.
+    signal; and message is a message telling what happened. It is the caller's responsibility to display the message.
     """
 
     if os.WIFEXITED(sts):
@@ -2227,87 +2517,250 @@ def get_user(name: str) -> User:
 
 
 ########################################
-# ../../../omlish/lite/http/parsing.py
-# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
-# --------------------------------------------
-#
-# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
-# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
-# documentation.
-#
-# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
-# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
-# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
-# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
-# alone or in any derivative version prepared by Licensee.
-#
-# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
-# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
-# any such work a brief summary of the changes made to Python.
-#
-# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
-# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
-# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
-# RIGHTS.
-#
-# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
-# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
-# ADVISED OF THE POSSIBILITY THEREOF.
-#
-# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
-#
-# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
-# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
-# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
-#
-# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
-# License Agreement.
+# ../../../omlish/lite/fdio/handlers.py
 
 
-##
+class FdIoHandler(abc.ABC):
+    @abc.abstractmethod
+    def fd(self) -> int:
+        raise NotImplementedError
 
+    #
 
-class ParseHttpRequestResult(abc.ABC):  # noqa
-    __slots__ = (
-        'server_version',
-        'request_line',
-        'request_version',
-        'version',
-        'headers',
-        'close_connection',
-    )
+    @property
+    @abc.abstractmethod
+    def closed(self) -> bool:
+        raise NotImplementedError
 
-    def __init__(
-            self,
-            *,
-            server_version: HttpProtocolVersion,
-            request_line: str,
-            request_version: HttpProtocolVersion,
-            version: HttpProtocolVersion,
-            headers: ta.Optional[HttpHeaders],
-            close_connection: bool,
-    ) -> None:
-        super().__init__()
+    @abc.abstractmethod
+    def close(self) -> None:
+        raise NotImplementedError
 
-        self.server_version = server_version
-        self.request_line = request_line
-        self.request_version = request_version
-        self.version = version
-        self.headers = headers
-        self.close_connection = close_connection
+    #
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}({", ".join(f"{a}={getattr(self, a)!r}" for a in self.__slots__)})'
+    def readable(self) -> bool:
+        return False
 
+    def writable(self) -> bool:
+        return False
 
-class EmptyParsedHttpResult(ParseHttpRequestResult):
-    pass
+    #
 
+    def on_readable(self) -> None:
+        raise TypeError
 
-class ParseHttpRequestError(ParseHttpRequestResult):
-    __slots__ = (
-        'code',
+    def on_writable(self) -> None:
+        raise TypeError
+
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:  # noqa
+        pass
+
+
+class SocketFdIoHandler(FdIoHandler, abc.ABC):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            sock: socket.socket,
+    ) -> None:
+        super().__init__()
+
+        self._addr = addr
+        self._sock: ta.Optional[socket.socket] = sock
+
+    def fd(self) -> int:
+        return check_not_none(self._sock).fileno()
+
+    @property
+    def closed(self) -> bool:
+        return self._sock is None
+
+    def close(self) -> None:
+        if self._sock is not None:
+            self._sock.close()
+        self._sock = None
+
+
+########################################
+# ../../../omlish/lite/fdio/kqueue.py
+
+
+KqueueFdIoPoller: ta.Optional[ta.Type[FdIoPoller]]
+if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
+
+    class _KqueueFdIoPoller(FdIoPoller):
+        DEFAULT_MAX_EVENTS = 1000
+
+        def __init__(
+                self,
+                *,
+                max_events: int = DEFAULT_MAX_EVENTS,
+        ) -> None:
+            super().__init__()
+
+            self._max_events = max_events
+
+            self._kqueue: ta.Optional[ta.Any] = None
+
+        #
+
+        def _get_kqueue(self) -> 'select.kqueue':
+            if (kq := self._kqueue) is not None:
+                return kq
+            kq = select.kqueue()
+            self._kqueue = kq
+            return kq
+
+        def close(self) -> None:
+            if self._kqueue is not None:
+                self._kqueue.close()
+                self._kqueue = None
+
+        def reopen(self) -> None:
+            for fd in self._readable:
+                self._register_readable(fd)
+            for fd in self._writable:
+                self._register_writable(fd)
+
+        #
+
+        def _register_readable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_READ, select.KQ_EV_ADD)
+
+        def _register_writable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_ADD)
+
+        def _unregister_readable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_READ, select.KQ_EV_DELETE)
+
+        def _unregister_writable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_DELETE)
+
+        def _control(self, fd: int, filter: int, flags: int) -> None:  # noqa
+            ke = select.kevent(fd, filter=filter, flags=flags)
+            kq = self._get_kqueue()
+            try:
+                kq.control([ke], 0)
+
+            except OSError as exc:
+                if exc.errno == errno.EBADF:
+                    # log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', ke.ident)
+                    pass
+                elif exc.errno == errno.ENOENT:
+                    # Can happen when trying to remove an already closed socket
+                    pass
+                else:
+                    raise
+
+        #
+
+        def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+            kq = self._get_kqueue()
+            try:
+                kes = kq.control(None, self._max_events, timeout)
+
+            except OSError as exc:
+                if exc.errno == errno.EINTR:
+                    return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                else:
+                    raise
+
+            r: ta.List[int] = []
+            w: ta.List[int] = []
+            for ke in kes:
+                if ke.filter == select.KQ_FILTER_READ:
+                    r.append(ke.ident)
+                if ke.filter == select.KQ_FILTER_WRITE:
+                    w.append(ke.ident)
+
+            return FdIoPoller.PollResult(r, w)
+
+    KqueueFdIoPoller = _KqueueFdIoPoller
+else:
+    KqueueFdIoPoller = None
+
+
+########################################
+# ../../../omlish/lite/http/parsing.py
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
+# alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+
+
+##
+
+
+class ParseHttpRequestResult(abc.ABC):  # noqa
+    __slots__ = (
+        'server_version',
+        'request_line',
+        'request_version',
+        'version',
+        'headers',
+        'close_connection',
+    )
+
+    def __init__(
+            self,
+            *,
+            server_version: HttpProtocolVersion,
+            request_line: str,
+            request_version: HttpProtocolVersion,
+            version: HttpProtocolVersion,
+            headers: ta.Optional[HttpHeaders],
+            close_connection: bool,
+    ) -> None:
+        super().__init__()
+
+        self.server_version = server_version
+        self.request_line = request_line
+        self.request_version = request_version
+        self.version = version
+        self.headers = headers
+        self.close_connection = close_connection
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join(f"{a}={getattr(self, a)!r}" for a in self.__slots__)})'
+
+
+class EmptyParsedHttpResult(ParseHttpRequestResult):
+    pass
+
+
+class ParseHttpRequestError(ParseHttpRequestResult):
+    __slots__ = (
+        'code',
         'message',
         *ParseHttpRequestResult.__slots__,
     )
@@ -2628,11 +3081,6 @@ class HttpRequestParser:
 
 ########################################
 # ../../../omlish/lite/inject.py
-"""
-TODO:
- - recursion detection
- - bind empty array
-"""
 
 
 ###
@@ -2925,7 +3373,11 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 
     for b in bs.bindings():
         if b.key.array:
-            am.setdefault(b.key, []).append(b.provider)
+            al = am.setdefault(b.key, [])
+            if isinstance(b.provider, ArrayInjectorProvider):
+                al.extend(b.provider.ps)
+            else:
+                al.append(b.provider)
         else:
             if b.key in pm:
                 raise KeyError(b.key)
@@ -3073,6 +3525,14 @@ def build_injection_kwargs_target(
 _INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
 
 
+@dc.dataclass(frozen=True)
+class _InjectorEager:
+    key: InjectorKey
+
+
+_INJECTOR_EAGER_ARRAY_KEY: InjectorKey[_InjectorEager] = InjectorKey(_InjectorEager, array=True)
+
+
 class _Injector(Injector):
     def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
         super().__init__()
@@ -3087,6 +3547,10 @@ class _Injector(Injector):
 
         self.__cur_req: ta.Optional[_Injector._Request] = None
 
+        if _INJECTOR_EAGER_ARRAY_KEY in self._pfm:
+            for e in self.provide(_INJECTOR_EAGER_ARRAY_KEY):
+                self.provide(e.key)
+
     class _Request:
         def __init__(self, injector: '_Injector') -> None:
             super().__init__()
@@ -3244,6 +3708,8 @@ class InjectorBinder:
             to_key: ta.Any = None,
 
             singleton: bool = False,
+
+            eager: bool = False,
     ) -> InjectorBindingOrBindings:
         if obj is None or obj is inspect.Parameter.empty:
             raise TypeError(obj)
@@ -3317,13 +3783,21 @@ class InjectorBinder:
         if singleton:
             provider = SingletonInjectorProvider(provider)
 
+        binding = InjectorBinding(key, provider)
+
         ##
 
-        binding = InjectorBinding(key, provider)
+        extras: ta.List[InjectorBinding] = []
+
+        if eager:
+            extras.append(bind_injector_eager_key(key))
 
         ##
 
-        return binding
+        if extras:
+            return as_injector_bindings(binding, *extras)
+        else:
+            return binding
 
 
 ###
@@ -3346,6 +3820,26 @@ def make_injector_factory(
     return outer
 
 
+def bind_injector_array(
+        obj: ta.Any = None,
+        *,
+        tag: ta.Any = None,
+) -> InjectorBindingOrBindings:
+    key = as_injector_key(obj)
+    if tag is not None:
+        if key.tag is not None:
+            raise ValueError('Must not specify multiple tags')
+        key = dc.replace(key, tag=tag)
+
+    if key.array:
+        raise ValueError('Key must not be array')
+
+    return InjectorBinding(
+        dc.replace(key, array=True),
+        ArrayInjectorProvider([]),
+    )
+
+
 def make_injector_array_type(
         ele: ta.Union[InjectorKey, InjectorKeyCls],
         cls: U,
@@ -3367,6 +3861,10 @@ def make_injector_array_type(
     return inner
 
 
+def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
+    return InjectorBinding(_INJECTOR_EAGER_ARRAY_KEY, ConstInjectorProvider(_InjectorEager(as_injector_key(key))))
+
+
 ##
 
 
@@ -3421,6 +3919,8 @@ class Injection:
             to_key: ta.Any = None,
 
             singleton: bool = False,
+
+            eager: bool = False,
     ) -> InjectorBindingOrBindings:
         return InjectorBinder.bind(
             obj,
@@ -3435,6 +3935,8 @@ class Injection:
             to_key=to_key,
 
             singleton=singleton,
+
+            eager=eager,
         )
 
     # helpers
@@ -3448,6 +3950,15 @@ class Injection:
     ) -> InjectorBindingOrBindings:
         return cls.bind(make_injector_factory(fn, cls_, ann))
 
+    @classmethod
+    def bind_array(
+            cls,
+            obj: ta.Any = None,
+            *,
+            tag: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return bind_injector_array(obj, tag=tag)
+
     @classmethod
     def bind_array_type(
             cls,
@@ -3462,98 +3973,320 @@ inj = Injection
 
 
 ########################################
-# ../../../omlish/lite/journald.py
+# ../../../omlish/lite/io.py
 
 
-##
+class DelimitingBuffer:
+    """
+    https://github.com/python-trio/trio/issues/796 :|
+    """
 
+    #
 
-class sd_iovec(ct.Structure):  # noqa
-    pass
+    class Error(Exception):
+        def __init__(self, buffer: 'DelimitingBuffer') -> None:
+            super().__init__(buffer)
+            self.buffer = buffer
 
+        def __repr__(self) -> str:
+            return attr_repr(self, 'buffer')
 
-sd_iovec._fields_ = [
-    ('iov_base', ct.c_void_p),  # Pointer to data.
-    ('iov_len', ct.c_size_t),  # Length of data.
-]
+    class ClosedError(Error):
+        pass
 
+    #
 
-##
+    DEFAULT_DELIMITERS: bytes = b'\n'
+
+    def __init__(
+            self,
+            delimiters: ta.Iterable[int] = DEFAULT_DELIMITERS,
+            *,
+            keep_ends: bool = False,
+            max_size: ta.Optional[int] = None,
+    ) -> None:
+        super().__init__()
 
+        self._delimiters = frozenset(check_isinstance(d, int) for d in delimiters)
+        self._keep_ends = keep_ends
+        self._max_size = max_size
 
-@cached_nullary
-def sd_libsystemd() -> ta.Any:
-    lib = ct.CDLL('libsystemd.so.0')
+        self._buf: ta.Optional[io.BytesIO] = io.BytesIO()
 
-    lib.sd_journal_sendv.restype = ct.c_int
-    lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
+    #
 
-    return lib
+    @property
+    def is_closed(self) -> bool:
+        return self._buf is None
+
+    def tell(self) -> int:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
+        return buf.tell()
+
+    def peek(self) -> bytes:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
+        return buf.getvalue()
+
+    def _find_delim(self, data: ta.Union[bytes, bytearray], i: int) -> ta.Optional[int]:
+        r = None  # type: int | None
+        for d in self._delimiters:
+            if (p := data.find(d, i)) >= 0:
+                if r is None or p < r:
+                    r = p
+        return r
+
+    def _append_and_reset(self, chunk: bytes) -> bytes:
+        buf = check_not_none(self._buf)
+        if not buf.tell():
+            return chunk
+
+        buf.write(chunk)
+        ret = buf.getvalue()
+        buf.seek(0)
+        buf.truncate()
+        return ret
 
+    class Incomplete(ta.NamedTuple):
+        b: bytes
 
-@cached_nullary
-def sd_try_libsystemd() -> ta.Optional[ta.Any]:
-    try:
-        return sd_libsystemd()
-    except OSError:  # noqa
-        return None
+    def feed(self, data: ta.Union[bytes, bytearray]) -> ta.Generator[ta.Union[bytes, Incomplete], None, None]:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
 
+        if not data:
+            self._buf = None
 
-##
+            if buf.tell():
+                yield self.Incomplete(buf.getvalue())
 
+            return
 
-def sd_journald_send(**fields: str) -> int:
-    lib = sd_libsystemd()
+        l = len(data)
+        i = 0
+        while i < l:
+            if (p := self._find_delim(data, i)) is None:
+                break
 
-    msgs = [
-        f'{k.upper()}={v}\0'.encode('utf-8')
-        for k, v in fields.items()
-    ]
+            n = p + 1
+            if self._keep_ends:
+                p = n
 
-    vec = (sd_iovec * len(msgs))()
-    cl = (ct.c_char_p * len(msgs))()  # noqa
-    for i in range(len(msgs)):
-        vec[i].iov_base = ct.cast(ct.c_char_p(msgs[i]), ct.c_void_p)
-        vec[i].iov_len = len(msgs[i]) - 1
+            yield self._append_and_reset(data[i:p])
 
-    return lib.sd_journal_sendv(vec, len(msgs))
+            i = n
 
+        if i >= l:
+            return
 
-##
+        if self._max_size is None:
+            buf.write(data[i:])
+            return
 
+        while i < l:
+            remaining_data_len = l - i
+            remaining_buf_capacity = self._max_size - buf.tell()
 
-SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
-    logging.FATAL: syslog.LOG_EMERG,  # system is unusable
-    # LOG_ALERT ?  # action must be taken immediately
-    logging.CRITICAL: syslog.LOG_CRIT,
-    logging.ERROR: syslog.LOG_ERR,
-    logging.WARNING: syslog.LOG_WARNING,
-    # LOG_NOTICE ?  # normal but significant condition
-    logging.INFO: syslog.LOG_INFO,
-    logging.DEBUG: syslog.LOG_DEBUG,
-}
+            if remaining_data_len < remaining_buf_capacity:
+                buf.write(data[i:])
+                return
 
+            p = i + remaining_buf_capacity
+            yield self.Incomplete(self._append_and_reset(data[i:p]))
+            i = p
 
-class JournaldLogHandler(logging.Handler):
-    """
-    TODO:
-     - fallback handler for when this barfs
-    """
 
-    def __init__(
-            self,
-            *,
-            use_formatter_output: bool = False,
-    ) -> None:
+class ReadableListBuffer:
+    def __init__(self) -> None:
         super().__init__()
+        self._lst: list[bytes] = []
 
-        sd_libsystemd()
+    def feed(self, d: bytes) -> None:
+        if d:
+            self._lst.append(d)
 
-        self._use_formatter_output = use_formatter_output
+    def _chop(self, i: int, e: int) -> bytes:
+        lst = self._lst
+        d = lst[i]
 
-    #
+        o = b''.join([
+            *lst[:i],
+            d[:e],
+        ])
 
-    EXTRA_RECORD_ATTRS_BY_JOURNALD_FIELD: ta.ClassVar[ta.Mapping[str, str]] = {
+        self._lst = [
+            *([d[e:]] if e < len(d) else []),
+            *lst[i + 1:],
+        ]
+
+        return o
+
+    def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
+        if n is None:
+            o = b''.join(self._lst)
+            self._lst = []
+            return o
+
+        if not (lst := self._lst):
+            return None
+
+        c = 0
+        for i, d in enumerate(lst):
+            r = n - c
+            if (l := len(d)) >= r:
+                return self._chop(i, r)
+            c += l
+
+        return None
+
+    def read_until(self, delim: bytes = b'\n') -> ta.Optional[bytes]:
+        if not (lst := self._lst):
+            return None
+
+        for i, d in enumerate(lst):
+            if (p := d.find(delim)) >= 0:
+                return self._chop(i, p + len(delim))
+
+        return None
+
+
+class IncrementalWriteBuffer:
+    def __init__(
+            self,
+            data: bytes,
+            *,
+            write_size: int = 0x10000,
+    ) -> None:
+        super().__init__()
+
+        check_non_empty(data)
+        self._len = len(data)
+        self._write_size = write_size
+
+        self._lst = [
+            data[i:i + write_size]
+            for i in range(0, len(data), write_size)
+        ]
+        self._pos = 0
+
+    @property
+    def rem(self) -> int:
+        return self._len - self._pos
+
+    def write(self, fn: ta.Callable[[bytes], int]) -> int:
+        lst = check_non_empty(self._lst)
+
+        t = 0
+        for i, d in enumerate(lst):  # noqa
+            n = fn(check_non_empty(d))
+            if not n:
+                break
+            t += n
+
+        if t:
+            self._lst = [
+                *([d[n:]] if n < len(d) else []),
+                *lst[i + 1:],
+            ]
+            self._pos += t
+
+        return t
+
+
+########################################
+# ../../../omlish/lite/journald.py
+
+
+##
+
+
+class sd_iovec(ct.Structure):  # noqa
+    pass
+
+
+sd_iovec._fields_ = [
+    ('iov_base', ct.c_void_p),  # Pointer to data.
+    ('iov_len', ct.c_size_t),  # Length of data.
+]
+
+
+##
+
+
+@cached_nullary
+def sd_libsystemd() -> ta.Any:
+    lib = ct.CDLL('libsystemd.so.0')
+
+    lib.sd_journal_sendv.restype = ct.c_int
+    lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
+
+    return lib
+
+
+@cached_nullary
+def sd_try_libsystemd() -> ta.Optional[ta.Any]:
+    try:
+        return sd_libsystemd()
+    except OSError:  # noqa
+        return None
+
+
+##
+
+
+def sd_journald_send(**fields: str) -> int:
+    lib = sd_libsystemd()
+
+    msgs = [
+        f'{k.upper()}={v}\0'.encode('utf-8')
+        for k, v in fields.items()
+    ]
+
+    vec = (sd_iovec * len(msgs))()
+    cl = (ct.c_char_p * len(msgs))()  # noqa
+    for i in range(len(msgs)):
+        vec[i].iov_base = ct.cast(ct.c_char_p(msgs[i]), ct.c_void_p)
+        vec[i].iov_len = len(msgs[i]) - 1
+
+    return lib.sd_journal_sendv(vec, len(msgs))
+
+
+##
+
+
+SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
+    logging.FATAL: syslog.LOG_EMERG,  # system is unusable
+    # LOG_ALERT ?  # action must be taken immediately
+    logging.CRITICAL: syslog.LOG_CRIT,
+    logging.ERROR: syslog.LOG_ERR,
+    logging.WARNING: syslog.LOG_WARNING,
+    # LOG_NOTICE ?  # normal but significant condition
+    logging.INFO: syslog.LOG_INFO,
+    logging.DEBUG: syslog.LOG_DEBUG,
+}
+
+
+class JournaldLogHandler(logging.Handler):
+    """
+    TODO:
+     - fallback handler for when this barfs
+    """
+
+    def __init__(
+            self,
+            *,
+            use_formatter_output: bool = False,
+    ) -> None:
+        super().__init__()
+
+        sd_libsystemd()
+
+        self._use_formatter_output = use_formatter_output
+
+    #
+
+    EXTRA_RECORD_ATTRS_BY_JOURNALD_FIELD: ta.ClassVar[ta.Mapping[str, str]] = {
         'name': 'name',
         'module': 'module',
         'exception': 'exc_text',
@@ -4333,8 +5066,8 @@ class ProcessPipes:
 
 def make_process_pipes(stderr=True) -> ProcessPipes:
     """
-    Create pipes for parent to child stdin/stdout/stderr communications.  Open fd in non-blocking mode so we can
-    read them in the mainloop without blocking.  If stderr is False, don't create a pipe for stderr.
+    Create pipes for parent to child stdin/stdout/stderr communications. Open fd in non-blocking mode so we can read
+    them in the mainloop without blocking. If stderr is False, don't create a pipe for stderr.
     """
 
     pipes: ta.Dict[str, ta.Optional[Fd]] = {
@@ -4484,32 +5217,32 @@ class ProcessConfig:
     umask: ta.Optional[int] = None
     priority: int = 999
 
-    autostart: bool = True
-    autorestart: str = 'unexpected'
+    auto_start: bool = True
+    auto_restart: str = 'unexpected'
 
-    startsecs: int = 1
-    startretries: int = 3
+    start_secs: int = 1
+    start_retries: int = 3
 
-    numprocs: int = 1
-    numprocs_start: int = 0
+    num_procs: int = 1
+    num_procs_start: int = 0
 
     @dc.dataclass(frozen=True)
     class Log:
         file: ta.Optional[str] = None
-        capture_maxbytes: ta.Optional[int] = None
+        capture_max_bytes: ta.Optional[int] = None
         events_enabled: bool = False
         syslog: bool = False
         backups: ta.Optional[int] = None
-        maxbytes: ta.Optional[int] = None
+        max_bytes: ta.Optional[int] = None
 
     stdout: Log = Log()
     stderr: Log = Log()
 
-    stopsignal: int = signal.SIGTERM
-    stopwaitsecs: int = 10
-    stopasgroup: bool = False
+    stop_signal: int = signal.SIGTERM
+    stop_wait_secs: int = 10
+    stop_as_group: bool = False
 
-    killasgroup: bool = False
+    kill_as_group: bool = False
 
     exitcodes: ta.Sequence[int] = (0,)
 
@@ -4534,14 +5267,14 @@ class ServerConfig:
     umask: int = 0o22
     directory: ta.Optional[str] = None
     logfile: str = 'supervisord.log'
-    logfile_maxbytes: int = 50 * 1024 * 1024
+    logfile_max_bytes: 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
+    min_fds: int = 1024
+    min_procs: int = 200
     nocleanup: bool = False
     strip_ansi: bool = False
     silent: bool = False
@@ -4554,7 +5287,7 @@ class ServerConfig:
             umask: ta.Union[int, str] = 0o22,
             directory: ta.Optional[str] = None,
             logfile: str = 'supervisord.log',
-            logfile_maxbytes: ta.Union[int, str] = 50 * 1024 * 1024,
+            logfile_max_bytes: ta.Union[int, str] = 50 * 1024 * 1024,
             loglevel: ta.Union[int, str] = logging.INFO,
             pidfile: str = 'supervisord.pid',
             child_logdir: ta.Optional[str] = None,
@@ -4564,7 +5297,7 @@ class ServerConfig:
             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),
+            logfile_max_bytes=parse_bytes_size(logfile_max_bytes),
             loglevel=parse_logging_level(loglevel),
             pidfile=check_path_with_existing_dir(pidfile),
             child_logdir=child_logdir if child_logdir else tempfile.gettempdir(),
@@ -4601,239 +5334,6 @@ def parse_logging_level(value: ta.Union[str, int]) -> int:
     return level
 
 
-########################################
-# ../poller.py
-
-
-class Poller(DaemonizeListener, abc.ABC):
-    def __init__(self) -> None:
-        super().__init__()
-
-    @abc.abstractmethod
-    def register_readable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def register_writable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unregister_readable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def unregister_writable(self, fd: Fd) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
-        raise NotImplementedError
-
-    def before_daemonize(self) -> None:  # noqa
-        pass
-
-    def after_daemonize(self) -> None:  # noqa
-        pass
-
-    def close(self) -> None:  # noqa
-        pass
-
-
-class SelectPoller(Poller):
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._readable: ta.Set[Fd] = set()
-        self._writable: ta.Set[Fd] = set()
-
-    def register_readable(self, fd: Fd) -> None:
-        self._readable.add(fd)
-
-    def register_writable(self, fd: Fd) -> None:
-        self._writable.add(fd)
-
-    def unregister_readable(self, fd: Fd) -> None:
-        self._readable.discard(fd)
-
-    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[Fd], ta.List[Fd]]:
-        try:
-            r, w, x = select.select(
-                self._readable,
-                self._writable,
-                [], timeout,
-            )
-        except OSError as exc:
-            if exc.args[0] == errno.EINTR:
-                log.debug('EINTR encountered in poll')
-                return [], []
-            if exc.args[0] == errno.EBADF:
-                log.debug('EBADF encountered in poll')
-                self.unregister_all()
-                return [], []
-            raise
-        return r, w
-
-
-class PollPoller(Poller):
-    _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
-    _WRITE = select.POLLOUT
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._poller = select.poll()
-        self._readable: set[Fd] = set()
-        self._writable: set[Fd] = set()
-
-    def register_readable(self, fd: Fd) -> None:
-        self._poller.register(fd, self._READ)
-        self._readable.add(fd)
-
-    def register_writable(self, fd: Fd) -> None:
-        self._poller.register(fd, self._WRITE)
-        self._writable.add(fd)
-
-    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: 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[Fd], ta.List[Fd]]:
-        fds = self._poll_fds(timeout)  # type: ignore
-        readable, writable = [], []
-        for fd, eventmask in fds:
-            if self._ignore_invalid(fd, eventmask):
-                continue
-            if eventmask & self._READ:
-                readable.append(fd)
-            if eventmask & self._WRITE:
-                writable.append(fd)
-        return readable, writable
-
-    def _poll_fds(self, timeout: float) -> ta.List[ta.Tuple[Fd, Fd]]:
-        try:
-            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: 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.
-            self._poller.unregister(fd)
-            self._readable.discard(fd)
-            self._writable.discard(fd)
-            return True
-        return False
-
-
-if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
-    class KqueuePoller(Poller):
-        max_events = 1000
-
-        def __init__(self) -> None:
-            super().__init__()
-
-            self._kqueue: ta.Optional[ta.Any] = select.kqueue()
-            self._readable: set[Fd] = set()
-            self._writable: set[Fd] = set()
-
-        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: 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: 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: 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: Fd, kevent: 'select.kevent') -> None:
-            try:
-                self._kqueue.control([kevent], 0)  # type: ignore
-            except OSError as error:
-                if error.errno == errno.EBADF:
-                    log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', fd)
-                else:
-                    raise
-
-        def poll(self, timeout: ta.Optional[float]) -> ta.Tuple[ta.List[Fd], ta.List[Fd]]:
-            readable, writable = [], []  # type: ignore
-
-            try:
-                kevents = self._kqueue.control(None, self.max_events, timeout)  # type: ignore
-            except OSError as error:
-                if error.errno == errno.EINTR:
-                    log.debug('EINTR encountered in poll')
-                    return readable, writable
-                raise
-
-            for kevent in kevents:
-                if kevent.filter == select.KQ_FILTER_READ:
-                    readable.append(kevent.ident)
-                if kevent.filter == select.KQ_FILTER_WRITE:
-                    writable.append(kevent.ident)
-
-            return readable, writable
-
-        def before_daemonize(self) -> None:
-            self.close()
-
-        def after_daemonize(self) -> None:
-            self._kqueue = select.kqueue()
-            for fd in self._readable:
-                self.register_readable(fd)
-            for fd in self._writable:
-                self.register_writable(fd)
-
-        def close(self) -> None:
-            self._kqueue.close()  # type: ignore
-            self._kqueue = None
-
-else:
-    KqueuePoller = None
-
-
-def get_poller_impl() -> ta.Type[Poller]:
-    if (
-            (sys.platform == 'darwin' or sys.platform.startswith('freebsd')) and
-            hasattr(select, 'kqueue') and
-            KqueuePoller is not None
-    ):
-        return KqueuePoller
-    elif hasattr(select, 'poll'):
-        return PollPoller
-    else:
-        return SelectPoller
-
-
 ########################################
 # ../../../omlish/lite/http/coroserver.py
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
@@ -5442,86 +5942,35 @@ class SupervisorStateManager(abc.ABC):
 ##
 
 
-class Dispatcher(abc.ABC):
-    @property
+class HasDispatchers(abc.ABC):
     @abc.abstractmethod
-    def channel(self) -> str:
+    def get_dispatchers(self) -> 'Dispatchers':
         raise NotImplementedError
 
+
+class ProcessDispatcher(FdIoHandler, abc.ABC):
     @property
     @abc.abstractmethod
-    def fd(self) -> Fd:
+    def channel(self) -> str:
         raise NotImplementedError
 
     @property
     @abc.abstractmethod
-    def closed(self) -> bool:
+    def process(self) -> 'Process':
         raise NotImplementedError
 
-    #
 
+class ProcessOutputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
-    def close(self) -> None:
+    def remove_logs(self) -> None:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def handle_error(self) -> None:
+    def reopen_logs(self) -> None:
         raise NotImplementedError
 
-    #
 
-    @abc.abstractmethod
-    def readable(self) -> bool:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def writable(self) -> bool:
-        raise NotImplementedError
-
-    #
-
-    def handle_read_event(self) -> None:
-        raise TypeError
-
-    def handle_write_event(self) -> None:
-        raise TypeError
-
-    #
-
-    def handle_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 ProcessOutputDispatcher(ProcessDispatcher, abc.ABC):
-    @abc.abstractmethod
-    def remove_logs(self) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def reopen_logs(self) -> None:
-        raise NotImplementedError
-
-
-class ProcessInputDispatcher(ProcessDispatcher, abc.ABC):
+class ProcessInputDispatcher(ProcessDispatcher, abc.ABC):
     @abc.abstractmethod
     def write(self, chars: ta.Union[bytes, str]) -> None:
         raise NotImplementedError
@@ -5625,13 +6074,139 @@ class ProcessGroup(
         raise NotImplementedError
 
 
+########################################
+# ../../../omlish/lite/fdio/corohttp.py
+
+
+class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            sock: socket.socket,
+            handler: HttpHandler,
+            *,
+            read_size: int = 0x10000,
+            write_size: int = 0x10000,
+    ) -> None:
+        check_state(not sock.getblocking())
+
+        super().__init__(addr, sock)
+
+        self._handler = handler
+        self._read_size = read_size
+        self._write_size = write_size
+
+        self._read_buf = ReadableListBuffer()
+        self._write_buf: IncrementalWriteBuffer | None = None
+
+        self._coro_srv = CoroHttpServer(
+            addr,
+            handler=self._handler,
+        )
+        self._srv_coro: ta.Optional[ta.Generator[CoroHttpServer.Io, ta.Optional[bytes], None]] = self._coro_srv.coro_handle()  # noqa
+
+        self._cur_io: CoroHttpServer.Io | None = None
+        self._next_io()
+
+    #
+
+    def _next_io(self) -> None:  # noqa
+        coro = check_not_none(self._srv_coro)
+
+        d: bytes | None = None
+        o = self._cur_io
+        while True:
+            if o is None:
+                try:
+                    if d is not None:
+                        o = coro.send(d)
+                        d = None
+                    else:
+                        o = next(coro)
+                except StopIteration:
+                    self.close()
+                    o = None
+                    break
+
+            if isinstance(o, CoroHttpServer.AnyLogIo):
+                print(o)
+                o = None
+
+            elif isinstance(o, CoroHttpServer.ReadIo):
+                if (d := self._read_buf.read(o.sz)) is None:
+                    break
+                o = None
+
+            elif isinstance(o, CoroHttpServer.ReadLineIo):
+                if (d := self._read_buf.read_until(b'\n')) is None:
+                    break
+                o = None
+
+            elif isinstance(o, CoroHttpServer.WriteIo):
+                check_none(self._write_buf)
+                self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
+                break
+
+            else:
+                raise TypeError(o)
+
+        self._cur_io = o
+
+    #
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return self._write_buf is not None
+
+    #
+
+    def on_readable(self) -> None:
+        try:
+            buf = check_not_none(self._sock).recv(self._read_size)
+        except BlockingIOError:
+            return
+        except ConnectionResetError:
+            self.close()
+            return
+        if not buf:
+            self.close()
+            return
+
+        self._read_buf.feed(buf)
+
+        if isinstance(self._cur_io, CoroHttpServer.AnyReadIo):
+            self._next_io()
+
+    def on_writable(self) -> None:
+        check_isinstance(self._cur_io, CoroHttpServer.WriteIo)
+        wb = check_not_none(self._write_buf)
+        while wb.rem > 0:
+            def send(d: bytes) -> int:
+                try:
+                    return check_not_none(self._sock).send(d)
+                except ConnectionResetError:
+                    self.close()
+                    return 0
+                except BlockingIOError:
+                    return 0
+            if not wb.write(send):
+                break
+
+        if wb.rem < 1:
+            self._write_buf = None
+            self._cur_io = None
+            self._next_io()
+
+
 ########################################
 # ../dispatchers.py
 
 
-class Dispatchers(KeyedCollection[Fd, Dispatcher]):
-    def _key(self, v: Dispatcher) -> Fd:
-        return v.fd
+class Dispatchers(KeyedCollection[Fd, FdIoHandler]):
+    def _key(self, v: FdIoHandler) -> Fd:
+        return Fd(v.fd())
 
     #
 
@@ -5640,9 +6215,9 @@ class Dispatchers(KeyedCollection[Fd, Dispatcher]):
             # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
             # dispatcher (eg. call handle_listener_state_change for event listener processes)
             if d.readable():
-                d.handle_read_event()
+                d.on_readable()
             if d.writable():
-                d.handle_write_event()
+                d.on_writable()
 
     #
 
@@ -5696,7 +6271,6 @@ class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
     def channel(self) -> str:
         return self._channel
 
-    @property
     def fd(self) -> Fd:
         return self._fd
 
@@ -5711,7 +6285,7 @@ class BaseProcessDispatcherImpl(ProcessDispatcher, abc.ABC):
             log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
             self._closed = True
 
-    def handle_error(self) -> None:
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:
         nil, t, v, tbinfo = compact_traceback()
 
         log.critical('uncaptured python exception, closing channel %s (%s:%s %s)', repr(self), t, v, tbinfo)
@@ -5784,7 +6358,7 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
         channel = self._channel  # noqa
 
         logfile = self._lc.file
-        maxbytes = self._lc.maxbytes  # noqa
+        max_bytes = self._lc.max_bytes  # noqa
         backups = self._lc.backups  # noqa
         to_syslog = self._lc.syslog
 
@@ -5796,8 +6370,8 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
         #         self.normal_log,
         #         filename=logfile,
         #         fmt='%(message)s',
-        #         rotating=bool(maxbytes),  # optimization
-        #         maxbytes=maxbytes,
+        #         rotating=bool(max_bytes),  # optimization
+        #         max_bytes=max_bytes,
         #         backups=backups,
         #     )
 
@@ -5809,17 +6383,17 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
 
     def _init_capture_log(self) -> None:
         """
-        Configure the capture log for this process.  This log is used to temporarily capture output when special output
+        Configure the capture log for this process. This log is used to temporarily capture output when special output
         is detected. Sets self.capture_log if capturing is enabled.
         """
 
-        capture_maxbytes = self._lc.capture_maxbytes
-        if capture_maxbytes:
+        capture_max_bytes = self._lc.capture_max_bytes
+        if capture_max_bytes:
             self._capture_log = logging.getLogger(__name__)
             # loggers.handle_boundIO(
             #     self._capture_log,
             #     fmt='%(message)s',
-            #     maxbytes=capture_maxbytes,
+            #     max_bytes=capture_max_bytes,
             # )
 
     def remove_logs(self) -> None:
@@ -5927,12 +6501,12 @@ class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispat
             return False
         return True
 
-    def handle_read_event(self) -> None:
+    def on_readable(self) -> None:
         data = read_fd(self._fd)
         self._output_buffer += data
         self.record_output()
         if not data:
-            # if we get no data back from the pipe, it means that the child process has ended.  See
+            # if we get no data back from the pipe, it means that the child process has ended. See
             # mail.python.org/pipermail/python-dev/2004-August/046850.html
             self.close()
 
@@ -5965,15 +6539,12 @@ class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatch
             return True
         return False
 
-    def readable(self) -> bool:
-        return False
-
     def flush(self) -> None:
         # other code depends on this raising EPIPE if the pipe is closed
         sent = os.write(self._fd, as_bytes(self._input_buffer))
         self._input_buffer = self._input_buffer[sent:]
 
-    def handle_write_event(self) -> None:
+    def on_writable(self) -> None:
         if self._input_buffer:
             try:
                 self.flush()
@@ -5985,79 +6556,6 @@ class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatch
                     raise
 
 
-########################################
-# ../groups.py
-
-
-class ProcessGroupManager(KeyedCollectionAccessors[str, ProcessGroup]):
-    def __init__(
-            self,
-            *,
-            event_callbacks: EventCallbacks,
-    ) -> None:
-        super().__init__()
-
-        self._event_callbacks = event_callbacks
-
-        self._by_name: ta.Dict[str, ProcessGroup] = {}
-
-    @property
-    def _by_key(self) -> ta.Mapping[str, ProcessGroup]:
-        return self._by_name
-
-    #
-
-    def all_processes(self) -> ta.Iterator[Process]:
-        for g in self:
-            yield from g
-
-    #
-
-    def add(self, group: ProcessGroup) -> None:
-        if (name := group.name) in self._by_name:
-            raise KeyError(f'Process group already exists: {name}')
-
-        self._by_name[name] = group
-
-        self._event_callbacks.notify(ProcessGroupAddedEvent(name))
-
-    def remove(self, name: str) -> None:
-        group = self._by_name[name]
-
-        group.before_remove()
-
-        del self._by_name[name]
-
-        self._event_callbacks.notify(ProcessGroupRemovedEvent(name))
-
-    def clear(self) -> None:
-        # FIXME: events?
-        self._by_name.clear()
-
-    #
-
-    class Diff(ta.NamedTuple):
-        added: ta.List[ProcessGroupConfig]
-        changed: ta.List[ProcessGroupConfig]
-        removed: ta.List[ProcessGroupConfig]
-
-    def diff(self, new: ta.Sequence[ProcessGroupConfig]) -> Diff:
-        cur = [group.config for group in self]
-
-        cur_by_name = {cfg.name: cfg for cfg in cur}
-        new_by_name = {cfg.name: cfg for cfg in new}
-
-        added = [cand for cand in new if cand.name not in cur_by_name]
-        removed = [cand for cand in cur if cand.name not in new_by_name]
-        changed = [cand for cand in new if cand != cur_by_name.get(cand.name, cand)]
-
-        return ProcessGroupManager.Diff(
-            added,
-            changed,
-            removed,
-        )
-
-
 ########################################
 # ../groupsimpl.py
 
@@ -6217,21 +6715,21 @@ class SupervisorSetupImpl(SupervisorSetup):
     def _cleanup_fds(self) -> None:
         # try to close any leaked file descriptors (for reload)
         start = 5
-        os.closerange(start, self._config.minfds)
+        os.closerange(start, self._config.min_fds)
 
     #
 
     def _set_uid_or_exit(self) -> None:
         """
-        Set the uid of the supervisord process.  Called during supervisord startup only.  No return value.  Exits the
+        Set the uid of the supervisord process. Called during supervisord startup only. No return value. Exits the
         process via usage() if privileges could not be dropped.
         """
 
         if self._user is None:
             if os.getuid() == 0:
                 warnings.warn(
-                    'Supervisor is running as root.  Privileges were not dropped because no user is specified in the '
-                    'config file.  If you intend to run as root, you can set user=root in the config file to avoid '
+                    'Supervisor is running as root. Privileges were not dropped because no user is specified in the '
+                    'config file. If you intend to run as root, you can set user=root in the config file to avoid '
                     'this message.',
                 )
         else:
@@ -6245,8 +6743,8 @@ class SupervisorSetupImpl(SupervisorSetup):
 
     def _set_rlimits_or_exit(self) -> None:
         """
-        Set the rlimits of the supervisord process.  Called during supervisord startup only.  No return value.  Exits
-        the process via usage() if any rlimits could not be set.
+        Set the rlimits of the supervisord process. Called during supervisord startup only. No return value. Exits the
+        process via usage() if any rlimits could not be set.
         """
 
         limits = []
@@ -6255,12 +6753,12 @@ class SupervisorSetupImpl(SupervisorSetup):
             limits.append({
                 'msg': (
                     'The minimum number of file descriptors required to run this process is %(min_limit)s as per the '
-                    '"minfds" command-line argument or config file setting. The current environment will only allow '
-                    'you to open %(hard)s file descriptors.  Either raise the number of usable file descriptors in '
-                    'your environment (see README.rst) or lower the minfds setting in the config file to allow the '
+                    '"min_fds" command-line argument or config file setting. The current environment will only allow '
+                    'you to open %(hard)s file descriptors. Either raise the number of usable file descriptors in '
+                    'your environment (see README.rst) or lower the min_fds setting in the config file to allow the '
                     'process to start.'
                 ),
-                'min': self._config.minfds,
+                'min': self._config.min_fds,
                 'resource': resource.RLIMIT_NOFILE,
                 'name': 'RLIMIT_NOFILE',
             })
@@ -6270,11 +6768,11 @@ class SupervisorSetupImpl(SupervisorSetup):
                 'msg': (
                     'The minimum number of available processes required to run this program is %(min_limit)s as per '
                     'the "minprocs" command-line argument or config file setting. The current environment will only '
-                    'allow you to open %(hard)s processes.  Either raise the number of usable processes in your '
+                    'allow you to open %(hard)s processes. Either raise the number of usable processes in your '
                     'environment (see README.rst) or lower the minprocs setting in the config file to allow the '
                     'program to start.'
                 ),
-                'min': self._config.minprocs,
+                'min': self._config.min_procs,
                 'resource': resource.RLIMIT_NPROC,
                 'name': 'RLIMIT_NPROC',
             })
@@ -6360,11 +6858,11 @@ class SupervisorSetupImpl(SupervisorSetup):
             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
+        # 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
+        # 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
@@ -6396,12 +6894,98 @@ class SupervisorSetupImpl(SupervisorSetup):
         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
+        # 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)
 
 
+########################################
+# ../groups.py
+
+
+class ProcessGroupManager(
+    KeyedCollectionAccessors[str, ProcessGroup],
+    HasDispatchers,
+):
+    def __init__(
+            self,
+            *,
+            event_callbacks: EventCallbacks,
+    ) -> None:
+        super().__init__()
+
+        self._event_callbacks = event_callbacks
+
+        self._by_name: ta.Dict[str, ProcessGroup] = {}
+
+    @property
+    def _by_key(self) -> ta.Mapping[str, ProcessGroup]:
+        return self._by_name
+
+    #
+
+    def all_processes(self) -> ta.Iterator[Process]:
+        for g in self:
+            yield from g
+
+    #
+
+    def get_dispatchers(self) -> Dispatchers:
+        return Dispatchers(
+            d
+            for g in self
+            for p in g
+            for d in p.get_dispatchers()
+        )
+
+    #
+
+    def add(self, group: ProcessGroup) -> None:
+        if (name := group.name) in self._by_name:
+            raise KeyError(f'Process group already exists: {name}')
+
+        self._by_name[name] = group
+
+        self._event_callbacks.notify(ProcessGroupAddedEvent(name))
+
+    def remove(self, name: str) -> None:
+        group = self._by_name[name]
+
+        group.before_remove()
+
+        del self._by_name[name]
+
+        self._event_callbacks.notify(ProcessGroupRemovedEvent(name))
+
+    def clear(self) -> None:
+        # FIXME: events?
+        self._by_name.clear()
+
+    #
+
+    class Diff(ta.NamedTuple):
+        added: ta.List[ProcessGroupConfig]
+        changed: ta.List[ProcessGroupConfig]
+        removed: ta.List[ProcessGroupConfig]
+
+    def diff(self, new: ta.Sequence[ProcessGroupConfig]) -> Diff:
+        cur = [group.config for group in self]
+
+        cur_by_name = {cfg.name: cfg for cfg in cur}
+        new_by_name = {cfg.name: cfg for cfg in new}
+
+        added = [cand for cand in new if cand.name not in cur_by_name]
+        removed = [cand for cand in cur if cand.name not in new_by_name]
+        changed = [cand for cand in new if cand != cur_by_name.get(cand.name, cand)]
+
+        return ProcessGroupManager.Diff(
+            added,
+            changed,
+            removed,
+        )
+
+
 ########################################
 # ../io.py
 
@@ -6409,49 +6993,59 @@ class SupervisorSetupImpl(SupervisorSetup):
 ##
 
 
-class IoManager:
+HasDispatchersList = ta.NewType('HasDispatchersList', ta.Sequence[HasDispatchers])
+
+
+class IoManager(HasDispatchers):
     def __init__(
             self,
             *,
-            poller: Poller,
-            process_groups: ProcessGroupManager,
+            poller: FdIoPoller,
+            has_dispatchers_list: HasDispatchersList,
     ) -> None:
         super().__init__()
 
         self._poller = poller
-        self._process_groups = process_groups
+        self._has_dispatchers_list = has_dispatchers_list
 
     def get_dispatchers(self) -> Dispatchers:
         return Dispatchers(
             d
-            for p in self._process_groups.all_processes()
-            for d in p.get_dispatchers()
+            for hd in self._has_dispatchers_list
+            for d in hd.get_dispatchers()
         )
 
     def poll(self) -> None:
         dispatchers = self.get_dispatchers()
 
-        for fd, dispatcher in dispatchers.items():
-            if dispatcher.readable():
-                self._poller.register_readable(fd)
-            if dispatcher.writable():
-                self._poller.register_writable(fd)
+        self._poller.update(
+            {fd for fd, d in dispatchers.items() if d.readable()},
+            {fd for fd, d in dispatchers.items() if d.writable()},
+        )
 
         timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
-        r, w = self._poller.poll(timeout)
-
-        for fd in r:
+        log.info(f'Polling: {timeout=}')  # noqa
+        polled = self._poller.poll(timeout)
+        log.info(f'Polled: {polled=}')  # noqa
+        if polled.msg is not None:
+            log.error(polled.msg)
+        if polled.exc is not None:
+            log.error('Poll exception: %r', polled.exc)
+
+        for r in polled.r:
+            fd = Fd(r)
             if fd in dispatchers:
+                dispatcher = dispatchers[fd]
                 try:
-                    dispatcher = dispatchers[fd]
                     log.debug('read event caused by %r', dispatcher)
-                    dispatcher.handle_read_event()
+                    dispatcher.on_readable()
                     if not dispatcher.readable():
                         self._poller.unregister_readable(fd)
                 except ExitNow:
                     raise
-                except Exception:  # noqa
-                    dispatchers[fd].handle_error()
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
             else:
                 # if the fd is not in combined map, we should unregister it. otherwise, it will be polled every
                 # time, which may cause 100% cpu usage
@@ -6461,18 +7055,20 @@ class IoManager:
                 except Exception:  # noqa
                     pass
 
-        for fd in w:
+        for w in polled.w:
+            fd = Fd(w)
             if fd in dispatchers:
+                dispatcher = dispatchers[fd]
                 try:
-                    dispatcher = dispatchers[fd]
                     log.debug('write event caused by %r', dispatcher)
-                    dispatcher.handle_write_event()
+                    dispatcher.on_writable()
                     if not dispatcher.writable():
                         self._poller.unregister_writable(fd)
                 except ExitNow:
                     raise
-                except Exception:  # noqa
-                    dispatchers[fd].handle_error()
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
             else:
                 log.debug('unexpected write event from fd %r', fd)
                 try:
@@ -6481,65 +7077,6 @@ class IoManager:
                     pass
 
 
-########################################
-# ../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,
-        )
-
-    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._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:
-            log.debug('received %s indicating nothing', sig_name(sig))
-
-
 ########################################
 # ../spawning.py
 
@@ -6568,6 +7105,123 @@ class ProcessSpawning:
         raise NotImplementedError
 
 
+########################################
+# ../http.py
+
+
+##
+
+
+class SocketServerFdIoHandler(SocketFdIoHandler):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            on_connect: ta.Callable[[socket.socket, SocketAddress], None],
+    ) -> None:
+        sock = socket.create_server(addr)
+        sock.setblocking(False)
+
+        super().__init__(addr, sock)
+
+        self._on_connect = on_connect
+
+        sock.listen(1)
+
+    def readable(self) -> bool:
+        return True
+
+    def on_readable(self) -> None:
+        cli_sock, cli_addr = check_not_none(self._sock).accept()
+        cli_sock.setblocking(False)
+
+        self._on_connect(cli_sock, cli_addr)
+
+
+##
+
+
+class HttpServer(HasDispatchers):
+    class Address(ta.NamedTuple):
+        a: SocketAddress
+
+    class Handler(ta.NamedTuple):
+        h: HttpHandler
+
+    def __init__(
+            self,
+            handler: Handler,
+            addr: Address = Address(('localhost', 8000)),
+    ) -> None:
+        super().__init__()
+
+        self._handler = handler.h
+        self._addr = addr.a
+
+        self._server = SocketServerFdIoHandler(self._addr, self._on_connect)
+
+        self._conns: ta.List[CoroHttpServerConnectionFdIoHandler] = []
+
+    def get_dispatchers(self) -> Dispatchers:
+        l = []
+        for c in self._conns:
+            if not c.closed:
+                l.append(c)
+        self._conns = l
+        return Dispatchers([
+            self._server,
+            *l,
+        ])
+
+    def _on_connect(self, sock: socket.socket, addr: SocketAddress) -> None:
+        conn = CoroHttpServerConnectionFdIoHandler(
+            addr,
+            sock,
+            self._handler,
+        )
+
+        self._conns.append(conn)
+
+
+##
+
+
+class SupervisorHttpHandler:
+    def __init__(
+            self,
+            *,
+            groups: ProcessGroupManager,
+    ) -> None:
+        super().__init__()
+
+        self._groups = groups
+
+    def handle(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        dct = {
+            'method': req.method,
+            'path': req.path,
+            'data': len(req.data or b''),
+            'groups': {
+                g.name: {
+                    'processes': {
+                        p.name: {
+                            'pid': p.pid,
+                        }
+                        for p in g
+                    },
+                }
+                for g in self._groups
+            },
+        }
+
+        return HttpHandlerResponse(
+            200,
+            data=json.dumps(dct, **JSON_PRETTY_KWARGS).encode('utf-8') + b'\n',
+            headers={
+                'Content-Type': 'application/json',
+            },
+        )
+
+
 ########################################
 # ../processimpl.py
 
@@ -6619,7 +7273,7 @@ class ProcessImpl(Process):
 
         self._killing = False  # true if we are trying to kill this process
 
-        self._backoff = 0  # backoff counter (to startretries)
+        self._backoff = 0  # backoff counter (to start_retries)
 
         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
@@ -6696,7 +7350,7 @@ class ProcessImpl(Process):
         self._pipes = sp.pipes
         self._dispatchers = sp.dispatchers
 
-        self._delay = time.time() + self.config.startsecs
+        self._delay = time.time() + self.config.start_secs
 
         return sp.pid
 
@@ -6754,17 +7408,17 @@ class ProcessImpl(Process):
 
         if self._state == ProcessState.STARTING:
             self._last_start = min(test_time, self._last_start)
-            if self._delay > 0 and test_time < (self._delay - self._config.startsecs):
-                self._delay = test_time + self._config.startsecs
+            if self._delay > 0 and test_time < (self._delay - self._config.start_secs):
+                self._delay = test_time + self._config.start_secs
 
         elif self._state == ProcessState.RUNNING:
-            if test_time > self._last_start and test_time < (self._last_start + self._config.startsecs):
-                self._last_start = test_time - self._config.startsecs
+            if test_time > self._last_start and test_time < (self._last_start + self._config.start_secs):
+                self._last_start = test_time - self._config.start_secs
 
         elif self._state == ProcessState.STOPPING:
             self._last_stop_report = min(test_time, self._last_stop_report)
-            if self._delay > 0 and test_time < (self._delay - self._config.stopwaitsecs):
-                self._delay = test_time + self._config.stopwaitsecs
+            if self._delay > 0 and test_time < (self._delay - self._config.stop_wait_secs):
+                self._delay = test_time + self._config.stop_wait_secs
 
         elif self._state == ProcessState.BACKOFF:
             if self._delay > 0 and test_time < (self._delay - self._backoff):
@@ -6773,7 +7427,7 @@ class ProcessImpl(Process):
     def stop(self) -> ta.Optional[str]:
         self._administrative_stop = True
         self._last_stop_report = 0
-        return self.kill(self._config.stopsignal)
+        return self.kill(self._config.stop_signal)
 
     def stop_report(self) -> None:
         """Log a 'waiting for x to stop' message with throttling."""
@@ -6796,7 +7450,7 @@ class ProcessImpl(Process):
 
     def kill(self, sig: int) -> ta.Optional[str]:
         """
-        Send a signal to the subprocess with the intention to kill it (to make it exit).  This may or may not actually
+        Send a signal to the subprocess with the intention to kill it (to make it exit). This may or may not actually
         kill it.
 
         Return None if the signal was sent, or an error message string if an error occurred or if the subprocess is not
@@ -6804,8 +7458,8 @@ class ProcessImpl(Process):
         """
         now = time.time()
 
-        # 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
+        # If the process is in BACKOFF and we want to stop or kill it, then BACKOFF -> STOPPED. This is needed because
+        # if start_retries 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.', self.name)
@@ -6820,25 +7474,25 @@ class ProcessImpl(Process):
 
         # If we're in the stopping state, then we've already sent the stop signal and this is the kill signal
         if self._state == ProcessState.STOPPING:
-            killasgroup = self._config.killasgroup
+            kill_as_group = self._config.kill_as_group
         else:
-            killasgroup = self._config.stopasgroup
+            kill_as_group = self._config.stop_as_group
 
         as_group = ''
-        if killasgroup:
+        if kill_as_group:
             as_group = 'process group '
 
         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
-        self._delay = now + self._config.stopwaitsecs
-        # we will already be in the STOPPING state if we're doing a SIGKILL as a result of overrunning stopwaitsecs
+        self._delay = now + self._config.stop_wait_secs
+        # we will already be in the STOPPING state if we're doing a SIGKILL as a result of overrunning stop_wait_secs
         self.check_in_state(ProcessState.RUNNING, ProcessState.STARTING, ProcessState.STOPPING)
         self.change_state(ProcessState.STOPPING)
 
         kpid = int(self.pid)
-        if killasgroup:
+        if kill_as_group:
             # send to the whole process group instead
             kpid = -kpid
 
@@ -6848,7 +7502,7 @@ class ProcessImpl(Process):
             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', 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
+                    # we could change the state here but we intentionally do not. we will do it during normal SIGCHLD
                     # processing.
                     return None
                 raise
@@ -6891,7 +7545,7 @@ class ProcessImpl(Process):
                         self.pid,
                         str(exc),
                     )
-                    # we could change the state here but we intentionally do not.  we will do it during normal SIGCHLD
+                    # we could change the state here but we intentionally do not. we will do it during normal SIGCHLD
                     # processing.
                     return None
                 raise
@@ -6918,7 +7572,8 @@ class ProcessImpl(Process):
         self._last_stop = now
 
         if now > self._last_start:
-            too_quickly = now - self._last_start < self._config.startsecs
+            log.info(f'{now - self._last_start=}')  # noqa
+            too_quickly = now - self._last_start < self._config.start_secs
         else:
             too_quickly = False
             log.warning(
@@ -6987,13 +7642,11 @@ class ProcessImpl(Process):
 
         self._check_and_adjust_for_system_clock_rollback(now)
 
-        logger = log
-
         if self._supervisor_states.state > SupervisorState.RESTARTING:
             # dont start any processes if supervisor is shutting down
             if state == ProcessState.EXITED:
-                if self._config.autorestart:
-                    if self._config.autorestart is RestartUnconditionally:
+                if self._config.auto_restart:
+                    if self._config.auto_restart is RestartUnconditionally:
                         # EXITED -> STARTING
                         self.spawn()
                     elif self._exitstatus not in self._config.exitcodes:
@@ -7001,38 +7654,38 @@ class ProcessImpl(Process):
                         self.spawn()
 
             elif state == ProcessState.STOPPED and not self._last_start:
-                if self._config.autostart:
+                if self._config.auto_start:
                     # STOPPED -> STARTING
                     self.spawn()
 
             elif state == ProcessState.BACKOFF:
-                if self._backoff <= self._config.startretries:
+                if self._backoff <= self._config.start_retries:
                     if now > self._delay:
                         # BACKOFF -> STARTING
                         self.spawn()
 
         if state == ProcessState.STARTING:
-            if now - self._last_start > self._config.startsecs:
+            if now - self._last_start > self._config.start_secs:
                 # STARTING -> RUNNING if the proc has started successfully and it has stayed up for at least
-                # proc.config.startsecs,
+                # proc.config.start_secs,
                 self._delay = 0
                 self._backoff = 0
                 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', self.name, msg)
+                msg = ('entered RUNNING state, process has stayed up for > than %s seconds (start_secs)' % self._config.start_secs)  # noqa
+                log.info('success: %s %s', self.name, msg)
 
         if state == ProcessState.BACKOFF:
-            if self._backoff > self._config.startretries:
+            if self._backoff > self._config.start_retries:
                 # 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', self.name, msg)
+                log.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
+                # 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', self.name, self.pid)
                 self.kill(signal.SIGKILL)
@@ -7049,6 +7702,65 @@ class ProcessImpl(Process):
         pass
 
 
+########################################
+# ../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,
+        )
+
+    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._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:
+            log.debug('received %s indicating nothing', sig_name(sig))
+
+
 ########################################
 # ../spawningimpl.py
 
@@ -7209,7 +7921,7 @@ class ProcessSpawningImpl(ProcessSpawning):
         return exe, args
 
     def _make_dispatchers(self, pipes: ProcessPipes) -> Dispatchers:
-        dispatchers: ta.List[Dispatcher] = []
+        dispatchers: ta.List[FdIoHandler] = []
 
         if pipes.stdout is not None:
             dispatchers.append(check_isinstance(self._output_dispatcher_factory(
@@ -7325,7 +8037,7 @@ class ProcessSpawningImpl(ProcessSpawning):
         else:
             os.dup2(check_not_none(pipes.child_stderr), 2)
 
-        for i in range(3, self._server_config.minfds):
+        for i in range(3, self._server_config.min_fds):
             if i in self._inherited_fds:
                 continue
             close_fd(Fd(i))
@@ -7399,7 +8111,7 @@ class Supervisor:
             self,
             *,
             config: ServerConfig,
-            poller: Poller,
+            poller: FdIoPoller,
             process_groups: ProcessGroupManager,
             signal_handler: SignalHandler,
             event_callbacks: EventCallbacks,
@@ -7515,7 +8227,9 @@ class Supervisor:
     #
 
     def _run_once(self) -> None:
+        now = time.time()
         self._poll()
+        log.info(f'Poll took {time.time() - now}')  # noqa
         self._reap()
         self._signal_handler.handle_signals()
         self._tick()
@@ -7567,6 +8281,7 @@ class Supervisor:
             return
 
         wp = waitpid()
+        log.info(f'Waited pid: {wp}')  # noqa
         if wp is None or not wp.pid:
             return
 
@@ -7612,7 +8327,7 @@ class WaitedPid(ta.NamedTuple):
 
 
 def waitpid() -> ta.Optional[WaitedPid]:
-    # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4.  There is
+    # 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
@@ -7635,6 +8350,17 @@ def waitpid() -> ta.Optional[WaitedPid]:
 # ../inject.py
 
 
+@dc.dataclass(frozen=True)
+class _FdIoPollerDaemonizeListener(DaemonizeListener):
+    _poller: FdIoPoller
+
+    def before_daemonize(self) -> None:
+        self._poller.close()
+
+    def after_daemonize(self) -> None:
+        self._poller.reopen()
+
+
 def bind_server(
         config: ServerConfig,
         *,
@@ -7644,22 +8370,24 @@ def bind_server(
     lst: ta.List[InjectorBindingOrBindings] = [
         inj.bind(config),
 
+        inj.bind_array(DaemonizeListener),
         inj.bind_array_type(DaemonizeListener, DaemonizeListeners),
 
         inj.bind(SupervisorSetupImpl, singleton=True),
         inj.bind(SupervisorSetup, to_key=SupervisorSetupImpl),
 
-        inj.bind(DaemonizeListener, array=True, to_key=Poller),
-
         inj.bind(EventCallbacks, singleton=True),
 
         inj.bind(SignalReceiver, singleton=True),
 
         inj.bind(IoManager, singleton=True),
+        inj.bind_array(HasDispatchers),
+        inj.bind_array_type(HasDispatchers, HasDispatchersList),
 
         inj.bind(SignalHandler, singleton=True),
 
         inj.bind(ProcessGroupManager, singleton=True),
+        inj.bind(HasDispatchers, array=True, to_key=ProcessGroupManager),
 
         inj.bind(Supervisor, singleton=True),
 
@@ -7692,7 +8420,26 @@ def bind_server(
 
     #
 
-    lst.append(inj.bind(get_poller_impl(), key=Poller, singleton=True))
+    poller_impl = next(filter(None, [
+        KqueueFdIoPoller,
+        PollFdIoPoller,
+        SelectFdIoPoller,
+    ]))
+    lst.append(inj.bind(poller_impl, key=FdIoPoller, singleton=True))
+    inj.bind(_FdIoPollerDaemonizeListener, array=True, singleton=True)
+
+    #
+
+    def _provide_http_handler(s: SupervisorHttpHandler) -> HttpServer.Handler:
+        return HttpServer.Handler(s.handle)
+
+    lst.extend([
+        inj.bind(HttpServer, singleton=True, eager=True),
+        inj.bind(HasDispatchers, array=True, to_key=HttpServer),
+
+        inj.bind(SupervisorHttpHandler, singleton=True),
+        inj.bind(_provide_http_handler),
+    ])
 
     #