mrok 0.1.8__tar.gz → 0.2.0__tar.gz

{mrok-0.1.8 → mrok-0.2.0}/.github/workflows/pr-build-merge.yaml

@@ -38,7 +38,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Install the project dependancies
+      - name: Install the project dependencies
         run: uv sync --all-extras --dev
 
       - name: Run formatting checks
@@ -77,7 +77,7 @@ jobs:
         with:
           python-version-file: ".python-version"
 
-      - name: Install the project dependancies
+      - name: Install the project dependencies
         run: uv sync --all-extras --dev
 
       - name: Run tests

{mrok-0.1.8 → mrok-0.2.0}/PKG-INFO

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

{mrok-0.1.8 → mrok-0.2.0}/mrok/controller/app.py

@@ -8,7 +8,8 @@ from fastapi.routing import APIRoute, APIRouter
 from mrok.conf import get_settings
 from mrok.controller.auth import authenticate
 from mrok.controller.openapi import generate_openapi_spec
-from mrok.controller.routes import router as extensions_router
+from mrok.controller.routes.extensions import router as extensions_router
+from mrok.controller.routes.instances import router as instances_router
 
 logger = logging.getLogger(__name__)
 
@@ -52,6 +53,7 @@ def setup_app():
     app.include_router(
         extensions_router, prefix="/extensions", dependencies=[Depends(authenticate)]
     )
+    app.include_router(instances_router, prefix="/instances", dependencies=[Depends(authenticate)])
 
     settings = get_settings()
 

mrok-0.2.0/mrok/controller/routes/instances.py

