mrok 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

mrok/cli/commands/admin/__init__.py

@@ -1,10 +1,12 @@
 import typer
 
 from mrok.cli.commands.admin import bootstrap
+from mrok.cli.commands.admin.list import app as list_app
 from mrok.cli.commands.admin.register import app as register_app
 from mrok.cli.commands.admin.unregister import app as unregister_app
 
 app = typer.Typer(help="mrok administrative commands.")
 app.add_typer(register_app)
 app.add_typer(unregister_app)
+app.add_typer(list_app)
 bootstrap.register(app)

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

@@ -0,0 +1,8 @@
+import typer
+
+from mrok.cli.commands.admin.list import extensions, instances
+
+app = typer.Typer(name="list", help="Show resources in OpenZiti.")
+
+extensions.register(app)
+instances.register(app)

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

@@ -0,0 +1,144 @@
+import asyncio
+from typing import Annotated
+
+import typer
+from rich import box
+from rich.table import Table
+
+from mrok.cli.commands.admin.utils import (
+    extract_names,
+    format_tags,
+    format_timestamp,
+    tags_to_filter,
+)
+from mrok.cli.rich import get_console
+from mrok.conf import Settings
+from mrok.ziti.api import ZitiManagementAPI
+
+
+async def get_extensions(
+    settings: Settings, detailed: bool, tags: list[str] | None = None
+) -> list[dict]:
+    async with ZitiManagementAPI(settings) as api:
+        if tags is None:
+            params = None
+        else:
+            params = {"filter": tags_to_filter(tags)}
+
+        services = [service async for service in api.services(params=params)]
+        if detailed:
+            for service in services:
+                service["configs"] = [
+                    config
+                    async for config in api.collection_iterator(
+                        f"/services/{service['id']}/configs",
+                    )
+                ]
+                service["policies"] = [
+                    policy
+                    async for policy in api.collection_iterator(
+                        f"/services/{service['id']}/service-policies",
+                    )
+                ]
+        return services
+
+
+def render_tsv(extensions: list[dict], detailed: bool) -> None:
+    console = get_console()
+    if detailed:
+        console.print("id\tname\tconfigurations\tpolicies\ttags\tcreated\tupdated")
+        for extension in extensions:
+            console.print(
+                f"{extension['id']}\t{extension['name']}\t"
+                f"{extract_names(extension['configs'], ', ')}\t"
+                f"{extract_names(extension['policies'], ', ')}\t"
+                f"{format_tags(extension['tags'], ', ')}\t"
+                f"{format_timestamp(extension['createdAt'])}\t"
+                f"{format_timestamp(extension['updatedAt'])}"
+            )
+    else:
+        console.print("id\tname\ttags\tcreated")
+        for extension in extensions:
+            console.print(
+                f"{extension['id']}\t{extension['name']}\t"
+                f"{format_tags(extension['tags'], ', ')}\t"
+                f"{format_timestamp(extension['createdAt'])}\t"
+            )
+
+
+def render_table(extensions: list[dict], detailed: bool) -> None:
+    table = Table(
+        box=box.ROUNDED,
+        title="🔍 Extensions in OpenZiti (services):",
+        title_justify="left",
+        border_style="#472AFF",
+        show_lines=True,
+    )
+    table.add_column("Id", style="green")
+    table.add_column("Name", style="bold cyan")
+    if detailed:
+        table.add_column("Configurations")
+        table.add_column("Service Policies")
+    table.add_column("Tags")
+    table.add_column("Created", style="dim")
+    if detailed:
+        table.add_column("Updated", style="dim")
+
+    for extension in extensions:
+        row = [
+            extension["id"],
+            extension["name"],
+        ]
+        if detailed:
+            row += [
+                extract_names(extension["configs"]),
+                extract_names(extension["policies"]),
+            ]
+        row += [
+            format_tags(extension["tags"]),
+            format_timestamp(extension["createdAt"]),
+        ]
+        if detailed:
+            row.append(format_timestamp(extension["updatedAt"]))
+
+        table.add_row(*row)
+
+    get_console().print(table)
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("extensions")
+    def list_extensions(
+        ctx: typer.Context,
+        detailed: bool = typer.Option(
+            False,
+            "--detailed",
+            "-d",
+            help="Output detailed information",
+        ),
+        tags: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--tag",
+                "-t",
+                help="Add tag",
+                show_default=True,
+            ),
+        ] = None,
+        tsv_output: bool = typer.Option(
+            False,
+            "--tsv",
+            help="Output as TSV",
+        ),
+    ):
+        """List extensions in OpenZiti (service)."""
+        extensions = asyncio.run(get_extensions(ctx.obj, detailed, tags))
+
+        if len(extensions) == 0:
+            get_console().print("No extensions found.")
+            return
+
+        if tsv_output:
+            render_tsv(extensions, detailed)
+        else:
+            render_table(extensions, detailed)

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

