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

ominfra/scripts/supervisor.py

@@ -4,6 +4,34 @@
 # @omlish-script
 # @omlish-amalg-output ../supervisor/main.py
 # ruff: noqa: N802 UP006 UP007 UP012 UP036
+# Supervisor is licensed under the following license:
+#
+#  A copyright notice accompanies this license document that identifies the copyright holders.
+#
+#  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+#  following conditions are met:
+#
+#  1. Redistributions in source code must retain the accompanying copyright notice, this list of conditions, and the
+#     following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the accompanying copyright notice, this list of conditions, and the
+#     following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+#  3. Names of the copyright holders must not be used to endorse or promote products derived from this software without
+#     prior written permission from the copyright holders.
+#
+#  4. If any files are modified, you must cause the modified files to carry prominent notices stating that you changed
+#     the files and the date of any change.
+#
+#  Disclaimer
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
+#   NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+#   EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+#   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+#   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+#   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import abc
 import base64
 import collections.abc
@@ -12,13 +40,18 @@ import ctypes as ct
 import dataclasses as dc
 import datetime
 import decimal
+import email.utils
 import enum
 import errno
 import fcntl
 import fractions
 import functools
 import grp
+import html
+import http.client
+import http.server
 import inspect
+import io
 import itertools
 import json
 import logging
@@ -30,11 +63,13 @@ import resource
 import select
 import shlex
 import signal
+import socket
 import stat
 import string
 import sys
 import syslog
 import tempfile
+import textwrap
 import threading
 import time
 import traceback
@@ -49,8 +84,7 @@ import weakref  # noqa
 
 
 if sys.version_info < (3, 8):
