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

mrok/agent/sidecar/main.py

@@ -1,27 +1,46 @@
-import asyncio
-import contextlib
-from functools import partial
+import logging
 from pathlib import Path
 
 from mrok.agent.sidecar.app import ForwardApp
-from mrok.http.config import MrokBackendConfig
-from mrok.http.master import Master
-from mrok.http.server import MrokServer
+from mrok.master import MasterBase
 
+logger = logging.getLogger("mrok.proxy")
 
-def run_sidecar(identity_file: str, target_addr: str | Path | tuple[str, int]):
-    config = MrokBackendConfig(ForwardApp(target_addr), identity_file)
-    server = MrokServer(config)
-    with contextlib.suppress(KeyboardInterrupt, asyncio.CancelledError):
-        server.run()
+
+class SidecarAgent(MasterBase):
+    def __init__(
+        self,
+        identity_file: str,
+        target_addr: str | Path | tuple[str, int],
+        workers: int = 4,
+        publishers_port: int = 50000,
+        subscribers_port: int = 50001,
+    ):
+        super().__init__(
+            identity_file,
+            workers,
+            False,
+            publishers_port,
+            subscribers_port,
+        )
+        self.target_address = target_addr
+
+    def get_asgi_app(self):
+        return ForwardApp(self.target_address)
 
 
 def run(
     identity_file: str,
     target_addr: str | Path | tuple[str, int],
-    workers=4,
-    reload=False,
+    workers: int = 4,
+    publishers_port: int = 50000,
+    subscribers_port: int = 50001,
 ):
-    start_fn = partial(run_sidecar, identity_file, target_addr)
-    master = Master(start_fn, workers=workers, reload=reload)
-    master.run()
+    agent = SidecarAgent(
+        identity_file,
+        target_addr,
+        workers=workers,
+        publishers_port=publishers_port,
+        subscribers_port=subscribers_port,
+    )
+    agent.run()

mrok/agent/ziticorn.py

@@ -1,29 +1,38 @@
-import asyncio
-import contextlib
-import os
-from functools import partial
+from mrok.http.types import ASGIApp
+from mrok.master import MasterBase
 
-from mrok.http.config import ASGIApplication, MrokBackendConfig
-from mrok.http.master import Master
-from mrok.http.server import MrokServer
 
+class ZiticornAgent(MasterBase):
+    def __init__(
+        self,
+        app: ASGIApp | str,
+        identity_file: str,
+        workers: int = 4,
+        reload: bool = False,
+        publishers_port: int = 50000,
+        subscribers_port: int = 50001,
+    ):
+        super().__init__(identity_file, workers, reload, publishers_port, subscribers_port)
+        self.app = app
 
-def run_ziticorn(app: ASGIApplication | str, identity_file: str):
-    import sys
-
-    sys.path.insert(0, os.getcwd())
-    config = MrokBackendConfig(app, identity_file)
-    server = MrokServer(config)
-    with contextlib.suppress(KeyboardInterrupt, asyncio.CancelledError):
-        server.run()
+    def get_asgi_app(self):
+        return self.app
 
 
 def run(
-    app: ASGIApplication | str,
+    app: ASGIApp | str,
     identity_file: str,
     workers: int = 4,
     reload: bool = False,
+    publishers_port: int = 50000,
+    subscribers_port: int = 50001,
 ):
-    start_fn = partial(run_ziticorn, app, identity_file)
-    master = Master(start_fn, workers=workers, reload=reload)
+    master = ZiticornAgent(
+        app,
+        identity_file,
+        workers=workers,
+        reload=reload,
+        publishers_port=publishers_port,
+        subscribers_port=subscribers_port,
+    )
     master.run()

mrok/cli/commands/__init__.py

@@ -1,7 +1,8 @@
-from mrok.cli.commands import admin, agent, controller
+from mrok.cli.commands import admin, agent, controller, proxy
 
 __all__ = [
     "admin",
     "agent",
     "controller",
+    "proxy",
 ]

mrok/cli/commands/admin/list/instances.py