@@ -0,0 +1,167 @@
+import asyncio
+from typing import Annotated
+
+import typer
+from rich import box
+from rich.table import Table
+
+from mrok.cli.commands.admin.utils import (
+    extract_names,
+    format_tags,
+    format_timestamp,
+    tags_to_filter,
+)
+from mrok.cli.rich import get_console
+from mrok.conf import Settings
+from mrok.ziti.api import ZitiManagementAPI
+from mrok.ziti.constants import (
+    MROK_IDENTITY_TYPE_TAG_NAME,
+    MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE,
+)
+
+
+async def get_instances(
+    settings: Settings, detailed: bool, extension: str | None = None, tags: list[str] | None = None
+) -> list[dict]:
+    async with ZitiManagementAPI(settings) as api:
+        tags = tags or []
+        tags.append(f"{MROK_IDENTITY_TYPE_TAG_NAME}={MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE}")
+        identities = [
+            identity async for identity in api.identities(params={"filter": tags_to_filter(tags)})
+        ]
+        if detailed or extension:
+            for identity in identities:
+                identity["services"] = [
+                    service
+                    async for service in api.collection_iterator(
+                        f"/identities/{identity['id']}/services"
+                    )
+                ]
+                identity["policies"] = [
+                    policy
+                    async for policy in api.collection_iterator(
+                        f"/identities/{identity['id']}/service-policies"
+                    )
+                ]
+
+        if extension:
+            return [
+                identity
+                for identity in identities
+                if any(
+                    service["id"] == extension or service["name"] == extension
+                    for service in identity["services"]
+                )
+            ]
+
+        return identities
+
+
+def render_tsv(instances: list[dict], detailed: bool) -> None:
+    console = get_console()
+    if detailed:
+        console.print("id\tname\tservices\tpolicies\ttags\tcreated\tupdated")
+        for instance in instances:
+            console.print(
+                f"{instance['id']}\t{instance['name']}\t"
+                f"{extract_names(instance['services'], ', ')}\t"
+                f"{extract_names(instance['policies'], ', ')}\t"
+                f"{format_tags(instance['tags'], ', ')}\t"
+                f"{format_timestamp(instance['createdAt'])}\t"
+                f"{format_timestamp(instance['updatedAt'])}"
+            )
+    else:
+        console.print("id\tname\ttags\tcreated")
+        for instance in instances:
+            console.print(
+                f"{instance['id']}\t{instance['name']}\t"
+                f"{format_tags(instance['tags'], ', ')}\t"
+                f"{format_timestamp(instance['createdAt'])}\t"
+            )
+
+
+def render_table(instances: list[dict], detailed: bool) -> None:
+    table = Table(
+        box=box.ROUNDED,
+        title="🔍 Instances in OpenZiti (identities):",
+        title_justify="left",
+        border_style="#472AFF",
+        show_lines=True,
+    )
+    table.add_column("Id", style="green")
+    table.add_column("Name", style="bold cyan")
+    if detailed:
+        table.add_column("Associated services")
+        table.add_column("Associated service policies")
+    table.add_column("Tags")
+    table.add_column("Created", style="dim")
+    if detailed:
+        table.add_column("Updated", style="dim")
+
+    for instance in instances:
+        row = [
+            instance["id"],
+            instance["name"],
+        ]
+        if detailed:
+            row += [
+                extract_names(instance["services"]),
+                extract_names(instance["policies"]),
+            ]
+        row += [
+            format_tags(instance["tags"]),
+            format_timestamp(instance["createdAt"]),
+        ]
+        if detailed:
+            row.append(format_timestamp(instance["updatedAt"]))
+
+        table.add_row(*row)
+
+    get_console().print(table)
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("instances")
+    def list_instances(
+        ctx: typer.Context,
+        extension: Annotated[
+            str | None,
+            typer.Option(
+                "--extension",
+                "-e",
+                help="Filter instances by extension",
+                show_default=True,
+            ),
+        ] = None,
+        tags: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--tag",
+                "-t",
+                help="Add tag",
+                show_default=True,
+            ),
+        ] = None,
+        detailed: bool = typer.Option(
+            False,
+            "--detailed",
+            "-d",
+            help="Output detailed information",
+        ),
+        tsv_output: bool = typer.Option(
+            False,
+            "--tsv",
+            help="Output as TSV",
+        ),
+    ):
+        """List instances in OpenZiti (identities)."""
+        instances = asyncio.run(get_instances(ctx.obj, detailed, extension, tags))
+
+        if len(instances) == 0:
+            get_console().print("No instances found.")
+            return
+
+        if tsv_output:
+            render_tsv(instances, detailed)
+        else:
+            render_table(instances, detailed)

