catalystwan 0.40.1.dev7__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

catalystwan/api/templates/payloads/cisco_vpn/feature/mapping.json.j2

@@ -1,24 +0,0 @@
-{% for host in mapping %}
-    {
-        "hostname": {
-            "vipObjectType": "object",
-            "vipType": "constant",
-            "vipValue": "{{ host.name }}",
-            "vipVariableName": "vpn_host_hostname"
-        },
-        "ip": {
-            "vipObjectType": "list",
-            "vipType": "constant",
-            "vipValue": [
-                {% for ip in host.ips%}
-                    "{{ ip }}"{% if not loop.last %},{% endif %}
-                {% endfor %}
-            ],
-            "vipVariableName": "vpn_host_ip"
-        },
-        "priority-order": [
-            "hostname",
-            "ip"
-        ]
-    }{% if not loop.last %},{% endif %}
-{% endfor %}

catalystwan/api/templates/payloads/tenant/tenant.json.j2

@@ -1,127 +0,0 @@
-{
-    "templateName": "{{ template_name }}",
-    "templateDescription": "{{ template_description }}",
-    "templateType": "tenant",
-    "deviceType": [
-        "vedge-C8000V"
-    ],
-    "templateMinVersion": "15.0.0",
-    "templateDefinition": {
-        "tenant": {
-            "vipType": {% if tenants %}"constant"{% else %}"ignore"{% endif %},
-            "vipValue": [
-                {% for tenant in tenants %}{
-							"global-tenant-id": {
-								"vipObjectType": "object",
-								"vipType": "constant",
-								"vipValue": {{ tenant.tenant_info.flake_id }} 
-							},
-                            "org-name": {
-                                "vipObjectType": "object",
-                                "vipType": "constant",
-                                "vipValue": "{{ tenant.organization_name }}",
-                                "vipVariableName": "tenantOrgName_login"
-                            },
-                            "priority-order": [
-                                "org-name",
-                                "universal-unique-id",
-                                "global-tenant-id",
-                                "tenant-tloc",
-                                "tier"
-                            ],
-                            "tier": {
-                                "max": {
-                                    "routes": {
-                                        "address-family": {
-                                            "ipv4": {
-                                                "unicast-route-limit": {
-                                                    "route-limit": {
-                                                        "vipObjectType": "object",
-                                                        "vipType": {% if tenant.tier_info.ipv4_route_limit %}"constant"{% else %}"ignore"{% endif %},
-                                                        "vipValue": {{ tenant.tier_info.ipv4_route_limit | tojson }}
-                                                    },
-                                                    "warning-only": {
-                                                        "vipObjectType": "node-only",
-                                                        "vipType": "ignore",
-                                                        "vipValue": false
-                                                    },
-                                                    "warning-threshold": {
-                                                        "vipObjectType": "object",
-                                                        "vipType": {% if tenant.tier_info.ipv4_route_limit_threshold %}"constant"{% else %}"ignore"{% endif %},
-                                                        "vipValue": {{ tenant.tier_info.ipv4_route_limit_threshold | tojson }}
-                                                    }
-                                                }
-                                            },
-                                            "ipv6": {
-                                                "unicast-route-limit": {
-                                                    "route-limit": {
-                                                        "vipObjectType": "object",
-                                                        "vipType": {% if tenant.tier_info.ipv6_route_limit %}"constant"{% else %}"ignore"{% endif %},
-                                                        "vipValue": {{ tenant.tier_info.ipv6_route_limit | tojson }}
-                                                    },
-                                                    "warning-only": {
-                                                        "vipObjectType": "node-only",
-                                                        "vipType": "ignore",
-                                                        "vipValue": false
-                                                    },
-                                                    "warning-threshold": {
-                                                        "vipObjectType": "object",
-                                                        "vipType": {% if tenant.tier_info.ipv6_route_limit_threshold %}"constant"{% else %}"ignore"{% endif %},
-                                                        "vipValue": {{ tenant.tier_info.ipv6_route_limit_threshold | tojson }}
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                },
-                                "max-vpn": {
-                                    "vipObjectType": "object",
-                                    "vipType": "constant",
-                                    "vipValue": {{ tenant.tier_info.vpn }}
-                                },
-                                "tier-name": {
-                                    "vipObjectType": "object",
-                                    "vipType": "constant",
-                                    "vipValue": "{{ tenant.tier_name }}"
-                                }
-                            },
-                            "tenant-tloc": {
-                                "vipObjectType": "tree",
-                                "vipPrimaryKey": [
-                                    "color", "encap"
-                                ],
-                                "vipType": "constant",
-                                "vipValue": [
-                                    {% for tloc in tenant.tier_info.tlocs %}{
-                                        "color": {
-                                            "vipObjectType": "object",
-                                            "vipType": "constant",
-                                            "vipValue": "{{ tloc.color }}"
-                                        },
-                                        "encap": {
-                                            "vipObjectType": "object",
-                                            "vipType": "constant",
-                                            "vipValue": "{{ tloc.encapsulation }}"
-                                        },
-                                        "priority-order": ["color", "encap"]
-                                    }
-                                    {% if not loop.last %},{% endif %}
-                                    {% endfor %}
-                                ]
-                            },
-                            "universal-unique-id": {
-                                "vipObjectType": "object",
-                                "vipType": "constant",
-                                "vipValue": "{{ tenant.tenant_info.tenant_id }}"
-                            }
-                        }{% if not loop.last %},{% endif %}
-                {% endfor %}
-            ],
-            "vipObjectType": "tree",
-            "vipPrimaryKey": [
-                "org-name"
-            ]
-        }
-    },
-    "factoryDefault": false
-}

catalystwan/api/templates/payloads/tenant/tenant_model.py

@@ -1,43 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, ClassVar, List, Optional
-
-from pydantic import BaseModel, ConfigDict
-
-from catalystwan.api.templates.feature_template import FeatureTemplate
-from catalystwan.endpoints.monitoring.device_details import Tier as TierInfo
-from catalystwan.models.tenant import Tenant as TenantInfo
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class Tenant(BaseModel):
-    """Tenant definition without TLOCs."""
-
-    organization_name: str
-    tier_name: str
-    tenant_info: Optional[TenantInfo] = None
-    tier_info: Optional[TierInfo] = None
-
-
-class TenantModel(FeatureTemplate):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    type: ClassVar[str] = "tenant"  # Tenant
-    payload_path: ClassVar[Path] = Path(__file__).parent / "tenant.json.j2"
-
-    tenants: List[Tenant] = []
-
-    def generate_payload(self, session: ManagerSession) -> str:
-        tenant_infos = session.endpoints.tenant_management.get_all_tenants()
-        tier_infos = session.endpoints.monitoring_device_details.get_tiers()
-
-        for tenant in self.tenants:
-            tenant.tier_info = tier_infos.filter(name=tenant.tier_name).single_or_default()
-            tenant.tenant_info = tenant_infos.filter(org_name=tenant.organization_name).single_or_default()
-
-        return super().generate_payload(session)

catalystwan/api/tenant_backup_restore_api.py

@@ -1,154 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-"""
-Module for apidocs/#/Tenant Backup Restore
-"""
-from __future__ import annotations
-
-import logging
-import re
-from pathlib import Path
-from typing import TYPE_CHECKING, List, Optional
-
-from catalystwan.api.task_status_api import SubTaskData, Task
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-
-class TenantBackupRestoreAPI:
-    """
-    Class for tenant backup and restore
-
-    Scope:
-        Provider-as-tenant or tenant
-
-    Attributes:
-        session (ManagerSession): logged in API client session
-
-    Example usage:
-        from catalystwan.api.tenant_backup_restore_api import TenantBackupRestoreAPI
-        from catalystwan.session import create_manager_session
-
-
-        tenant_session = create_manager_session(
-             tenant_domain, tenantadmin, password, port)
-        provider_tenant_session = create_manager_session(
-            domain, admin, password, port, subdomain=tenant_domain)
-
-        tenant_backup_restore = TenantBackupRestoreAPI(tenant_session)
-        provider_backup_restore = TenantBackupRestoreAPI(provider_tenant_session)
-
-        file_name = tenant_backup_restore.export()
-        file_list = provider_backup_restore.list()
-        file = tenant_backup_restore.download(file_name)
-        status = provider_backup_restore.import_file(file)
-        deleted_list = tenant_backup_restore.delete(file_name)
-        deleted_list = provider_backup_restore.delete_all()
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-
-    def list(self) -> list:
-        """Return a list of backup files stored on vManage
-
-        Returns:
-            list of filenames
-
-        Example usage:
-            fileList = ProviderBackupRestore.list()
-        """
-        return self.session.get_json("/dataservice/tenantbackup/list")["backup_files"]
-
-    def export(self, timeout: int = 300) -> str:
-        """Export tenant backup file from DB to vManage storage
-
-        Args:
-            timeout: Max polling time for task (default: 300 seconds)
-
-        Returns:
-            str: filename of exported tenant backup file stored on vManage
-
-        Example usage:
-            fileName = ProviderBackupRestore.export()
-        """
-        response = self.session.get_json("/dataservice/tenantbackup/export")
-        status = Task(self.session, response["processId"]).wait_for_completed(timeout_seconds=timeout)
-        string = re.search("""file location: (.*)""", status.sub_tasks_data[0].activity[-1])
-        assert string, "File location not found."
-        return string.group(1)
-
-    def delete(self, file: str) -> List[str]:
-        """Delete tenant backup file
-
-        Args:
-            file (str): device ID (usually system-ip)
-
-        Returns:
-            http response for delete operation
-
-        Example usage:
-            message = ProviderBackupRestore.delete(fileName)
-        """
-        url = f"/dataservice/tenantbackup/delete?fileName={file}"
-        return self.session.delete(url).json()["Deleted"]
-
-    def delete_all(self) -> List[str]:
-        """Delete all tenant backup files
-
-        Returns:
-            http response for delete operation
-
-        Example usage:
-            message = ProviderBackupRestore.delete_all()
-        """
-        return self.delete("all")
-
-    def download(self, file: str, download_dir: Optional[Path] = None) -> Path:
-        """Download tenant backup file
-
-        Args:
-            file: full path or base name of tenant backup file
-            download_dir: download directory (defaul: current working directory)
-
-        Returns:
-            Path to downloaded tenant backup file
-
-        Example usage:
-            file = ProviderBackupRestore.download(fileName)
-        """
-
-        if "/dataservice/tenantbackup/download/" not in file:
-            tenant_id = file.split("_")[1]
-            file = f"/dataservice/tenantbackup/download/{tenant_id}/{file}"
-
-        download_dir = download_dir if download_dir else Path.cwd()
-        download = download_dir / Path(file).name
-        self.session.get_file(file, download)
-        return download
-
-    def import_file(self, file: Path, timeout: int = 300) -> SubTaskData:
-        """Upload the file for tenant import to the DB and poll for Success
-
-        Args:
-            file: The path of the file to be upladed
-            timeout: Max polling time for task (default: 300 seconds)
-
-        Returns:
-            TaskStatus object with Success and Activity messages
-
-        Example usage:
-             status = ProviderBackupRestore.import_file(file)
-        """
-
-        url = "/dataservice/tenantbackup/import"
-        files = {"file": (file.name, open(str(file), "rb"))}
-        response = self.session.post(url, data={}, files=files)
-        return (
-            Task(self.session, response.json()["processId"])
-            .wait_for_completed(timeout_seconds=timeout)
-            .sub_tasks_data[0]
-        )

catalystwan/api/tenant_management_api.py

@@ -1,127 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, List
-
-from catalystwan.api.task_status_api import Task
-from catalystwan.endpoints.tenant_management import (
-    TenantBulkDeleteRequest,
-    TenantManagement,
-    TenantStatus,
-    TenantUpdateRequest,
-    vSmartPlacementUpdateRequest,
-    vSmartTenantCapacity,
-    vSmartTenantMap,
-)
-from catalystwan.models.tenant import Tenant
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-from catalystwan.typed_list import DataSequence
-
-
-class TenantManagementAPI:
-    def __init__(self, session: ManagerSession):
-        self.session = session
-        self._endpoints = TenantManagement(session)
-
-    def get(self) -> DataSequence[Tenant]:
-        """Lists all the tenants on the vManage.
-
-        In a multitenant vManage system, this API is only avaiable in the Provider view.
-
-        Returns:
-            DataSequence[TenantInfo]: List-like object containing tenant information
-        """
-        return self._endpoints.get_all_tenants()
-
-    def create(self, tenants: List[Tenant]) -> Task:
-        """Creates tenants on vManage
-
-        Args:
-            tenants (List[Tenant]): List of tenants to be created
-
-        Returns:
-            Task: Object representing tenant creation process
-        """
-        task_id = self._endpoints.create_tenant_async_bulk(tenants).id
-        return Task(self.session, task_id)
-
-    def update(self, tenant_update_request: TenantUpdateRequest) -> Tenant:
-        """Updates Tenant on vManage
-
-        Args:
-            tenant_update_request (TenantUpdateRequest): Tenant attributes to be updated (must contain tenantId)
-
-        Returns:
-            Tenant: Updated tenant data
-        """
-        return self._endpoints.update_tenant(
-            tenant_id=tenant_update_request.tenant_id, tenant_update_request=tenant_update_request
-        )
-
-    def delete(self, tenant_id_list: List[str], password: str) -> Task:
-        """Deletes tenants on vManage
-
-        Args:
-            tenant_ids (List[str]): Tenant IDs to be deleted
-            password (Optional[str]): Provider password if not provided current session password will be used
-
-        Returns:
-            Task: Object representing tenant deletion process
-        """
-        delete_request = TenantBulkDeleteRequest(tenant_id_list=tenant_id_list, password=password)
-        task_id = self._endpoints.delete_tenant_async_bulk(delete_request).id
-        return Task(self.session, task_id)
-
-    def get_statuses(self) -> DataSequence[TenantStatus]:
-        """Gets tenant statuses from vManage
-
-        Returns:
-            DataSequence[TenantStatus]: List-like object containing tenants statuses
-        """
-        return self._endpoints.get_all_tenant_statuses()
-
-    def get_hosting_capacity_on_vsmarts(self) -> DataSequence[vSmartTenantCapacity]:
-        """Gets tenant hosting capacity on vSmarts
-
-        Returns:
-            DataSequence[vSmartTenantCapacity]: List-like object containing tenant capacity information for each vSmart
-        """
-        return self._endpoints.get_tenant_hosting_capacity_on_vsmarts()
-
-    def update_vsmart_placement(self, tenant_id: str, src_vsmart_uuid: str, dst_vsmart_uuid: str):
-        """Updates vSmart placement
-
-        Args:
-            tenant_id (str): Tenant ID
-            src_vsmart_uuid (str): Source vSmart uuid
-            dst_vsmart_uuid (str): Destination vSmart uuid
-        """
-        self._endpoints.update_tenant_vsmart_placement(
-            tenant_id=tenant_id,
-            vsmart_placement_update_request=vSmartPlacementUpdateRequest(
-                src_vsmart_uuid=src_vsmart_uuid, dest_vsmart_uuid=dst_vsmart_uuid
-            ),
-        )
-
-    def get_vsmart_mapping(self) -> vSmartTenantMap:
-        """Gets vSmart to tenant mapping
-
-        Returns:
-            vSmartTenantMap: Contains vSmart to tenant mapping
-        """
-        return self._endpoints.get_tenant_vsmart_mapping()
-
-    def vsession_id(self, tenant_id: str) -> str:
-        """Gets VSessionId for given tenant
-
-        Args:
-            tenant_id (str): Tenant ID
-
-        Returns:
-            str: Contains VSessionId for given tenant
-        """
-        return self._endpoints.vsession_id(tenant_id).vsessionid

catalystwan/api/tenant_migration_api.py

@@ -1,121 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-import re
-from pathlib import Path
-from typing import TYPE_CHECKING, Optional
-
-from packaging.version import Version  # type: ignore
-
-from catalystwan.api.task_status_api import Task, TaskResult
-from catalystwan.endpoints.tenant_migration import ImportInfo, MigrationFile, MigrationTokenQueryParams
-from catalystwan.exceptions import TenantMigrationExportFileNotFound
-from catalystwan.models.tenant import TenantExport
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class ExportTask(Task):
-    def __init__(self, session: ManagerSession, task_id: str):
-        super().__init__(session, task_id)
-
-    @staticmethod
-    def get_file_name_from_export_task_result(task_result: TaskResult) -> str:
-        filepath = re.search("""file location: (.*)""", task_result.sub_tasks_data[0].activity[-1])
-        if not filepath:
-            raise TenantMigrationExportFileNotFound("Client cannot find export file name in export task result")
-        return Path(filepath.group(1)).name
-
-    def wait_for_file(self) -> str:
-        task_result = super().wait_for_completed()
-        return self.get_file_name_from_export_task_result(task_result)
-
-
-class ImportTask(Task):
-    def __init__(self, session: ManagerSession, import_info: ImportInfo):
-        super().__init__(session, import_info.process_id)
-        self.import_info = import_info
-
-
-class TenantMigrationAPI:
-    """Set of methods used in tenant migration"""
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-
-    def export_tenant(self, tenant: TenantExport) -> ExportTask:
-        """Exports the deployment and configuration data from a Cisco vManage instance.
-        Should be executed on migration origin.
-
-        Args:
-            tenant (Tenant): Tenant object containig required fields: desc, name, subdomain, org_name
-
-        Returns:
-            Task: object representing initiated export process
-        """
-        process_id = self.session.endpoints.tenant_migration.export_tenant_data(tenant).process_id
-        return ExportTask(self.session, process_id)
-
-    def download(self, download_path: Path, remote_filename: str = "default.tar.gz"):
-        """Download exported deployment and configuration data from a Cisco vManage instance
-        to a local file system. Should be executed on migration origin.
-
-        Args:
-            download_path (Path): full download path containing a filename eg.: Path("/home/user/tenant-export.tar.gz")
-            remote_filename (str): path to exported tenant migration file on vManage
-        """
-        tenant_data = self.session.endpoints.tenant_migration.download_tenant_data(remote_filename)
-        with open(download_path, "wb") as file:
-            file.write(tenant_data)
-
-    def import_tenant(self, import_file: Path, migration_key: Optional[str] = None) -> ImportTask:
-        """Imports the deployment and configuration data into multi-tenant vManage instance.
-        Should be executed on migration target.
-
-        Args:
-            import_file (Path): full path to previously exported data file
-            migration_key (str): migration key (required starting from 20.13)
-
-        Returns:
-            ImportTask: object representing initiated import process
-        """
-        import_file_payload = MigrationFile(import_file)
-        if self.session.api_version >= Version("20.13") and migration_key is not None:
-            import_info = self.session.endpoints.tenant_migration.import_tenant_data_with_key(
-                import_file_payload, migration_key
-            )
-        else:
-            import_info = self.session.endpoints.tenant_migration.import_tenant_data(import_file_payload)
-        return ImportTask(self.session, import_info)
-
-    def store_token(self, migration_id: str, download_path: Path):
-        """Stores migration token as text file for given migration identifier.
-        Should be executed on migration target.
-
-        Args:
-            migration_id (str): migration identifier (it is obtained after import tenant task is finished)
-            download_path (Path): full download path containing a filename eg.: Path("/home/user/import-token.txt")
-        """
-        params = MigrationTokenQueryParams(migration_id=migration_id)
-        token = self.session.endpoints.tenant_migration.get_migration_token(params)
-        with open(download_path, "w") as file:
-            file.write(token)
-
-    def migrate_network(self, token_file: Path) -> Task:
-        """Starts migration procedure on migration origin.
-
-        Args:
-            token_file (Path): full path to previously stored text file with import token.
-
-        Returns:
-            Task: object representing initiated migration process
-        """
-        with open(token_file, "r") as file:
-            token = file.read()
-        process_id = self.session.endpoints.tenant_migration.migrate_network(token).process_id
-        return Task(self.session, process_id)