mrok 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

mrok/proxy/app.py

@@ -2,11 +2,13 @@ import asyncio
 import logging
 from pathlib import Path
 
+import openziti
+from openziti.context import ZitiContext
+
 from mrok.conf import get_settings
 from mrok.http.forwarder import ForwardAppBase
 from mrok.http.types import Scope, StreamReader, StreamWriter
 from mrok.logging import setup_logging
-from mrok.proxy.ziti import ZitiSocketCache
 
 logger = logging.getLogger("mrok.proxy")
 
@@ -30,7 +32,7 @@ class ProxyApp(ForwardAppBase):
             if settings.proxy.domain[0] == "."
             else f".{settings.proxy.domain}"
         )
-        self._ziti_socket_cache = ZitiSocketCache(self._identity_file)
+        self._ziti_ctx: ZitiContext | None = None
 
     def get_target_from_header(self, headers: dict[str, str], name: str) -> str | None:
         header_value = headers.get(name, "")
@@ -47,11 +49,17 @@ class ProxyApp(ForwardAppBase):
             raise ProxyError("Neither Host nor X-Forwarded-Host contain a valid target name")
         return target
 
+    def _get_ziti_ctx(self) -> ZitiContext:
+        if self._ziti_ctx is None:
+            ctx, err = openziti.load(str(self._identity_file), timeout=10_000)
+            if err != 0:
+                raise Exception(f"Cannot create a Ziti context from the identity file: {err}")
+            self._ziti_ctx = ctx
+        return self._ziti_ctx
+
     async def startup(self):
         setup_logging(get_settings())
-
-    async def shutdown(self):
-        await self._ziti_socket_cache.stop()
+        self._get_ziti_ctx()
 
     async def select_backend(
         self,
@@ -59,6 +67,6 @@ class ProxyApp(ForwardAppBase):
         headers: dict[str, str],
     ) -> tuple[StreamReader, StreamWriter] | tuple[None, None]:
         target_name = self.get_target_name(headers)
-        sock = self._ziti_socket_cache.get_or_create(target_name)
+        sock = self._get_ziti_ctx().connect(target_name)
         reader, writer = await asyncio.open_connection(sock=sock)
         return reader, writer