mrok/cli/commands/admin/utils.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 import typer
 
 from mrok.ziti.api import TagsType
@@ -21,3 +23,27 @@ def parse_tags(pairs: list[str] | None) -> TagsType | None:
             val = raw
         result[key.strip()] = val
     return result
+
+
+def tags_to_filter(tags: list[str]) -> str:
+    parsed_tags = parse_tags(tags)
+    return " and ".join([f'tags.{key}="{value}"' for key, value in parsed_tags.items()])
+
+
+def format_timestamp(iso_timestamp: str) -> str:
+    dt = datetime.strptime(iso_timestamp, "%Y-%m-%dT%H:%M:%S.%fZ")
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def format_tags(tags: dict, delimiter: str = "\n") -> str:
+    if not tags:
+        return "-"
+
+    return f"{delimiter}".join(f"{k}: {v}" for k, v in tags.items())
+
+
+def extract_names(data: list[dict], delimiter: str = "\n") -> str:
+    if not data:
+        return "-"
+
+    return f"{delimiter}".join(item["name"] for item in data if item.get("name"))

mrok/ziti/api.py

@@ -81,8 +81,16 @@ class BaseZitiAPI(ABC):
         response.raise_for_status()
         return response.json()["data"]["id"]
 
-    async def get(self, endpoint: str, id: str) -> dict[str, Any]:
-        response = await self.httpx_client.get(f"{endpoint}/{id}")
+    async def get(
+        self,
+        endpoint: str,
+        id: str,
+        additional_path: str | None = None,
+    ) -> dict[str, Any]:
+        url = f"{endpoint}/{id}"
+        if additional_path:
+            url = f"{url}/{additional_path}"
+        response = await self.httpx_client.get(url)
         response.raise_for_status()
         return response.json()["data"]
 
@@ -258,11 +266,17 @@ class ZitiManagementAPI(BaseZitiAPI):
     def base_url(self):
         return f"{self.settings.ziti.api.management}/edge/management/v1"
 
-    def services(self) -> AsyncGenerator[dict[str, Any], None]:
-        return self.collection_iterator("/services")
+    def services(
+        self,
+        params: dict[str, Any] | None = None,
+    ) -> AsyncGenerator[dict[str, Any], None]:
+        return self.collection_iterator("/services", params=params)
 
-    def identities(self) -> AsyncGenerator[dict[str, Any], None]:
-        return self.collection_iterator("/identities")
+    def identities(
+        self,
+        params: dict[str, Any] | None = None,
+    ) -> AsyncGenerator[dict[str, Any], None]:
+        return self.collection_iterator("/identities", params=params)
 
     async def search_config(self, id_or_name) -> dict[str, Any] | None:
         return await self.search_by_id_or_name("/configs", id_or_name)
@@ -383,6 +397,9 @@ class ZitiManagementAPI(BaseZitiAPI):
     async def search_config_type(self, id_or_name: str) -> dict[str, Any] | None:
         return await self.search_by_id_or_name("/config-types", id_or_name)
 
+    async def delete_config_type(self, config_type_id: str) -> dict[str, Any] | None:
+        return await self.delete("/config-types", config_type_id)
+
     async def get_identity(self, identity_id: str) -> dict[str, Any]:
         return await self.get("/identities", identity_id)
 

