mrok 0.4.3__tar.gz → 0.4.5__tar.gz

{mrok-0.4.3 → mrok-0.4.5}/PKG-INFO

@@ -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 → mrok-0.4.5}/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 → mrok-0.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mrok"
-version = "0.4.3"
+version = "0.4.5"
 description = "MPT Extensions OpenZiti Orchestrator"
 readme = { file = "README.md", content-type = "text/markdown" }
 authors = [

mrok-0.4.3/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)