-    raise OSError(
-        f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
+    raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
 
 
 ########################################
@@ -64,6 +98,16 @@ TomlPos = int  # ta.TypeAlias
 # ../../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 
+# ../../../omlish/lite/socket.py
+SocketAddress = ta.Any
+SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
+
+# ../events.py
+EventCallback = ta.Callable[['Event'], None]
+
+# ../../../omlish/lite/http/parsing.py
+HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
+
 # ../../../omlish/lite/inject.py
 InjectorKeyCls = ta.Union[type, ta.NewType]
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
@@ -73,11 +117,11 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 # ../../configs.py
 ConfigMapping = ta.Mapping[str, ta.Any]
 
-# ../context.py
-ServerEpoch = ta.NewType('ServerEpoch', int)
+# ../../../omlish/lite/http/handlers.py
+HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']
 
-# ../process.py
-InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+# ../../../omlish/lite/http/coroserver.py
+CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
 
 
 ########################################
@@ -1254,6 +1298,11 @@ def check_not_isinstance(v: T, spec: ta.Union[type, tuple]) -> T:
     return v
 
 
+def check_none(v: T) -> None:
+    if v is not None:
+        raise ValueError(v)
+
+
 def check_not_none(v: ta.Optional[T]) -> T:
     if v is None:
         raise ValueError
@@ -1294,6 +1343,25 @@ def check_single(vs: ta.Iterable[T]) -> T:
     return v
 
 
+########################################
+# ../../../omlish/lite/http/versions.py
+
+
+class HttpProtocolVersion(ta.NamedTuple):
+    major: int
+    minor: int
+
+    def __str__(self) -> str:
+        return f'HTTP/{self.major}.{self.minor}'
+
+
+class HttpProtocolVersions:
+    HTTP_0_9 = HttpProtocolVersion(0, 9)
+    HTTP_1_0 = HttpProtocolVersion(1, 0)
+    HTTP_1_1 = HttpProtocolVersion(1, 1)
+    HTTP_2_0 = HttpProtocolVersion(2, 0)
+
+
 ########################################
 # ../../../omlish/lite/json.py
 
@@ -1424,6 +1492,88 @@ def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
         todo.extend(reversed(cur.__subclasses__()))
 
 
+########################################
+# ../../../omlish/lite/socket.py
+"""
+TODO:
+ - SocketClientAddress family / tuple pairs
+  + codification of https://docs.python.org/3/library/socket.html#socket-families
+"""
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SocketAddressInfoArgs:
+    host: ta.Optional[str]
+    port: ta.Union[str, int, None]
+    family: socket.AddressFamily = socket.AddressFamily.AF_UNSPEC
+    type: int = 0
+    proto: int = 0
+    flags: socket.AddressInfo = socket.AddressInfo(0)
+
+
+@dc.dataclass(frozen=True)
+class SocketAddressInfo:
+    family: socket.AddressFamily
+    type: int
+    proto: int
+    canonname: ta.Optional[str]
+    sockaddr: SocketAddress
+
+
+def get_best_socket_family(
+        host: ta.Optional[str],
+        port: ta.Union[str, int, None],
+        family: ta.Union[int, socket.AddressFamily] = socket.AddressFamily.AF_UNSPEC,
+) -> ta.Tuple[socket.AddressFamily, SocketAddress]:
+    """https://github.com/python/cpython/commit/f289084c83190cc72db4a70c58f007ec62e75247"""
+
+    infos = socket.getaddrinfo(
+        host,
+        port,
+        family,
+        type=socket.SOCK_STREAM,
+        flags=socket.AI_PASSIVE,
+    )
+    ai = SocketAddressInfo(*next(iter(infos)))
+    return ai.family, ai.sockaddr
+
+
+##
+
+
+class SocketHandler(abc.ABC):
+    def __init__(
+            self,
+            client_address: SocketAddress,
+            rfile: ta.BinaryIO,
+            wfile: ta.BinaryIO,
+    ) -> None:
+        super().__init__()
+
+        self._client_address = client_address
+        self._rfile = rfile
+        self._wfile = wfile
+
+    @abc.abstractmethod
+    def handle(self) -> None:
+        raise NotImplementedError
+
+
+########################################
+# ../../../omlish/lite/typing.py
+
+
+@dc.dataclass(frozen=True)
+class Func(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)
+
+
 ########################################
 # ../events.py
 
@@ -1438,9 +1588,6 @@ class Event(abc.ABC):  # noqa
 ##
 
 
-EventCallback = ta.Callable[['Event'], None]
-
-
 class EventCallbacks:
     def __init__(self) -> None:
         super().__init__()
@@ -1910,6 +2057,371 @@ def timeslice(period: int, when: float) -> int:
     return int(when - (when % period))
 
 
+########################################
+# ../../../omlish/lite/http/parsing.py
+
+
+##
+
+
+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__,
+    )
+
+    def __init__(
+            self,
+            *,
+            code: http.HTTPStatus,
+            message: ta.Union[str, ta.Tuple[str, str]],
+
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(**kwargs)
+
+        self.code = code
+        self.message = message
+
+
+class ParsedHttpRequest(ParseHttpRequestResult):
+    __slots__ = (
+        'method',
+        'path',
+        'headers',
+        'expects_continue',
+        *[a for a in ParseHttpRequestResult.__slots__ if a != 'headers'],
+    )
+
+    def __init__(
+            self,
+            *,
+            method: str,
+            path: str,
+            headers: HttpHeaders,
+            expects_continue: bool,
+
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(
+            headers=headers,
+            **kwargs,
+        )
+
+        self.method = method
+        self.path = path
+        self.expects_continue = expects_continue
+
+    headers: HttpHeaders
+
+
+#
+
+
+class HttpRequestParser:
+    DEFAULT_SERVER_VERSION = HttpProtocolVersions.HTTP_1_0
+
+    # The default request version. This only affects responses up until the point where the request line is parsed, so
+    # it mainly decides what the client gets back when sending a malformed request line.
+    # Most web servers default to HTTP 0.9, i.e. don't send a status line.
+    DEFAULT_REQUEST_VERSION = HttpProtocolVersions.HTTP_0_9
+
+    #
+
+    DEFAULT_MAX_LINE: int = 0x10000
+    DEFAULT_MAX_HEADERS: int = 100
+
+    #
+
+    def __init__(
+            self,
+            *,
+            server_version: HttpProtocolVersion = DEFAULT_SERVER_VERSION,
+
+            max_line: int = DEFAULT_MAX_LINE,
+            max_headers: int = DEFAULT_MAX_HEADERS,
+    ) -> None:
+        super().__init__()
+
+        if server_version >= HttpProtocolVersions.HTTP_2_0:
+            raise ValueError(f'Unsupported protocol version: {server_version}')
+        self._server_version = server_version
+
+        self._max_line = max_line
+        self._max_headers = max_headers
+
+    #
+
+    @property
+    def server_version(self) -> HttpProtocolVersion:
+        return self._server_version
+
+    #
+
+    def _run_read_line_coro(
+            self,
+            gen: ta.Generator[int, bytes, T],
+            read_line: ta.Callable[[int], bytes],
+    ) -> T:
+        sz = next(gen)
+        while True:
+            try:
+                sz = gen.send(read_line(sz))
+            except StopIteration as e:
+                return e.value
+
+    #
+
+    def parse_request_version(self, version_str: str) -> HttpProtocolVersion:
+        if not version_str.startswith('HTTP/'):
+            raise ValueError(version_str)  # noqa
+
+        base_version_number = version_str.split('/', 1)[1]
+        version_number_parts = base_version_number.split('.')
+
+        # RFC 2145 section 3.1 says there can be only one "." and
+        #   - major and minor numbers MUST be treated as separate integers;
+        #   - HTTP/2.4 is a lower version than HTTP/2.13, which in turn is lower than HTTP/12.3;
+        #   - Leading zeros MUST be ignored by recipients.
+        if len(version_number_parts) != 2:
+            raise ValueError(version_number_parts)  # noqa
+        if any(not component.isdigit() for component in version_number_parts):
+            raise ValueError('non digit in http version')  # noqa
+        if any(len(component) > 10 for component in version_number_parts):
+            raise ValueError('unreasonable length http version')  # noqa
+
+        return HttpProtocolVersion(
+            int(version_number_parts[0]),
+            int(version_number_parts[1]),
+        )
+
+    #
+
+    def coro_read_raw_headers(self) -> ta.Generator[int, bytes, ta.List[bytes]]:
+        raw_headers: ta.List[bytes] = []
+        while True:
+            line = yield self._max_line + 1
+            if len(line) > self._max_line:
+                raise http.client.LineTooLong('header line')
+            raw_headers.append(line)
+            if len(raw_headers) > self._max_headers:
+                raise http.client.HTTPException(f'got more than {self._max_headers} headers')
+            if line in (b'\r\n', b'\n', b''):
+                break
+        return raw_headers
+
+    def read_raw_headers(self, read_line: ta.Callable[[int], bytes]) -> ta.List[bytes]:
+        return self._run_read_line_coro(self.coro_read_raw_headers(), read_line)
+
+    def parse_raw_headers(self, raw_headers: ta.Sequence[bytes]) -> HttpHeaders:
+        return http.client.parse_headers(io.BytesIO(b''.join(raw_headers)))
+
+    #
+
+    def coro_parse(self) -> ta.Generator[int, bytes, ParseHttpRequestResult]:
+        raw_request_line = yield self._max_line + 1
+
+        # Common result kwargs
+
+        request_line = '-'
+        request_version = self.DEFAULT_REQUEST_VERSION
+
+        # Set to min(server, request) when it gets that far, but if it fails before that the server authoritatively
+        # responds with its own version.
+        version = self._server_version
+
+        headers: HttpHeaders | None = None
+
+        close_connection = True
+
+        def result_kwargs():
+            return dict(
+                server_version=self._server_version,
+                request_line=request_line,
+                request_version=request_version,
+                version=version,
+                headers=headers,
+                close_connection=close_connection,
+            )
+
+        # Decode line
+
+        if len(raw_request_line) > self._max_line:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.REQUEST_URI_TOO_LONG,
+                message='Request line too long',
+                **result_kwargs(),
+            )
+
+        if not raw_request_line:
+            return EmptyParsedHttpResult(**result_kwargs())
+
+        request_line = raw_request_line.decode('iso-8859-1').rstrip('\r\n')
+
+        # Split words
+
+        words = request_line.split()
+        if len(words) == 0:
+            return EmptyParsedHttpResult(**result_kwargs())
+
+        # Parse and set version
+
+        if len(words) >= 3:  # Enough to determine protocol version
+            version_str = words[-1]
+            try:
+                request_version = self.parse_request_version(version_str)
+
+            except (ValueError, IndexError):
+                return ParseHttpRequestError(
+                    code=http.HTTPStatus.BAD_REQUEST,
+                    message=f'Bad request version ({version_str!r})',
+                    **result_kwargs(),
+                )
+
+            if (
+                    request_version < HttpProtocolVersions.HTTP_0_9 or
+                    request_version >= HttpProtocolVersions.HTTP_2_0
+            ):
+                return ParseHttpRequestError(
+                    code=http.HTTPStatus.HTTP_VERSION_NOT_SUPPORTED,
+                    message=f'Invalid HTTP version ({version_str})',
+                    **result_kwargs(),
+                )
+
+            version = min([self._server_version, request_version])
+
+            if version >= HttpProtocolVersions.HTTP_1_1:
+                close_connection = False
+
+        # Verify word count
+
+        if not 2 <= len(words) <= 3:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.BAD_REQUEST,
+                message=f'Bad request syntax ({request_line!r})',
+                **result_kwargs(),
+            )
+
+        # Parse method and path
+
+        method, path = words[:2]
+        if len(words) == 2:
+            close_connection = True
+            if method != 'GET':
+                return ParseHttpRequestError(
+                    code=http.HTTPStatus.BAD_REQUEST,
+                    message=f'Bad HTTP/0.9 request type ({method!r})',
+                    **result_kwargs(),
+                )
+
+        # gh-87389: The purpose of replacing '//' with '/' is to protect against open redirect attacks possibly
+        # triggered if the path starts with '//' because http clients treat //path as an absolute URI without scheme
+        # (similar to http://path) rather than a path.
+        if path.startswith('//'):
+            path = '/' + path.lstrip('/')  # Reduce to a single /
+
+        # Parse headers
+
+        try:
+            raw_gen = self.coro_read_raw_headers()
+            raw_sz = next(raw_gen)
+            while True:
+                buf = yield raw_sz
+                try:
+                    raw_sz = raw_gen.send(buf)
+                except StopIteration as e:
+                    raw_headers = e.value
+                    break
+
+            headers = self.parse_raw_headers(raw_headers)
+
+        except http.client.LineTooLong as err:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
+                message=('Line too long', str(err)),
+                **result_kwargs(),
+            )
+
+        except http.client.HTTPException as err:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
+                message=('Too many headers', str(err)),
+                **result_kwargs(),
+            )
+
+        # Check for connection directive
+
+        conn_type = headers.get('Connection', '')
+        if conn_type.lower() == 'close':
+            close_connection = True
+        elif (
+                conn_type.lower() == 'keep-alive' and
+                version >= HttpProtocolVersions.HTTP_1_1
+        ):
+            close_connection = False
+
+        # Check for expect directive
+
+        expect = headers.get('Expect', '')
+        if (
+                expect.lower() == '100-continue' and
+                version >= HttpProtocolVersions.HTTP_1_1
+        ):
+            expects_continue = True
+        else:
+            expects_continue = False
+
+        # Return
+
+        return ParsedHttpRequest(
+            method=method,
+            path=path,
+            expects_continue=expects_continue,
+            **result_kwargs(),
+        )
+
+    def parse(self, read_line: ta.Callable[[int], bytes]) -> ParseHttpRequestResult:
+        return self._run_read_line_coro(self.coro_parse(), read_line)
+
+
 ########################################
 # ../../../omlish/lite/inject.py
 
