tigrcorn-runtime 0.3.16.dev13__tar.gz → 0.3.17.dev1__tar.gz

{tigrcorn_runtime-0.3.16.dev13/src/tigrcorn_runtime.egg-info → tigrcorn_runtime-0.3.17.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrcorn-runtime
-Version: 0.3.16.dev13
+Version: 0.3.17.dev1
 Summary: Server runner, app loading, lifecycle hooks, workers, reload, and embedded runtime for the Tigrcorn ASGI3 web server.
 Author-email: Jacob Stewart <jacob@swarmauri.com>
 License: Apache License
@@ -187,12 +187,12 @@ Classifier: Typing :: Typed
 Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tigrcorn-core==0.3.16.dev13
-Requires-Dist: tigrcorn-config==0.3.16.dev13
-Requires-Dist: tigrcorn-asgi==0.3.16.dev13
-Requires-Dist: tigrcorn-transports==0.3.16.dev13
-Requires-Dist: tigrcorn-protocols==0.3.16.dev13
-Requires-Dist: tigrcorn-security==0.3.16.dev13
+Requires-Dist: tigrcorn-core==0.3.17.dev1
+Requires-Dist: tigrcorn-config==0.3.17.dev1
+Requires-Dist: tigrcorn-asgi==0.3.17.dev1
+Requires-Dist: tigrcorn-transports==0.3.17.dev1
+Requires-Dist: tigrcorn-protocols==0.3.17.dev1
+Requires-Dist: tigrcorn-security==0.3.17.dev1
 Provides-Extra: uvloop
 Requires-Dist: uvloop>=0.19.0; platform_system != "Windows" and extra == "uvloop"
 Provides-Extra: trio

{tigrcorn_runtime-0.3.16.dev13 → tigrcorn_runtime-0.3.17.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tigrcorn-runtime"
-version = "0.3.16.dev13"
+version = "0.3.17.dev1"
 description = "Server runner, app loading, lifecycle hooks, workers, reload, and embedded runtime for the Tigrcorn ASGI3 web server."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"
@@ -30,12 +30,12 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "tigrcorn-core==0.3.16.dev13",
-  "tigrcorn-config==0.3.16.dev13",
-  "tigrcorn-asgi==0.3.16.dev13",
-  "tigrcorn-transports==0.3.16.dev13",
-  "tigrcorn-protocols==0.3.16.dev13",
-  "tigrcorn-security==0.3.16.dev13",
+  "tigrcorn-core==0.3.17.dev1",
+  "tigrcorn-config==0.3.17.dev1",
+  "tigrcorn-asgi==0.3.17.dev1",
+  "tigrcorn-transports==0.3.17.dev1",
+  "tigrcorn-protocols==0.3.17.dev1",
+  "tigrcorn-security==0.3.17.dev1",
 ]
 
 [project.optional-dependencies]

{tigrcorn_runtime-0.3.16.dev13 → tigrcorn_runtime-0.3.17.dev1}/src/tigrcorn_runtime/embedded.py

@@ -38,7 +38,9 @@ class EmbeddedServer:
     async def close(self) -> None:
         if self.server is None:
             return
-        await self.server.close()
+        server = self.server
+        await server.close()
+        self.server = None
 
     async def __aenter__(self) -> 'EmbeddedServer':
         await self.start()
@@ -73,5 +75,17 @@ class EmbeddedServer:
                 endpoints.append(path)
         return endpoints
 
+    def describe(self) -> dict[str, Any]:
+        if self.server is not None:
+            return self.server.describe()
+        server = TigrCornServer(self.app, self.config)
+        return server.describe()
+
+    def resource_ownership(self) -> dict[str, Any]:
+        if self.server is not None:
+            return self.server.resource_ownership()
+        server = TigrCornServer(self.app, self.config)
+        return server.resource_ownership()
+
 
 __all__ = ['EmbeddedServer']

tigrcorn_runtime-0.3.17.dev1/src/tigrcorn_runtime/server/runner/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .core import TigrCornServer
+
+__all__ = ['TigrCornServer']

tigrcorn_runtime-0.3.17.dev1/src/tigrcorn_runtime/server/runner/base.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from .imports import *
+
+class _TigrCornServerBase:
+    def __init__(self, app: ASGIApp, config: ServerConfig) -> None:
+        selection = resolve_app_dispatch(app, config.app.interface)
+        self.app = selection.app
+        self.app_dispatch_selection = selection
+        self.app_interface = selection.interface
+        self.app_interface_source = selection.source
+        self.app_interface_reason = selection.reason
+        self.config = config
+        self._resolved_logging = resolve_logging_config(config.log_level, config=config.logging)
+        self.logger = configure_logging(config.log_level, config=config.logging)
+        self.access_logger = AccessLogger(
+            self.logger,
+            enabled=self._resolved_logging.access_log,
+            fmt=self._resolved_logging.access_log_format,
+        )
+        self.state = ServerState()
+        self.lifespan = LifespanManager(app, mode=config.lifespan)
+        self._listeners: list[TCPListener | UDPListener | UnixListener | PipeListener | InProcListener] = []
+        self._datagram_handlers: list[HTTP3DatagramHandler] = []
+        self._transport_domain_accounting = TransportDomainAccounting()
+        self._quic_operational_security: dict[str, QuicOperationalSecurityRuntime] = {}
+        self._webtransport_governance = WebTransportGovernanceManager(default_webtransport_budget_policy())
+        self._should_exit = asyncio.Event()
+        self._started = False
+        self._metrics_server: asyncio.AbstractServer | None = None
+        self._request_budget_task: asyncio.Task[None] | None = None
+        self._statsd_exporter = StatsdExporter(config.metrics.statsd_host, logger=self.logger) if config.metrics.statsd_host else None
+        self._otel_exporter = OtelExporter(config.metrics.otel_endpoint, logger=self.logger) if config.metrics.otel_endpoint else None
+        policy = SchedulerPolicy()
+        if config.scheduler.max_connections is not None:
+            policy.max_connections = config.scheduler.max_connections
+        if config.scheduler.max_tasks is not None:
+            policy.max_tasks = config.scheduler.max_tasks
+        if config.scheduler.max_streams is not None:
+            policy.max_streams_per_session = config.scheduler.max_streams
+        if config.scheduler.limit_concurrency is not None:
+            policy.limit_concurrency = config.scheduler.limit_concurrency
+        self.scheduler = ProductionScheduler(policy)
+        self._request_budget = None
+        if config.process.limit_max_requests is not None:
+            jitter = max(0, config.process.max_requests_jitter)
+            self._request_budget = config.process.limit_max_requests + (random.randint(0, jitter) if jitter else 0)
+
+__all__ = [name for name in globals() if not name.startswith('__')]

tigrcorn_runtime-0.3.17.dev1/src/tigrcorn_runtime/server/runner/client_handlers.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from .imports import *
+
+class _TigrCornServerClientHandlerMixin:
+    def _make_client_handler(self, listener_cfg: ListenerConfig):
+        if listener_cfg.kind == 'udp':
+            h3_handler = HTTP3DatagramHandler(
+                app=self.app,
+                config=self.config,
+                listener=listener_cfg,
+                access_logger=self.access_logger,
+                scheduler=self.scheduler,
+                metrics=self.state.metrics,
+                webtransport_governance=self._webtransport_governance,
+            )
+            self._datagram_handlers.append(h3_handler)
+
+            async def udp_handler(packet, endpoint) -> None:
+                sessions_before = len(h3_handler.sessions)
+                responses_before = sum(len(session.responded_streams) for session in h3_handler.sessions.values())
+                self._record_quic_operational_security_packet(listener_cfg, packet, endpoint)
+                await h3_handler.handle_packet(packet, endpoint)
+                if len(h3_handler.sessions) > sessions_before:
+                    self.state.metrics.connection_opened()
+                responses_after = sum(len(session.responded_streams) for session in h3_handler.sessions.values())
+                if responses_after > responses_before:
+                    self.state.metrics.requests_served += responses_after - responses_before
+
+            return udp_handler
+
+        if listener_cfg.kind == 'pipe':
+            raw_handler = RawFramedApplicationHandler(
+                app=self.app,
+                config=self.config,
+                listener=listener_cfg,
+                access_logger=self.access_logger,
+            )
+
+            async def pipe_handler(connection, data) -> None:
+                handled = await raw_handler.feed_bytes(connection, data, path=listener_cfg.path)
+                self.state.metrics.requests_served += handled
+                self.state.metrics.bytes_received += len(data)
+
+            return pipe_handler
+
+        async def handler(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+            await self._handle_client(reader, writer, listener_cfg)
+
+        return handler
+
+    async def _handle_client(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+        listener_cfg: ListenerConfig,
+    ) -> None:
+        lease = self.scheduler.acquire_connection()
+        if lease is None:
+            writer.close()
+            with suppress(Exception):
+                await writer.wait_closed()
+            return
+        self.state.metrics.connection_opened()
+        peername = writer.get_extra_info('peername')
+        sockname = writer.get_extra_info('sockname')
+        ssl_obj = writer.get_extra_info('ssl_object')
+        selected_alpn = ssl_obj.selected_alpn_protocol() if ssl_obj else None
+        tls_payload = tls_extension_payload(writer)
+        scope_tls_extensions = {'tls': tls_payload} if tls_payload is not None else None
+        client_host, client_port = peer_parts(peername)
+        server_host, server_port = peer_parts(sockname)
+        client = (client_host, client_port) if client_host is not None and client_port is not None else None
+        server = (server_host or '', server_port)
+        scheme = 'https' if ssl_obj else (listener_cfg.scheme or 'http')
+        ws_scheme = 'wss' if ssl_obj else 'ws'
+        try:
+            if selected_alpn == 'h2' and '2' in listener_cfg.http_versions:
+                h2_handler = HTTP2ConnectionHandler(
+                    app=self.app,
+                    config=self.config,
+                    access_logger=self.access_logger,
+                    scheduler=self.scheduler,
+                    metrics=self.state.metrics,
+                    reader=reader,
+                    writer=writer,
+                    client=client,
+                    server=server,
+                    scheme=scheme,
+                    scope_extensions=scope_tls_extensions,
+                )
+                await h2_handler.handle()
+                return
+
+            initial = b''
+            if '2' in listener_cfg.http_versions and self.config.enable_h2c:
+                initial = await self._read_preface_probe(reader)
+                if initial == H2_PREFACE:
+                    h2_handler = HTTP2ConnectionHandler(
+                        app=self.app,
+                        config=self.config,
+                        access_logger=self.access_logger,
+                        scheduler=self.scheduler,
+                        metrics=self.state.metrics,
+                        reader=reader,
+                        writer=writer,
+                        client=client,
+                        server=server,
+                        scheme=scheme,
+                        prebuffer=initial,
+                        scope_extensions=scope_tls_extensions,
+                    )
+                    await h2_handler.handle()
+                    return
+
+            buffered_reader: StreamReaderLike = PrebufferedReader(reader, initial)
+            await self._handle_http11_connection(
+                buffered_reader,
+                writer,
+                listener_cfg,
+                client=client,
+                server=server,
+                scheme=scheme,
+                ws_scheme=ws_scheme,
+                scope_extensions=scope_tls_extensions,
+            )
+        finally:
+            lease.release()
+            self.state.metrics.connection_closed()
+            writer.close()
+            with suppress(Exception):
+                await writer.wait_closed()
+
+__all__ = [name for name in globals() if not name.startswith('__')]

tigrcorn_runtime-0.3.17.dev1/src/tigrcorn_runtime/server/runner/core.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from .base import _TigrCornServerBase
+from .diagnostics import _TigrCornServerDiagnosticsMixin
+from .lifecycle import _TigrCornServerLifecycleMixin
+from .listeners import _TigrCornServerListenerMixin
+from .client_handlers import _TigrCornServerClientHandlerMixin
+from .http11 import _TigrCornServerHTTP11Mixin
+from .http11_send import _TigrCornServerHTTP11SendMixin
+from .http11_serve import _TigrCornServerHTTP11ServeMixin
+from .metrics import _TigrCornServerMetricsMixin
+
+
+class TigrCornServer(
+    _TigrCornServerMetricsMixin,
+    _TigrCornServerHTTP11ServeMixin,
+    _TigrCornServerHTTP11SendMixin,
+    _TigrCornServerHTTP11Mixin,
+    _TigrCornServerClientHandlerMixin,
+    _TigrCornServerListenerMixin,
+    _TigrCornServerLifecycleMixin,
+    _TigrCornServerDiagnosticsMixin,
+    _TigrCornServerBase,
+):
+    pass
+
+
+__all__ = ['TigrCornServer']

tigrcorn_runtime-0.3.17.dev1/src/tigrcorn_runtime/server/runner/diagnostics.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from .imports import *
+
+class _TigrCornServerDiagnosticsMixin:
+    def describe(self) -> dict[str, Any]:
+        configured_protocols: set[str] = set()
+        configured_transports: set[str] = set()
+        listeners: list[dict[str, Any]] = []
+        bound_endpoints = self._bound_endpoint_strings()
+        for index, listener in enumerate(self.config.listeners):
+            protocols = tuple(sorted(listener.enabled_protocols))
+            configured_protocols.update(protocols)
+            configured_transports.add(listener.kind)
+            listeners.append(
+                {
+                    "id": f"listener:{index}",
+                    "active": self._started and index < len(self._listeners),
+                    "kind": listener.kind,
+                    "label": listener.label,
+                    "bound_endpoint": bound_endpoints[index] if index < len(bound_endpoints) else None,
+                    "protocols": list(protocols),
+                    "http_versions": list(listener.http_versions),
+                    "tls": {
+                        "enabled": listener.ssl_enabled,
+                        "alpn_protocols": list(listener.alpn_protocols),
+                        "certfile": self._redact(listener.ssl_certfile),
+                        "keyfile": self._redact(listener.ssl_keyfile),
+                        "ca_certs": self._redact(listener.ssl_ca_certs),
+                        "client_cert_required": bool(listener.ssl_require_client_cert),
+                        "ocsp_mode": listener.ocsp_mode,
+                        "crl_mode": listener.crl_mode,
+                    },
+                }
+            )
+        return {
+            "schema_version": "1.0",
+            "runtime": self.config.process.runtime,
+            "active": self._started,
+            "profile": self.config.app.profile or "default",
+            "app_interface": {
+                "selected": self.app_interface,
+                "source": self.app_interface_source,
+                "reason": self.app_interface_reason,
+            },
+            "capabilities": {
+                "protocols": ["http1", "http2", "http3", "lifespan", "quic", "websocket", "webtransport"],
+                "transports": sorted(TRANSPORTS),
+            },
+            "configured_protocols": sorted(configured_protocols),
+            "active_protocols": sorted(configured_protocols) if self._started else [],
+            "configured_transports": sorted(configured_transports),
+            "active_transports": sorted(configured_transports) if self._started else [],
+            "transport_domains": self.transport_domain_diagnostics(),
+            "quic_operational_security": self.quic_operational_security_evidence(),
+            "webtransport_resource_governance": self.webtransport_resource_governance(),
+            "listeners": listeners,
+            "worker": {
+                "count": self.config.process.workers,
+                "class": self.config.process.worker_class,
+                "runtime": self.config.process.runtime,
+            },
+            "observability": {
+                "metrics_enabled": bool(self.config.metrics.enabled),
+                "metrics_bind": self.config.metrics.bind,
+                "statsd_enabled": bool(self.config.metrics.statsd_host),
+                "otel_enabled": bool(self.config.metrics.otel_endpoint),
+                "structured_logging": bool(self.config.logging.structured),
+            },
+        }
+
+    def _bound_endpoint_strings(self) -> list[str]:
+        endpoints: list[str] = []
+        for listener in self._listeners:
+            server = getattr(listener, "server", None)
+            sockets = getattr(server, "sockets", None) if server is not None else None
+            if sockets:
+                endpoints.append(str(sockets[0].getsockname()))
+                continue
+            transport = getattr(listener, "transport", None)
+            if transport is not None:
+                sockname = transport.get_extra_info("sockname")
+                if sockname is not None:
+                    endpoints.append(str(sockname))
+                    continue
+            path = getattr(listener, "path", None)
+            if path:
+                endpoints.append(str(path))
+        return endpoints
+
+    def transport_domain_diagnostics(self) -> dict[str, Any]:
+        active_domains = self._active_transport_domain_ids() if self._started else ()
+        return transport_domain_diagnostics(
+            accounting=self._transport_domain_accounting,
+            active_domains=active_domains,
+            endpoint_identities=self._transport_domain_endpoint_identities(active_domains),
+        )
+
+    def quic_operational_security_evidence(self) -> dict[str, Any]:
+        return {
+            label: collector.runtime_evidence()
+            for label, collector in sorted(self._quic_operational_security.items())
+        }
+
+    def webtransport_resource_governance(self) -> dict[str, Any]:
+        return self._jsonable(self._webtransport_governance.snapshot())
+
+    def _active_transport_domain_ids(self) -> tuple[str, ...]:
+        domains: set[str] = set()
+        for index, listener in enumerate(self.config.listeners):
+            if index >= len(self._listeners):
+                continue
+            domains.update(self._listener_transport_domain_ids(listener))
+        return tuple(sorted(domains))
+
+    def _configured_transport_domain_ids(self) -> tuple[str, ...]:
+        domains: set[str] = set()
+        for listener in self.config.listeners:
+            domains.update(self._listener_transport_domain_ids(listener))
+        return tuple(sorted(domains))
+
+    @staticmethod
+    def _listener_transport_domain_ids(listener: ListenerConfig) -> tuple[str, ...]:
+        domains = {"listener", _normalize_listener_kind(listener.kind)}
+        if "quic" in listener.enabled_protocols:
+            domains.add("quic")
+        return tuple(sorted(domains))
+
+    def _transport_domain_endpoint_identities(self, active_domains: Iterable[str]) -> dict[str, str | None]:
+        endpoint = ",".join(self._bound_endpoint_strings()) or None
+        return {domain_id: endpoint for domain_id in active_domains}
+
+    @staticmethod
+    def _redact(value: Any) -> str | None:
+        return "<redacted>" if value else None
+
+    @staticmethod
+    def _jsonable(value: Any) -> Any:
+        if isinstance(value, tuple):
+            return [_TigrCornServerDiagnosticsMixin._jsonable(item) for item in value]
+        if isinstance(value, list):
+            return [_TigrCornServerDiagnosticsMixin._jsonable(item) for item in value]
+        if isinstance(value, dict):
+            return {
+                key: _TigrCornServerDiagnosticsMixin._jsonable(item)
+                for key, item in value.items()
+            }
+        return value
+
+__all__ = [name for name in globals() if not name.startswith('__')]

tigrcorn_runtime-0.3.17.dev1/src/tigrcorn_runtime/server/runner/http11.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from .imports import *
+
+class _TigrCornServerHTTP11Mixin:
+    async def _read_preface_probe(self, reader: asyncio.StreamReader) -> bytes:
+        data = await asyncio.wait_for(reader.read(len(H2_PREFACE)), timeout=self.config.http.read_timeout)
+        if not data:
+            return b''
+        if H2_PREFACE.startswith(data) and data != H2_PREFACE:
+            with suppress(Exception):
+                data += await asyncio.wait_for(reader.readexactly(len(H2_PREFACE) - len(data)), timeout=0.05)
+        return data
+
+    async def _handle_http11_connection(
+        self,
+        reader: StreamReaderLike,
+        writer: asyncio.StreamWriter,
+        listener_cfg: ListenerConfig,
+        *,
+        client: tuple[str, int] | None,
+        server: tuple[str, int] | tuple[str, None] | None,
+        scheme: str,
+        ws_scheme: str,
+        scope_extensions: dict | None = None,
+    ) -> None:
+        keep_handling = True
+        handled_requests = 0
+        while keep_handling and not self.state.shutting_down:
+            request_timeout = self.config.http.keep_alive_timeout if handled_requests else self.config.http.read_timeout
+            if self.config.http.http1_header_read_timeout is not None:
+                request_timeout = min(request_timeout, self.config.http.http1_header_read_timeout)
+            try:
+                request = await asyncio.wait_for(
+                    read_http11_request_head(
+                        reader,
+                        max_body_size=self.config.max_body_size,
+                        max_header_size=self.config.max_header_size,
+                        max_incomplete_event_size=self.config.http.http1_max_incomplete_event_size,
+                        buffer_size=self.config.http.http1_buffer_size,
+                    ),
+                    timeout=request_timeout,
+                )
+            except asyncio.TimeoutError:
+                break
+            except Exception as exc:
+                self.state.metrics.protocol_errors += 1
+                self.logger.warning('protocol error from %s: %s', client, exc)
+                await self._write_error(writer, 400, b'bad request', keep_alive=False)
+                break
+            if request is None:
+                break
+
+            proxy_view = resolve_proxy_view(
+                request.headers,
+                client=client,
+                server=server,
+                scheme=scheme,
+                root_path=self.config.proxy.root_path,
+                enabled=self.config.proxy.proxy_headers,
+                forwarded_allow_ips=self.config.proxy.forwarded_allow_ips,
+            )
+            request_client = proxy_view.client
+            request_server = proxy_view.server
+            request_scheme = proxy_view.scheme
+            request_ws_scheme = 'wss' if request_scheme == 'https' else 'ws'
+            request.keep_alive = apply_keep_alive_policy(request.keep_alive, enabled=self.config.http.http1_keep_alive)
+
+            if request.method.upper() == 'CONNECT':
+                await self._handle_http11_connect_tunnel(reader, writer, request, client=request_client)
+                keep_handling = False
+                break
+
+            if request.websocket_upgrade:
+                if not listener_cfg.websocket:
+                    await self._write_error(writer, 426, b'websocket not enabled', keep_alive=False)
+                    break
+                work_lease = self.scheduler.acquire_work()
+                if work_lease is None:
+                    self.state.metrics.scheduler_task_rejected()
+                    await self._write_error(writer, 503, b'scheduler overloaded', keep_alive=False)
+                    break
+                handler = WebSocketConnectionHandler(
+                    app=self.app,
+                    config=self.config,
+                    access_logger=self.access_logger,
+                    request=request,
+                    reader=reader,
+                    writer=writer,
+                    client=request_client,
+                    server=request_server,
+                    scheme=request_ws_scheme,
+                    scope_extensions=scope_extensions,
+                    metrics=self.state.metrics,
+                )
+                try:
+                    self.state.metrics.websocket_opened()
+                    await handler.handle()
+                finally:
+                    work_lease.release()
+                    self.state.metrics.websocket_closed()
+                    keep_handling = False
+                break
+
+            work_lease = self.scheduler.acquire_work()
+            if work_lease is None:
+                self.state.metrics.scheduler_task_rejected()
+                await self._write_error(writer, 503, b'scheduler overloaded', keep_alive=False)
+                break
+            try:
+                keep_handling = await self._serve_http11_request(
+                reader,
+                writer,
+                request,
+                client=request_client,
+                server=request_server,
+                scheme=request_scheme,
+                scope_extensions=scope_extensions,
+            )
+            finally:
+                work_lease.release()
+            handled_requests += 1
+
+    async def _drain_writer(self, writer: asyncio.StreamWriter) -> None:
+        await asyncio.wait_for(writer.drain(), timeout=self.config.http.write_timeout)
+
+    async def _write_continue(self, writer: asyncio.StreamWriter) -> None:
+        writer.write(b'HTTP/1.1 100 Continue\r\n\r\n')
+        await self._drain_writer(writer)
+
+    def _build_http11_receive(
+        self,
+        reader: StreamReaderLike,
+        writer: asyncio.StreamWriter,
+        request: ParsedRequestHead,
+    ) -> HTTPRequestReceive | HTTPStreamingRequestReceive:
+        if request.body_kind == 'none':
+            return HTTPRequestReceive(b'')
+        return HTTPStreamingRequestReceive(
+            reader=reader,
+            content_length=request.content_length if request.body_kind == 'content-length' else None,
+            chunked=request.body_kind == 'chunked',
+            max_body_size=self.config.max_body_size,
+            expect_continue=request.expect_continue,
+            on_expect_continue=lambda: self._write_continue(writer),
+            max_chunk_size=self.config.http.http1_buffer_size,
+            trailer_policy=self.config.http.trailer_policy,
+        )
+
+    def _http11_scope_extensions(self, request: ParsedRequestHead, *, scope_extensions: dict | None = None) -> dict:
+        extensions: dict = dict(scope_extensions or {})
+        if request.body_kind == 'chunked' and self.config.http.trailer_policy != 'drop':
+            extensions['tigrcorn.http.request_trailers'] = {}
+        if request.method.upper() == 'CONNECT':
+            extensions['tigrcorn.http.connect'] = {'authority': request.target}
+        extensions['tigrcorn.http.response.file'] = {'protocol': 'http/1.1', 'streaming': True, 'sendfile': True}
+        extensions['http.response.pathsend'] = {}
+        return extensions
+
+    @staticmethod
+    @staticmethod
+    def _parse_connect_authority(authority: str) -> tuple[str, int]:
+        return parse_connect_authority(authority)
+
+    async def _relay_stream(self, reader: StreamReaderLike, writer: asyncio.StreamWriter) -> None:
+        try:
+            while True:
+                chunk = await asyncio.wait_for(reader.read(65536), timeout=self.config.http.idle_timeout)
+                if not chunk:
+                    break
+                writer.write(chunk)
+                await self._drain_writer(writer)
+                self.state.metrics.bytes_sent += len(chunk)
+        finally:
+            writer.close()
+            with suppress(Exception):
+                await writer.wait_closed()
+
+__all__ = [name for name in globals() if not name.startswith('__')]