@@ -21,7 +21,11 @@ from mrok.ziti.constants import (
 
 
 async def get_instances(
-    settings: Settings, detailed: bool, extension: str | None = None, tags: list[str] | None = None
+    settings: Settings,
+    detailed: bool,
+    extension: str | None = None,
+    tags: list[str] | None = None,
+    online_only: bool = False,
 ) -> list[dict]:
     async with ZitiManagementAPI(settings) as api:
         tags = tags or []
@@ -29,6 +33,9 @@ async def get_instances(
         identities = [
             identity async for identity in api.identities(params={"filter": tags_to_filter(tags)})
         ]
+        if online_only:
+            identities = list(filter(lambda i: i["hasEdgeRouterConnection"], identities))
+
         if detailed or extension:
             for identity in identities:
                 identity["services"] = [
@@ -60,10 +67,11 @@ async def get_instances(
 def render_tsv(instances: list[dict], detailed: bool) -> None:
     console = get_console()
     if detailed:
-        console.print("id\tname\tservices\tpolicies\ttags\tcreated\tupdated")
+        console.print("id\tname\tstatus\tservices\tpolicies\ttags\tcreated\tupdated")
         for instance in instances:
             console.print(
                 f"{instance['id']}\t{instance['name']}\t"
+                f"{'online' if instance['hasEdgeRouterConnection'] else 'offline'}\t"
                 f"{extract_names(instance['services'], ', ')}\t"
                 f"{extract_names(instance['policies'], ', ')}\t"
                 f"{format_tags(instance['tags'], ', ')}\t"
@@ -71,10 +79,11 @@ def render_tsv(instances: list[dict], detailed: bool) -> None:
                 f"{format_timestamp(instance['updatedAt'])}"
             )
     else:
-        console.print("id\tname\ttags\tcreated")
+        console.print("id\tname\tstatus\ttags\tcreated")
         for instance in instances:
             console.print(
                 f"{instance['id']}\t{instance['name']}\t"
+                f"{'online' if instance['hasEdgeRouterConnection'] else 'offline'}\t"
                 f"{format_tags(instance['tags'], ', ')}\t"
                 f"{format_timestamp(instance['createdAt'])}\t"
             )
@@ -90,6 +99,7 @@ def render_table(instances: list[dict], detailed: bool) -> None:
     )
     table.add_column("Id", style="green")
     table.add_column("Name", style="bold cyan")
+    table.add_column("Status", justify="center")
     if detailed:
         table.add_column("Associated services")
         table.add_column("Associated service policies")
@@ -102,6 +112,7 @@ def render_table(instances: list[dict], detailed: bool) -> None:
         row = [
             instance["id"],
             instance["name"],
+            "🟢" if instance["hasEdgeRouterConnection"] else "⚪",
         ]
         if detailed:
             row += [
@@ -142,6 +153,15 @@ def register(app: typer.Typer) -> None:
                 show_default=True,
             ),
         ] = None,
+        online_only: Annotated[
+            bool,
+            typer.Option(
+                "--online-only",
+                "-o",
+                help="Show only connected instances",
+                show_default=True,
+            ),
+        ] = False,
         detailed: bool = typer.Option(
             False,
             "--detailed",
@@ -155,7 +175,7 @@ def register(app: typer.Typer) -> None:
         ),
     ):
         """List instances in OpenZiti (identities)."""
-        instances = asyncio.run(get_instances(ctx.obj, detailed, extension, tags))
+        instances = asyncio.run(get_instances(ctx.obj, detailed, extension, tags, online_only))
 
         if len(instances) == 0:
             get_console().print("No instances found.")

mrok/cli/commands/admin/register/extensions.py

@@ -8,14 +8,14 @@ from rich import print
 from mrok.cli.commands.admin.utils import parse_tags
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiManagementAPI
-from mrok.ziti.services import register_extension
+from mrok.ziti.services import register_service
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
 
 async def do_register(settings: Settings, extension_id: str, tags: list[str] | None):
     async with ZitiManagementAPI(settings) as api:
-        await register_extension(settings, api, extension_id, tags=parse_tags(tags))
+        await register_service(settings, api, extension_id, tags=parse_tags(tags))
 
 
 def validate_extension_id(extension_id: str) -> str:

mrok/cli/commands/admin/register/instances.py

@@ -9,7 +9,7 @@ import typer
 from mrok.cli.commands.admin.utils import parse_tags
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiClientAPI, ZitiManagementAPI
-from mrok.ziti.identities import register_instance
+from mrok.ziti.identities import register_identity
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
@@ -18,8 +18,8 @@ async def do_register(
     settings: Settings, extension_id: str, instance_id: str, tags: list[str] | None
 ):
     async with ZitiManagementAPI(settings) as mgmt_api, ZitiClientAPI(settings) as client_api:
-        return await register_instance(
-            mgmt_api, client_api, extension_id, instance_id, tags=parse_tags(tags)
+        return await register_identity(
+            settings, mgmt_api, client_api, extension_id, instance_id, tags=parse_tags(tags)
         )
 
 

mrok/cli/commands/admin/unregister/extensions.py

@@ -5,14 +5,14 @@ import typer
 
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiManagementAPI
-from mrok.ziti.services import unregister_extension
+from mrok.ziti.services import unregister_service
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
 
 async def do_unregister(settings: Settings, extension_id: str):
     async with ZitiManagementAPI(settings) as api:
-        await unregister_extension(settings, api, extension_id)
+        await unregister_service(settings, api, extension_id)
 
 
 def validate_extension_id(extension_id: str):

mrok/cli/commands/admin/unregister/instances.py

@@ -5,14 +5,14 @@ import typer
 
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiManagementAPI
-from mrok.ziti.identities import unregister_instance
+from mrok.ziti.identities import unregister_identity
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
 
 async def do_unregister(settings: Settings, extension_id: str, instance_id: str):
     async with ZitiManagementAPI(settings) as api:
-        await unregister_instance(api, extension_id, instance_id)
+        await unregister_identity(settings, api, extension_id, instance_id)
 
 
 def validate_extension_id(extension_id: str):

mrok/cli/commands/agent/__init__.py

@@ -1,6 +1,8 @@
 import typer
 
+from mrok.cli.commands.agent.dev import app as dev_app
 from mrok.cli.commands.agent.run import app as run_app
 
 app = typer.Typer(help="mrok agent commands.")
 app.add_typer(run_app)
+app.add_typer(dev_app)

mrok/cli/commands/agent/dev/__init__.py

@@ -0,0 +1,7 @@
+import typer
+
+from mrok.cli.commands.agent.dev import console, web
+
+app = typer.Typer(name="dev", help="Dev tools for mrok agent.")
+console.register(app)
+web.register(app)

mrok/cli/commands/agent/dev/console.py

@@ -0,0 +1,25 @@
+from typing import Annotated
+
+import typer
+
+from mrok.agent.devtools.inspector.app import InspectorApp
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("console")
+    def run_dev_console(
+        subscriber_port: Annotated[
+            int,
+            typer.Option(
+                "--subscriber-port",
+                "-s",
+                help=(
+                    "TCP port where the mrok inspector console application "
+                    "should connect to subscribe to request/response messages."
+                ),
+                show_default=True,
+            ),
+        ] = 50001,
+    ):
+        app = InspectorApp(subscriber_port)
+        app.run()

mrok/cli/commands/agent/dev/web.py

@@ -0,0 +1,37 @@
+from typing import Annotated
+
+import typer
+
+from mrok.agent.devtools.inspector.server import InspectorServer
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("web")
+    def run_web_console(
+        port: Annotated[
+            int,
+            typer.Option(
+                "--port",
+                "-p",
+                help="TCP port where the mrok inspector web application will listen for requests.",
+                show_default=True,
+            ),
+        ] = 7777,
+        subscriber_port: Annotated[
+            int,
+            typer.Option(
+                "--subscriber-port",
+                "-s",
+                help=(
+                    "TCP port where the mrok inspector web application "
+                    "should connect to subscribe to request/response messages."
+                ),
+                show_default=True,
+            ),
+        ] = 50001,
+    ):
+        server = InspectorServer(
+            port=port,
+            subscriber_port=subscriber_port,
+        )
+        server.serve()

mrok/cli/commands/agent/run/asgi.py

@@ -1,16 +1,10 @@
-import multiprocessing
 from pathlib import Path
 from typing import Annotated
 
 import typer
 
-# from app.logging import get_logging_config
 from mrok.agent import ziticorn
-
-
-def number_of_workers():
-    return (multiprocessing.cpu_count() * 2) + 1
-
+from mrok.cli.utils import number_of_workers
 
 default_workers = number_of_workers()
 
@@ -18,14 +12,8 @@ default_workers = number_of_workers()
 def register(app: typer.Typer) -> None:
     @app.command("asgi")
     def run_asgi(
-        app: str = typer.Argument(
-            ...,
-            help="ASGI application",
-        ),
-        identity_file: Path = typer.Argument(
-            ...,
-            help="Identity json file",
-        ),
+        app: Annotated[str, typer.Argument(..., help="ASGI application")],
+        identity_file: Annotated[Path, typer.Argument(..., help="Identity json file")],
         workers: Annotated[
             int,
             typer.Option(
@@ -44,6 +32,37 @@ def register(app: typer.Typer) -> None:
                 show_default=True,
             ),
         ] = False,
+        publishers_port: Annotated[
+            int,
+            typer.Option(
+                "--publishers-port",
+                "-p",
+                help=(
+                    "TCP port where the mrok agent "
+                    "should connect to publish to request/response messages."
+                ),
+                show_default=True,
+            ),
+        ] = 50000,
+        subscribers_port: Annotated[
+            int,
+            typer.Option(
+                "--subscribers-port",
+                "-s",
+                help=(
+                    "TCP port where the mrok agent should listen for incoming subscribers "
+                    "connections for request/response messages."
+                ),
+                show_default=True,
+            ),
+        ] = 50001,
     ):
         """Run an ASGI application exposing it through OpenZiti network."""
-        ziticorn.run(app, str(identity_file), workers=workers, reload=reload)
+        ziticorn.run(
+            app,
+            str(identity_file),
+            workers=workers,
+            reload=reload,
+            publishers_port=publishers_port,
+            subscribers_port=subscribers_port,
+        )

mrok/cli/commands/agent/run/sidecar.py

@@ -1,15 +1,10 @@
-import multiprocessing
 from pathlib import Path
 from typing import Annotated
 
 import typer
 
 from mrok.agent import sidecar
-
-
-def number_of_workers():
-    return (multiprocessing.cpu_count() * 2) + 1
-
+from mrok.cli.utils import number_of_workers
 
 default_workers = number_of_workers()
 
@@ -34,15 +29,30 @@ def register(app: typer.Typer) -> None:
                 show_default=True,
             ),
         ] = default_workers,