mrok/ziti/bootstrap.py

@@ -19,19 +19,27 @@ async def bootstrap_identity(
 
     identity_json = None
     existing_identity = await mgmt_api.search_identity(identity_name)
+    policy = await mgmt_api.search_router_policy(identity_name)
+    config_type_name = f"{mode}.proxy.v1"
+    config_type = await mgmt_api.search_config_type(config_type_name)
 
     if forced and existing_identity:
         logger.info(f"Deleting existing identity '{identity_name}' ({existing_identity['id']})")
 
-        policy = await mgmt_api.search_router_policy(identity_name)
         if policy:
             await mgmt_api.delete_router_policy(policy["id"])
             logger.info(f"Deleted existing ERP '{policy['name']}' ({policy['id']})")
+            policy = None
 
         await mgmt_api.delete_identity(existing_identity["id"])
         logger.info("Deleted existing identity")
         existing_identity = None
 
+    if forced and config_type:
+        await mgmt_api.delete_config_type(config_type["id"])
+        logger.info(f"Deleted existing config type '{config_type_name}' ({config_type['id']})")
+        config_type = None
+
     if existing_identity:
         frontend_id = existing_identity["id"]
         logger.info(f"Identity '{identity_name}' ({frontend_id}) is already enrolled")
@@ -44,7 +52,6 @@ async def bootstrap_identity(
         )
         logger.info(f"Identity '{identity_name}' ({frontend_id}) successfully enrolled")
 
-    policy = await mgmt_api.search_router_policy(identity_name)
     if not policy:
         policy_id = await mgmt_api.create_router_policy(
             identity_name,
@@ -55,8 +62,6 @@ async def bootstrap_identity(
     else:
         logger.info(f"Found ERP '{policy['name']}' ({policy['id']})")
 
-    config_type_name = f"{mode}.proxy.v1"
-    config_type = await mgmt_api.search_config_type(config_type_name)
     if config_type is None:
         config_type_id = await mgmt_api.create_config_type(config_type_name, tags=tags)
         logger.info(f"Created '{config_type_name}' ({config_type_id}) config type")

mrok/ziti/constants.py

@@ -3,4 +3,7 @@ import mrok
 MROK_VERSION_TAG_NAME = "mrok"
 MROK_VERSION_TAG_VALUE = mrok.__version__
 MROK_VERSION_TAG = {MROK_VERSION_TAG_NAME: MROK_VERSION_TAG_VALUE}
-MROK_SERVICE_TAG_NAME = "mrok.service"
+MROK_SERVICE_TAG_NAME = "mrok-service"
+MROK_IDENTITY_TYPE_TAG_NAME = "mrok-identity-type"
+MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE = "instance"
+MROK_IDENTITY_TYPE_TAG_VALUE_PROXY = "proxy"

mrok/ziti/identities.py

@@ -5,7 +5,12 @@ import jwt
 
 from mrok.ziti import pki
 from mrok.ziti.api import TagsType, ZitiClientAPI, ZitiManagementAPI
-from mrok.ziti.constants import MROK_SERVICE_TAG_NAME
+from mrok.ziti.constants import (
+    MROK_IDENTITY_TYPE_TAG_NAME,
+    MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE,
+    MROK_IDENTITY_TYPE_TAG_VALUE_PROXY,
+    MROK_SERVICE_TAG_NAME,
+)
 from mrok.ziti.errors import (
     ProxyIdentityAlreadyExistsError,
     ServiceNotFoundError,
@@ -25,6 +30,7 @@ async def register_instance(
     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 = await mgmt_api.search_service(service_name)
     if not service:
         raise ServiceNotFoundError(f"A service with name `{extension_id}` does not exists.")
@@ -100,6 +106,8 @@ async def enroll_proxy_identity(
         raise ProxyIdentityAlreadyExistsError(
             f"A proxy identity with name `{identity_name}` already exists."
         )
+    tags = tags or {}
+    tags[MROK_IDENTITY_TYPE_TAG_NAME] = MROK_IDENTITY_TYPE_TAG_VALUE_PROXY
     identity_id = await mgmt_api.create_device_identity(identity_name, tags=tags)
     identity_json = await _enroll_identity(mgmt_api, client_api, identity_id)
     logger.info(f"Enrolled proxy identity '{identity_name}'")

{mrok-0.1.7.dist-info → mrok-0.1.9.dist-info}/METADATA

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

{mrok-0.1.7.dist-info → mrok-0.1.9.dist-info}/RECORD

@@ -11,9 +11,12 @@ 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/commands/__init__.py,sha256=M6Sypb2vAh6qxQQJNIO9xop2DrD6zt6TEp8rbbD7LS0,114
-mrok/cli/commands/admin/__init__.py,sha256=dc5oZVdcLzG0Jroq1eIzX3VslcgP58fBX8aWzZHKYF4,333
+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=yd6FWHqsyfgWu8ch9WX8Js18Hvlx7LdzwMHCaB1ExXU,645
+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=HpEXk7DfeAXeUwi8Z4qnOmQCB1_lPm2JVBl8k0tjvUk,5179
 mrok/cli/commands/admin/register/__init__.py,sha256=5Jb_bc2L47MEpQIrOcquzduTFWQ01Jd1U1MpqaR-Ekw,209
 mrok/cli/commands/admin/register/extensions.py,sha256=nX2PUX8hmsWjyp2dGgge2YmkfeGgGXhqk7fwUx99o9o,1489
 mrok/cli/commands/admin/register/instances.py,sha256=_9xpa4rZYmf7SZ58hx103EuEbA3o2FZYbAVmpT8oRhM,1930
@@ -47,15 +50,15 @@ mrok/http/master.py,sha256=o_0Sxe2XuTgVAwvBbWkYcO3HkCcfvYP4rgxcuIDPwXo,2426
 mrok/http/protocol.py,sha256=ap8jbLUvgbAH81ZJZCBkQiYR7mkV_eL3rpfwEkoE8sU,392
 mrok/http/server.py,sha256=Mj7C85fc-DXp-WTBWaOd7ag808oliLmFBH5bf-G2FHg,370
 mrok/ziti/__init__.py,sha256=20OWMiexRhOovZOX19zlX87-V78QyWnEnSZfyAftUdE,263
-mrok/ziti/api.py,sha256=vWu9XXptPCcuaoI0c0VM4QFd_vmh2ZgdmqQSzZ-kIPk,15700
-mrok/ziti/bootstrap.py,sha256=pg-8tt2t2Xt-o85UZe2ixfEtX_6eDuK5gqaCbfuCD6Q,2522
-mrok/ziti/constants.py,sha256=VO0LnsXZse2q4TW6HYqO6nrSQ8wX1673iEy-s9Y7jPU,192
+mrok/ziti/api.py,sha256=onVOSgcqALTeC3EBX-RPJvkqQ3OhhzvJ91HPsGaIJC4,16171
+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=nVdXVeAGnW8slwy_X2N52vSDXbIF_TMD46751ajJpgE,5088
+mrok/ziti/identities.py,sha256=oE_3j6Y4xCr6uKNdprW55bxGsyKnmJt-MrxrylB2Ey4,5388
 mrok/ziti/pki.py,sha256=-V3LDAtntYZ4C6IH2rqfAANxmzpOZ32Rd0MK_27YNME,1906
 mrok/ziti/services.py,sha256=JnznLTHNZjgbFwnBtv7y2XIp4NiQxLVawwP9EfWdVuM,3208
-mrok-0.1.7.dist-info/METADATA,sha256=Z0jLZf_ZJeUJ8pTe6xy64GDbToee3XDCX72HM242ZjU,15506
-mrok-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mrok-0.1.7.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
-mrok-0.1.7.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
-mrok-0.1.7.dist-info/RECORD,,
+mrok-0.1.9.dist-info/METADATA,sha256=C6efuUa5kHfw19OLwZVawjLZEcGXBMCH7vV3YniB9Fw,15506
+mrok-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mrok-0.1.9.dist-info/entry_points.txt,sha256=tloXwvU1uJicBJR2h-8HoVclPgwJWDwuREMHN8Zq-nU,38
+mrok-0.1.9.dist-info/licenses/LICENSE.txt,sha256=6PaICaoA3yNsZKLv5G6OKqSfLSoX7MakYqTDgJoTCBs,11346
+mrok-0.1.9.dist-info/RECORD,,