Home /Modules/http-2.0/h21_flow.py

h21_flow.py

http-2.0/h21_flow.py · 169 line(s) · py

"""Strict Python reference for SLeeLa HTTP 2.1 application envelopes.
The current native server uses HTTP/1.x transport; this is not IETF HTTP/2.
"""
from __future__ import annotations
from dataclasses import dataclass
from enum import IntEnum
from typing import Callable, Dict, Tuple

ENVELOPE_VERSION=2
MAX_PAYLOAD=4096
MAX_SERVICES=64
MAX_OPS_PER_SERVICE=64
MAX_NAME_BYTES=63
KNOWN_FLAGS=0x0B

class Flag(IntEnum):
    NONE=0x00
    BINARY=0x01
    COMPRESSED=0x02
    IDEMPOTENT=0x08
class Status(IntEnum):
    OK=0
    APP_ERROR=1
    UNKNOWN_SERVICE=2
    UNKNOWN_OPERATION=3
    BAD_ENVELOPE=4
    TOO_LARGE=5
    RETRY_DENIED=6
class RetryClass(IntEnum):
    READ=0
    IDEMPOTENT=1
    MUTATING=2

def _uint(value, maximum, label):
    if isinstance(value,bool) or not isinstance(value,int) or not 0<=value<=maximum:
        raise ValueError("invalid "+label)
    return value

def _name(value,label):
    if not isinstance(value,str): raise ValueError("invalid "+label)
    raw=value.encode("utf-8","strict")
    if not raw or len(raw)>MAX_NAME_BYTES or any(b<0x21 or b==0x7f for b in raw):
        raise ValueError("invalid "+label)
    return value

def _text_parts(wire,prefix,field_count):
    if not isinstance(wire,bytes): raise ValueError("wire must be bytes")
    colon=wire.find(b":")
    if colon<0 or colon>127: raise ValueError("malformed header")
    try: header=wire[:colon].decode("ascii")
    except UnicodeDecodeError as exc: raise ValueError("non-ASCII header") from exc
    parts=header.split(" ")
    if len(parts)!=field_count or parts[0]!=prefix or any(not p for p in parts):
        raise ValueError("malformed header")
    tail=wire[colon+1:]
    if tail.endswith(b"\n"): tail=tail[:-1]
    return parts[1:],tail

@dataclass
class Envelope:
    service_id:int
    op_id:int
    request_id:int
    payload:bytes=b""
    flags:int=Flag.NONE
    version:int=ENVELOPE_VERSION
    def pack_text(self):
        _uint(self.version,255,"version")
        if self.version!=ENVELOPE_VERSION: raise ValueError("unsupported version")
        _uint(self.flags,255,"flags")
        if self.flags & ~KNOWN_FLAGS: raise ValueError("unknown flags")
        _uint(self.service_id,0xffffffff,"service id")
        _uint(self.op_id,0xffffffff,"operation id")
        _uint(self.request_id,0xffffffffffffffff,"request id")
        if not isinstance(self.payload,bytes) or len(self.payload)>MAX_PAYLOAD:
            raise ValueError("payload too large or not bytes")
        head=(f"H21 {self.version} {self.flags} {self.service_id} {self.op_id} "
              f"{self.request_id} {len(self.payload)}:").encode("ascii")
        return head+self.payload+b"\n"
    @staticmethod
    def unpack_text(wire):
        fields,payload=_text_parts(wire,"H21",7)
        ver,flags,sid,oid,rid,plen=fields
        if not all(v.isascii() and v.isdecimal() for v in fields):
            raise ValueError("numeric fields must be unsigned decimal")
        n=int(plen)
        if n>MAX_PAYLOAD or len(payload)!=n: raise ValueError("payload length mismatch")
        env=Envelope(int(sid),int(oid),int(rid),payload,int(flags),int(ver))
        env.pack_text()
        return env

@dataclass
class Response:
    status:Status
    request_id:int
    result:bytes=b""
    def pack_text(self):
        try: status=Status(self.status)
        except (ValueError,TypeError) as exc: raise ValueError("invalid status") from exc
        _uint(self.request_id,0xffffffffffffffff,"request id")
        if not isinstance(self.result,bytes) or len(self.result)>MAX_PAYLOAD:
            raise ValueError("result too large or not bytes")
        return f"H21R {int(status)} {self.request_id} {len(self.result)}:".encode("ascii")+self.result+b"\n"
    @staticmethod
    def unpack_text(wire):
        fields,result=_text_parts(wire,"H21R",4)
        status,rid,rlen=fields
        if not all(v.isascii() and v.isdecimal() for v in fields):
            raise ValueError("numeric fields must be unsigned decimal")
        n=int(rlen)
        if n>MAX_PAYLOAD or len(result)!=n: raise ValueError("result length mismatch")
        return Response(Status(int(status)),int(rid),result)

Handler=Callable[[bytes,object],Tuple[Status,bytes]]
class Naming:
    def __init__(self):
        self._services:Dict[str,int]={}
        self._ops:Dict[Tuple[int,str],int]={}
        self._next_service=1
    def intern_service(self,name):
        name=_name(name,"service name")
        if name in self._services: return self._services[name]
        if len(self._services)>=MAX_SERVICES: return 0
        sid=self._next_service; self._next_service+=1; self._services[name]=sid
        return sid
    def intern_op(self,service,op):
        sid=self.intern_service(service)
        if not sid:return 0
        op=_name(op,"operation name"); key=(sid,op)
        if key in self._ops:return self._ops[key]
        count=sum(1 for service_id,_ in self._ops if service_id==sid)
        if count>=MAX_OPS_PER_SERVICE:return 0
        self._ops[key]=count+1
        return count+1

class Pipeline:
    def __init__(self):
        self.naming=Naming()
        self._handlers:Dict[Tuple[int,int],Tuple[RetryClass,Handler,object]]={}
        self.requests_handled=0
    def register(self,service,op,retry,handler,ctx=None):
        if not callable(handler):raise ValueError("handler must be callable")
        try: retry=RetryClass(retry)
        except (ValueError,TypeError) as exc: raise ValueError("invalid retry class") from exc
        sid=self.naming.intern_service(service)
        oid=self.naming.intern_op(service,op) if sid else 0
        if not sid or not oid:raise ValueError("naming capacity or name validation failed")
        self._handlers[(sid,oid)]=(retry,handler,ctx)
        return sid,oid
    def dispatch(self,env):
        binding=self._handlers.get((env.service_id,env.op_id))
        if binding is None:
            known=env.service_id in self.naming._services.values()
            return Response(Status.UNKNOWN_OPERATION if known else Status.UNKNOWN_SERVICE,env.request_id)
        _,handler,ctx=binding
        try:
            status,result=handler(env.payload,ctx); status=Status(status)
            if not isinstance(result,bytes) or len(result)>MAX_PAYLOAD:
                return Response(Status.TOO_LARGE,env.request_id)
            response=Response(status,env.request_id,result)
        except Exception:
            response=Response(Status.APP_ERROR,env.request_id)
        self.requests_handled+=1
        return response
    def handle_wire(self,wire):
        try: response=self.dispatch(Envelope.unpack_text(wire))
        except (ValueError,UnicodeError,OverflowError): response=Response(Status.BAD_ENVELOPE,0)
        return response.pack_text()