-        reload: Annotated[
-            bool,
+        publishers_port: Annotated[
+            int,
+            typer.Option(
+                "--publishers-port",
+                "-p",
+                help=(
+                    "TCP port where the mrok agent "
+                    "should connect to publish to request/response messages."
+                ),
+                show_default=True,
+            ),
+        ] = 50000,
+        subscribers_port: Annotated[
+            int,
             typer.Option(
-                "--reload",
-                "-r",
-                help="Enable auto-reload. Default: False",
+                "--subscribers-port",
+                "-s",
+                help=(
+                    "TCP port where the mrok agent should listen for incoming subscribers "
+                    "connections for request/response messages."
+                ),
                 show_default=True,
             ),
-        ] = False,
+        ] = 50001,
     ):
         """Run a Sidecar Proxy to expose a web application through OpenZiti."""
         if ":" in str(target):
@@ -51,4 +61,10 @@ def register(app: typer.Typer) -> None:
         else:
             target_addr = str(target)  # type: ignore
 
-        sidecar.run(str(identity_file), target_addr, workers=workers, reload=reload)
+        sidecar.run(
+            str(identity_file),
+            target_addr,
+            workers=workers,
+            publishers_port=publishers_port,
+            subscribers_port=subscribers_port,
+        )

mrok/cli/commands/agent/utils.py

