tigrcorn-protocols 0.3.16.dev5__py3-none-any.whl

tigrcorn_protocols/http1/serializer.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from tigrcorn_core.utils.headers import apply_response_header_policy, get_header, sanitize_early_hints_headers, strip_connection_specific_headers
+
+
+_REASON_PHRASES = {
+    100: b"Continue",
+    101: b"Switching Protocols",
+    103: b"Early Hints",
+    200: b"OK",
+    201: b"Created",
+    202: b"Accepted",
+    204: b"No Content",
+    206: b"Partial Content",
+    301: b"Moved Permanently",
+    302: b"Found",
+    304: b"Not Modified",
+    307: b"Temporary Redirect",
+    308: b"Permanent Redirect",
+    400: b"Bad Request",
+    401: b"Unauthorized",
+    402: b"Payment Required",
+    403: b"Forbidden",
+    404: b"Not Found",
+    405: b"Method Not Allowed",
+    406: b"Not Acceptable",
+    408: b"Request Timeout",
+    413: b"Content Too Large",
+    416: b"Range Not Satisfiable",
+    421: b"Misdirected Request",
+    426: b"Upgrade Required",
+    431: b"Request Header Fields Too Large",
+    500: b"Internal Server Error",
+    502: b"Bad Gateway",
+    503: b"Service Unavailable",
+    504: b"Gateway Timeout",
+}
+
+
+def _reason(status: int) -> bytes:
+    return _REASON_PHRASES.get(status, b"OK")
+
+
+
+def response_allows_body(status: int) -> bool:
+    return not (100 <= status < 200 or status in {204, 304})
+
+
+
+def response_allows_implicit_content_length(status: int) -> bool:
+    return response_allows_body(status)
+
+
+
+def _normalize_response_headers(
+    *,
+    status: int,
+    headers: list[tuple[bytes, bytes]],
+    keep_alive: bool,
+    server_header: bytes | None,
+    chunked: bool,
+    include_date_header: bool,
+    default_headers: list[tuple[bytes, bytes]] | None,
+    alt_svc_values: list[bytes] | None,
+) -> list[tuple[bytes, bytes]]:
+    if 100 <= status < 200:
+        if status == 103:
+            return sanitize_early_hints_headers(headers)
+        return [(bytes(k).lower(), bytes(v)) for k, v in strip_connection_specific_headers(headers)]
+
+    normalized = apply_response_header_policy(
+        headers,
+        server_header=server_header,
+        include_date_header=include_date_header,
+        default_headers=default_headers or (),
+        alt_svc_values=alt_svc_values or (),
+    )
+    if get_header(normalized, b'connection') is None:
+        normalized.append((b'connection', b'keep-alive' if keep_alive else b'close'))
+
+    if not response_allows_body(status):
+        normalized = [(k, v) for k, v in normalized if k != b'transfer-encoding']
+        if status == 204:
+            normalized = [(k, v) for k, v in normalized if k != b'content-length']
+        return normalized
+
+    if chunked and get_header(normalized, b'transfer-encoding') is None and get_header(normalized, b'content-length') is None:
+        normalized.append((b'transfer-encoding', b'chunked'))
+    return normalized
+
+
+
+HTTP11_RESPONSE_METADATA_RULES: tuple[dict[str, object], ...] = (
+    {
+        'selector': '1xx',
+        'allows_body': False,
+        'allows_transfer_encoding': False,
+        'allows_content_length': False,
+        'implicit_content_length': False,
+        'notes': 'informational responses never carry a final response body',
+    },
+    {
+        'selector': '204',
+        'allows_body': False,
+        'allows_transfer_encoding': False,
+        'allows_content_length': False,
+        'implicit_content_length': False,
+        'notes': '204 response body is always empty',
+    },
+    {
+        'selector': '304',
+        'allows_body': False,
+        'allows_transfer_encoding': False,
+        'allows_content_length': True,
+        'implicit_content_length': False,
+        'notes': '304 is bodyless but may carry representation metadata',
+    },
+    {
+        'selector': 'other-final',
+        'allows_body': True,
+        'allows_transfer_encoding': True,
+        'allows_content_length': True,
+        'implicit_content_length': True,
+        'notes': 'non-bodyless final responses may receive implicit Content-Length when fully buffered',
+    },
+)
+
+
+def http11_response_metadata_rules() -> tuple[dict[str, object], ...]:
+    return tuple(dict(entry) for entry in HTTP11_RESPONSE_METADATA_RULES)
+
+
+def serialize_http11_response_head(
+    *,
+    status: int,
+    headers: list[tuple[bytes, bytes]],
+    keep_alive: bool,
+    server_header: bytes | None = None,
+    chunked: bool = False,
+    include_date_header: bool = True,
+    default_headers: list[tuple[bytes, bytes]] | None = None,
+    alt_svc_values: list[bytes] | None = None,
+) -> bytes:
+    normalized = _normalize_response_headers(
+        status=status,
+        headers=headers,
+        keep_alive=keep_alive,
+        server_header=server_header,
+        chunked=chunked,
+        include_date_header=include_date_header,
+        default_headers=default_headers,
+        alt_svc_values=alt_svc_values,
+    )
+    status_line = b"HTTP/1.1 " + str(status).encode("ascii") + b" " + _reason(status)
+    lines = [status_line] + [k + b": " + v for k, v in normalized]
+    return b"\r\n".join(lines) + b"\r\n\r\n"
+
+
+
+def serialize_http11_response_whole(
+    *,
+    status: int,
+    headers: list[tuple[bytes, bytes]],
+    body: bytes,
+    keep_alive: bool,
+    server_header: bytes | None = None,
+    include_date_header: bool = True,
+    default_headers: list[tuple[bytes, bytes]] | None = None,
+    alt_svc_values: list[bytes] | None = None,
+) -> bytes:
+    normalized = [(k.lower(), v) for k, v in headers]
+    payload = body if response_allows_body(status) else b""
+    if response_allows_implicit_content_length(status) and get_header(normalized, b"content-length") is None:
+        normalized.append((b"content-length", str(len(payload)).encode("ascii")))
+    head = serialize_http11_response_head(
+        status=status,
+        headers=normalized,
+        keep_alive=keep_alive,
+        server_header=server_header,
+        chunked=False,
+        include_date_header=include_date_header,
+        default_headers=default_headers,
+        alt_svc_values=alt_svc_values,
+    )
+    return head + payload
+
+
+
+def serialize_http11_response_chunk(chunk: bytes) -> bytes:
+    return f"{len(chunk):X}".encode("ascii") + b"\r\n" + chunk + b"\r\n"
+
+
+
+def finalize_chunked_body(trailers: list[tuple[bytes, bytes]] | None = None) -> bytes:
+    if not trailers:
+        return b"0\r\n\r\n"
+    lines = [b"0"] + [bytes(name) + b": " + bytes(value) for name, value in trailers]
+    return b"\r\n".join(lines) + b"\r\n\r\n"

