mrok 0.4.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

{mrok-0.4.6.dist-info → mrok-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrok
-Version: 0.4.6
+Version: 0.5.0
 Summary: MPT Extensions OpenZiti Orchestrator
 Author: SoftwareOne AG
 License:                                  Apache License
@@ -207,21 +207,18 @@ License:                                  Apache License
 License-File: LICENSE.txt
 Requires-Python: <4,>=3.12
 Requires-Dist: asn1crypto<2.0.0,>=1.5.1
-Requires-Dist: cachetools<7.0.0,>=6.2.2
 Requires-Dist: cryptography<46.0.0,>=45.0.7
 Requires-Dist: dynaconf<4.0.0,>=3.2.11
 Requires-Dist: fastapi-pagination<0.15.0,>=0.14.1
 Requires-Dist: fastapi[standard]<0.120.0,>=0.119.0
 Requires-Dist: gunicorn<24.0.0,>=23.0.0
 Requires-Dist: hdrhistogram<0.11.0,>=0.10.3
-Requires-Dist: httptools<0.8.0,>=0.7.1
-Requires-Dist: httpx<0.29.0,>=0.28.1
+Requires-Dist: httpcore<2.0.0,>=1.0.9
 Requires-Dist: openziti<2.0.0,>=1.3.1
 Requires-Dist: psutil<8.0.0,>=7.1.3
 Requires-Dist: pydantic<3.0.0,>=2.11.7
 Requires-Dist: pyfiglet<2.0.0,>=1.0.4
 Requires-Dist: pyjwt<3.0.0,>=2.10.1
-Requires-Dist: pytest-textual-snapshot<2.0.0,>=1.1.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.2
 Requires-Dist: pyzmq<28.0.0,>=27.1.0
 Requires-Dist: rich<15.0.0,>=14.1.0

{mrok-0.4.6.dist-info → mrok-0.5.0.dist-info}/RECORD

@@ -1,27 +1,24 @@
 mrok/__init__.py,sha256=D1PUs3KtMCqG4bFLceVNG62L3RN53NS95uSCNXpgvzs,181
 mrok/conf.py,sha256=_5Z-A5LyojQeY8J7W8C0QidsmrPl99r9qKYEoMf4kcI,840
-mrok/constants.py,sha256=65OlmploxfND686E4mt9LR9MqYn8I5k-L0H-R5KsLG8,201
-mrok/datastructures.py,sha256=gp8KF2JoNOxIRzYStVZLKL_XVDbcIVSIDnmpQo4FNt0,4067
+mrok/constants.py,sha256=UTGYqs3DgEd_SN-k0JK10ekmHVWQaaARtdh1Y-0JG_s,122
 mrok/errors.py,sha256=ruNMDFr2_0ezCGXuCG1OswCEv-bHOIzMMd02J_0ABcs,37
 mrok/logging.py,sha256=ZMWn0w4fJ-F_g-L37H_GM14BSXAIF2mFF_ougX5S7mg,2856
-mrok/master.py,sha256=XuketJZuB1YWdbTs819pjLum7Qfv232F9ZCxdwRztCQ,8340
-mrok/metrics.py,sha256=asweK_7xiV5MtkDkvbEm9Tktqrl2KHM8VflF0AkNGI0,4036
 mrok/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mrok/agent/ziticorn.py,sha256=marXGcr6CbDdiNi8V3CZJhg8YCUbKw6ySuO3-0-zf8g,900
+mrok/agent/ziticorn.py,sha256=iENhronSKhPIhXhTMj7pElaLZgeEsgEVTKp_1yMa3Dk,907
 mrok/agent/devtools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mrok/agent/devtools/__main__.py,sha256=R8ezbW7hCik5r45U3w2TgiTubg9SlbVsWA-bapILJXU,781
 mrok/agent/devtools/inspector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mrok/agent/devtools/inspector/__main__.py,sha256=HeYcRf1bjXPji2LKMPCcTU61afrRH2P1RqnFmHClRTc,524
-mrok/agent/devtools/inspector/app.py,sha256=_pzxemMqIunE5EdMq5amjqpOGsMWIOw17GgiCtRAi6Q,16464
+mrok/agent/devtools/inspector/app.py,sha256=E1WKcc5k7afq6xq_efEpOk9g5CaXmYjU1kNACZrYYyg,16486
 mrok/agent/devtools/inspector/server.py,sha256=C4uD6_1psSHMjJLUDCMPGvKdQYKaEwYTw27NAbwuuA0,636
 mrok/agent/sidecar/__init__.py,sha256=DrjJGhqFyxsVODW06KI20Wpr6HsD2lD6qFCKUXc7GIE,59
-mrok/agent/sidecar/app.py,sha256=YOQLwPPqcElbF2kU15bcw-ePzZM09eVJQZ6Z5NYg9u8,1509
-mrok/agent/sidecar/main.py,sha256=h31wynUCcFmRckvqLHtH97w1QgMv4fzcmYjhRPUobxY,1076
+mrok/agent/sidecar/app.py,sha256=8gLB9tgxzC4l6CBYB9MW9A6-v2cjJHx-xVNwAnCD7hI,2506
+mrok/agent/sidecar/main.py,sha256=m3aKhOHwIEsXDeTMynHmv41JnBIjv-QUgQ4uw1rrsDA,1068
 mrok/cli/__init__.py,sha256=mtFEa8IeS1x6Gm4dUYoSnAxyEzNqbUVSmWxtuZUMR84,61
 mrok/cli/main.py,sha256=DFcYPwDskXi8SKAgEsuP4GMFzaniIf_6bZaSDWvYKDk,2724
 mrok/cli/rich.py,sha256=P3Dyu8EArUR9_0j7DPK7LRx85TWdYdZ1SaJzD_S1ZCE,511
 mrok/cli/utils.py,sha256=m_olScdIUGks5IoC6p2F9D6CQIucWZ7LHyrvwm2bkJw,106
-mrok/cli/commands/__init__.py,sha256=jihISOj3ZZQ_dn0rogXrJOx6b283KLRUfTw9USQgAhI,134
+mrok/cli/commands/__init__.py,sha256=-UOGzh38oWX7fPeI2nc5I9z8LylRdQAt868q4G6rNGk,140
 mrok/cli/commands/admin/__init__.py,sha256=WU49jpMF9p18UONjYywWEFzjF57zLpLKJ0qAZvrzcR4,414
 mrok/cli/commands/admin/bootstrap.py,sha256=iOnHctYajgcHrG_Idjn5Y7VVSaWYRIhdgqKSw9TWq9I,1680
 mrok/cli/commands/admin/utils.py,sha256=wQ-qQJGFyhikMJY_CWT-G6sTEIZb-LUdj1AUZisLPBw,1363
@@ -45,8 +42,8 @@ mrok/cli/commands/agent/run/sidecar.py,sha256=Tj5inAeSX1E3yCVs2q4P3sP3trvvwk2lYM
 mrok/cli/commands/controller/__init__.py,sha256=2xw-YVN0akiLiuGUU3XbYyZZ0ugOjQ6XhtTkzEKSmMA,161
 mrok/cli/commands/controller/openapi.py,sha256=QLjVao9UkB2vBaGkFi_q_jrlg4Np4ldMRwDIJsrJ7A8,1175
 mrok/cli/commands/controller/run.py,sha256=yl1p7oRHhQINWWjUKlRHtMIWUCV0KsxYdyVyazhX834,2406
-mrok/cli/commands/proxy/__init__.py,sha256=Y9oluemsuWSaykDniLVsI2cyTurcEO3_GJDHgf-7BdU,120
-mrok/cli/commands/proxy/run.py,sha256=QzKAjNCib-SS8IrGGHOxDjTtgTQxfeeeqmI3LaIkiLo,1293
+mrok/cli/commands/frontend/__init__.py,sha256=0kK37yG6qs7yAa8TYlKZUA-nHrWsO4y5CjbVkXafnuk,123
+mrok/cli/commands/frontend/run.py,sha256=4w9B662_7ASWuN_skWWWXXQyTcp0G4I-FzvfjL7Yiu0,1305
 mrok/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mrok/controller/app.py,sha256=XxCIB7N1YE52vSYfvGW2UPgEEOZ9jxDMe2l9D2SfXi8,1866
 mrok/controller/auth.py,sha256=hYa0OPJ5X0beGxRP6qbxwJOVXj5TmzHjmam2OjTBKn4,2704
@@ -56,25 +53,30 @@ mrok/controller/dependencies/__init__.py,sha256=voewk6gjkA0OarL6HFmfT_RLqBns0Fpl
 mrok/controller/dependencies/conf.py,sha256=2Pa8fxJHkZ29q6UL-w6hUP_wr7WnNELfw5LlzWg1Tec,162
 mrok/controller/dependencies/ziti.py,sha256=fYoxeJb4s6p2_3gxbExbFSRabjpvp_gZMBb3ocXZV3Y,702
 mrok/controller/openapi/__init__.py,sha256=U1dw45w76CcoQagyqg_FXdMuJF3qJZZM6wG8TeTe3Zo,101
-mrok/controller/openapi/examples.py,sha256=ZI0BP7L6sI0z7Mq1I3uc2UrweGpzpPeGSIuf1bUKkgg,1419
+mrok/controller/openapi/examples.py,sha256=-Mwj41veIeydYaRSxcihN02g_jMuUrtvMfTjs08Dzf8,1852
 mrok/controller/openapi/utils.py,sha256=Kn55ISAWlMJNwrJTum7iFrBvJvr81To76pCK8W-s79Q,1114
 mrok/controller/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mrok/controller/routes/extensions.py,sha256=zoY4sNz_BIZcbly6WXM7Rbpn2jmB89njS_0xdJkoKfs,9192
 mrok/controller/routes/instances.py,sha256=v-fn_F6JHbDZ4YUNCIZzClgHp6aC1Eu5HB7k7qBG5pk,2202
-mrok/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mrok/http/config.py,sha256=k73-4hBo6jag1RpyZagJLtTCL6EQoebZaX8Vv-CMN_k,2050
-mrok/http/constants.py,sha256=ao5gI2HFBWmrdd2Yc6XFK_RGaHk-omxI4AqvfIiGes8,409
-mrok/http/forwarder.py,sha256=vAf2nh6Fmr07JdRJkK4dPHKJilP9PnsYZcroqsnilB8,13751
-mrok/http/lifespan.py,sha256=UdbOqjWZsHzJJjX0CTd2hY96Jpk5QWtdHJEzPG6Z4hQ,1288
-mrok/http/middlewares.py,sha256=SGo4EwhTId2uJx1aMuqGbNy7MXgZlDEdZI0buzBYVv0,5011
-mrok/http/pool.py,sha256=Q-pRwgYPusqEKQCwZsRQ2mnGaDfyWknWpvydUu5KtEU,7696
-mrok/http/protocol.py,sha256=ap8jbLUvgbAH81ZJZCBkQiYR7mkV_eL3rpfwEkoE8sU,392
-mrok/http/server.py,sha256=Mj7C85fc-DXp-WTBWaOd7ag808oliLmFBH5bf-G2FHg,370
-mrok/http/types.py,sha256=A82zloEqW8KdKahdNrbW5fhlJNUo2enLNRVMWIJTatA,632
-mrok/http/utils.py,sha256=sOixYu3R9-nNoMFYdifrreYvcFRIHYVtb6AAmtVzaLE,2125
-mrok/proxy/__init__.py,sha256=vWXyImroqM1Eq8e_oFPBup8VJ3reyp8SVjFTbLzRkI8,51
-mrok/proxy/app.py,sha256=VvMRmYLwsItjCcecy6ccrkk564LnArIermHTRVDxh9U,3469
-mrok/proxy/main.py,sha256=ZXpticE6J4FABaslDB_8J5qklPsf3e7xIFSZmcPAAjQ,1588
+mrok/frontend/__init__.py,sha256=SN3LoFwAye18lfJ8OKNNS-7kLc2A9OxPGIEIEYYtAOA,54
+mrok/frontend/app.py,sha256=We7z5xrbxvOuLsmWgsqfoECZ8FTWOtlw80a14g_8p9M,2632
+mrok/frontend/main.py,sha256=kaje2kfS902TNQwwKn12WEr4N7hKHPg_NwczXAdplwY,1445
+mrok/proxy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mrok/proxy/app.py,sha256=mqb07evKlGUzgqEy-LMzjyeIg1VjUFu83pZeBA4zVyM,5976
+mrok/proxy/backend.py,sha256=T8DDA733CqbFWp5lrf_tKQK_VDgcERKTfesvxofl3AY,1493
+mrok/proxy/config.py,sha256=aUTx0-dNAT7U0UEp5bX7-IO7p3HS082QUocAVq2NUWk,2053
+mrok/proxy/constants.py,sha256=ao5gI2HFBWmrdd2Yc6XFK_RGaHk-omxI4AqvfIiGes8,409
+mrok/proxy/datastructures.py,sha256=SDwhWpJTJrwK9hamHb_Og5PxKXG6VGOwVeoPxtaQLnU,5173
+mrok/proxy/exceptions.py,sha256=61OhdihQNdnBUqAI9mbBkXD1yWg-6Eftk7EhWCU1VF0,642
+mrok/proxy/lifespan.py,sha256=9qevhD_5Y0f8fGTh2axdfWx7v1K4vnWtiUNyJLesOHE,262
+mrok/proxy/master.py,sha256=Houudf2eYZkP5Ri8JtmFeIlWtMuTvybpPaMeIPNyLRg,8484
+mrok/proxy/metrics.py,sha256=NPhEbHoRdZ7YLKJPxmLc-sCFmos_L0iZwO0ufUs4SNg,3654
+mrok/proxy/middlewares.py,sha256=XHOSQPCXAqUWU2lg1iNkIfTWcfCOJrhEJ_bhVpX-ToQ,5504
+mrok/proxy/protocol.py,sha256=ap8jbLUvgbAH81ZJZCBkQiYR7mkV_eL3rpfwEkoE8sU,392
+mrok/proxy/server.py,sha256=Mj7C85fc-DXp-WTBWaOd7ag808oliLmFBH5bf-G2FHg,370
+mrok/proxy/streams.py,sha256=KxiEFiyAWlFQ7t-t8PZHfDveysBk4Wjo2La-aL7XghQ,1371
+mrok/proxy/types.py,sha256=oET5CXqcBvk4kf_giNojZ9kfF5wygy3Z-MvcDd38LMU,555
+mrok/proxy/utils.py,sha256=OxX6pJv_Wh_KgWx95YeJ3YeuSgwm2tsd00897P3fxys,2126
 mrok/ziti/__init__.py,sha256=20OWMiexRhOovZOX19zlX87-V78QyWnEnSZfyAftUdE,263
 mrok/ziti/api.py,sha256=KvGiT9d4oSgC3JbFWLDQyuHcLX2HuZJoJ8nHmWtCDkY,16154
 mrok/ziti/bootstrap.py,sha256=QIDhlkIxPW2QRuumFq2D1WDbD003P5f3z24pAUsyeBI,2696
@@ -83,8 +85,8 @@ mrok/ziti/errors.py,sha256=yYCbVDwktnR0AYduqtynIjo73K3HOhIrwA_vQimvEd4,368
 mrok/ziti/identities.py,sha256=1BcwfqAJHMBhc3vRaf0aLaIkoHskj5Xe2Lsq2lO9Vs8,6735
 mrok/ziti/pki.py,sha256=o2tySqHC8-7bvFuI2Tqxg9vX6H6ZSxWxfP_9x29e19M,1954
 mrok/ziti/services.py,sha256=zR1PEBYwXVou20iJK4euh0ZZFAo9UB8PZk8f6SDmiUE,3194
-mrok-0.4.6.dist-info/METADATA,sha256=Io64noW9WGLw9asC4xjeuLS7Wh8bFefufJmTjUK8Syo,15836
-mrok-0.4.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mrok-0.4.6.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
-mrok-0.4.6.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
-mrok-0.4.6.dist-info/RECORD,,
+mrok-0.5.0.dist-info/METADATA,sha256=-rLLRvaOAveuVDJR_ZLNWohgU9EdIM1jgrnH6LoqgHc,15705
+mrok-0.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mrok-0.5.0.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
+mrok-0.5.0.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
+mrok-0.5.0.dist-info/RECORD,,

mrok/http/forwarder.py

@@ -1,354 +0,0 @@
-import abc
-import asyncio
-import logging
-from contextlib import AbstractAsyncContextManager
-
-from mrok.http.types import ASGIReceive, ASGISend, Scope, StreamPair
-
-logger = logging.getLogger("mrok.proxy")
-
-
-class BackendSelectionError(Exception):
-    def __init__(self, status: int = 500, message: str = "Internal Server Error"):
-        self.status = status
-        self.message = message
-
-
-class InvalidBackendError(BackendSelectionError):
-    def __init__(self):
-        super().__init__(status=502, message="Bad Gateway")
-
-
-class BackendUnavailableError(BackendSelectionError):
-    def __init__(self):
-        super().__init__(status=503, message="Service Unavailable")
-
-
-class ForwardAppBase(abc.ABC):
-    """Generic HTTP forwarder base class.
-
-    Subclasses must implement `select_backend(scope)` to return an
-    (asyncio.StreamReader, asyncio.StreamWriter) pair connected to the
-    desired backend. The base class implements the HTTP/1.1 framing
-    and streaming logic (requests and responses).
-    """
-
-    def __init__(
-        self,
-        read_chunk_size: int = 65536,
-        lifespan_timeout: float = 10.0,
-    ) -> None:
-        self._read_chunk_size: int = int(read_chunk_size)
-        self._lifespan_timeout = lifespan_timeout
-
-    async def handle_lifespan(self, receive: ASGIReceive, send: ASGISend) -> None:
-        while True:
-            event = await receive()
-            etype = event.get("type")
-
-            if etype == "lifespan.startup":
-                try:
-                    await asyncio.wait_for(self.startup(), self._lifespan_timeout)
-                except TimeoutError:
-                    logger.exception("Lifespan startup timed out")
-                    await send({"type": "lifespan.startup.failed", "message": "startup timeout"})
-                    continue
-                except Exception as e:
-                    logger.exception("Exception during lifespan startup")
-                    await send({"type": "lifespan.startup.failed", "message": str(e)})
-                    continue
-                await send({"type": "lifespan.startup.complete"})
-
-            elif etype == "lifespan.shutdown":
-                try:
-                    await asyncio.wait_for(self.shutdown(), self._lifespan_timeout)
-                except TimeoutError:
-                    logger.exception("Lifespan shutdown timed out")
-                    await send({"type": "lifespan.shutdown.failed", "message": "shutdown timeout"})
-                    return
-                except Exception as exc:
-                    logger.exception("Exception during lifespan shutdown")
-                    await send({"type": "lifespan.shutdown.failed", "message": str(exc)})
-                    return
-                await send({"type": "lifespan.shutdown.complete"})
-                return
-
-    async def startup(self):
-        return
-
-    async def shutdown(self):
-        return
-
-    @abc.abstractmethod
-    def select_backend(
-        self, scope: Scope, headers: dict[str, str]
-    ) -> AbstractAsyncContextManager[StreamPair]:
-        raise NotImplementedError()
-
-    async def __call__(self, scope: Scope, receive: ASGIReceive, send: ASGISend) -> None:
-        """ASGI callable entry point.
-
-        Delegates to smaller helper methods for readability. Subclasses only
-        need to implement backend selection.
-        """
-        scope_type = scope.get("type")
-        if scope_type == "lifespan":
-            await self.handle_lifespan(receive, send)
-            return
-
-        if scope.get("type") != "http":
-            await send({"type": "http.response.start", "status": 500, "headers": []})
-            await send({"type": "http.response.body", "body": b"Unsupported"})
-            return
-
-        method = scope.get("method", "GET")
-        path_qs = self.format_path(scope)
-
-        headers = list(scope.get("headers", []))
-        headers = self.ensure_host_header(headers, scope)
-        try:
-            async with self.select_backend(
-                scope, {k[0].decode().lower(): k[1].decode() for k in headers}
-            ) as (reader, writer):
-                if not (reader and writer):
-                    await send({"type": "http.response.start", "status": 502, "headers": []})
-                    await send({"type": "http.response.body", "body": b"Bad Gateway"})
-                    return
-
-                use_chunked = self.ensure_chunked_if_needed(headers)
-
-                await self.write_request_line_and_headers(writer, method, path_qs, headers)
-
-                await self.stream_request_body(receive, writer, use_chunked)
-
-                status_line = await reader.readline()
-                if not status_line:
-                    await send({"type": "http.response.start", "status": 502, "headers": []})
-                    await send({"type": "http.response.body", "body": b"Bad Gateway"})
-                    return
-
-                status, headers_out, raw_headers = await self.read_status_and_headers(
-                    reader, status_line
-                )
-
-                await send(
-                    {"type": "http.response.start", "status": status, "headers": headers_out}
-                )
-
-                await self.stream_response_body(reader, send, raw_headers)
-        except BackendSelectionError as bse:
-            await send({"type": "http.response.start", "status": bse.status, "headers": []})
-            await send({"type": "http.response.body", "body": bse.message.encode()})
-            return
-
-    def format_path(self, scope: Scope) -> str:
-        raw_path = scope.get("raw_path")
-        if raw_path:
-            return raw_path.decode()
-        q = scope.get("query_string", b"")
-        path = scope.get("path", "/")
-        path_qs = path
-        if q:
-            path_qs += "?" + q.decode()
-        return path_qs
-
-    def ensure_host_header(
-        self, headers: list[tuple[bytes, bytes]], scope: Scope
-    ) -> list[tuple[bytes, bytes]]:
-        if any(n.lower() == b"host" for n, _ in headers):
-            return headers
-        server = scope.get("server")
-        if server:
-            host = f"{server[0]}:{server[1]}" if server[1] else server[0]
-            headers.append((b"host", host.encode()))
-        return headers
-
-    def ensure_chunked_if_needed(self, headers: list[tuple[bytes, bytes]]) -> bool:
-        has_content_length = any(n.lower() == b"content-length" for n, _ in headers)
-        has_transfer_encoding = any(n.lower() == b"transfer-encoding" for n, _ in headers)
-        if not has_content_length and not has_transfer_encoding:
-            headers.append((b"transfer-encoding", b"chunked"))
-            return True
-        return False
-
-    async def write_request_line_and_headers(
-        self,
-        writer: asyncio.StreamWriter,
-        method: str,
-        path_qs: str,
-        headers: list[tuple[bytes, bytes]],
-    ) -> None:
-        writer.write(f"{method} {path_qs} HTTP/1.1\r\n".encode())
-        for name, value in headers:
-            if name.lower() == b"expect":
-                continue
-            writer.write(name + b": " + value + b"\r\n")
-        writer.write(b"\r\n")
-        await writer.drain()
-
-    async def stream_request_body(
-        self, receive: ASGIReceive, writer: asyncio.StreamWriter, use_chunked: bool
-    ) -> None:
-        if use_chunked:
-            await self.stream_request_chunked(receive, writer)
-            return
-
-        await self.stream_request_until_end(receive, writer)
-
-    async def stream_request_chunked(
-        self, receive: ASGIReceive, writer: asyncio.StreamWriter
-    ) -> None:
-        """Send request body to backend using HTTP/1.1 chunked encoding."""
-        while True:
-            event = await receive()
-            if event["type"] == "http.request":
-                body = event.get("body", b"") or b""
-                if body:
-                    writer.write(f"{len(body):X}\r\n".encode())
-                    writer.write(body)
-                    writer.write(b"\r\n")
-                    await writer.drain()
-                if not event.get("more_body", False):
-                    break
-            elif event["type"] == "http.disconnect":
-                return
-
-        writer.write(b"0\r\n\r\n")
-        await writer.drain()
-
-    async def stream_request_until_end(
-        self, receive: ASGIReceive, writer: asyncio.StreamWriter
-    ) -> None:
-        """Send request body to backend when content length/transfer-encoding
-        already provided (no chunking).
-        """
-        while True:
-            event = await receive()
-            if event["type"] == "http.request":
-                body = event.get("body", b"") or b""
-                if body:
-                    writer.write(body)
-                    await writer.drain()
-                if not event.get("more_body", False):
-                    break
-            elif event["type"] == "http.disconnect":
-                return
-
-    async def read_status_and_headers(
-        self, reader: asyncio.StreamReader, first_line: bytes
-    ) -> tuple[int, list[tuple[bytes, bytes]], dict[bytes, bytes]]:
-        parts = first_line.decode(errors="ignore").split(" ", 2)
-        status = int(parts[1]) if len(parts) >= 2 and parts[1].isdigit() else 502
-        headers: list[tuple[bytes, bytes]] = []
-        raw_headers: dict[bytes, bytes] = {}
-        while True:
-            line = await reader.readline()
-            if line in (b"\r\n", b"\n", b""):
-                break
-            i = line.find(b":")
-            if i == -1:
-                continue
-            name = line[:i].strip().lower()
-            value = line[i + 1 :].strip()
-            headers.append((name, value))
-            raw_headers[name] = value
-
-        return status, headers, raw_headers
-
-    def is_chunked(self, te_value: bytes) -> bool:
-        """Return True if transfer-encoding header tokens include 'chunked'."""
-        if not te_value:
-            return False
-        # split on commas, strip spaces and check tokens
-        tokens = [t.strip() for t in te_value.split(b",")]
-        return any(t.lower() == b"chunked" for t in tokens)
-
-    def parse_content_length(self, cl_value: bytes | None) -> int | None:
-        """Parse Content-Length header value to int, or return None if invalid."""
-        if cl_value is None:
-            return None
-        try:
-            return int(cl_value)
-        except Exception:
-            return None
-
-    async def drain_trailers(self, reader: asyncio.StreamReader) -> None:
-        """Consume trailer header lines until an empty line is encountered."""
-        while True:
-            trailer = await reader.readline()
-            if trailer in (b"\r\n", b"\n", b""):
-                break
-
-    async def stream_response_chunked(self, reader: asyncio.StreamReader, send: ASGISend) -> None:
-        """Read chunked-encoded response from reader, decode and forward to ASGI send."""
-        while True:
-            size_line = await reader.readline()
-            if not size_line:
-                break
-            size_str = size_line.split(b";", 1)[0].strip()
-            try:
-                size = int(size_str, 16)
-            except Exception:
-                break
-            if size == 0:
-                # consume trailers
-                await self.drain_trailers(reader)
-                break
-            try:
-                chunk = await reader.readexactly(size)
-            except Exception:
-                break
-            # consume the CRLF after the chunk
-            try:
-                await reader.readexactly(2)
-            except Exception:
-                logger.warning("failed to read CRLF after chunk from backend")
-            await send({"type": "http.response.body", "body": chunk, "more_body": True})
-
-        await send({"type": "http.response.body", "body": b"", "more_body": False})
-
-    async def stream_response_with_content_length(
-        self, reader: asyncio.StreamReader, send: ASGISend, content_length: int
-    ) -> None:
-        """Read exactly content_length bytes and forward to ASGI send events."""
-        remaining = content_length
-        sent_final = False
-        while remaining > 0:
-            to_read = min(self._read_chunk_size, remaining)
-            chunk = await reader.read(to_read)
-            if not chunk:
-                break
-            remaining -= len(chunk)
-            more = remaining > 0
-            await send({"type": "http.response.body", "body": chunk, "more_body": more})
-            if not more:
-                sent_final = True
-
-        if not sent_final:
-            await send({"type": "http.response.body", "body": b"", "more_body": False})
-
-    async def stream_response_until_eof(self, reader: asyncio.StreamReader, send: ASGISend) -> None:
-        """Read from reader until EOF and forward chunks to ASGI send events."""
-        while True:
-            chunk = await reader.read(self._read_chunk_size)
-            if not chunk:
-                break
-            await send({"type": "http.response.body", "body": chunk, "more_body": True})
-        await send({"type": "http.response.body", "body": b"", "more_body": False})
-
-    async def stream_response_body(
-        self, reader: asyncio.StreamReader, send: ASGISend, raw_headers: dict[bytes, bytes]
-    ) -> None:
-        te = raw_headers.get(b"transfer-encoding", b"").lower()
-        cl = raw_headers.get(b"content-length")
-
-        if self.is_chunked(te):
-            await self.stream_response_chunked(reader, send)
-            return
-
-        content_length = self.parse_content_length(cl)
-        if content_length is not None:
-            await self.stream_response_with_content_length(reader, send, content_length)
-            return
-
-        await self.stream_response_until_eof(reader, send)

mrok/http/lifespan.py

@@ -1,39 +0,0 @@
-import logging
-from collections.abc import Awaitable, Callable
-
-from uvicorn.config import Config
-from uvicorn.lifespan.on import LifespanOn
-
-AsyncCallback = Callable[[], Awaitable[None]]
-
-
-class MrokLifespan(LifespanOn):
-    def __init__(self, config: Config) -> None:
-        super().__init__(config)
-        self.logger = logging.getLogger("mrok.proxy")
-
-
-class LifespanWrapper:
-    def __init__(
-        self, app, on_startup: AsyncCallback | None = None, on_shutdown: AsyncCallback | None = None
-    ):
-        self.app = app
-        self.on_startup = on_startup
-        self.on_shutdown = on_shutdown
-
-    async def __call__(self, scope, receive, send):
-        if scope["type"] == "lifespan":
-            while True:
-                event = await receive()
-                if event["type"] == "lifespan.startup":
-                    if self.on_startup:
-                        await self.on_startup()
-                    await send({"type": "lifespan.startup.complete"})
-
-                elif event["type"] == "lifespan.shutdown":
-                    if self.on_shutdown:
-                        await self.on_shutdown()
-                    await send({"type": "lifespan.shutdown.complete"})
-                    break
-        else:
-            await self.app(scope, receive, send)