@@ -0,0 +1,5 @@
+import multiprocessing
+
+
+def number_of_workers() -> int:
+    return (multiprocessing.cpu_count() * 2) + 1

mrok/cli/commands/controller/run.py

@@ -1,18 +1,14 @@
-import multiprocessing
 from collections.abc import Callable
 from typing import Annotated, Any
 
 import typer
 from gunicorn.app.base import BaseApplication
 
+from mrok.cli.utils import number_of_workers
 from mrok.controller.app import app as asgi_app
 from mrok.logging import get_logging_config
 
 
-def number_of_workers():
-    return (multiprocessing.cpu_count() * 2) + 1
-
-
 class StandaloneApplication(BaseApplication):  # pragma: no cover
     def __init__(self, application: Callable, options: dict[str, Any] | None = None):
         self.options = options or {}

mrok/cli/commands/proxy/__init__.py

@@ -0,0 +1,6 @@
+import typer
+
+from mrok.cli.commands.proxy import run
+
+app = typer.Typer(help="mrok proxy commands.")
+run.register(app)

mrok/cli/commands/proxy/run.py

@@ -0,0 +1,49 @@
+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/cli/utils.py

@@ -0,0 +1,5 @@
+import multiprocessing
+
+
+def number_of_workers() -> int:
+    return (multiprocessing.cpu_count() * 2) + 1

mrok/conf.py

@@ -15,6 +15,12 @@ DEFAULT_SETTINGS = {
         "ssl_verify": False,
     },
     "PAGINATION": {"limit": 50},
+    "SIDECAR": {
+        "textual_port": 4040,
+        "store_port": 5051,
+        "store_size": 1000,
+        "textual_command": "python mrok/agent/sidecar/inspector.py",
+    },
 }
 
 _settings = None

mrok/controller/auth.py

@@ -80,8 +80,8 @@ async def authenticate(
         )
         return payload
     except jwt.InvalidKeyError as e:
-        logger.error(f"Invalid jwt token: {e}")
+        logger.error(f"Invalid jwt token: {e} ({credentials.credentials})")
         raise UNAUTHORIZED_EXCEPTION
     except jwt.InvalidTokenError as e:
-        logger.error(f"Invalid jwt token: {e}")
+        logger.error(f"Invalid jwt token: {e} ({credentials.credentials})")
         raise UNAUTHORIZED_EXCEPTION