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

ominfra/scripts/supervisor.py

@@ -12,13 +12,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 +35,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 +56,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 +70,13 @@ 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']
+
+# ../../../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,6 +86,12 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 # ../../configs.py
 ConfigMapping = ta.Mapping[str, ta.Any]
 
+# ../../../omlish/lite/http/handlers.py
+HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']
+
+# ../../../omlish/lite/http/coroserver.py
+CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
+
 # ../context.py
 ServerEpoch = ta.NewType('ServerEpoch', int)
 
@@ -1254,6 +1273,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 +1318,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 +1467,76 @@ 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
+
+
 ########################################
 # ../events.py
 
@@ -1910,6 +2023,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 +2397,22 @@ def timeslice(period: int, when: float) -> int:
 
 
 @dc.dataclass(frozen=True)
-class InjectorKey:
+class InjectorKey(ta.Generic[T]):
     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 +2456,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 +2494,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)
 
@@ -2332,8 +2826,8 @@ class InjectorBinder:
             to_fn = obj
             if key is None:
                 sig = _injection_signature(obj)
-                ty = check_isinstance(sig.return_annotation, type)
-                key = InjectorKey(ty)
+                key_cls = check_valid_injector_key_cls(sig.return_annotation)
+                key = InjectorKey(key_cls)
         else:
             if to_const is not None:
                 raise TypeError('Cannot bind instance with to_const')
@@ -2387,7 +2881,7 @@ class InjectorBinder:
 # injector
 
 
-_INJECTOR_INJECTOR_KEY = InjectorKey(Injector)
+_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
 
 
 class _Injector(Injector):
@@ -2542,7 +3036,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 +4075,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,6 +4226,566 @@ 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
 
@@ -5740,13 +6823,13 @@ class Supervisor:
 
 
 ########################################
-# main.py
+# ../inject.py
 
 
 ##
 
 
-def build_server_bindings(
+def bind_server(
         config: ServerConfig,
         *,
         server_epoch: ta.Optional[ServerEpoch] = None,
@@ -5795,6 +6878,10 @@ def build_server_bindings(
     return inj.as_bindings(*lst)
 
 
+########################################
+# main.py
+
+
 ##
 
 
@@ -5803,6 +6890,10 @@ def main(
         *,
         no_logging: bool = False,
 ) -> None:
+    server_cls = CoroHttpServer  # noqa
+
+    #
+
     import argparse
 
     parser = argparse.ArgumentParser()
@@ -5836,14 +6927,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[ServerContext]
+        supervisor = injector[Supervisor]
 
         try:
             supervisor.main()