@@ -0,0 +1,71 @@
+import logging
+
+from fastapi import APIRouter, HTTPException, status
+
+from mrok.controller.dependencies import ZitiManagementAPI
+from mrok.controller.openapi import examples
+from mrok.controller.pagination import LimitOffsetPage, paginate
+from mrok.controller.schemas import InstanceRead
+
+logger = logging.getLogger("mrok.controller")
+
+router = APIRouter()
+
+
+async def fetch_instance_or_404(mgmt_api: ZitiManagementAPI, id_or_instance_id: str):
+    identity = await mgmt_api.search_identity(id_or_instance_id)
+    if not identity:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+        )
+    return identity
+
+
+@router.get(
+    "/{id_or_instance_id}",
+    response_model=InstanceRead,
+    responses={
+        200: {
+            "description": "Instance",
+            "content": {"application/json": {"example": examples.INSTANCE_RESPONSE}},
+        },
+    },
+    dependencies=[],
+    tags=["Instances"],
+)
+async def get_instance_by_id_or_instance_id(
+    mgmt_api: ZitiManagementAPI,
+    id_or_instance_id: str,
+):
+    identity = await fetch_instance_or_404(mgmt_api, id_or_instance_id)
+    return InstanceRead(**identity)
+
+
+@router.get(
+    "",
+    response_model=LimitOffsetPage[InstanceRead],
+    responses={
+        200: {
+            "description": "List of Instances",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "data": [examples.INSTANCE_RESPONSE],
+                        "$meta": {
+                            "pagination": {
+                                "total": 1,
+                                "limit": 10,
+                                "offset": 0,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    tags=["Instances"],
+)
+async def get_instances(
+    mgmt_api: ZitiManagementAPI,
+):
+    return await paginate(mgmt_api, "/identities", InstanceRead)

{mrok-0.1.8 → mrok-0.2.0}/mrok/ziti/api.py

@@ -397,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-0.1.8 → mrok-0.2.0}/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-0.1.8 → mrok-0.2.0}/pyproject.toml

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

mrok-0.1.8/tests/controller/test_instances.py → mrok-0.2.0/tests/controller/test_extensions.py

@@ -1,15 +1,227 @@
 from urllib.parse import quote
 
 import pytest
+from dynaconf.base import LazySettings
 from httpx import AsyncClient
 from pytest_httpx import HTTPXMock
 from pytest_mock import MockerFixture
 
 from mrok.ziti.api import ZitiClientAPI, ZitiManagementAPI
 from mrok.ziti.constants import MROK_SERVICE_TAG_NAME, MROK_VERSION_TAG_NAME
+from mrok.ziti.errors import (
+    ConfigTypeNotFoundError,
+    MrokError,
+    ProxyIdentityNotFoundError,
+    ServiceAlreadyRegisteredError,
+    ServiceNotFoundError,
+)
 from tests.conftest import SettingsFactory
 
 
+@pytest.mark.asyncio
+async def test_list_extensions(
+    api_client: AsyncClient, settings_factory: SettingsFactory, httpx_mock: HTTPXMock
+):
+    settings = settings_factory()
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?limit=5&offset=0",
+        json={
+            "meta": {"pagination": {"totalCount": 10, "limit": 5, "offset": 0}},
+            "data": [{"id": f"svc{i}", "name": "svc"} for i in range(5)],
+        },
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?limit=5&offset=5",
+        json={
+            "meta": {"pagination": {"totalCount": 10, "limit": 5, "offset": 5}},
+            "data": [{"id": f"svc{5 + i}", "name": "svc"} for i in range(5)],
+        },
+    )
+    response = await api_client.get("/extensions?limit=5&offset=0")
+    assert response.status_code == 200
+    page_1 = response.json()
+    assert len(page_1["data"]) == 5
+    assert page_1["$meta"]["pagination"]["offset"] == 0
+
+    response = await api_client.get("/extensions?limit=5&offset=5")
+    assert response.status_code == 200
+    page_2 = response.json()
+    assert len(page_2["data"]) == 5
+    assert page_2["$meta"]["pagination"]["offset"] == 5
+
+    assert sorted(page_1["data"], key=lambda x: x["id"]) != sorted(
+        page_2["data"], key=lambda x: x["id"]
+    )
+
+
+@pytest.mark.asyncio
+async def test_register_extension(mocker: MockerFixture, api_client: AsyncClient):
+    mocked_register = mocker.patch(
+        "mrok.controller.routes.extensions.register_extension",
+        return_value={
+            "id": "a1b2cd",
+            "name": "ext-1234-5678",
+            "tags": {
+                MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+                "account": "ACC-1234-5678",
+            },
+        },
+    )
+
+    response = await api_client.post(
+        "/extensions",
+        json={
+            "extension": {"id": "EXT-1234-5678"},
+            "tags": {"account": "ACC-1234-5678"},
+        },
+    )
+    assert response.status_code == 201
+    assert response.json() == {
+        "id": "a1b2cd",
+        "extension": {"id": "EXT-1234-5678"},
+        "name": "ext-1234-5678",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+            "account": "ACC-1234-5678",
+        },
+    }
+    assert mocked_register.call_count == 1
+    assert isinstance(mocked_register.mock_calls[0].args[0], LazySettings)
+    assert isinstance(mocked_register.mock_calls[0].args[1], ZitiManagementAPI)
+    assert mocked_register.mock_calls[0].args[2] == "EXT-1234-5678"
+    assert mocked_register.mock_calls[0].args[3] == {"account": "ACC-1234-5678"}
+
+
+@pytest.mark.asyncio
+async def test_register_extension_already_exists(mocker: MockerFixture, api_client: AsyncClient):
+    mocker.patch(
+        "mrok.controller.routes.extensions.register_extension",
+        side_effect=ServiceAlreadyRegisteredError("Extension `EXT-1234-5678` already registered."),
+    )
+
+    response = await api_client.post(
+        "/extensions",
+        json={
+            "extension": {"id": "EXT-1234-5678"},
+            "tags": {"account": "ACC-1234-5678"},
+        },
+    )
+    assert response.status_code == 400
+    assert response.json() == {"detail": "Extension `EXT-1234-5678` already registered."}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("exc_type", [ProxyIdentityNotFoundError, ConfigTypeNotFoundError])
+async def test_register_extension_mrok_not_configured(
+    mocker: MockerFixture,
+    api_client: AsyncClient,
+    exc_type: MrokError,
+):
+    mocker.patch(
+        "mrok.controller.routes.extensions.register_extension",
+        side_effect=exc_type("this is the error."),  # type: ignore
+    )
+
+    response = await api_client.post(
+        "/extensions",
+        json={
+            "extension": {"id": "EXT-1234-5678"},
+            "tags": {"account": "ACC-1234-5678"},
+        },
+    )
+    assert response.status_code == 400
+    assert response.json() == {"detail": "OpenZiti not configured properly: this is the error."}
+
+
+@pytest.mark.asyncio
+async def test_get_extension(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        f'(id="EXT-1234-5678" or name="ext-1234-5678") and tags.{MROK_VERSION_TAG_NAME} != null'
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 1}},
+            "data": [
+                {
+                    "id": "svc1",
+                    "name": "ext-1234-5678",
+                    "tags": {MROK_VERSION_TAG_NAME: "0.0.0.dev0"},
+                }
+            ],
+        },
+    )
+
+    response = await api_client.get("/extensions/EXT-1234-5678")
+    assert response.status_code == 200
+    assert response.json() == {
+        "id": "svc1",
+        "extension": {"id": "EXT-1234-5678"},
+        "name": "ext-1234-5678",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+        },
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_extension_not_found(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        f'(id="EXT-1234-5678" or name="ext-1234-5678") and tags.{MROK_VERSION_TAG_NAME} != null'
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 0}},
+            "data": [],
+        },
+    )
+
+    response = await api_client.get("/extensions/EXT-1234-5678")
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_extension(
+    mocker: MockerFixture,
+    api_client: AsyncClient,
+):
+    mocker.patch(
+        "mrok.controller.routes.extensions.unregister_extension",
+    )
+
+    response = await api_client.delete("/extensions/EXT-1234-5678")
+    assert response.status_code == 204
+
+
+@pytest.mark.asyncio
+async def test_delete_extension_not_found(
+    mocker: MockerFixture,
+    api_client: AsyncClient,
+):
+    mocker.patch(
+        "mrok.controller.routes.extensions.unregister_extension",
+        side_effect=ServiceNotFoundError("not found"),
+    )
+
+    response = await api_client.delete("/extensions/EXT-1234-5678")
+    assert response.status_code == 404
+
+
 @pytest.mark.asyncio
 async def test_list_instances(
     mocker: MockerFixture,
@@ -19,7 +231,8 @@ async def test_list_instances(
 ):
     settings = settings_factory()
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     query = quote(f'tags.{MROK_SERVICE_TAG_NAME} = "ext-1234-5678"')
     httpx_mock.add_response(
@@ -58,10 +271,11 @@ async def test_list_instances(
 @pytest.mark.asyncio
 async def test_register_instance(mocker: MockerFixture, api_client: AsyncClient):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     mocked_register = mocker.patch(
-        "mrok.controller.routes.register_instance",
+        "mrok.controller.routes.extensions.register_instance",
         return_value=(
             {
                 "id": "a1b2cd",
@@ -114,7 +328,8 @@ async def test_get_instance(
     httpx_mock: HTTPXMock,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     settings = settings_factory()
     query = quote(
@@ -161,7 +376,8 @@ async def test_get_instance_by_instance_id(
     httpx_mock: HTTPXMock,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     settings = settings_factory()
     query = quote(f'(id="ins1" or name="ins1") and tags.{MROK_VERSION_TAG_NAME} != null')
@@ -205,7 +421,8 @@ async def test_get_instance_not_found(
     httpx_mock: HTTPXMock,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     settings = settings_factory()
     query = quote(
@@ -231,11 +448,11 @@ async def test_delete_instance(
     api_client: AsyncClient,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_instance_or_404",
+        "mrok.controller.routes.extensions.fetch_instance_or_404",
         return_value={"name": "ins-1234-5678.ext-1234-5678"},
     )
     mocker.patch(
-        "mrok.controller.routes.unregister_instance",
+        "mrok.controller.routes.extensions.unregister_instance",
     )
 
     response = await api_client.delete("/extensions/EXT-1234-5678/instances/INS-1234-5678-0001")
@@ -243,7 +460,7 @@ async def test_delete_instance(
 
 
 @pytest.mark.asyncio
-async def test_delete_extension_not_found(
+async def test_delete_instance_extension_not_found(
     mocker: MockerFixture,
     api_client: AsyncClient,
     settings_factory: SettingsFactory,
@@ -251,7 +468,8 @@ async def test_delete_extension_not_found(
 ):
     settings = settings_factory()
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
 
     query = quote(

mrok-0.2.0/tests/controller/test_instances.py

@@ -0,0 +1,157 @@
+from urllib.parse import quote
+
+import pytest
+from httpx import AsyncClient
+from pytest_httpx import HTTPXMock
+
+from mrok.ziti.constants import MROK_SERVICE_TAG_NAME, MROK_VERSION_TAG_NAME
+from tests.conftest import SettingsFactory
+
+
+@pytest.mark.asyncio
+async def test_list_instances(
+    api_client: AsyncClient,
+    settings_factory: SettingsFactory,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?&limit=10&offset=0",
+        json={
+            "meta": {"pagination": {"totalCount": 15, "limit": 10, "offset": 0}},
+            "data": [{"id": f"ins{i}", "name": "ins.svc"} for i in range(10)],
+        },
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?&limit=10&offset=10",
+        json={
+            "meta": {"pagination": {"totalCount": 15, "limit": 10, "offset": 10}},
+            "data": [{"id": f"ins{i}", "name": "ins.svc"} for i in range(11, 16)],
+        },
+    )
+    response = await api_client.get("/instances?limit=10&offset=0")
+    assert response.status_code == 200
+    page_1 = response.json()
+    assert len(page_1["data"]) == 10
+    assert page_1["$meta"]["pagination"]["offset"] == 0
+
+    response = await api_client.get("/instances?limit=10&offset=10")
+    assert response.status_code == 200
+    page_2 = response.json()
+    assert len(page_2["data"]) == 5
+    assert page_2["$meta"]["pagination"]["offset"] == 10
+
+    assert sorted(page_1["data"], key=lambda x: x["id"]) != sorted(
+        page_2["data"], key=lambda x: x["id"]
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_instance(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        '(id="INS-1234-1234-0001.ext-1234-1234" or name="ins-1234-1234-0001.ext-1234-1234") '
+        f"and tags.{MROK_VERSION_TAG_NAME} != null"
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 1}},
+            "data": [
+                {
+                    "id": "ins1",
+                    "name": "ins-1234-1234-0001.ext-1234-1234",
+                    "tags": {
+                        MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+                        MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+                    },
+                }
+            ],
+        },
+    )
+
+    response = await api_client.get("/instances/INS-1234-1234-0001.ext-1234-1234")
+    assert response.status_code == 200
+    assert response.json() == {
+        "id": "ins1",
+        "identity": None,
+        "extension": {"id": "EXT-1234-1234"},
+        "instance": {"id": "INS-1234-1234-0001"},
+        "name": "ins-1234-1234-0001.ext-1234-1234",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+            MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+        },
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_instance_by_instance_id(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(f'(id="ins1" or name="ins1") and tags.{MROK_VERSION_TAG_NAME} != null')
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 1}},
+            "data": [
+                {
+                    "id": "ins1",
+                    "name": "ins-1234-1234-0001.ext-1234-1234",
+                    "tags": {
+                        MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+                        MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+                    },
+                }
+            ],
+        },
+    )
+
+    response = await api_client.get("/instances/ins1")
+    assert response.status_code == 200
+    assert response.json() == {
+        "id": "ins1",
+        "extension": {"id": "EXT-1234-1234"},
+        "instance": {"id": "INS-1234-1234-0001"},
+        "name": "ins-1234-1234-0001.ext-1234-1234",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+            MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+        },
+        "identity": None,
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_instance_not_found(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        '(id="INS-1234-1234-0001.ext-1234-1234" or name="ins-1234-1234-0001.ext-1234-1234") '
+        f"and tags.{MROK_VERSION_TAG_NAME} != null"
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 10}},
+            "data": [],
+        },
+    )
+
+    response = await api_client.get("/instances/INS-1234-1234-0001.ext-1234-1234")
+    assert response.status_code == 404

{mrok-0.1.8 → mrok-0.2.0}/tests/ziti/test_api.py

@@ -236,6 +236,7 @@ async def test_search_methods(
     ("method_name", "endpoint"),
     [
         ("delete_config", "/configs"),
+        ("delete_config_type", "/config-types"),
         ("delete_service_policy", "/service-policies"),
         ("delete_service_router_policy", "/service-edge-router-policies"),
         ("delete_router_policy", "/edge-router-policies"),