@@ -1919,12 +2431,28 @@ def timeslice(period: int, when: float) -> int:
 
 
 @dc.dataclass(frozen=True)
-class InjectorKey:
-    cls: InjectorKeyCls
+class InjectorKey(ta.Generic[T]):
+    # Before PEP-560 typing.Generic was a metaclass with a __new__ that takes a 'cls' arg, so instantiating a dataclass
+    # with kwargs (such as through dc.replace) causes `TypeError: __new__() got multiple values for argument 'cls'`.
+    # See:
+    #  - https://github.com/python/cpython/commit/d911e40e788fb679723d78b6ea11cabf46caed5a
+    #  - https://gist.github.com/wrmsr/4468b86efe9f373b6b114bfe85b98fd3
+    cls_: InjectorKeyCls
+
     tag: ta.Any = None
     array: bool = False
 
 
+def is_valid_injector_key_cls(cls: ta.Any) -> bool:
+    return isinstance(cls, type) or is_new_type(cls)
+
+
+def check_valid_injector_key_cls(cls: T) -> T:
+    if not is_valid_injector_key_cls(cls):
+        raise TypeError(cls)
+    return cls
+
+
 ##
 
 
@@ -1968,6 +2496,12 @@ class Injector(abc.ABC):
     def inject(self, obj: ta.Any) -> ta.Any:
         raise NotImplementedError
 
+    def __getitem__(
+            self,
+            target: ta.Union[InjectorKey[T], ta.Type[T]],
+    ) -> T:
+        return self.provide(target)
+
 
 ###
 # exceptions
@@ -2000,7 +2534,7 @@ def as_injector_key(o: ta.Any) -> InjectorKey:
         raise TypeError(o)
     if isinstance(o, InjectorKey):
         return o
-    if isinstance(o, type) or is_new_type(o):
+    if is_valid_injector_key_cls(o):
         return InjectorKey(o)
     raise TypeError(o)
 
@@ -2025,14 +2559,14 @@ class FnInjectorProvider(InjectorProvider):
 
 @dc.dataclass(frozen=True)
 class CtorInjectorProvider(InjectorProvider):
-    cls: type
+    cls_: type
 
     def __post_init__(self) -> None:
