mrok 0.2.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

mrok/proxy/streams.py

@@ -0,0 +1,124 @@
+import asyncio
+
+from mrok.proxy.types import ConnectionCache, ConnectionKey
+
+
+class CachedStreamReader:
+    def __init__(
+        self,
+        reader: asyncio.StreamReader,
+        key: ConnectionKey,
+        manager: ConnectionCache,
+    ):
+        self._reader = reader
+        self._key = key
+        self._manager = manager
+
+    async def read(self, n: int = -1) -> bytes:
+        try:
+            return await self._reader.read(n)
+        except (
+            asyncio.CancelledError,
+            asyncio.IncompleteReadError,
+            asyncio.LimitOverrunError,
+            BrokenPipeError,
+            ConnectionAbortedError,
+            ConnectionResetError,
+            RuntimeError,
+            TimeoutError,
+            UnicodeDecodeError,
+        ):
+            asyncio.create_task(self._manager.invalidate(self._key))
+            raise
+
+    async def readexactly(self, n: int) -> bytes:
+        try:
+            return await self._reader.readexactly(n)
+        except (
+            asyncio.CancelledError,
+            asyncio.IncompleteReadError,
+            asyncio.LimitOverrunError,
+            BrokenPipeError,
+            ConnectionAbortedError,
+            ConnectionResetError,
+            RuntimeError,
+            TimeoutError,
+            UnicodeDecodeError,
+        ):
+            asyncio.create_task(self._manager.invalidate(self._key))
+            raise
+
+    async def readline(self) -> bytes:
+        try:
+            return await self._reader.readline()
+        except (
+            asyncio.CancelledError,
+            asyncio.IncompleteReadError,
+            asyncio.LimitOverrunError,
+            BrokenPipeError,
+            ConnectionAbortedError,
+            ConnectionResetError,
+            RuntimeError,
+            TimeoutError,
+            UnicodeDecodeError,
+        ):
+            asyncio.create_task(self._manager.invalidate(self._key))
+            raise
+
+    def at_eof(self) -> bool:
+        return self._reader.at_eof()
+
+    @property
+    def underlying(self) -> asyncio.StreamReader:
+        return self._reader
+
+
+class CachedStreamWriter:
+    def __init__(
+        self,
+        writer: asyncio.StreamWriter,
+        key: ConnectionKey,
+        manager: ConnectionCache,
+    ):
+        self._writer = writer
+        self._key = key
+        self._manager = manager
+
+    def write(self, data: bytes) -> None:
+        try:
+            return self._writer.write(data)
+        except (RuntimeError, TypeError):
+            asyncio.create_task(self._manager.invalidate(self._key))
+            raise
+
+    async def drain(self) -> None:
+        try:
+            return await self._writer.drain()
+        except (
+            asyncio.CancelledError,
+            BrokenPipeError,
+            ConnectionAbortedError,
+            ConnectionResetError,
+            RuntimeError,
+            TimeoutError,
+        ):
+            asyncio.create_task(self._manager.invalidate(self._key))
+            raise
+
+    def close(self) -> None:
+        return self._writer.close()
+
+    async def wait_closed(self) -> None:
+        try:
+            return await self._writer.wait_closed()
+        except (ConnectionResetError, BrokenPipeError):
+            asyncio.create_task(self._manager.invalidate(self._key))
+            raise
+
+    @property
+    def transport(self):
+        return self._writer.transport
+
+    @property
+    def underlying(self) -> asyncio.StreamWriter:
+        return self._writer

mrok/proxy/types.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from mrok.http.types import StreamReader, StreamWriter
+
+ConnectionKey = tuple[str, str | None]
+CachedStream = tuple[StreamReader, StreamWriter]
+
+
+class ConnectionCache(Protocol):
+    async def invalidate(self, key: ConnectionKey) -> None: ...

mrok/proxy/ziti.py

