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

mrok/ziti/identities.py

@@ -5,8 +5,9 @@ from typing import Any
 import jwt
 
 from mrok.conf import Settings
+from mrok.types.ziti import Tags
 from mrok.ziti import pki
-from mrok.ziti.api import TagsType, ZitiClientAPI, ZitiManagementAPI
+from mrok.ziti.api import ZitiClientAPI, ZitiManagementAPI
 from mrok.ziti.constants import (
     MROK_IDENTITY_TYPE_TAG_NAME,
     MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE,
@@ -29,7 +30,7 @@ async def register_identity(
     client_api: ZitiClientAPI,
     service_external_id: str,
     identity_external_id: str,
-    tags: TagsType | None = None,
+    tags: Tags | None = None,
 ):
     service_name = service_external_id.lower()
     identity_tags = copy.copy(tags or {})
@@ -39,7 +40,7 @@ async def register_identity(
     if not service:
         raise ServiceNotFoundError(f"A service with name `{service_external_id}` does not exists.")
 
-    identity_name = f"{identity_external_id.lower()}.{service_name}"
+    identity_name = identity_external_id.lower()
     service_policy_name = f"{identity_name}:bind"
     self_service_policy_name = f"self.{service_policy_name}"
 
@@ -129,7 +130,7 @@ async def enroll_proxy_identity(
     mgmt_api: ZitiManagementAPI,
     client_api: ZitiClientAPI,
     identity_name: str,
-    tags: TagsType | None = None,
+    tags: Tags | None = None,
 ):
     identity = await mgmt_api.search_identity(identity_name)
     if identity:

mrok/ziti/services.py

@@ -2,7 +2,8 @@ import logging
 from typing import Any
 
 from mrok.conf import Settings
-from mrok.ziti.api import TagsType, ZitiManagementAPI
+from mrok.types.ziti import Tags
+from mrok.ziti.api import ZitiManagementAPI
 from mrok.ziti.errors import (
     ConfigTypeNotFoundError,
     ProxyIdentityNotFoundError,
@@ -14,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 
 async def register_service(
-    settings: Settings, mgmt_api: ZitiManagementAPI, external_id: str, tags: TagsType | None
+    settings: Settings, mgmt_api: ZitiManagementAPI, external_id: str, tags: Tags | None
 ) -> dict[str, Any]:
     service_name = external_id.lower()
     registered = False

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrok
-Version: 0.4.6
+Version: 0.6.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.6.0.dist-info}/RECORD

@@ -1,30 +1,27 @@
 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=eHUYs9QaSp35rBzYHRV-SrYxF5ySyECaQg7U-XbdINE,1025
 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=rmfm0GVz_iZ_tqne6E966D2He5QVprO2g7PHFrnjG0U,16484
 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=sPQqjnwETRQk0cj8hAxSVUDCkYqsVZCS6ixEqkcGY5A,2534
+mrok/agent/sidecar/main.py,sha256=jeJzrCbltfXOYsKSCjcw8h5lxh4_bGT87kCC5dV4kYU,2190
 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
+mrok/cli/commands/admin/bootstrap.py,sha256=9ADSeiVbFAZXh6GxHEf9h2g_XHGOIlMmg1rgsxMfdow,1699
+mrok/cli/commands/admin/utils.py,sha256=Z7YTAFZKOi6nkw2oX4rJoGoUD41RYL3AOqEDhlV3jR0,1357
 mrok/cli/commands/admin/list/__init__.py,sha256=kjCMcpn1gopcrQaaHxfFh8Kyngldepnle8R2br5dJ_0,195
 mrok/cli/commands/admin/list/extensions.py,sha256=16fhDB5ucL8su2WQnSaQ1E6MhgC4vkP9-nuHAcPpzyE,4405
 mrok/cli/commands/admin/list/instances.py,sha256=kaqeyidwUxgYqfaHXqp2m76rm5h2ErBsYyZcNeaBRwY,5912
@@ -41,50 +38,57 @@ mrok/cli/commands/agent/dev/console.py,sha256=rrKAGoKXVQQBOC75H0JSuX1sYyvc2QSrV-
 mrok/cli/commands/agent/dev/web.py,sha256=O9dYk-o1FV2E_sKLOezdEmLsnexwbJNDdsYL5pATZRQ,1028
 mrok/cli/commands/agent/run/__init__.py,sha256=E_IJCl3BfMffqFASe8gzJwhhQgt5bQfjhuyekVwdEBA,164
 mrok/cli/commands/agent/run/asgi.py,sha256=dCgzwJtTLv2eyEIP7v1tDfe_PrFBS02SfN5dSDw1Jzg,2054
-mrok/cli/commands/agent/run/sidecar.py,sha256=Tj5inAeSX1E3yCVs2q4P3sP3trvvwk2lYMSUtyFfxo8,2098
+mrok/cli/commands/agent/run/sidecar.py,sha256=UOewegTLFwAZ70VFJb6_9kV0LmsvnXuq-yqgrMlTeZo,4182
 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=_X1ylMe4-YCTghsu0XY-PB4nk3PL-PQq9YIgbkgJok8,2796
 mrok/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mrok/controller/app.py,sha256=XxCIB7N1YE52vSYfvGW2UPgEEOZ9jxDMe2l9D2SfXi8,1866
 mrok/controller/auth.py,sha256=hYa0OPJ5X0beGxRP6qbxwJOVXj5TmzHjmam2OjTBKn4,2704
 mrok/controller/pagination.py,sha256=raYpYa34q8Ckl4BXBOEdpWlKkFj6z7e6QLWr2HT7dzI,2187
-mrok/controller/schemas.py,sha256=AaF8_bEwZTHM02apVEBAzlUb2t71zoxYaG-VHtPNeMk,1705
+mrok/controller/schemas.py,sha256=PZPEsSJNrGSuplfjCPF_E-VJ721AzgR1Jj8P-Shw1cg,1699
 mrok/controller/dependencies/__init__.py,sha256=voewk6gjkA0OarL6HFmfT_RLqBns0Fpl-VIqK5xVAEI,202
 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=I2cvEI2ZGhbeazFhF6LavxBYywsv-4QkuNxCDo6-dkA,2627
+mrok/frontend/main.py,sha256=0KtchIGLn70A_Oxekmhr_qSYUg5QqIMfrdYcyFdpj9s,1717
+mrok/proxy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mrok/proxy/app.py,sha256=flnVPoUO3pSF3b0nYFBhKjZ9jp5ljijo2a-5e37gACs,6016
+mrok/proxy/asgi.py,sha256=2uw5bLquyUsiYlNwq8RhJd8OqVvSJDvYjzOVGLLB3Cs,3528
+mrok/proxy/backend.py,sha256=dRmIUJin2DM3PUxrVX0j4t1oB6DOX7N9JV2lIcopE38,1649
+mrok/proxy/constants.py,sha256=ao5gI2HFBWmrdd2Yc6XFK_RGaHk-omxI4AqvfIiGes8,409
+mrok/proxy/event_publisher.py,sha256=TAuwEqIhRYxgazJFgC3DekwUAXlJ2UFjbdx_A9vwA1g,2511
+mrok/proxy/exceptions.py,sha256=61OhdihQNdnBUqAI9mbBkXD1yWg-6Eftk7EhWCU1VF0,642
+mrok/proxy/master.py,sha256=HB2q_nPLim23z0mGDGKs_RshhGVAO8VgOYP4hA__zC4,6891
+mrok/proxy/metrics.py,sha256=Sg2aIiaj9fzkyu190YCsJvNn5P-XLun3BcvuVBsdWbA,3640
+mrok/proxy/middleware.py,sha256=St8r2hY5vfn4q5FtuqeI85tVmSZmC6Vkbecpx_iX6SM,4455
+mrok/proxy/models.py,sha256=CA520bqexPwYUHDrkg58OXAyzBIKQSU9i-SlymU_vt0,5188
+mrok/proxy/stream.py,sha256=7V-bSAF9uNV1yVHKaEhHo95WxafSGWkyHPVABZX0djY,2134
+mrok/proxy/utils.py,sha256=OxX6pJv_Wh_KgWx95YeJ3YeuSgwm2tsd00897P3fxys,2126
+mrok/proxy/worker.py,sha256=uEUC2Hbx0YQiDMFNZfwkHMDnijN96b6iRoIErfI21Tg,1921
+mrok/proxy/ziticorn.py,sha256=YwbyNUK-TL3dANntM6gtlP9Su39QvDCC0dSbuZisXIo,2873
+mrok/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mrok/types/proxy.py,sha256=40Yds4tUykMpzsoQbMtHG85r8xtm5Q3fQZ17bp7cDiM,818
+mrok/types/ziti.py,sha256=EeQnTbDEJ-Y-KMS6zu1Xjxb58Up2VxUwqzUwy3H28JY,36
 mrok/ziti/__init__.py,sha256=20OWMiexRhOovZOX19zlX87-V78QyWnEnSZfyAftUdE,263
-mrok/ziti/api.py,sha256=KvGiT9d4oSgC3JbFWLDQyuHcLX2HuZJoJ8nHmWtCDkY,16154
-mrok/ziti/bootstrap.py,sha256=QIDhlkIxPW2QRuumFq2D1WDbD003P5f3z24pAUsyeBI,2696
+mrok/ziti/api.py,sha256=ikl3l446Gu-YZuJJFRHFSBpKhh5KJxmk-Jr4YbSrqbk,16072
+mrok/ziti/bootstrap.py,sha256=PRZlYDtcGbix-1bQDuJ4wX4dy845VAx9SFPotc4BCeg,2715
 mrok/ziti/constants.py,sha256=Urq1X3bCBQZfw8NbnEa1pqmY4oq1wmzkwPfzam3kbTw,339
 mrok/ziti/errors.py,sha256=yYCbVDwktnR0AYduqtynIjo73K3HOhIrwA_vQimvEd4,368
-mrok/ziti/identities.py,sha256=1BcwfqAJHMBhc3vRaf0aLaIkoHskj5Xe2Lsq2lO9Vs8,6735
+mrok/ziti/identities.py,sha256=9BIBQOirvcdAkRFNqZPTOkC8kvDQbq6EgaQMq22NQsQ,6730
 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/ziti/services.py,sha256=TukG0vAZxgjbS8OLiyg7u1GwuVeGTco-rb9ne6a4PUA,3213
+mrok-0.6.0.dist-info/METADATA,sha256=0z3llP3xsGv5I-CZANA3tA9rhqNQ9sgH2j2sdLX5z7A,15705
+mrok-0.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mrok-0.6.0.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
+mrok-0.6.0.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
+mrok-0.6.0.dist-info/RECORD,,

mrok/cli/commands/proxy/run.py

@@ -1,49 +0,0 @@
-from pathlib import Path
-from typing import Annotated
-
-import typer
-
-from mrok import proxy
-from mrok.cli.utils import number_of_workers
-
-default_workers = number_of_workers()
-
-
-def register(app: typer.Typer) -> None:
-    @app.command("run")
-    def run_proxy(
-        ctx: typer.Context,
-        identity_file: Path = typer.Argument(
-            ...,
-            help="Identity json file",
-        ),
-        host: Annotated[
-            str,
-            typer.Option(
-                "--host",
-                "-h",
-                help="Host to bind to. Default: 127.0.0.1",
-                show_default=True,
-            ),
-        ] = "127.0.0.1",
-        port: Annotated[
-            int,
-            typer.Option(
-                "--port",
-                "-P",
-                help="Port to bind to. Default: 8000",
-                show_default=True,
-            ),
-        ] = 8000,
-        workers: Annotated[
-            int,
-            typer.Option(
-                "--workers",
-                "-w",
-                help=f"Number of workers. Default: {default_workers}",
-                show_default=True,
-            ),
-        ] = default_workers,
-    ):
-        """Run the mrok proxy with Gunicorn and Uvicorn workers."""
-        proxy.run(identity_file, host, port, workers)

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)