-        check_isinstance(self.cls, type)
+        check_isinstance(self.cls_, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
-            return i.inject(self.cls)
+            return i.inject(self.cls_)
 
         return pfn
 
@@ -2181,19 +2715,42 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 # inspection
 
 
-_INJECTION_SIGNATURE_CACHE: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKeyDictionary()
+# inspect.signature(eval_str=True) was added in 3.10 and we have to support 3.8, so we have to get_type_hints to eval
+# str annotations *in addition to* getting the signature for parameter information.
+class _InjectionInspection(ta.NamedTuple):
+    signature: inspect.Signature
+    type_hints: ta.Mapping[str, ta.Any]
+
+
+_INJECTION_INSPECTION_CACHE: ta.MutableMapping[ta.Any, _InjectionInspection] = weakref.WeakKeyDictionary()
+
 
+def _do_injection_inspect(obj: ta.Any) -> _InjectionInspection:
+    uw = obj
+    while True:
+        if isinstance(uw, functools.partial):
+            uw = uw.func
+        else:
+            if (uw2 := inspect.unwrap(uw)) is uw:
+                break
+            uw = uw2
+
+    return _InjectionInspection(
+        inspect.signature(obj),
+        ta.get_type_hints(uw),
+    )
 
-def _injection_signature(obj: ta.Any) -> inspect.Signature:
+
+def _injection_inspect(obj: ta.Any) -> _InjectionInspection:
     try:
-        return _INJECTION_SIGNATURE_CACHE[obj]
+        return _INJECTION_INSPECTION_CACHE[obj]
     except TypeError:
-        return inspect.signature(obj)
+        return _do_injection_inspect(obj)
     except KeyError:
         pass
-    sig = inspect.signature(obj)
-    _INJECTION_SIGNATURE_CACHE[obj] = sig
-    return sig
+    insp = _do_injection_inspect(obj)
+    _INJECTION_INSPECTION_CACHE[obj] = insp
+    return insp
 
 
 class InjectionKwarg(ta.NamedTuple):
@@ -2214,20 +2771,20 @@ def build_injection_kwargs_target(
         skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
         raw_optional: bool = False,
 ) -> InjectionKwargsTarget:
-    sig = _injection_signature(obj)
+    insp = _injection_inspect(obj)
 
     seen: ta.Set[InjectorKey] = set(map(as_injector_key, skip_kwargs)) if skip_kwargs is not None else set()
     kws: ta.List[InjectionKwarg] = []
-    for p in list(sig.parameters.values())[skip_args:]:
+    for p in list(insp.signature.parameters.values())[skip_args:]:
         if p.annotation is inspect.Signature.empty:
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
             continue
 
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
-            raise TypeError(sig)
+            raise TypeError(insp)
 
-        ann = p.annotation
+        ann = insp.type_hints.get(p.name, p.annotation)
         if (
                 not raw_optional and
                 is_optional_alias(ann)
@@ -2253,38 +2810,98 @@ def build_injection_kwargs_target(
 
 
 ###
-# binder
+# injector
 
 
-class InjectorBinder:
-    def __new__(cls, *args, **kwargs):  # noqa
-        raise TypeError
+_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
 
-    _FN_TYPES: ta.Tuple[type, ...] = (
-        types.FunctionType,
-        types.MethodType,
 
-        classmethod,
-        staticmethod,
+class _Injector(Injector):
+    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
+        super().__init__()
 
-        functools.partial,
-        functools.partialmethod,
-    )
+        self._bs = check_isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
 
-    @classmethod
-    def _is_fn(cls, obj: ta.Any) -> bool:
-        return isinstance(obj, cls._FN_TYPES)
+        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
 
-    @classmethod
-    def bind_as_fn(cls, icls: ta.Type[T]) -> ta.Type[T]:
-        check_isinstance(icls, type)
-        if icls not in cls._FN_TYPES:
-            cls._FN_TYPES = (*cls._FN_TYPES, icls)
-        return icls
+        if _INJECTOR_INJECTOR_KEY in self._pfm:
+            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
 
-    _BANNED_BIND_TYPES: ta.Tuple[type, ...] = (
-        InjectorProvider,
-    )
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        key = as_injector_key(key)
+
+        if key == _INJECTOR_INJECTOR_KEY:
+            return Maybe.just(self)
+
+        fn = self._pfm.get(key)
+        if fn is not None:
+            return Maybe.just(fn(self))
+
+        if self._p is not None:
+            pv = self._p.try_provide(key)
+            if pv is not None:
+                return Maybe.empty()
+
+        return Maybe.empty()
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        v = self.try_provide(key)
+        if v.present:
+            return v.must()
+        raise UnboundInjectorKeyError(key)
+
+    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(obj)
+        ret: ta.Dict[str, ta.Any] = {}
+        for kw in kt.kwargs:
+            if kw.has_default:
+                if not (mv := self.try_provide(kw.key)).present:
+                    continue
+                v = mv.must()
+            else:
+                v = self.provide(kw.key)
+            ret[kw.name] = v
+        return ret
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        kws = self.provide_kwargs(obj)
+        return obj(**kws)
+
+
+###
+# binder
+
+
+class InjectorBinder:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    _FN_TYPES: ta.Tuple[type, ...] = (
+        types.FunctionType,
+        types.MethodType,
+
+        classmethod,
+        staticmethod,
+
+        functools.partial,
+        functools.partialmethod,
+    )
+
+    @classmethod
+    def _is_fn(cls, obj: ta.Any) -> bool:
+        return isinstance(obj, cls._FN_TYPES)
+
+    @classmethod
+    def bind_as_fn(cls, icls: ta.Type[T]) -> ta.Type[T]:
+        check_isinstance(icls, type)
+        if icls not in cls._FN_TYPES:
+            cls._FN_TYPES = (*cls._FN_TYPES, icls)
+        return icls
+
+    _BANNED_BIND_TYPES: ta.Tuple[type, ...] = (
+        InjectorProvider,
+    )
 
     @classmethod
     def bind(
@@ -2301,7 +2918,7 @@ class InjectorBinder:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         if obj is None or obj is inspect.Parameter.empty:
             raise TypeError(obj)
         if isinstance(obj, cls._BANNED_BIND_TYPES):
@@ -2331,9 +2948,9 @@ class InjectorBinder:
         elif cls._is_fn(obj) and not has_to:
             to_fn = obj
             if key is None:
-                sig = _injection_signature(obj)
-                ty = check_isinstance(sig.return_annotation, type)
-                key = InjectorKey(ty)
+                insp = _injection_inspect(obj)
+                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
+                key = InjectorKey(key_cls)
         else:
             if to_const is not None:
                 raise TypeError('Cannot bind instance with to_const')
@@ -2384,67 +3001,21 @@ class InjectorBinder:
 
 
 ###
-# injector
-
-
-_INJECTOR_INJECTOR_KEY = InjectorKey(Injector)
-
-
-class _Injector(Injector):
-    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
-        super().__init__()
-
-        self._bs = check_isinstance(bs, InjectorBindings)
-        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
-
-        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
-
-        if _INJECTOR_INJECTOR_KEY in self._pfm:
-            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
-
-    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
-        key = as_injector_key(key)
-
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
-
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
+# injection helpers
 
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
 
-        return Maybe.empty()
+def make_injector_factory(
+        factory_cls: ta.Any,
+        factory_fn: ta.Callable[..., T],
+) -> ta.Callable[..., Func[T]]:
+    def outer(injector: Injector) -> factory_cls:
+        def inner(*args, **kwargs):
+            return injector.inject(functools.partial(factory_fn, *args, **kwargs))
+        return Func(inner)
+    return outer
 
-    def provide(self, key: ta.Any) -> ta.Any:
-        v = self.try_provide(key)
-        if v.present:
-            return v.must()
-        raise UnboundInjectorKeyError(key)
 
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
-        kt = build_injection_kwargs_target(obj)
-        ret: ta.Dict[str, ta.Any] = {}
-        for kw in kt.kwargs:
-            if kw.has_default:
-                if not (mv := self.try_provide(kw.key)).present:
-                    continue
-                v = mv.must()
-            else:
-                v = self.provide(kw.key)
-            ret[kw.name] = v
-        return ret
-
-    def inject(self, obj: ta.Any) -> ta.Any:
-        kws = self.provide_kwargs(obj)
-        return obj(**kws)
-
-
-###
-# injection helpers
+##
 
 
 class Injection:
@@ -2475,6 +3046,12 @@ class Injection:
     def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
+    # injector
+
+    @classmethod
+    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), p)
+
     # binder
 
     @classmethod
@@ -2492,7 +3069,7 @@ class Injection:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         return InjectorBinder.bind(
             obj,
 
@@ -2508,11 +3085,15 @@ class Injection:
             singleton=singleton,
         )
 
-    # injector
+    # helpers
 
     @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
-        return _Injector(as_injector_bindings(*args), p)
+    def bind_factory(
+            cls,
+            factory_cls: ta.Any,
+            factory_fn: ta.Callable[..., T],
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_factory(factory_cls, factory_fn))
 
 
 inj = Injection
@@ -2542,7 +3123,6 @@ sd_iovec._fields_ = [
 def sd_libsystemd() -> ta.Any:
     lib = ct.CDLL('libsystemd.so.0')
 
-    lib.sd_journal_sendv = lib['sd_journal_sendv']  # type: ignore
     lib.sd_journal_sendv.restype = ct.c_int
     lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
 
@@ -3582,6 +4162,36 @@ def get_poller_impl() -> ta.Type[Poller]:
         return SelectPoller
 
 
+########################################
+# ../../../omlish/lite/http/handlers.py
+
+
+@dc.dataclass(frozen=True)
+class HttpHandlerRequest:
+    client_address: SocketAddress
+    method: str
+    path: str
+    headers: HttpHeaders
+    data: ta.Optional[bytes]
+
+
+@dc.dataclass(frozen=True)
+class HttpHandlerResponse:
+    status: ta.Union[http.HTTPStatus, int]
+
+    headers: ta.Optional[ta.Mapping[str, str]] = None
+    data: ta.Optional[bytes] = None
+    close_connection: ta.Optional[bool] = None
+
+
+class HttpHandlerError(Exception):
+    pass
+
+
+class UnsupportedMethodHttpHandlerError(Exception):
+    pass
+
+
 ########################################
 # ../configs.py
 
@@ -3703,11 +4313,571 @@ def prepare_server_config(dct: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, ta.An
     return out
 
 
+########################################
+# ../../../omlish/lite/http/coroserver.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.
+"""
+"Test suite" lol:
+
+curl -v localhost:8000
+curl -v localhost:8000 -d 'foo'
+curl -v -XFOO localhost:8000 -d 'foo'
+curl -v -XPOST -H 'Expect: 100-Continue' localhost:8000 -d 'foo'
+
+curl -v -0 localhost:8000
+curl -v -0 localhost:8000 -d 'foo'
+curl -v -0 -XFOO localhost:8000 -d 'foo'
+
+curl -v -XPOST localhost:8000 -d 'foo' --next -XPOST localhost:8000 -d 'bar'
+curl -v -XPOST localhost:8000 -d 'foo' --next -XFOO localhost:8000 -d 'bar'
+curl -v -XFOO localhost:8000 -d 'foo' --next -XPOST localhost:8000 -d 'bar'
+curl -v -XFOO localhost:8000 -d 'foo' --next -XFOO localhost:8000 -d 'bar'
+"""
+
+
+##
+
+
+class CoroHttpServer:
+    """
+    Adapted from stdlib:
+     - https://github.com/python/cpython/blob/4b4e0dbdf49adc91c35a357ad332ab3abd4c31b1/Lib/http/server.py#L146
+    """
+
+    #
+
+    def __init__(
+            self,
+            client_address: SocketAddress,
+            *,
+            handler: HttpHandler,
+            parser: HttpRequestParser = HttpRequestParser(),
+
+            default_content_type: ta.Optional[str] = None,
+
+            error_message_format: ta.Optional[str] = None,
+            error_content_type: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        self._client_address = client_address
+
+        self._handler = handler
+        self._parser = parser
+
+        self._default_content_type = default_content_type or self.DEFAULT_CONTENT_TYPE
+
+        self._error_message_format = error_message_format or self.DEFAULT_ERROR_MESSAGE
+        self._error_content_type = error_content_type or self.DEFAULT_ERROR_CONTENT_TYPE
+
+    #
+
+    @property
+    def client_address(self) -> SocketAddress:
+        return self._client_address
+
+    @property
+    def handler(self) -> HttpHandler:
+        return self._handler
+
+    @property
+    def parser(self) -> HttpRequestParser:
+        return self._parser
+
+    #
+
+    def _format_timestamp(self, timestamp: ta.Optional[float] = None) -> str:
+        if timestamp is None:
+            timestamp = time.time()
+        return email.utils.formatdate(timestamp, usegmt=True)
+
+    #
+
+    def _header_encode(self, s: str) -> bytes:
+        return s.encode('latin-1', 'strict')
+
+    class _Header(ta.NamedTuple):
+        key: str
+        value: str
+
+    def _format_header_line(self, h: _Header) -> str:
+        return f'{h.key}: {h.value}\r\n'
+
+    def _get_header_close_connection_action(self, h: _Header) -> ta.Optional[bool]:
+        if h.key.lower() != 'connection':
+            return None
+        elif h.value.lower() == 'close':
+            return True
+        elif h.value.lower() == 'keep-alive':
+            return False
+        else:
+            return None
+
+    def _make_default_headers(self) -> ta.List[_Header]:
+        return [
+            self._Header('Date', self._format_timestamp()),
+        ]
+
+    #
+
+    _STATUS_RESPONSES: ta.Mapping[int, ta.Tuple[str, str]] = {
+        v: (v.phrase, v.description)
+        for v in http.HTTPStatus.__members__.values()
+    }
+
+    def _format_status_line(
+            self,
+            version: HttpProtocolVersion,
+            code: ta.Union[http.HTTPStatus, int],
+            message: ta.Optional[str] = None,
+    ) -> str:
+        if message is None:
+            if code in self._STATUS_RESPONSES:
+                message = self._STATUS_RESPONSES[code][0]
+            else:
+                message = ''
+
+        return f'{version} {int(code)} {message}\r\n'
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class _Response:
+        version: HttpProtocolVersion
+        code: http.HTTPStatus
+
+        message: ta.Optional[str] = None
+        headers: ta.Optional[ta.Sequence['CoroHttpServer._Header']] = None
+        data: ta.Optional[bytes] = None
+        close_connection: ta.Optional[bool] = False
+
+        def get_header(self, key: str) -> ta.Optional['CoroHttpServer._Header']:
+            for h in self.headers or []:
+                if h.key.lower() == key.lower():
+                    return h
+            return None
+
+    #
+
+    def _build_response_bytes(self, a: _Response) -> bytes:
+        out = io.BytesIO()
+
+        if a.version >= HttpProtocolVersions.HTTP_1_0:
+            out.write(self._header_encode(self._format_status_line(
+                a.version,
+                a.code,
+                a.message,
+            )))
+
+            for h in a.headers or []:
+                out.write(self._header_encode(self._format_header_line(h)))
+
+            out.write(b'\r\n')
+
+        if a.data is not None:
+            out.write(a.data)
+
+        return out.getvalue()
+
+    #
+
+    DEFAULT_CONTENT_TYPE = 'text/plain'
+
+    def _preprocess_response(self, resp: _Response) -> _Response:
+        nh: ta.List[CoroHttpServer._Header] = []
+        kw: ta.Dict[str, ta.Any] = {}
+
+        if resp.get_header('Content-Type') is None:
+            nh.append(self._Header('Content-Type', self._default_content_type))
+        if resp.data is not None and resp.get_header('Content-Length') is None:
+            nh.append(self._Header('Content-Length', str(len(resp.data))))
+
+        if nh:
+            kw.update(headers=[*(resp.headers or []), *nh])
+
+        if (clh := resp.get_header('Connection')) is not None:
+            if self._get_header_close_connection_action(clh):
+                kw.update(close_connection=True)
+
+        if not kw:
+            return resp
+        return dc.replace(resp, **kw)
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class Error:
+        version: HttpProtocolVersion
+        code: http.HTTPStatus
+        message: str
+        explain: str
+
+        method: ta.Optional[str] = None
+
+    def _build_error(
+            self,
+            code: ta.Union[http.HTTPStatus, int],
+            message: ta.Optional[str] = None,
+            explain: ta.Optional[str] = None,
+            *,
+            version: ta.Optional[HttpProtocolVersion] = None,
+            method: ta.Optional[str] = None,
+    ) -> Error:
+        code = http.HTTPStatus(code)
+
+        try:
+            short_msg, long_msg = self._STATUS_RESPONSES[code]
+        except KeyError:
+            short_msg, long_msg = '???', '???'
+        if message is None:
+            message = short_msg
+        if explain is None:
+            explain = long_msg
+
+        if version is None:
+            version = self._parser.server_version
+
+        return self.Error(
+            version=version,
+            code=code,
+            message=message,
+            explain=explain,
+
+            method=method,
+        )
+
+    #
+
+    DEFAULT_ERROR_MESSAGE = textwrap.dedent("""\
+        <!DOCTYPE HTML>
+        <html lang="en">
+            <head>
+                <meta charset="utf-8">
+                <title>Error response</title>
+            </head>
+            <body>
+                <h1>Error response</h1>
+                <p>Error code: %(code)d</p>
+                <p>Message: %(message)s.</p>
+                <p>Error code explanation: %(code)s - %(explain)s.</p>
+            </body>
+        </html>
+    """)
+
+    DEFAULT_ERROR_CONTENT_TYPE = 'text/html;charset=utf-8'
+
+    def _build_error_response(self, err: Error) -> _Response:
+        headers: ta.List[CoroHttpServer._Header] = [
+            *self._make_default_headers(),
+            self._Header('Connection', 'close'),
+        ]
+
+        # Message body is omitted for cases described in:
+        #  - RFC7230: 3.3. 1xx, 204(No Content), 304(Not Modified)
+        #  - RFC7231: 6.3.6. 205(Reset Content)
+        data: ta.Optional[bytes] = None
+        if (
+                err.code >= http.HTTPStatus.OK and
+                err.code not in (
+                    http.HTTPStatus.NO_CONTENT,
+                    http.HTTPStatus.RESET_CONTENT,
+                    http.HTTPStatus.NOT_MODIFIED,
+                )
+        ):
+            # HTML encode to prevent Cross Site Scripting attacks (see bug #1100201)
+            content = self._error_message_format.format(
+                code=err.code,
+                message=html.escape(err.message, quote=False),
+                explain=html.escape(err.explain, quote=False),
+            )
+            body = content.encode('UTF-8', 'replace')
+
+            headers.extend([
+                self._Header('Content-Type', self._error_content_type),
+                self._Header('Content-Length', str(len(body))),
+            ])
+
+            if err.method != 'HEAD' and body:
+                data = body
+
+        return self._Response(
+            version=err.version,
+            code=err.code,
+            message=err.message,
+            headers=headers,
+            data=data,
+            close_connection=True,
+        )
+
+    #
+
+    class Io(abc.ABC):  # noqa
+        pass
+
+    #
+
+    class AnyLogIo(Io):
+        pass
+
+    @dc.dataclass(frozen=True)
+    class ParsedRequestLogIo(AnyLogIo):
+        request: ParsedHttpRequest
+
+    @dc.dataclass(frozen=True)
+    class ErrorLogIo(AnyLogIo):
+        error: 'CoroHttpServer.Error'
+
+    #
+
+    class AnyReadIo(Io):  # noqa
+        pass
+
+    @dc.dataclass(frozen=True)
+    class ReadIo(AnyReadIo):
+        sz: int
+
+    @dc.dataclass(frozen=True)
+    class ReadLineIo(AnyReadIo):
+        sz: int
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class WriteIo(Io):
+        data: bytes
+
+    #
+
+    def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], None]:
+        while True:
+            gen = self.coro_handle_one()
+
+            o = next(gen)
+            i: ta.Optional[bytes]
+            while True:
+                if isinstance(o, self.AnyLogIo):
+                    i = None
+                    yield o
+
+                elif isinstance(o, self.AnyReadIo):
+                    i = check_isinstance((yield o), bytes)
+
+                elif isinstance(o, self._Response):
+                    i = None
+                    r = self._preprocess_response(o)
+                    b = self._build_response_bytes(r)
+                    check_none((yield self.WriteIo(b)))
+
+                else:
+                    raise TypeError(o)
+
+                try:
+                    o = gen.send(i)
+                except EOFError:
+                    return
+                except StopIteration:
+                    break
+
+    def coro_handle_one(self) -> ta.Generator[
+        ta.Union[AnyLogIo, AnyReadIo, _Response],
+        ta.Optional[bytes],
+        None,
+    ]:
+        # Parse request
+
+        gen = self._parser.coro_parse()
+        sz = next(gen)
+        while True:
+            try:
+                line = check_isinstance((yield self.ReadLineIo(sz)), bytes)
+                sz = gen.send(line)
+            except StopIteration as e:
+                parsed = e.value
+                break
+
+        if isinstance(parsed, EmptyParsedHttpResult):
+            raise EOFError  # noqa
+
+        if isinstance(parsed, ParseHttpRequestError):
+            err = self._build_error(
+                parsed.code,
+                *parsed.message,
+                version=parsed.version,
+            )
+            yield self.ErrorLogIo(err)
+            yield self._build_error_response(err)
+            return
+
+        parsed = check_isinstance(parsed, ParsedHttpRequest)
+
+        # Log
+
+        check_none((yield self.ParsedRequestLogIo(parsed)))
+
+        # Handle CONTINUE
+
+        if parsed.expects_continue:
+            # https://bugs.python.org/issue1491
+            # https://github.com/python/cpython/commit/0f476d49f8d4aa84210392bf13b59afc67b32b31
+            yield self._Response(
+                version=parsed.version,
+                code=http.HTTPStatus.CONTINUE,
+            )
+
+        # Read data
+
+        request_data: ta.Optional[bytes]
+        if (cl := parsed.headers.get('Content-Length')) is not None:
+            request_data = check_isinstance((yield self.ReadIo(int(cl))), bytes)
+        else:
+            request_data = None
+
+        # Build request
+
+        handler_request = HttpHandlerRequest(
+            client_address=self._client_address,
+            method=check_not_none(parsed.method),
+            path=parsed.path,
+            headers=parsed.headers,
+            data=request_data,
+        )
+
+        # Build handler response
+
+        try:
+            handler_response = self._handler(handler_request)
+
+        except UnsupportedMethodHttpHandlerError:
+            err = self._build_error(
+                http.HTTPStatus.NOT_IMPLEMENTED,
+                f'Unsupported method ({parsed.method!r})',
+                version=parsed.version,
+                method=parsed.method,
+            )
+            yield self.ErrorLogIo(err)
+            yield self._build_error_response(err)
+            return
+
+        # Build internal response
+
+        response_headers = handler_response.headers or {}
+        response_data = handler_response.data
+
+        headers: ta.List[CoroHttpServer._Header] = [
+            *self._make_default_headers(),
+        ]
+
+        for k, v in response_headers.items():
+            headers.append(self._Header(k, v))
+
+        if handler_response.close_connection and 'Connection' not in headers:
+            headers.append(self._Header('Connection', 'close'))
+
+        yield self._Response(
+            version=parsed.version,
+            code=http.HTTPStatus(handler_response.status),
+            headers=headers,
+            data=response_data,
+            close_connection=handler_response.close_connection,
+        )
+
+
+##
+
+
+class CoroHttpServerSocketHandler(SocketHandler):
+    def __init__(
+            self,
+            client_address: SocketAddress,
+            rfile: ta.BinaryIO,
+            wfile: ta.BinaryIO,
+            *,
+            server_factory: CoroHttpServerFactory,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
+    ) -> None:
+        super().__init__(
+            client_address,
+            rfile,
+            wfile,
+        )
+
+        self._server_factory = server_factory
+        self._log_handler = log_handler
+
+    def handle(self) -> None:
+        server = self._server_factory(self._client_address)
+
+        gen = server.coro_handle()
+
+        o = next(gen)
+        while True:
+            if isinstance(o, CoroHttpServer.AnyLogIo):
+                i = None
+                if self._log_handler is not None:
+                    self._log_handler(server, o)
+
+            elif isinstance(o, CoroHttpServer.ReadIo):
+                i = self._rfile.read(o.sz)
+
+            elif isinstance(o, CoroHttpServer.ReadLineIo):
+                i = self._rfile.readline(o.sz)
+
+            elif isinstance(o, CoroHttpServer.WriteIo):
+                i = None
+                self._wfile.write(o.data)
+                self._wfile.flush()
+
+            else:
+                raise TypeError(o)
+
+            try:
+                if i is not None:
+                    o = gen.send(i)
+                else:
+                    o = next(gen)
+            except StopIteration:
+                break
+
+
 ########################################
 # ../types.py
 
 
-class AbstractServerContext(abc.ABC):
+class ServerContext(abc.ABC):
     @property
     @abc.abstractmethod
     def config(self) -> ServerConfig:
@@ -3724,12 +4894,24 @@ class AbstractServerContext(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def pid_history(self) -> ta.Dict[int, 'AbstractSubprocess']:
+    def pid_history(self) -> ta.Dict[int, 'Process']:
         raise NotImplementedError
 
 
+# class Dispatcher(abc.ABC):
+#     pass
+#
+#
+# class OutputDispatcher(Dispatcher, abc.ABC):
+#     pass
+#
+#
+# class InputDispatcher(Dispatcher, abc.ABC):
+#     pass
+
+
 @functools.total_ordering
-class AbstractSubprocess(abc.ABC):
+class Process(abc.ABC):
     @property
     @abc.abstractmethod
     def pid(self) -> int:
@@ -3748,7 +4930,7 @@ class AbstractSubprocess(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def context(self) -> AbstractServerContext:
+    def context(self) -> ServerContext:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -3784,12 +4966,12 @@ class AbstractSubprocess(abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # dict[int, Dispatcher]
+    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # Dispatcher]:
         raise NotImplementedError
 
 
 @functools.total_ordering
-class AbstractProcessGroup(abc.ABC):
+class ProcessGroup(abc.ABC):
     @property
     @abc.abstractmethod
     def config(self) -> ProcessGroupConfig:
@@ -3801,12 +4983,48 @@ class AbstractProcessGroup(abc.ABC):
     def __eq__(self, other):
         return self.config.priority == other.config.priority
 
+    @abc.abstractmethod
+    def transition(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def stop_all(self) -> None:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def before_remove(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_dispatchers(self) -> ta.Mapping[int, ta.Any]:  # Dispatcher]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def reopen_logs(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_unstopped_processes(self) -> ta.List[Process]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def after_setuid(self) -> None:
+        raise NotImplementedError
+
 
 ########################################
 # ../context.py
 
 
-class ServerContext(AbstractServerContext):
+ServerEpoch = ta.NewType('ServerEpoch', int)
+
+
+class ServerContextImpl(ServerContext):
     def __init__(
             self,
             config: ServerConfig,
@@ -3820,7 +5038,7 @@ class ServerContext(AbstractServerContext):
         self._poller = poller
         self._epoch = epoch
 
-        self._pid_history: ta.Dict[int, AbstractSubprocess] = {}
+        self._pid_history: ta.Dict[int, Process] = {}
         self._state: SupervisorState = SupervisorState.RUNNING
 
         if config.user is not None:
@@ -3853,7 +5071,7 @@ class ServerContext(AbstractServerContext):
         self._state = state
 
     @property
-    def pid_history(self) -> ta.Dict[int, AbstractSubprocess]:
+    def pid_history(self) -> ta.Dict[int, Process]:
         return self._pid_history
 
     @property
@@ -4200,7 +5418,7 @@ def check_execv_args(filename, argv, st) -> None:
 class Dispatcher(abc.ABC):
     def __init__(
             self,
-            process: AbstractSubprocess,
+            process: Process,
             channel: str,
             fd: int,
             *,
@@ -4219,7 +5437,7 @@ class Dispatcher(abc.ABC):
         return f'<{self.__class__.__name__} at {id(self)} for {self._process} ({self._channel})>'
 
     @property
-    def process(self) -> AbstractSubprocess:
+    def process(self) -> Process:
         return self._process
 
     @property
@@ -4274,7 +5492,7 @@ class OutputDispatcher(Dispatcher):
 
     def __init__(
             self,
-            process: AbstractSubprocess,
+            process: Process,
             event_type: ta.Type[ProcessCommunicationEvent],
             fd: int,
             **kwargs: ta.Any,
@@ -4483,7 +5701,7 @@ class OutputDispatcher(Dispatcher):
 class InputDispatcher(Dispatcher):
     def __init__(
             self,
-            process: AbstractSubprocess,
+            process: Process,
             channel: str,
             fd: int,
             **kwargs: ta.Any,
@@ -4532,31 +5750,26 @@ class InputDispatcher(Dispatcher):
 ##
 
 
-@dc.dataclass(frozen=True)
-class SubprocessFactory:
-    fn: ta.Callable[[ProcessConfig, AbstractProcessGroup], AbstractSubprocess]
-
-    def __call__(self, config: ProcessConfig, group: AbstractProcessGroup) -> AbstractSubprocess:
-        return self.fn(config, group)
+ProcessFactory = ta.NewType('ProcessFactory', Func[Process])  # (config: ProcessConfig, group: ProcessGroup)
 
 
-class ProcessGroup(AbstractProcessGroup):
+class ProcessGroupImpl(ProcessGroup):
     def __init__(
             self,
             config: ProcessGroupConfig,
             context: ServerContext,
             *,
-            subprocess_factory: SubprocessFactory,
+            process_factory: ProcessFactory,
     ):
         super().__init__()
 
         self._config = config
         self._context = context
-        self._subprocess_factory = subprocess_factory
+        self._process_factory = process_factory
 
         self._processes = {}
         for pconfig in self._config.processes or []:
-            process = self._subprocess_factory(pconfig, self)
+            process = self._process_factory(pconfig, self)
             self._processes[pconfig.name] = process
 
     @property
@@ -4568,7 +5781,7 @@ class ProcessGroup(AbstractProcessGroup):
         return self._config.name
 
     @property
-    def context(self) -> AbstractServerContext:
+    def context(self) -> ServerContext:
         return self._context
 
     def __repr__(self):
@@ -4603,7 +5816,7 @@ class ProcessGroup(AbstractProcessGroup):
                 # BACKOFF -> FATAL
                 proc.give_up()
 
-    def get_unstopped_processes(self) -> ta.List[AbstractSubprocess]:
+    def get_unstopped_processes(self) -> ta.List[Process]:
         return [x for x in self._processes.values() if not x.get_state().stopped]
 
     def get_dispatchers(self) -> ta.Dict[int, Dispatcher]:
@@ -4680,18 +5893,21 @@ class ProcessGroups:
 # ../process.py
 
 
+InheritedFds = ta.NewType('InheritedFds', ta.FrozenSet[int])
+
+
 ##
 
 
-class Subprocess(AbstractSubprocess):
+class ProcessImpl(Process):
     """A class to manage a subprocess."""
 
     def __init__(
             self,
             config: ProcessConfig,
-            group: AbstractProcessGroup,
+            group: ProcessGroup,
             *,
-            context: AbstractServerContext,
+            context: ServerContext,
             event_callbacks: EventCallbacks,
 
             inherited_fds: ta.Optional[InheritedFds] = None,
@@ -4730,7 +5946,7 @@ class Subprocess(AbstractSubprocess):
         return self._pid
 
     @property
-    def group(self) -> AbstractProcessGroup:
+    def group(self) -> ProcessGroup:
         return self._group
 
     @property
@@ -4738,7 +5954,7 @@ class Subprocess(AbstractSubprocess):
         return self._config
 
     @property
-    def context(self) -> AbstractServerContext:
+    def context(self) -> ServerContext:
         return self._context
 
     @property
@@ -5385,7 +6601,7 @@ class SignalHandler:
     def __init__(
             self,
             *,
-            context: ServerContext,
+            context: ServerContextImpl,
             signal_receiver: SignalReceiver,
             process_groups: ProcessGroups,
     ) -> None:
@@ -5437,19 +6653,14 @@ class SignalHandler:
 ##
 
 
-@dc.dataclass(frozen=True)
-class ProcessGroupFactory:
-    fn: ta.Callable[[ProcessGroupConfig], ProcessGroup]
-
-    def __call__(self, config: ProcessGroupConfig) -> ProcessGroup:
-        return self.fn(config)
+ProcessGroupFactory = ta.NewType('ProcessGroupFactory', Func[ProcessGroup])  # (config: ProcessGroupConfig)
 
 
 class Supervisor:
     def __init__(
             self,
             *,
-            context: ServerContext,
+            context: ServerContextImpl,
             poller: Poller,
             process_groups: ProcessGroups,
             signal_handler: SignalHandler,
@@ -5473,7 +6684,7 @@ class Supervisor:
     #
 
     @property
-    def context(self) -> ServerContext:
+    def context(self) -> ServerContextImpl:
         return self._context
 
     def get_state(self) -> SupervisorState:
@@ -5520,16 +6731,16 @@ class Supervisor:
         return True
 
     def get_process_map(self) -> ta.Dict[int, Dispatcher]:
-        process_map = {}
+        process_map: ta.Dict[int, Dispatcher] = {}
         for group in self._process_groups:
             process_map.update(group.get_dispatchers())
         return process_map
 
-    def shutdown_report(self) -> ta.List[Subprocess]:
-        unstopped: ta.List[Subprocess] = []
+    def shutdown_report(self) -> ta.List[Process]:
+        unstopped: ta.List[Process] = []
 
         for group in self._process_groups:
-            unstopped.extend(group.get_unstopped_processes())  # type: ignore
+            unstopped.extend(group.get_unstopped_processes())
 
         if unstopped:
             # throttle 'waiting for x to die' reports
@@ -5740,13 +6951,13 @@ class Supervisor:
 
 
 ########################################
-# main.py
+# ../inject.py
 
 
 ##
 
 
-def build_server_bindings(
+def bind_server(
         config: ServerConfig,
         *,
         server_epoch: ta.Optional[ServerEpoch] = None,
@@ -5757,8 +6968,8 @@ def build_server_bindings(
 
         inj.bind(get_poller_impl(), key=Poller, singleton=True),
 
-        inj.bind(ServerContext, singleton=True),
-        inj.bind(AbstractServerContext, to_key=ServerContext),
+        inj.bind(ServerContextImpl, singleton=True),
+        inj.bind(ServerContext, to_key=ServerContextImpl),
 
         inj.bind(EventCallbacks, singleton=True),
 
@@ -5767,21 +6978,10 @@ def build_server_bindings(
         inj.bind(SignalHandler, singleton=True),
         inj.bind(ProcessGroups, singleton=True),
         inj.bind(Supervisor, singleton=True),
-    ]
-
-    #
 
-    def make_process_group_factory(injector: Injector) -> ProcessGroupFactory:
-        def inner(group_config: ProcessGroupConfig) -> ProcessGroup:
-            return injector.inject(functools.partial(ProcessGroup, group_config))
-        return ProcessGroupFactory(inner)
-    lst.append(inj.bind(make_process_group_factory))
-
-    def make_subprocess_factory(injector: Injector) -> SubprocessFactory:
-        def inner(process_config: ProcessConfig, group: AbstractProcessGroup) -> AbstractSubprocess:
-            return injector.inject(functools.partial(Subprocess, process_config, group))
-        return SubprocessFactory(inner)
-    lst.append(inj.bind(make_subprocess_factory))
+        inj.bind_factory(ProcessGroupFactory, ProcessGroupImpl),
+        inj.bind_factory(ProcessFactory, ProcessImpl),
+    ]
 
     #
 
@@ -5795,6 +6995,10 @@ def build_server_bindings(
     return inj.as_bindings(*lst)
 
 
+########################################
+# main.py
+
+
 ##
 
 
@@ -5803,6 +7007,10 @@ def main(
         *,
         no_logging: bool = False,
 ) -> None:
+    server_cls = CoroHttpServer  # noqa
+
+    #
+
     import argparse
 
     parser = argparse.ArgumentParser()
@@ -5836,14 +7044,14 @@ def main(
             prepare=prepare_server_config,
         )
 
-        injector = inj.create_injector(build_server_bindings(
+        injector = inj.create_injector(bind_server(
             config,
             server_epoch=ServerEpoch(epoch),
             inherited_fds=inherited_fds,
         ))
 
-        context = injector.provide(ServerContext)
-        supervisor = injector.provide(Supervisor)
+        context = injector[ServerContextImpl]
+        supervisor = injector[Supervisor]
 
         try:
             supervisor.main()