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

catalystwan/api/dashboard_api.py

@@ -1,215 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from catalystwan.typed_list import DataSequence
-from catalystwan.utils.creation_tools import create_dataclass
-from catalystwan.utils.dashboard import (
-    CertificatesStatus,
-    Count,
-    DeviceHealth,
-    DeviceHealthOverview,
-    DevicesHealth,
-    LicensedDevices,
-    TenantStatus,
-    TransportHealth,
-    TunnelHealth,
-)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class DashboardAPI:
-    """Dashboard API gathers information from vManage dashboard.
-
-    Attributes:
-        session (ManagerSession): logged in API client session
-
-    Usage example:
-        # Create session
-        session = create_manager_session(...)
-        # Get information about tenant status
-        tenant_status = session.api.dashboard.get_tenant_status()
-    """
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-
-    def get_vmanages_count(self) -> DataSequence[Count]:
-        """
-        Get information about number of vmanages.
-
-        Returns:
-            DataSequance of Count dataclass with vManages
-        """
-        vmanages = self.session.get_data("/dataservice/clusterManagement/health/summary")
-
-        vmanages = DataSequence(Count, [create_dataclass(Count, vmanage) for vmanage in vmanages])
-        for vmanage in vmanages:
-            vmanage.status_list = DataSequence(Count, [create_dataclass(Count, item) for item in vmanage.status_list])
-
-        return vmanages
-
-    def get_devices_count(self) -> DataSequence[Count]:
-        """
-        Get information about number of devices (does not include vManages).
-
-        Returns:
-            DataSequance of Count dataclass with devices
-        """
-        devices = self.session.get_data("/dataservice/network/connectionssummary")
-
-        devices = DataSequence(Count, [create_dataclass(Count, device) for device in devices])
-        for device in devices:
-            device.status_list = DataSequence(Count, [create_dataclass(Count, item) for item in device.status_list])
-
-        return devices
-
-    def get_certificates_status(self) -> DataSequence[CertificatesStatus]:
-        """
-        Get information about status of certificates.
-
-        Returns:
-            DataSequance of CertificatesStatus dataclass with devices
-        """
-        devices = self.session.get_data("/dataservice/certificate/stats/summary")
-
-        return DataSequence(CertificatesStatus, [create_dataclass(CertificatesStatus, device) for device in devices])
-
-    def get_control_statuses_count(self) -> DataSequence[Count]:
-        """
-        Get information about control statuses.
-
-        Returns:
-            DataSequance of Count dataclass with control statuses
-        """
-        statuses = self.session.get_data("/dataservice/device/control/count")
-
-        statuses = DataSequence(Count, [create_dataclass(Count, status) for status in statuses])
-        for status in statuses:
-            status.status_list = DataSequence(Count, [create_dataclass(Count, item) for item in status.status_list])
-
-        return statuses
-
-    def get_bfd_connectivity_count(self) -> DataSequence[Count]:
-        """
-        Get information about bfd connectivity count.
-
-        Returns:
-            DataSequance of Count dataclass with bfd connectivity
-        """
-        response = self.session.get("/dataservice/device/bfd/sites/summary")
-
-        bfd_response = response.dataseq(Count)
-        for item in bfd_response:
-            item.status_list = DataSequence(
-                Count, [create_dataclass(Count, bfd_connection) for bfd_connection in item.status_list]  # type:ignore
-            )
-
-        return bfd_response
-
-    def get_edges_inventory_count(self) -> DataSequence[Count]:
-        """
-        Get information about edges inventory.
-
-        Returns:
-            DataSequance of Count dataclass with edges inventory count
-        """
-        response = self.session.get("/dataservice/device/vedgeinventory/summary")
-
-        edges_inventory = response.dataseq(Count)
-
-        return edges_inventory
-
-    def get_transport_interface_distribution(self) -> DataSequence[Count]:
-        """
-        Get information about transport interface distribution.
-
-        Returns:
-            DataSequance of Count dataclass with transport interface distribution
-        """
-        response = self.session.get("/dataservice/device/tlocutil")
-
-        transport_interface = response.dataseq(Count)
-
-        return transport_interface
-
-    def get_tenant_status(self) -> DataSequence[TenantStatus]:
-        """
-        Get information about tenant status, including:
-        - control status
-        - site health
-        - vEdge health
-        - vSmart status
-
-        Returns:
-            DataSequance of TenantStatus dataclass with tenant status information
-        """
-        response = self.session.get("/dataservice/tenantstatus")
-
-        transport_interface = response.dataseq(TenantStatus)
-
-        return transport_interface
-
-    def get_devices_health(self) -> DevicesHealth:
-        """
-        Get information about devices health
-
-        Returns:
-            DevicesHealth object
-        """
-        response = self.session.get_json("/dataservice/health/devices")
-        devices_health = create_dataclass(DevicesHealth, response)
-
-        devices_health.devices = DataSequence(
-            DeviceHealth, [create_dataclass(DeviceHealth, device) for device in devices_health.devices]  # type: ignore
-        )
-
-        return devices_health
-
-    def get_licensed_devices(self) -> DataSequence[LicensedDevices]:
-        """
-        Get information about licensed devices.
-
-        Returns:
-            DataSequance of LicensedDevices dataclass with licences information.
-        """
-        response = self.session.get("/dataservice/msla/monitoring/licensedDeviceCount")
-
-        return response.dataseq(LicensedDevices)
-
-    def get_devices_health_overview(self) -> DataSequence[DeviceHealthOverview]:
-        """
-        Get information about health overview devices.
-
-        Returns:
-            DataSequance of DeviceHealthOverview dataclass with health information.
-        """
-        response = self.session.get_json("/dataservice/health/devices/overview")
-
-        return DataSequence(DeviceHealthOverview, [create_dataclass(DeviceHealthOverview, response)])
-
-    def get_transport_health(self) -> DataSequence[TransportHealth]:
-        """
-        Get information about loss percentage, latency and jitter for all links and combinations of colors.
-
-        Returns:
-            DataSequance of TransportHealth dataclass with loss percentage, latency and jitter information.
-        """
-        response = self.session.get("/dataservice/statistics/approute/transport/summary/loss_percentage")
-
-        return response.dataseq(TransportHealth)
-
-    def get_tunnel_health(self) -> DataSequence[TunnelHealth]:
-        """
-        Get information about state, loss percentage, latency and jitter for tunnels.
-
-        Returns:
-            DataSequance of TunnelHealth dataclass with tunnel health information.
-        """
-        response = self.session.get("/dataservice/statistics/approute/tunnels/health/latency")
-
-        return response.dataseq(TunnelHealth)