tigrcorn_protocols/http1/state.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class HTTP11ConnectionState:
+    requests_served: int = 0
+    keep_alive: bool = True

tigrcorn_protocols/http2/__init__.py

@@ -0,0 +1,16 @@
+from .codec import FrameBuffer, FrameWriter, HTTP2Frame
+from .handler import HTTP2ConnectionHandler
+from .hpack import decode_header_block, encode_header_block
+from .state import H2ConnectionState, H2StreamLifecycle, H2StreamState
+
+__all__ = [
+    "HTTP2Frame",
+    "FrameBuffer",
+    "FrameWriter",
+    "HTTP2ConnectionHandler",
+    "encode_header_block",
+    "decode_header_block",
+    "H2ConnectionState",
+    "H2StreamState",
+    "H2StreamLifecycle",
+]

tigrcorn_protocols/http2/codec.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, Mapping
+
+from tigrcorn_core.errors import ProtocolError
+from tigrcorn_core.utils.bytes import decode_u24, encode_u24, split_chunks
+
+FRAME_DATA = 0x0
+FRAME_HEADERS = 0x1
+FRAME_PRIORITY = 0x2
+FRAME_RST_STREAM = 0x3
+FRAME_SETTINGS = 0x4
+FRAME_PUSH_PROMISE = 0x5
+FRAME_PING = 0x6
+FRAME_GOAWAY = 0x7
+FRAME_WINDOW_UPDATE = 0x8
+FRAME_CONTINUATION = 0x9
+
+H2_NO_ERROR = 0x0
+H2_PROTOCOL_ERROR = 0x1
+H2_INTERNAL_ERROR = 0x2
+H2_FLOW_CONTROL_ERROR = 0x3
+H2_SETTINGS_TIMEOUT = 0x4
+H2_STREAM_CLOSED = 0x5
+H2_FRAME_SIZE_ERROR = 0x6
+H2_REFUSED_STREAM = 0x7
+H2_CANCEL = 0x8
+H2_COMPRESSION_ERROR = 0x9
+H2_CONNECT_ERROR = 0xA
+H2_ENHANCE_YOUR_CALM = 0xB
+H2_INADEQUATE_SECURITY = 0xC
+H2_HTTP_1_1_REQUIRED = 0xD
+
+FLAG_ACK = 0x1
+FLAG_END_STREAM = 0x1
+FLAG_END_HEADERS = 0x4
+FLAG_PADDED = 0x8
+FLAG_PRIORITY = 0x20
+
+SETTING_HEADER_TABLE_SIZE = 0x1
+SETTING_ENABLE_PUSH = 0x2
+SETTING_MAX_CONCURRENT_STREAMS = 0x3
+SETTING_INITIAL_WINDOW_SIZE = 0x4
+SETTING_MAX_FRAME_SIZE = 0x5
+SETTING_MAX_HEADER_LIST_SIZE = 0x6
+SETTING_ENABLE_CONNECT_PROTOCOL = 0x8
+
+DEFAULT_SETTINGS = {
+    SETTING_HEADER_TABLE_SIZE: 4096,
+    SETTING_ENABLE_PUSH: 0,
+    SETTING_MAX_CONCURRENT_STREAMS: 128,
+    SETTING_INITIAL_WINDOW_SIZE: 65535,
+    SETTING_MAX_FRAME_SIZE: 16384,
+    SETTING_MAX_HEADER_LIST_SIZE: 65536,
+    SETTING_ENABLE_CONNECT_PROTOCOL: 1,
+}
+
+
+@dataclass(slots=True)
+class HTTP2Frame:
+    frame_type: int
+    flags: int
+    stream_id: int
+    payload: bytes = b""
+
+    @property
+    def length(self) -> int:
+        return len(self.payload)
+
+
+class FrameBuffer:
+    def __init__(self) -> None:
+        self._buffer = bytearray()
+
+    def feed(self, data: bytes) -> None:
+        self._buffer.extend(data)
+
+    def pop_all(self) -> list[HTTP2Frame]:
+        frames: list[HTTP2Frame] = []
+        while len(self._buffer) >= 9:
+            length = decode_u24(self._buffer[:3])
+            total = 9 + length
+            if len(self._buffer) < total:
+                break
+            frame_type = self._buffer[3]
+            flags = self._buffer[4]
+            stream_id = int.from_bytes(self._buffer[5:9], "big") & 0x7FFFFFFF
+            payload = bytes(self._buffer[9:total])
+            del self._buffer[:total]
+            frames.append(HTTP2Frame(frame_type=frame_type, flags=flags, stream_id=stream_id, payload=payload))
+        return frames
+
+
+class FrameWriter:
+    def __init__(self, max_frame_size: int = 16384) -> None:
+        self.max_frame_size = max_frame_size
+
+    def headers(self, stream_id: int, block: bytes, *, end_stream: bool = False) -> bytes:
+        pieces = list(split_chunks(block, self.max_frame_size)) or [b""]
+        raw = bytearray()
+        for idx, piece in enumerate(pieces):
+            flags = 0
+            if idx == len(pieces) - 1:
+                flags |= FLAG_END_HEADERS
+                if end_stream:
+                    flags |= FLAG_END_STREAM
+            raw.extend(serialize_frame(FRAME_HEADERS if idx == 0 else FRAME_CONTINUATION, flags, stream_id, piece))
+        return bytes(raw)
+
+    def push_promise(self, stream_id: int, promised_stream_id: int, block: bytes) -> bytes:
+        first_capacity = max(self.max_frame_size - 4, 0)
+        first_piece = block[:first_capacity]
+        remainder = block[first_capacity:]
+        payload = (promised_stream_id & 0x7FFFFFFF).to_bytes(4, "big") + first_piece
+        if not remainder:
+            return serialize_frame(FRAME_PUSH_PROMISE, FLAG_END_HEADERS, stream_id, payload)
+        raw = bytearray()
+        raw.extend(serialize_frame(FRAME_PUSH_PROMISE, 0, stream_id, payload))
+        pieces = list(split_chunks(remainder, self.max_frame_size))
+        for idx, piece in enumerate(pieces):
+            flags = FLAG_END_HEADERS if idx == len(pieces) - 1 else 0
+            raw.extend(serialize_frame(FRAME_CONTINUATION, flags, stream_id, piece))
+        return bytes(raw)
+
+    def data(self, stream_id: int, payload: bytes, *, end_stream: bool = False) -> bytes:
+        pieces = list(split_chunks(payload, self.max_frame_size)) or [b""]
+        raw = bytearray()
+        for idx, piece in enumerate(pieces):
+            flags = FLAG_END_STREAM if idx == len(pieces) - 1 and end_stream else 0
+            raw.extend(serialize_frame(FRAME_DATA, flags, stream_id, piece))
+        return bytes(raw)
+
+
+def serialize_frame(frame_type: int, flags: int, stream_id: int, payload: bytes = b"") -> bytes:
+    if stream_id < 0 or stream_id > 0x7FFFFFFF:
+        raise ValueError("stream_id out of range")
+    header = bytearray()
+    header.extend(encode_u24(len(payload)))
+    header.append(frame_type & 0xFF)
+    header.append(flags & 0xFF)
+    header.extend((stream_id & 0x7FFFFFFF).to_bytes(4, "big"))
+    return bytes(header) + payload
+
+
+def encode_settings(settings: Mapping[int, int]) -> bytes:
+    payload = bytearray()
+    for setting_id, value in settings.items():
+        payload.extend(int(setting_id).to_bytes(2, "big"))
+        payload.extend(int(value).to_bytes(4, "big"))
+    return bytes(payload)
+
+
+def decode_settings(payload: bytes) -> dict[int, int]:
+    if len(payload) % 6 != 0:
+        raise ProtocolError("invalid SETTINGS payload length")
+    settings: dict[int, int] = {}
+    for offset in range(0, len(payload), 6):
+        key = int.from_bytes(payload[offset : offset + 2], "big")
+        value = int.from_bytes(payload[offset + 2 : offset + 6], "big")
+        if key in settings:
+            raise ProtocolError("duplicate SETTINGS parameter")
+        if key == SETTING_ENABLE_PUSH and value not in {0, 1}:
+            raise ProtocolError("ENABLE_PUSH must be 0 or 1")
+        if key == SETTING_INITIAL_WINDOW_SIZE and value > 0x7FFFFFFF:
+            raise ProtocolError("INITIAL_WINDOW_SIZE too large")
+        if key == SETTING_MAX_FRAME_SIZE and not 16_384 <= value <= 16_777_215:
+            raise ProtocolError("MAX_FRAME_SIZE out of range")
+        if key == SETTING_ENABLE_CONNECT_PROTOCOL and value not in {0, 1}:
+            raise ProtocolError("ENABLE_CONNECT_PROTOCOL must be 0 or 1")
+        settings[key] = value
+    return settings
+
+
+def serialize_settings(settings: Mapping[int, int]) -> bytes:
+    return serialize_frame(FRAME_SETTINGS, 0, 0, encode_settings(settings))
+
+
+def serialize_settings_ack() -> bytes:
+    return serialize_frame(FRAME_SETTINGS, FLAG_ACK, 0, b"")
+
+
+def serialize_window_update(stream_id: int, increment: int) -> bytes:
+    if not 1 <= increment <= 0x7FFFFFFF:
+        raise ValueError("WINDOW_UPDATE increment out of range")
+    return serialize_frame(FRAME_WINDOW_UPDATE, 0, stream_id, increment.to_bytes(4, "big"))
+
+
+def parse_window_update(payload: bytes) -> int:
+    if len(payload) != 4:
+        raise ProtocolError("WINDOW_UPDATE payload must be 4 bytes")
+    increment = int.from_bytes(payload, "big") & 0x7FFFFFFF
+    if increment <= 0:
+        raise ProtocolError("WINDOW_UPDATE increment must be positive")
+    return increment
+
+
+def serialize_ping(data: bytes, *, ack: bool = False) -> bytes:
+    if len(data) != 8:
+        raise ValueError("PING payload must be 8 bytes")
+    return serialize_frame(FRAME_PING, FLAG_ACK if ack else 0, 0, data)
+
+
+def serialize_goaway(last_stream_id: int, error_code: int = 0, debug_data: bytes = b"") -> bytes:
+    payload = bytearray()
+    payload.extend((last_stream_id & 0x7FFFFFFF).to_bytes(4, "big"))
+    payload.extend(int(error_code).to_bytes(4, "big"))
+    payload.extend(debug_data)
+    return serialize_frame(FRAME_GOAWAY, 0, 0, bytes(payload))
+
+
+def parse_goaway(payload: bytes) -> tuple[int, int, bytes]:
+    if len(payload) < 8:
+        raise ProtocolError("GOAWAY payload too short")
+    last_stream_id = int.from_bytes(payload[:4], "big") & 0x7FFFFFFF
+    error_code = int.from_bytes(payload[4:8], "big")
+    return last_stream_id, error_code, payload[8:]
+
+
+def parse_priority(payload: bytes) -> tuple[bool, int, int]:
+    if len(payload) != 5:
+        raise ProtocolError("PRIORITY payload must be 5 bytes")
+    dependency_raw = int.from_bytes(payload[:4], "big")
+    exclusive = bool(dependency_raw & 0x80000000)
+    dependency = dependency_raw & 0x7FFFFFFF
+    weight = payload[4]
+    return exclusive, dependency, weight
+
+
+def parse_push_promise(payload: bytes, flags: int) -> tuple[int, bytes]:
+    payload = strip_padding(payload, flags)
+    if len(payload) < 4:
+        raise ProtocolError("PUSH_PROMISE payload too short")
+    promised_stream_id = int.from_bytes(payload[:4], "big") & 0x7FFFFFFF
+    return promised_stream_id, payload[4:]
+
+
+def serialize_push_promise(stream_id: int, promised_stream_id: int, header_block_fragment: bytes, *, end_headers: bool = True) -> bytes:
+    flags = FLAG_END_HEADERS if end_headers else 0
+    payload = (promised_stream_id & 0x7FFFFFFF).to_bytes(4, "big") + header_block_fragment
+    return serialize_frame(FRAME_PUSH_PROMISE, flags, stream_id, payload)
+
+
+def serialize_rst_stream(stream_id: int, error_code: int = 0) -> bytes:
+    return serialize_frame(FRAME_RST_STREAM, 0, stream_id, int(error_code).to_bytes(4, "big"))
+
+
+def strip_padding(payload: bytes, flags: int) -> bytes:
+    if not (flags & FLAG_PADDED):
+        return payload
+    if not payload:
+        raise ProtocolError("PADDED frame missing pad length")
+    pad_length = payload[0]
+    body = payload[1:]
+    if pad_length > len(body):
+        raise ProtocolError("invalid padding")
+    return body[:-pad_length] if pad_length else body
+
+
+def headers_payload_fragment(payload: bytes, flags: int) -> bytes:
+    payload = strip_padding(payload, flags)
+    if flags & FLAG_PRIORITY:
+        if len(payload) < 5:
+            raise ProtocolError("HEADERS priority payload too short")
+        payload = payload[5:]
+    return payload

tigrcorn_protocols/http2/flow.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+
+from tigrcorn_protocols.http2.state import FlowWindow, MAX_FLOW_WINDOW
+
+
+@dataclass(slots=True)
+class FlowWaiter:
+    window: FlowWindow
+    _event: asyncio.Event = field(default_factory=asyncio.Event)
+
+    def __post_init__(self) -> None:
+        if self.window.available > 0:
+            self._event.set()
+
+    def notify(self) -> None:
+        if self.window.available > 0:
+            self._event.set()
+
+    async def wait(self) -> None:
+        while self.window.available <= 0:
+            self._event.clear()
+            await self._event.wait()
+
+
+def next_adaptive_window_target(current_target: int, observed_bytes: int) -> int:
+    if observed_bytes <= 0:
+        return current_target
+    threshold = max(1, current_target // 2)
+    if observed_bytes < threshold:
+        return current_target
+    proposed = max(current_target * 2, observed_bytes * 2)
+    return min(MAX_FLOW_WINDOW, proposed)