@@ -0,0 +1,173 @@
+"""Ziti-backed connection manager for the proxy.
+
+This manager owns creation of connections via an OpenZiti context, wraps
+streams to observe IO errors, evicts idle entries, and serializes creation
+per-key.
+"""
+
+import asyncio
+import logging
+import time
+from pathlib import Path
+
+# typing imports intentionally minimized
+import openziti
+
+from mrok.http.types import StreamReader, StreamWriter
+from mrok.proxy.dataclasses import CachedStreamEntry
+from mrok.proxy.streams import CachedStreamReader, CachedStreamWriter
+from mrok.proxy.types import CachedStream, ConnectionKey
+
+logger = logging.getLogger("mrok.proxy")
+
+
+class ZitiConnectionManager:
+    def __init__(
+        self,
+        identity_file: str | Path,
+        ziti_timeout_ms: int = 10000,
+        ttl_seconds: float = 60.0,
+        purge_interval: float = 10.0,
+    ):
+        self._identity_file = identity_file
+        self._ziti_ctx = None
+        self._ziti_timeout_ms = ziti_timeout_ms
+        self._ttl = float(ttl_seconds)
+        self._purge_interval = float(purge_interval)
+        self._cache: dict[ConnectionKey, CachedStreamEntry] = {}
+        self._lock = asyncio.Lock()
+        self._in_progress: dict[ConnectionKey, asyncio.Lock] = {}
+        self._purge_task: asyncio.Task | None = None
+
+    async def get(self, target: str) -> tuple[StreamReader, StreamWriter] | tuple[None, None]:
+        head, _, tail = target.partition(".")
+        terminator = target if head and tail else ""
+        service = tail if tail else head
+        r, w = await self._get_or_create_key((service, terminator))
+        return r, w
+
+    async def invalidate(self, key: ConnectionKey) -> None:
+        async with self._lock:
+            item = self._cache.pop(key, None)
+        if item is None:
+            return
+        await self._close_writer(item.writer)
+
+    async def start(self) -> None:
+        if self._ziti_ctx is None:
+            ctx, err = openziti.load(str(self._identity_file), timeout=self._ziti_timeout_ms)
+            if err != 0:
+                raise Exception(f"Cannot create a Ziti context from the identity file: {err}")
+            self._ziti_ctx = ctx
+        if self._purge_task is None:
+            self._purge_task = asyncio.create_task(self._purge_loop())
+            logger.info("Ziti connection manager started")
+
+    async def stop(self) -> None:
+        if self._purge_task is not None:
+            self._purge_task.cancel()
+            try:
+                await self._purge_task
+            except asyncio.CancelledError:
+                logger.debug("Purge task was cancelled")
+            except Exception as e:
+                logger.warning(f"An error occurred stopping the purge task: {e}")
+            self._purge_task = None
+            logger.info("Ziti connection manager stopped")
+
+        async with self._lock:
+            items = list(self._cache.items())
+            self._cache.clear()
+
+        for _, item in items:
+            await self._close_writer(item.writer)
+
+    async def _purge_loop(self) -> None:
+        try:
+            while True:
+                await asyncio.sleep(self._purge_interval)
+                await self._purge_once()
+        except asyncio.CancelledError:
+            return
+
+    async def _purge_once(self) -> None:
+        to_close: list[tuple[StreamReader, StreamWriter]] = []
+        async with self._lock:
+            now = time.time()
+            for key, item in list(self._cache.items()):
+                if now - item.last_access > self._ttl:
+                    to_close.append((item.reader, item.writer))
+                    del self._cache[key]
+
+        for _, writer in to_close:
+            writer.close()
+            await self._close_writer(writer)
+
+    def _is_writer_closed(self, writer: StreamWriter) -> bool:
+        return writer.transport.is_closing()
+
+    async def _close_writer(self, writer: StreamWriter) -> None:
+        writer.close()
+        try:
+            await writer.wait_closed()
+        except Exception as e:
+            logger.debug(f"Error closing writer: {e}")
+
+    async def _get_or_create_key(self, key: ConnectionKey) -> CachedStream:
+        """Internal: create or return a cached wrapped pair for the concrete key."""
+        await self._purge_once()
+        to_close = None
+        async with self._lock:
+            if key in self._cache:
+                now = time.time()
+                item = self._cache[key]
+                reader, writer = item.reader, item.writer
+                if not self._is_writer_closed(writer) and not reader.at_eof():
+                    self._cache[key] = CachedStreamEntry(reader, writer, now)
+                    return reader, writer
+                to_close = writer
+                del self._cache[key]
+
+            lock = self._in_progress.get(key)
+            if lock is None:
+                lock = asyncio.Lock()
+                self._in_progress[key] = lock
+
+        if to_close:
+            await self._close_writer(to_close)
+
+        async with lock:
+            try:
+                # # double-check cache after acquiring the per-key lock
+                # async with self._lock:
+                #     now = time.time()
+                #     if key in self._cache:
+                #         r, w, _ = self._cache[key]
+                #         if not self._is_writer_closed(w) and not r.at_eof():
+                #             self._cache[key] = (r, w, now)
+                #             return r, w
+
+                # perform creation via ziti context
+                extension, instance = key
+                logger.info(f"Create connection to {extension}: {instance}")
+                # loop = asyncio.get_running_loop()
+                # sock = await loop.run_in_executor(None, self._ziti_ctx.connect,
+                # extension, instance)
+                if instance:
+                    sock = self._ziti_ctx.connect(
+                        extension, terminator=instance
+                    )  # , terminator=instance)
+                else:
+                    sock = self._ziti_ctx.connect(extension)
+                orig_reader, orig_writer = await asyncio.open_connection(sock=sock)
+
+                reader = CachedStreamReader(orig_reader, key, self)
+                writer = CachedStreamWriter(orig_writer, key, self)
+
+                async with self._lock:
+                    self._cache[key] = CachedStreamEntry(reader, writer, time.time())
+
+                return reader, writer
+            finally:
+                async with self._lock:
+                    self._in_progress.pop(key, None)