catalystwan/api/device_action_api.py

@@ -1,216 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
-
-from tenacity import retry, retry_if_result, stop_after_attempt, wait_fixed  # type: ignore
-
-from catalystwan.api.basic_api import DevicesAPI, DeviceStateAPI
-from catalystwan.dataclasses import Device
-from catalystwan.utils.certificate_status import CertificateStatus
-from catalystwan.utils.operation_status import OperationStatus
-from catalystwan.utils.personality import Personality
-from catalystwan.utils.reachability import Reachability
-from catalystwan.utils.validate_status import ValidateStatus
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class DeviceActionAPI(ABC):
-    """API method to execute action on Device."""
-
-    def __init__(self, session: ManagerSession, dev: Device):
-        self.session = session
-        self.dev = dev
-        self.action_status = ""
-        self.action_id = ""
-        self.action_status_api = "/dataservice/device/action/status/"
-
-    def __str__(self):
-        return str(self.session)
-
-    @abstractmethod
-    def execute(self):
-        raise NotImplementedError
-
-    @abstractmethod
-    def wait_for_completed(
-        self,
-        sleep_seconds: int,
-        timeout_seconds: int,
-        expected_status: str,
-        expected_reachability: str,
-    ):
-        raise NotImplementedError
-
-
-class RebootAction(DeviceActionAPI):
-    """API method to perform reboot on Device."""
-
-    def execute(self):
-        """Reboots the device.
-
-        Returns:
-            reboot process id
-
-        Raises:
-            Exception when reboot was not successful.
-
-        Usage example:
-        # Create session and chose device
-        session = create_manager_session(...)
-        device = DevicesAPI(session).get().filter(personality = Personality.VSMART)[0]
-        # Restart device
-        RebootAction(session, device).execute()
-        """
-        controllers = (Personality.VBOND, Personality.VSMART)
-        device_type = "controller" if self.dev.personality in controllers else self.dev.personality.value
-
-        body = {
-            "action": "reboot",
-            "deviceType": device_type,
-            "devices": [{"deviceIP": self.dev.id, "deviceId": self.dev.uuid}],
-        }
-        response = self.session.post("/dataservice/device/action/reboot", json=body).json()
-        if response.get("id"):
-            self.action_id = response["id"]
-        else:
-            raise Exception(f"Problem with reboot of {self.dev.id} occurred")
-
-    def wait_for_completed(
-        self,
-        sleep_seconds: int = 15,
-        timeout_seconds: int = 1800,
-        expected_status: str = OperationStatus.SUCCESS.value,
-        expected_reachability: str = Reachability.REACHABLE.value,
-    ):
-        def check_status(action_data):
-            return not action_data == expected_status
-
-        @retry(
-            wait=wait_fixed(sleep_seconds),
-            stop=stop_after_attempt(int(timeout_seconds / sleep_seconds)),
-            retry=retry_if_result(check_status),
-        )
-        def wait_for_come_up():
-            status_api = f"{self.action_status_api}{self.action_id}"
-            # from my observation it is necessary to wait minimum 1 second for data related with reboot
-            try:
-                action_data = self.session.get_data(f"{status_api}")[0]["status"]
-                logger.debug(f"Status of device {self.dev.hostname} reboot is: {action_data}")
-            except IndexError:
-                action_data = ""
-            status = DeviceStateAPI(self.session).get_system_status(self.dev.id)
-            # it is necessary to wait also for Success of reboot because device can be reachable even several
-            # seconds after execute reboot
-            if status.reachability.value == expected_reachability:
-                return action_data
-            else:
-                return None
-
-        wait_for_come_up()
-
-
-class ValidateAction(DeviceActionAPI):  # TODO check
-    """
-    API method to perform validate Device
-
-    Usage example:
-    # Create session and chose device
-    session = create_manager_session(...)
-    device = DevicesAPI(session).get().filter(personality = Personality.VSMART)[0]
-    # Validate device
-    ValidateAction(session, device).execute()
-    """
-
-    def execute(self, valid: bool = True):
-        """
-        validate device
-        """
-        body = {
-            "chasisNumber": self.dev.uuid,
-            "serialNumber": self.dev.board_serial,
-            "validity": "valid" if valid else "invalid",
-        }
-
-        response = self.session.post(url="/dataservice/certificate/save/vedge/list", json=body).json()
-        if response.get("id"):
-            self.action_id = response["id"]
-        else:
-            raise Exception(f"Problem with validate of {self.dev.id} occurred")
-
-    def wait_for_completed(
-        self,
-        sleep_seconds: int = 15,
-        timeout_seconds: int = 180,
-        expected_status: str = ValidateStatus.validate.value,
-        expected_reachability: str = Reachability.REACHABLE.value,
-    ):
-        def check_status(action_data):
-            return not action_data["validity"] == expected_status
-
-        @retry(
-            wait=wait_fixed(sleep_seconds),
-            stop=stop_after_attempt(int(timeout_seconds / sleep_seconds)),
-            retry=retry_if_result(check_status),
-        )
-        def wait_for_come_up():
-            status = DeviceStateAPI(self.session).get_system_status(self.dev.id)
-            if status.reachability.value == expected_reachability:
-                return self.session.get_data(f"/dataservice/device?host-name={self.dev.hostname}")[0]
-            else:
-                return None
-
-        wait_for_come_up()
-
-
-class DecommissionAction(DeviceActionAPI):
-    """
-    API method to decommission Device
-
-    Usage example:
-    # Create session and chose device
-    session = create_manager_session(...)
-    device = DevicesAPI(session).get().filter(personality = Personality.VSMART)[0]
-    # Decommission device
-    DecommissionAction(session, device).execute()
-    """
-
-    def execute(self):
-        """
-        Decommission device.
-        """
-        url = f"/dataservice/system/device/decommission/{self.dev.uuid}"
-        response = self.session.put(url)
-        if response.status_code != 200:
-            raise Exception(f"Problem with decomission of {self.dev.id} occurred")
-
-    def wait_for_completed(
-        self,
-        sleep_seconds: int = 15,
-        timeout_seconds: int = 20,
-        expected_status: str = CertificateStatus.generated.value,
-        expected_reachability=Reachability.UNREACHABLE.value,
-    ):
-        def check_status(action_data):
-            return not action_data.vedgeCertificateState == expected_status
-
-        @retry(
-            wait=wait_fixed(sleep_seconds),
-            stop=stop_after_attempt(int(timeout_seconds / sleep_seconds)),
-            retry=retry_if_result(check_status),
-        )
-        def wait_for_status():
-            status = DevicesAPI(self.session).get_device_details(self.dev.uuid)
-            if status.reachability.value == expected_reachability:
-                return status
-            else:
-                return None
-
-        wait_for_status()