catalystwan 0.40.2.dev1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

catalystwan/api/logs_api.py

@@ -1,63 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from datetime import datetime as dt
-from pathlib import Path
-from typing import TYPE_CHECKING, Optional
-from urllib.parse import quote
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class LogsAPI:
-    """Class for get and save audit log file
-
-    Usage example:
-        # Create session
-        session = create_manager_session(...)
-        # Get auditlogs
-        session.api.logs.get_auditlogs()
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-
-    def get_auditlogs(self, file_path: Optional[str] = None, n_hours: int = 1) -> None:
-        query = {
-            "query": {
-                "condition": "AND",
-                "rules": [
-                    {
-                        "field": "entry_time",
-                        "type": "date",
-                        "value": [f"{n_hours}"],
-                        "operator": "last_n_hours",
-                    }
-                ],
-            }
-        }
-        addon_to_url = quote(str(query), safe="").replace("%27", "%22")
-
-        url_path = f"/dataservice/auditlog/severity?query={addon_to_url}"
-        logs = self.session.get_data(url_path)
-
-        if file_path is None:
-            file_path = str(Path(__file__).parents[0] / "audit.log")
-
-        with open(file_path, "w") as file:
-            for log in logs:
-                time = dt.utcfromtimestamp(log["entry_time"] / 1000)
-                time_readable = time.strftime("%Y-%m-%d %H:%M:%S")
-                file.write(
-                    f"Entry time: {time_readable} - LogId: {log['logid']} - "
-                    f"Log message: {log['logmessage']} - TenantId: {log['tenant']}\n"
-                )
-
-        logger.info(f"Logs saved to {file_path}")
-
-        return None

catalystwan/api/monitoring_status_api.py

@@ -1,76 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, List
-
-from catalystwan.endpoints.monitoring.status import MonitoringStatus, Status, UpdateStatus
-from catalystwan.typed_list import DataSequence
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class MonitoringStatusAPI:
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-        self._endpoints = MonitoringStatus(session)
-
-    def __str__(self) -> str:
-        return str(self.session)
-
-    def get_statistic_settings(self) -> DataSequence[Status]:
-        """Get list of enabled statistics indexes
-
-        Returns:
-            DataSequence[EnabledIndex]: DataSequence of EnabledIndex objects
-        """
-        return self._endpoints.get_statistics_settings()
-
-    def update_statistics_settings(self, payload: List[UpdateStatus]) -> DataSequence[Status]:
-        """Update statistics indexes
-
-        Args:
-            payload (list[Status]): list of UpdateStatus objects
-
-        Returns:
-            DataSequence[Status]: DataSequence of Status objects
-        """
-        return self._endpoints.update_statistics_settings(payload)
-
-    def get_disabled_devices_by_index(self, index_name: str) -> List[str]:
-        """Get list of disabled devices for a statistics index
-
-        Args:
-            index_name (str): name of the statistics index
-
-        Returns:
-            List[str]: List of disables devices ips
-        """
-        return self._endpoints.get_disabled_device_list(index_name).root
-
-    def update_disabled_devices_by_index(self, index_name: str, payload: List[str]) -> bool:
-        """Update list of disabled devices for a statistics index
-
-        Args:F
-            index_name (str): name of the statistics index
-            payload (list[str]): list of str objects
-
-        Returns:
-            bool: True if successful
-        """
-        return self._endpoints.update_statistics_device_list(index_name, payload).response
-
-    def get_enabled_index_for_device(self, device_ip: str) -> List[str]:
-        """Get list of enabled device for statistics index
-
-        Args:
-            device_ip (str): IP address of the device
-
-        Returns:
-            List[str]: List of enables indexes
-        """
-        return self._endpoints.get_enabled_index_for_device(device_ip).root

catalystwan/api/mtt_aaa_api.py

@@ -1,197 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-from catalystwan.dataclasses import TenantAAA, TenantRadiusServer, TenantTacacsServer
-from catalystwan.exceptions import CatalystwanException
-from catalystwan.utils.creation_tools import asdict, create_dataclass
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-
-class AAAConfigNotPresent(CatalystwanException):
-    pass
-
-
-def status_ok(func):
-    def wrapper(*args, **kwargs):
-        response = func(*args, **kwargs)
-        return True if response.status_code in [200, 204] else False
-
-    return wrapper
-
-
-class TenantAaaAPI:
-    """
-    Used to configure  mtt tenant management users remote servers
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-        self.url_path = "/dataservice/admin/aaa"
-
-    def __str__(self) -> str:
-        return str(self.session)
-
-    def aaa_exists(self) -> bool:
-        return True if self.session.get_data(self.url_path) else False
-
-    @status_ok
-    def add_aaa(self, tenant_aaa: TenantAAA):
-        """ "
-        TenantAAA:
-            "authOrder": [ "local", "radius", "tacacs"],
-            "authFallback": true,
-            "adminAuthOrder": false,
-            "auditDisable": false,
-            "accounting": false,
-            "radiusServers": "server1"
-        returns bool depending on the api post call
-        """
-        data = asdict(tenant_aaa)  # type: ignore
-        return self.session.post(url=self.url_path, json=data)
-
-    def get_aaa(self) -> TenantAAA:
-        """
-        Returns the Tenant AAA
-        :param aaa:
-        :return:
-        """
-        logger.debug("AAA config")
-        tenant_aaa = self.session.get_data(self.url_path)
-        # return tenant_aaa
-        return create_dataclass(TenantAAA, tenant_aaa)
-
-    @status_ok
-    def del_aaa(self):
-        """
-        Delete aaa works only for tenants
-        :return:
-        """
-        if not self.aaa_exists():
-            raise AAAConfigNotPresent("No AAA config present for Tenant")
-        logger.debug("Delete AAA config on tenant")
-        return self.session.delete(self.url_path)
-
-    @status_ok
-    def put_aaa(self, tenant_AAA: TenantAAA):
-        """
-        Updated the AAA for tenant
-        :return:
-        """
-        data = asdict(tenant_AAA)  # type: ignore
-        return self.session.put(url=self.url_path, json=data)
-
-
-class TenantRadiusAPI:
-    """
-    Used to configure  mtt tenant remote aaa radius servers
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-        self.url_path = "/dataservice/admin/radius"
-
-    def __str__(self) -> str:
-        return str(self.session)
-
-    @status_ok
-    def add_radius(self, radius_server: TenantRadiusServer):
-        """
-        Create RADIUS for tenant
-        :param radius_server:
-        :return:
-        """
-        logger.debug("Add RADIUS config")
-        data = asdict(radius_server)  # type: ignore
-        return self.session.post(url=self.url_path, json=data)
-
-    @status_ok
-    def put_radius(self, radius_server: TenantRadiusServer):
-        """
-        edit radius server
-        :param radius_server:
-        :return:
-        """
-        logger.debug("Update RADIUS config")
-        data = asdict(radius_server)  # type: ignore
-        return self.session.put(url=self.url_path, json=data)
-
-    @status_ok
-    def delete_radius(self):
-        """
-        edit radius server
-        :param radius_server:
-        :return: True|False
-        """
-        logger.debug("Delete RADIUS config")
-        return self.session.delete(self.url_path)
-
-    def get_radius(self) -> TenantRadiusServer:
-        """
-        Retrieve Radius server
-        :return: TenantRadiusServer
-        """
-        logger.debug("RADIUS config")
-        data = self.session.get_data(self.url_path)
-        return create_dataclass(TenantRadiusServer, data)
-
-
-class TenantTacacsAPI:
-    """
-    Used to configure mtt tenant remote aaa TACACS servers
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-        self.url_path = "/dataservice/admin/tacacs"
-
-    def __str__(self) -> str:
-        return str(self.session)
-
-    @status_ok
-    def add_tacacs(self, tacacs_server: TenantTacacsServer):
-        """
-        Create TACACS for tenant
-        :param tacacs_server:
-        :return:
-        """
-        logger.debug("TACACS config")
-        data = asdict(tacacs_server)  # type: ignore
-        return self.session.post(url=self.url_path, json=data)
-
-    @status_ok
-    def put_tacacs(self, tacacs_server: TenantTacacsServer):
-        """
-        Update tacacs server
-        :param tacacs_server:
-        :return:
-        """
-        logger.debug("Update TACACS config")
-        data = asdict(tacacs_server)  # type: ignore
-        return self.session.put(url=self.url_path, json=data)
-
-    @status_ok
-    def delete_tacacs(self):
-        """
-        Deletes tacacs server
-        :param tacacs_server:
-        :return: True|False
-        """
-        logger.debug("Delete TACACS config")
-        return self.session.delete(self.url_path)
-
-    def get_tacacs(self) -> TenantTacacsServer:
-        """
-        Retrieves Tacacs server
-        :return: TenantTacacsServer
-        """
-        logger.debug("TACACS config")
-        data = self.session.get_data(self.url_path)
-        return create_dataclass(TenantTacacsServer, data)