{mrok-0.4.3.dist-info → mrok-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrok
-Version: 0.4.3
+Version: 0.4.5
 Summary: MPT Extensions OpenZiti Orchestrator
 Author: SoftwareOne AG
 License:                                  Apache License

{mrok-0.4.3.dist-info → mrok-0.4.5.dist-info}/RECORD

@@ -71,9 +71,8 @@ mrok/http/server.py,sha256=Mj7C85fc-DXp-WTBWaOd7ag808oliLmFBH5bf-G2FHg,370
 mrok/http/types.py,sha256=XpNrvbfpANKvmjOBYtLF1FmDHoJF3z_MIMQHXoJlvmE,1302
 mrok/http/utils.py,sha256=sOixYu3R9-nNoMFYdifrreYvcFRIHYVtb6AAmtVzaLE,2125
 mrok/proxy/__init__.py,sha256=vWXyImroqM1Eq8e_oFPBup8VJ3reyp8SVjFTbLzRkI8,51
-mrok/proxy/app.py,sha256=-xmHKSSqQhNdwISRXQCUVLI1n6HWs3d46cgKQ6_NC3A,2157
+mrok/proxy/app.py,sha256=kWMg4oi0WtwHS0CD4iOK2-dghBzu8ya7aRIH-jn-61g,2436
 mrok/proxy/main.py,sha256=ZXpticE6J4FABaslDB_8J5qklPsf3e7xIFSZmcPAAjQ,1588
-mrok/proxy/ziti.py,sha256=Ce02EimVJNffyluFr1nhOMXh6kZ0kY2nt6Shg58wkBw,3206
 mrok/ziti/__init__.py,sha256=20OWMiexRhOovZOX19zlX87-V78QyWnEnSZfyAftUdE,263
 mrok/ziti/api.py,sha256=KvGiT9d4oSgC3JbFWLDQyuHcLX2HuZJoJ8nHmWtCDkY,16154
 mrok/ziti/bootstrap.py,sha256=QIDhlkIxPW2QRuumFq2D1WDbD003P5f3z24pAUsyeBI,2696
@@ -82,8 +81,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.3.dist-info/METADATA,sha256=rfG5MT0fAz27oU7Jzr8RFD3LLA9Syci51df1gHFSgLI,15836
-mrok-0.4.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mrok-0.4.3.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
-mrok-0.4.3.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
-mrok-0.4.3.dist-info/RECORD,,
+mrok-0.4.5.dist-info/METADATA,sha256=jomSUZzuiMTTuC3T3zzisYfaFnevrSbQJ7y1-sM6lgU,15836
+mrok-0.4.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mrok-0.4.5.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
+mrok-0.4.5.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
+mrok-0.4.5.dist-info/RECORD,,

mrok/proxy/ziti.py

@@ -1,103 +0,0 @@
-import asyncio
-import contextlib
-from asyncio import Task
-from pathlib import Path
-
-import openziti
-from aiocache import Cache
-from openziti.context import ZitiContext
-from openziti.zitisock import ZitiSocket
-
-
-class ZitiSocketCache:
-    def __init__(
-        self,
-        identity_file: str | Path,
-        ziti_ctx_timeout_ms: int = 10_000,
-        ttl_seconds: float = 60.0,
-        cleanup_interval: float = 10.0,
-    ) -> None:
-        self._identity_file = identity_file
-        self._ziti_ctx_timeout_ms = ziti_ctx_timeout_ms
-        self._ttl_seconds = ttl_seconds
-        self._cleanup_interval = cleanup_interval
-
-        self._ziti_ctx: ZitiContext | None = None
-        self._cache = Cache(Cache.MEMORY)
-        self._active_sockets: dict[str, ZitiSocket] = {}
-        self._cleanup_task: Task | None = None
-
-    def _get_ziti_ctx(self) -> ZitiContext:
-        if self._ziti_ctx is None:
-            ctx, err = openziti.load(str(self._identity_file), timeout=self._ziti_ctx_timeout_ms)
-            if err != 0:
-                raise Exception(f"Cannot create a Ziti context from the identity file: {err}")
-            self._ziti_ctx = ctx
-        return self._ziti_ctx
-
-    async def _create_socket(self, key: str):
-        return self._get_ziti_ctx().connect(key)
-
-    async def get_or_create(self, key: str):
-        sock = await self._cache.get(key)
-
-        if sock:
-            await self._cache.set(key, sock, ttl_seconds=self._ttl_seconds)
-            self._active_sockets[key] = sock
-            return sock
-
-        sock = await self._create_socket(key)
-        await self._cache.set(key, sock, ttl_seconds=self._ttl_seconds)
-        self._active_sockets[key] = sock
-        return sock
-
-    async def invalidate(self, key: str):
-        sock = await self._cache.get(key)
-        if sock:
-            await self._close_socket(sock)
-
-        await self._cache.delete(key)
-        self._active_sockets.pop(key, None)
-
-    async def start(self):
-        self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
-        # Warmup ziti context
-        self._get_ziti_ctx()
-
-    async def stop(self):
-        """
-        Cleanup: stop background task + close all sockets.
-        """
-        self._cleanup_task.cancel()
-        with contextlib.suppress(Exception):
-            await self._cleanup_task
-
-        for sock in list(self._active_sockets.values()):
-            await self._close_socket(sock)
-
-        self._active_sockets.clear()
-        await self._cache.clear()
-
-    @staticmethod
-    async def _close_socket(sock: ZitiSocket):
-        with contextlib.suppress(Exception):
-            sock.close()
-
-    async def _periodic_cleanup(self):
-        try:
-            while True:
-                await asyncio.sleep(self._cleanup_interval)
-                await self._cleanup_once()
-        except asyncio.CancelledError:
-            return
-
-    async def _cleanup_once(self):
-        keys_now = set(await self._cache.keys())
-        known_keys = set(self._active_sockets.keys())
-
-        expired = known_keys - keys_now
-
-        for key in expired:
-            sock = self._active_sockets.pop(key, None)
-            if sock:
-                await self._close_socket(sock)