mrok/ziti/identities.py

@@ -1,8 +1,10 @@
+import copy
 import logging
 from typing import Any
 
 import jwt
 
+from mrok.conf import Settings
 from mrok.ziti import pki
 from mrok.ziti.api import TagsType, ZitiClientAPI, ZitiManagementAPI
 from mrok.ziti.constants import (
@@ -16,31 +18,37 @@ from mrok.ziti.errors import (
     ServiceNotFoundError,
     UserIdentityNotFoundError,
 )
+from mrok.ziti.services import register_service, unregister_service
 
 logger = logging.getLogger("mrok.ziti")
 
 
-async def register_instance(
+async def register_identity(
+    settings: Settings,
     mgmt_api: ZitiManagementAPI,
     client_api: ZitiClientAPI,
-    extension_id: str,
-    instance_id: str,
+    service_external_id: str,
+    identity_external_id: str,
     tags: TagsType | None = None,
 ):
-    service_name = extension_id.lower()
-    tags = tags or {}
-    tags[MROK_SERVICE_TAG_NAME] = service_name
-    tags[MROK_IDENTITY_TYPE_TAG_NAME] = MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE
+    service_name = service_external_id.lower()
+    identity_tags = copy.copy(tags or {})
+    identity_tags[MROK_SERVICE_TAG_NAME] = service_name
+    identity_tags[MROK_IDENTITY_TYPE_TAG_NAME] = MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE
     service = await mgmt_api.search_service(service_name)
     if not service:
-        raise ServiceNotFoundError(f"A service with name `{extension_id}` does not exists.")
+        raise ServiceNotFoundError(f"A service with name `{service_external_id}` does not exists.")
 
-    identity_name = f"{instance_id.lower()}.{service_name}"
+    identity_name = f"{identity_external_id.lower()}.{service_name}"
     service_policy_name = f"{identity_name}:bind"
+    self_service_policy_name = f"self.{service_policy_name}"
 
     identity = await mgmt_api.search_identity(identity_name)
     if identity:
         service_policy = await mgmt_api.search_service_policy(service_policy_name)
+        if service_policy:
+            await mgmt_api.delete_service_policy(service_policy["id"])
+        service_policy = await mgmt_api.search_service_policy(self_service_policy_name)
         if service_policy:
             await mgmt_api.delete_service_policy(service_policy["id"])
         router_policy = await mgmt_api.search_router_policy(identity_name)
@@ -48,7 +56,7 @@ async def register_instance(
             await mgmt_api.delete_router_policy(router_policy["id"])
         await mgmt_api.delete_identity(identity["id"])
 
-    identity_id = await mgmt_api.create_user_identity(identity_name, tags=tags)
+    identity_id = await mgmt_api.create_user_identity(identity_name, tags=identity_tags)
     identity = await mgmt_api.get_identity(identity_id)
 
     identity_json = await _enroll_identity(
@@ -58,33 +66,55 @@ async def register_instance(
         identity,
         mrok={
             "identity": identity_name,
-            "extension": extension_id,
-            "instance": instance_id,
+            "extension": service_external_id,
+            "instance": identity_external_id,
+            "domain": settings.proxy.domain,
+            "tags": identity_tags,
         },
     )
 
+    self_service = await mgmt_api.search_service(identity_name)
+    if not self_service:
+        self_service = await register_service(settings, mgmt_api, identity_name, tags)
+
     await mgmt_api.create_bind_service_policy(service_policy_name, service["id"], identity_id)
+    await mgmt_api.create_bind_service_policy(
+        self_service_policy_name,
+        self_service["id"],
+        identity_id,
+    )
     await mgmt_api.create_router_policy(identity_name, identity_id)
 
     return identity, identity_json
 
 
-async def unregister_instance(
+async def unregister_identity(
+    settings: Settings,
     mgmt_api: ZitiManagementAPI,
-    extension_id: str,
-    instance_id: str,
+    service_external_id: str,
+    identity_external_id: str,
 ):
-    service_name = extension_id.lower()
+    service_name = service_external_id.lower()
     service = await mgmt_api.search_service(service_name)
     if not service:
-        raise ServiceNotFoundError(f"A service with name `{extension_id}` does not exists.")
+        raise ServiceNotFoundError(f"A service with name `{service_external_id}` does not exists.")
 
-    identity_name = f"{instance_id.lower()}.{service_name}"
+    identity_name = f"{identity_external_id.lower()}.{service_name}"
     service_policy_name = f"{identity_name}:bind"
 
     identity = await mgmt_api.search_identity(identity_name)
     if not identity:
-        raise UserIdentityNotFoundError(f"Instance `{instance_id}` not found.")
+        raise UserIdentityNotFoundError(f"Identity `{identity_external_id}` not found.")
+
+    self_service_policy_name = f"self.{service_policy_name}"
+
+    service_policy = await mgmt_api.search_service_policy(self_service_policy_name)
+    if service_policy:
+        await mgmt_api.delete_service_policy(service_policy["id"])
+
+    self_service = await mgmt_api.search_service(identity_name)
+    if self_service:
+        await unregister_service(settings, mgmt_api, identity_name)
 
     service_policy = await mgmt_api.search_service_policy(service_policy_name)
     if service_policy:
@@ -120,7 +150,7 @@ async def _enroll_identity(
     client_api: ZitiClientAPI,
     identity_id: str,
     identity: dict[str, Any] | None = None,
-    mrok: dict[str, str] | None = None,
+    mrok: dict[str, str | dict] | None = None,
 ):
     if identity is None:
         identity = await mgmt_api.get_identity(identity_id)

mrok/ziti/services.py

@@ -13,10 +13,10 @@ from mrok.ziti.errors import (
 logger = logging.getLogger(__name__)
 
 
-async def register_extension(
-    settings: Settings, mgmt_api: ZitiManagementAPI, extension_id: str, tags: TagsType | None
+async def register_service(
+    settings: Settings, mgmt_api: ZitiManagementAPI, external_id: str, tags: TagsType | None
 ) -> dict[str, Any]:
-    service_name = extension_id.lower()
+    service_name = external_id.lower()
     registered = False
     proxy_identity = await mgmt_api.search_identity(settings.proxy.identity)
     if not proxy_identity:
@@ -58,17 +58,17 @@ async def register_extension(
         await mgmt_api.create_service_router_policy(service_name, service_id, tags=tags)
         registered = True
     if not registered:
-        raise ServiceAlreadyRegisteredError(f"Extension `{extension_id}` already registered.")
+        raise ServiceAlreadyRegisteredError(f"Service `{external_id}` already registered.")
     return service
 
 
-async def unregister_extension(
-    settings: Settings, mgmt_api: ZitiManagementAPI, extension_id: str
+async def unregister_service(
+    settings: Settings, mgmt_api: ZitiManagementAPI, external_id: str
 ) -> None:
-    service_name = extension_id.lower()
+    service_name = external_id.lower()
     service = await mgmt_api.search_service(service_name)
     if not service:
-        raise ServiceNotFoundError(f"Extension `{extension_id}` not found.")
+        raise ServiceNotFoundError(f"Service `{external_id}` not found.")
 
     router_policy = await mgmt_api.search_service_router_policy(service_name)
     if router_policy:

{mrok-0.2.3.dist-info → mrok-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrok
-Version: 0.2.3
+Version: 0.4.0
 Summary: MPT Extensions OpenZiti Orchestrator
 Author: SoftwareOne AG
 License:                                  Apache License
@@ -212,14 +212,20 @@ 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: 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
+Requires-Dist: textual-serve<2.0.0,>=1.1.3
+Requires-Dist: textual<7.0.0,>=6.5.0
 Requires-Dist: typer<0.20.0,>=0.19.2
 Requires-Dist: uvicorn-worker<0.5.0,>=0.4.0
 Description-Content-Type: text/markdown

mrok-0.4.0.dist-info/RECORD

@@ -0,0 +1,92 @@
+mrok/__init__.py,sha256=D1PUs3KtMCqG4bFLceVNG62L3RN53NS95uSCNXpgvzs,181
+mrok/conf.py,sha256=_5Z-A5LyojQeY8J7W8C0QidsmrPl99r9qKYEoMf4kcI,840
+mrok/datastructures.py,sha256=gp8KF2JoNOxIRzYStVZLKL_XVDbcIVSIDnmpQo4FNt0,4067
+mrok/errors.py,sha256=ruNMDFr2_0ezCGXuCG1OswCEv-bHOIzMMd02J_0ABcs,37
+mrok/logging.py,sha256=ZMWn0w4fJ-F_g-L37H_GM14BSXAIF2mFF_ougX5S7mg,2856
+mrok/master.py,sha256=6_bUic39mXE37lt0PBf_BtY2D2mBR7KzPj65JP7HWPc,8287
+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/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/server.py,sha256=C4uD6_1psSHMjJLUDCMPGvKdQYKaEwYTw27NAbwuuA0,636
+mrok/agent/sidecar/__init__.py,sha256=DrjJGhqFyxsVODW06KI20Wpr6HsD2lD6qFCKUXc7GIE,59
+mrok/agent/sidecar/app.py,sha256=1p6qWkXVq78zcJ2dhCYlw8CqfwPsgEtu07Lp5csK3Iw,874
+mrok/agent/sidecar/main.py,sha256=h31wynUCcFmRckvqLHtH97w1QgMv4fzcmYjhRPUobxY,1076
+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/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/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
+mrok/cli/commands/admin/register/__init__.py,sha256=5Jb_bc2L47MEpQIrOcquzduTFWQ01Jd1U1MpqaR-Ekw,209
+mrok/cli/commands/admin/register/extensions.py,sha256=p1qX5gSQX1IGpOQjO2MJzbc09v1ebdFuPo94QzJErKk,1485
+mrok/cli/commands/admin/register/instances.py,sha256=XB6uAchc7Rm8uAu7o3-oHaN_rS8CCIBf0QKWZGW86fI,1940
+mrok/cli/commands/admin/unregister/__init__.py,sha256=-GjjCPX1pISbWmJK6GpKO3ijGsDQb21URjU1hNu99O4,215
+mrok/cli/commands/admin/unregister/extensions.py,sha256=GR3Iwzeksk_R0GkgmCSG7iHRcUrI7ABqDi25Gbes64Y,1016
+mrok/cli/commands/admin/unregister/instances.py,sha256=-28wL8pTXTWHVHtw93y8-dqi-Dlf0OZOnlBCKOyGo80,1138
+mrok/cli/commands/agent/__init__.py,sha256=ZAi7eTkKQtfwwV1c1mv3uvEEsyMMrhCQ_-id_0wksAQ,218
+mrok/cli/commands/agent/utils.py,sha256=m_olScdIUGks5IoC6p2F9D6CQIucWZ7LHyrvwm2bkJw,106
+mrok/cli/commands/agent/dev/__init__.py,sha256=ZfreyRuaLqO0AwPS8Ll1DIpsKacsu7_dTmbxV5QecOM,172
+mrok/cli/commands/agent/dev/console.py,sha256=rrKAGoKXVQQBOC75H0JSuX1sYyvc2QSrV-dfMPK49p4,673
+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/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/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/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/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=DakD9hrrCWAzB1B_4SgQaQaEHcDYLLI9WaYs5F0O36I,12977
+mrok/http/lifespan.py,sha256=UdbOqjWZsHzJJjX0CTd2hY96Jpk5QWtdHJEzPG6Z4hQ,1288
+mrok/http/middlewares.py,sha256=SGo4EwhTId2uJx1aMuqGbNy7MXgZlDEdZI0buzBYVv0,5011
+mrok/http/protocol.py,sha256=ap8jbLUvgbAH81ZJZCBkQiYR7mkV_eL3rpfwEkoE8sU,392
+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=MwJZ91MQ1oWkbmsX7-NooZSV9BkLVZPFmUKpNPC4HHQ,2490
+mrok/proxy/dataclasses.py,sha256=DtX-Yuma-uOECOPefJnoQJhZMEtT6Za_27cd-lJE9Iw,237
+mrok/proxy/main.py,sha256=ZXpticE6J4FABaslDB_8J5qklPsf3e7xIFSZmcPAAjQ,1588
+mrok/proxy/streams.py,sha256=6TMZwrQPbSyQqpqavsoTeyUmS2O026pJfiCnxLopPqg,3425
+mrok/proxy/types.py,sha256=dgWqAj6dFGVH_Q8-k8sU5h18yoUF_fTn-SRPIfEs_gA,308
+mrok/proxy/ziti.py,sha256=dKd6UzmEAFu9-gey871sPEDUZTkt4YVPyCYRzeA5mlA,6539
+mrok/ziti/__init__.py,sha256=20OWMiexRhOovZOX19zlX87-V78QyWnEnSZfyAftUdE,263
+mrok/ziti/api.py,sha256=KvGiT9d4oSgC3JbFWLDQyuHcLX2HuZJoJ8nHmWtCDkY,16154
+mrok/ziti/bootstrap.py,sha256=QIDhlkIxPW2QRuumFq2D1WDbD003P5f3z24pAUsyeBI,2696
+mrok/ziti/constants.py,sha256=Urq1X3bCBQZfw8NbnEa1pqmY4oq1wmzkwPfzam3kbTw,339
+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.0.dist-info/METADATA,sha256=39Su41kvqC4oAsQl1_ZG7b5v1xRr6c2YK6x84XgURi8,15796
+mrok-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mrok-0.4.0.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
+mrok-0.4.0.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
+mrok-0.4.0.dist-info/RECORD,,

{mrok-0.2.3.dist-info → mrok-0.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any