catalystwan/api/omp_api.py

@@ -1,124 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, List
-
-from catalystwan.dataclasses import (
-    OmpAdvertisedRouteData,
-    OmpAdvertisedTlocData,
-    OmpPeerData,
-    OmpReceivedRouteData,
-    OmpReceivedTlocData,
-    OmpServiceData,
-    OmpSummaryData,
-)
-from catalystwan.utils.creation_tools import create_dataclass
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class OmpAPI:
-    """OMP API methods of vManage for get common omp data.
-
-    Attributes:
-        session (ManagerSession): logged in API client session
-
-    Usage example:
-        # Create session and chose device
-        session = create_manager_session(...)
-        device = DevicesAPI(session).get().filter(personality = Personality.VSMART)[0]
-        # Gets OMP peers for a device
-        omp_peers = session.api.omp.get_omp_peers(device.id)
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-
-    def __str__(self) -> str:
-        return str(self.session)
-
-    def get_omp_peers(self, device_id: str) -> List[OmpPeerData]:
-        """Gets OMP peers for a device.
-
-        Args:
-            device_id (str): device ID (usually system-ip)
-
-        Returns:
-            List[OmpPeerData]: OmpPeerData object
-        """
-        items = self.session.get_data(f"/dataservice/device/omp/peers?deviceId={device_id}")
-        return [create_dataclass(OmpPeerData, item) for item in items]
-
-    def get_advertised_routes(self, device_id: str) -> List[OmpAdvertisedRouteData]:
-        """Gets OMP advertised routes data for a device.
-
-        Args:
-            device_id (str): device ID (usually system-ip)
-
-        Returns:
-            List[OmpAdvertisedRouteData]: OmpAdvertisedRouteData objects
-        """
-        items = self.session.get_data(f"/dataservice/device/omp/routes/advertised?deviceId={device_id}")
-        return [create_dataclass(OmpAdvertisedRouteData, item) for item in items]
-
-    def get_received_routes(self, device_id: str) -> List[OmpReceivedRouteData]:
-        """Gets OMP received routes data for a device.
-
-        Args:
-            device_id (str): device ID (usually system-ip)
-
-        Returns:
-            List[OmpReceivedRouteData]: OmpReceivedRouteData objects
-        """
-        items = self.session.get_data(f"/dataservice/device/omp/routes/received?deviceId={device_id}")
-        return [create_dataclass(OmpReceivedRouteData, item) for item in items]
-
-    def get_advertised_tlocs(self, device_id: str) -> List[OmpAdvertisedTlocData]:
-        """Gets OMP advertised TLOCs data for a device.
-
-        Args:
-            device_id (str): device_id: device ID (usually system-ip)
-
-        Returns:
-            List[OmpAdvertisedTlocData]: OmpAdvertisedTlocData objects
-        """
-        items = self.session.get_data(f"/dataservice/device/omp/tlocs/advertised?deviceId={device_id}")
-        return [create_dataclass(OmpAdvertisedTlocData, item) for item in items]
-
-    def get_received_tlocs(self, device_id: str) -> List[OmpReceivedTlocData]:
-        """Gets OMP received TLOCs for a device.
-
-        Args:
-            device_id (str): device ID (usually system-ip)
-
-        Returns:
-            List[OmpReceivedTlocData]: OmpReceivedTlocData objects
-        """
-        items = self.session.get_data(f"/dataservice/device/omp/tlocs/received?deviceId={device_id}")
-        return [create_dataclass(OmpReceivedTlocData, item) for item in items]
-
-    def get_services(self, device_id: str) -> List[OmpServiceData]:
-        """Gets OMP services data for a device.
-
-        Args:
-            device_id (str): device ID (usually system-ip)
-
-        Returns:
-            List[OmpServiceData]: OmpServiceData objects
-        """
-        items = self.session.get_data(f"/dataservice/device/omp/services?deviceId={device_id}")
-        return [create_dataclass(OmpServiceData, item) for item in items]
-
-    def get_omp_summary(self, device_id: str) -> List[OmpSummaryData]:
-        """Gets OMP summaries data for a device.
-
-        Args:
-            device_id (str): device ID (usually system-ip)
-
-        Returns:
-            List[OmpSummaryData]: OmpSummaryData objects
-        """
-        items = self.session.get_data(f"/dataservice/device/omp/summary?deviceId={device_id}")
-        return [create_dataclass(OmpSummaryData, item) for item in items]

catalystwan/api/packet_capture_api.py

@@ -1,152 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-import time
-from contextlib import contextmanager
-from enum import Enum
-from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, Optional
-
-from catalystwan.api.basic_api import DeviceStateAPI
-from catalystwan.dataclasses import Device, PacketSetup, Status
-from catalystwan.utils.creation_tools import create_dataclass
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-
-class DownloadStatus(Enum):
-    COMPLETED = "COMPLETED"
-    IMPOSSIBLE = "IMPOSSIBLE"
-    FILESIZE = None
-
-
-class PacketCaptureAPI:
-    """Methods for setting up packet capture session, and download .pcap session file.
-
-    Args:
-        session:
-        vpn: Defaults to 0.
-        interface: Defaults to ge0/1.
-
-    Examples:
-        >>> edge_device = session.api.devices.get().filter(personality=Personality.EDGE)[0]
-        >>> packet_capture = session.api.packet_capture.get_packets(edge_device)
-    """
-
-    def __init__(
-        self,
-        session: ManagerSession,
-        vpn: str = "0",
-        interface: str = "ge0/1",
-    ) -> None:
-        self.session = session
-        self.vpn = vpn
-        self.interface = interface
-
-    def get_packets(self, device: Device, duration_seconds=120) -> Status:
-        """Initiate packet capture process.
-
-        Args:
-            device (Device): Device class object
-            duration_seconds (int, optional): Duration od packet capturing . Defaults to 20.
-
-        Returns:
-            Status
-        """
-        with DeviceStateAPI(self.session).enable_data_stream():
-            try:
-                with self.channel(device):
-                    with self.start_stop(device):
-                        time.sleep(duration_seconds)
-            except PermissionError as err:
-                failed_status_dict = {
-                    "fileDownloadStatus": DownloadStatus.IMPOSSIBLE.value,
-                    "fileSize": DownloadStatus.FILESIZE.value,
-                }
-                self.status = create_dataclass(Status, failed_status_dict)
-                logger.error(str(err))
-            return self.status
-
-    @contextmanager
-    def channel(self, device: Device) -> Iterator:
-        """Creates packet capture session.
-
-        Args:
-            device (Device): Device class object
-
-        Raises:
-            PermissionError: if already another packet capture session is active
-
-        Yields:
-            Iterator: packet_channel which contains session ID
-        """
-        query = {
-            "deviceUUID": device.uuid,
-            "vpn": self.vpn,
-            "interface": self.interface,
-            "type": "control",
-        }
-
-        try:
-            url_path = r"/dataservice/stream/device/capture"
-            packet_setup = self.session.post(url=url_path, json=query).json()
-            logger.debug(f"Packet capture session for device {device.uuid} has been opened")
-            self.packet_channel = create_dataclass(PacketSetup, packet_setup)
-            if self.packet_channel.is_new_session is True:
-                yield self.packet_channel
-            else:
-                self.status = None  # type: ignore
-                raise PermissionError("Can't start new session, another is already open")
-        finally:
-            for _ in range(3):
-                time.sleep(10)
-                self.status = self.get_status(self.packet_channel)
-                if self.status.file_download_status == DownloadStatus.COMPLETED.value:
-                    self.download_capture_session(self.packet_channel, device)
-                    logger.debug(f"Packet downloading for device {device.uuid} has been finished")
-                    url_path = f"/dataservice/stream/device/capture/disable/{self.packet_channel.session_id}"
-                    self.session.get_json(url_path)
-                    logger.debug(f"Packet capture session for device {device.uuid} has been disabled")
-                    break
-
-    @contextmanager
-    def start_stop(self, device: Device) -> Iterator:
-        """Start and stops packet capturing.
-
-        Yields:
-            Iterator: None
-        """
-        try:
-            url_path = f"/dataservice/stream/device/capture/start/{self.packet_channel.session_id}"
-            self.session.get_json(url_path)
-            logger.debug(f"Packet capturing for device {device.uuid} has been started")
-            yield None
-
-        finally:
-            url_path = f"/dataservice/stream/device/capture/stop/{self.packet_channel.session_id}"
-            self.session.get_json(url_path)
-            logger.debug(f"Packet capturing for device {device.uuid} has been stoped")
-
-    def get_interface_name(self, device: Device) -> str:
-        url_path = f"/dataservice/device/interface/synced?deviceId={device.local_system_ip}"
-        ifname = dict(self.session.get_json(url_path))
-        if_name = str(ifname["data"][0]["ifname"])
-        return if_name
-
-    def download_capture_session(self, packet: PacketSetup, device: Device, file_path: Optional[str] = None) -> bool:
-        if file_path is None:
-            file_path = f"{Path(__file__).parents[0]}/{device.uuid}.pcap"
-        url = f"/dataservice/stream/device/capture/download/{packet.session_id}"
-        self.session.get_file(url, file_path)  # type: ignore
-        return True
-
-    def get_status(self, packet_channel: PacketSetup) -> Status:
-        url_path = f"/dataservice/stream/device/capture/status/{packet_channel.session_id}"
-        status = self.session.get_json(url_path)
-        self.status = create_dataclass(Status, status)
-        return self.status

catalystwan/api/parcel_api.py

@@ -1,42 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Protocol
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-from catalystwan.endpoints.configuration_feature_profile import ParcelId, SDRoutingConfigurationFeatureProfile
-from catalystwan.models.feature_profile_parcel import FullConfig, FullConfigParcel
-
-
-class ParcelAPI(Protocol):
-    def create(self, name: str, description: str, data: dict) -> ParcelId:
-        ...
-
-    def edit(self, parcel_id: str, name: str, description: str, data: dict) -> None:
-        ...
-
-    def delete(self, parcel_id: str) -> None:
-        ...
-
-
-class SDRoutingFullConfigParcelAPI(ParcelAPI):
-    def __init__(self, session: ManagerSession, fp_id: str):
-        self.session = session
-        self.fp_id = fp_id
-        self.endpoint = SDRoutingConfigurationFeatureProfile(session)
-
-    def create(self, name: str, description: str, data: dict) -> ParcelId:
-        payload = FullConfigParcel(name=name, description=description, data=FullConfig(fullconfig=data["fullconfig"]))
-
-        return self.endpoint.create_cli_full_config_parcel(self.fp_id, payload=payload)
-
-    def edit(self, parcel_id: str, name: str, description: str, data: dict) -> None:
-        payload = FullConfigParcel(name=name, description=description, data=FullConfig(fullconfig=data["fullconfig"]))
-
-        self.endpoint.edit_cli_full_config_parcel(cli_fp_id=self.fp_id, parcel_id=parcel_id, payload=payload)
-
-    def delete(self, parcel_id: str) -> None:
-        self.endpoint.delete_cli_full_config_parcel(cli_fp_id=self.fp_id, parcel_id=parcel_id)