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

catalystwan/api/resource_pool_api.py

@@ -1,74 +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 ResourcePoolData
-from catalystwan.typed_list import DataSequence
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-
-class ResourcePoolAPI:
-    """API methods of Resource Pool.
-
-    Attributes:
-        session: logged in API client session
-    Usage example:
-        # Create session
-        session = create_manager_session(...)
-        # Create device vpn
-        resource_poold_data = session.api.resource_pool.create()
-    """
-
-    URL = "/dataservice/resourcepool/resource/vpn"
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-
-    def get(self, tenant_id: str, tenant_vpn: int) -> DataSequence[ResourcePoolData]:
-        """Get device vpn for tenant.
-
-        Args:
-            tenant_id: The tenant id.
-            tenant_vpn: The number of tenant vpn.
-
-        Returns:
-            DataSequence[ResourcePoolData] for tenant.
-
-        TODO note - tenant id doesn't work, need to enter tenant organization name.
-        """
-        parameters = {"tenantId": tenant_id, "tenantVpn": tenant_vpn}
-        response = self.session.get(url=ResourcePoolAPI.URL, params=parameters)
-        return response.dataseq(ResourcePoolData)
-
-    def create(self) -> DataSequence[ResourcePoolData]:
-        """Create device vpn.
-
-        Returns:
-            DataSequence[ResourcePoolData].
-        """
-        response = self.session.put(url=ResourcePoolAPI.URL)
-        logger.info("Create Resource poll vpn.")
-        return response.dataseq(ResourcePoolData)
-
-    def delete(self, tenant_id: str, tenant_vpn: int) -> bool:
-        """Delete device vpn for tenant.
-
-        Args:
-            tenant_id: The tenant id.
-            tenant_vpn: The number of tenant vpn.
-
-        Returns:
-            bool: True if all ok, False like something wrong
-
-        TODO note - tenant id doesn't work, need to enter tenant organization name.
-        """
-        parameters = {"tenantId": tenant_id, "tenant_vpn": tenant_vpn}
-        response = self.session.delete(url=ResourcePoolAPI.URL, params=parameters)
-        return response.ok

catalystwan/api/software_action_api.py

@@ -1,269 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, List, Optional, cast
-
-from catalystwan.api.task_status_api import Task
-from catalystwan.api.versions_utils import DeviceVersions, RepositoryAPI
-from catalystwan.endpoints.configuration_device_actions import (
-    InstallActionPayload,
-    InstallData,
-    InstallDevice,
-    InstallInput,
-    PartitionActionPayload,
-)
-from catalystwan.endpoints.configuration_device_inventory import DeviceDetailsResponse
-from catalystwan.exceptions import EmptyVersionPayloadError, ImageNotInRepositoryError  # type: ignore
-from catalystwan.typed_list import DataSequence
-from catalystwan.utils.personality import Personality
-from catalystwan.utils.upgrades_helper import get_install_specification, validate_personality_homogeneity
-from catalystwan.version import parse_vmanage_version
-
-logger = logging.getLogger(__name__)
-
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class SoftwareActionAPI:
-    """
-    API methods for software actions. All methods
-    are exececutable on all device categories.
-
-    Usage example:
-    # Create session
-    session = create_manager_session(...)
-
-    # Prepare devices list
-    controllers = session.endpoints.configuration_device_inventory.get_device_details('controllers')
-    vsmarts = controllers.filter(personality=Personality.VSMART)
-    software_image = "viptela-20.7.2-x86_64.tar.gz"
-
-    # Upgrade
-    upgrade_id = SoftwareActionAPI(session).install(devices = vsmarts, software_image=software_image)
-
-    # Check upgrade status
-    TaskAPI(session, software_action_id).wait_for_completed()
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-        self.repository = RepositoryAPI(self.session)
-        self.device_versions = DeviceVersions(self.session)
-
-    def activate(
-        self,
-        devices: DataSequence[DeviceDetailsResponse],
-        version_to_activate: Optional[str] = "",
-        image: Optional[str] = "",
-    ) -> Task:
-        """
-        Set chosen version as current version. Requires that selected devices have already version_to_activate
-        or image present in their available files.
-
-        Args:
-            devices (List[DeviceDetailsResponse]): For those devices software will be activated
-            version_to_activate (Optional[str]): version to be set as current version
-            image (Optional[str]): software image name in available files
-
-            Notice: Have to pass one of those arguments (version_to_activate, image)
-
-        Raises:
-            EmptyVersionPayloadError: If selected version_to_activate or image not detected in available files
-
-        Returns:
-            str: Activate software action id
-        """
-        validate_personality_homogeneity(devices)
-        if image and not version_to_activate:
-            version = cast(str, self.repository.get_image_version(image))
-        elif version_to_activate and not image:
-            version = cast(str, version_to_activate)
-        else:
-            raise ValueError("You can not provide software_image and image version at the same time!")
-
-        if not version:
-            raise ImageNotInRepositoryError(
-                "Based on provided arguments, software version to activate on device(s) cannot be detected."
-            )
-
-        payload_devices = self.device_versions.get_device_available(version, devices)
-        for device in payload_devices:
-            if not device.version:
-                raise EmptyVersionPayloadError("PartitionDevice payload contains entry with empty version field.")
-
-        device_type = get_install_specification(devices.first()).device_type.value
-        partition_payload = PartitionActionPayload(
-            action="changepartition", devices=[dev for dev in payload_devices], device_type=device_type
-        )
-
-        partition_action = self.session.endpoints.configuration_device_actions.process_mark_change_partition(
-            payload=partition_payload
-        )
-
-        return Task(self.session, partition_action.id)
-
-    def install(
-        self,
-        devices: DataSequence[DeviceDetailsResponse],
-        reboot: bool = False,
-        sync: bool = True,
-        v_edge_vpn: int = 0,
-        v_smart_vpn: int = 0,
-        image: Optional[str] = None,
-        image_version: Optional[str] = None,
-        downgrade_check: bool = True,
-        remote_server_name: Optional[str] = None,
-        remote_image_filename: Optional[str] = None,
-    ) -> Task:
-        """
-        Method to install new software
-
-        Args:
-            devices (List[DeviceDetailsResponse]): For those devices software will be activated
-            reboot (bool, optional): reboot device after action end
-            sync (bool, optional): Synchronize settings. Defaults to True.
-            v_edge_vpn (int, optional): vEdge VPN
-            v_smart_vpn (int, optional): vSmart VPN
-            image (str): path to software image or its name from available files
-            image_version (str): version of software image
-            downgrade_check (bool, optional): perform a downgrade check when applicable
-            remote_server_name (str): name of configured Remote Server
-            remote_image_filename (str): filename to choose from selected Remote Server
-
-            Notice: Have to pass one of those:
-                - image_version
-                - image
-                - remote_server_name and remote_image_filename
-
-        Raises:
-            ValueError: Raise error if downgrade in certain cases or wrong arguments combination provided
-            ImageNotInRepositoryError: If selected image, image_version or remote_image_filename not found
-
-        Returns:
-            Task: Task object representing started install process
-        """
-        validate_personality_homogeneity(devices)
-
-        if (
-            sum(
-                [
-                    image is not None,
-                    image_version is not None,
-                    all([remote_server_name is not None, remote_image_filename is not None]),
-                ]
-            )
-            != 1
-        ):
-            raise ValueError(
-                "Please provide one option to detect software to install. "
-                "Pick either 'image', 'image_version', or both 'remote_server_name' and 'remote_image_filename'."
-            )
-
-        # FIXME downgrade_check will be supported when software images from Remote Server will have versions fields
-        if remote_server_name and remote_image_filename and downgrade_check:
-            raise ValueError("Downgrade check is not supported for install action for images from Remote Server.")
-
-        version, remote_image_details = None, None
-        if image:
-            version = cast(str, self.repository.get_image_version(image))
-        if image_version:
-            version = cast(str, image_version)
-        if remote_server_name and remote_image_filename:
-            remote_image_details = self.repository.get_remote_image(remote_image_filename, remote_server_name)
-
-        if not any([version, remote_image_details]):
-            raise ImageNotInRepositoryError(
-                "Based on provided arguments, software version to install on device(s) cannot be detected."
-            )
-
-        install_specification = get_install_specification(devices.first(), remote=bool(remote_image_details))
-        install_devices = [
-            InstallDevice(**device.model_dump(by_alias=True))
-            for device in self.device_versions.get_device_list(devices)
-        ]
-
-        if version:
-            input = InstallInput(
-                v_edge_vpn=v_edge_vpn,
-                v_smart_vpn=v_smart_vpn,
-                family=install_specification.family.value,
-                version=version,
-                version_type=install_specification.version_type.value,
-                reboot=reboot,
-                sync=sync,
-            )
-        else:
-            input = InstallInput(
-                v_edge_vpn=v_edge_vpn,
-                v_smart_vpn=v_smart_vpn,
-                data=[
-                    InstallData(
-                        family=install_specification.family.value,
-                        version=remote_image_details.version_id,  # type: ignore
-                        remote_server_id=remote_image_details.remote_server_id,  # type: ignore
-                        version_id=remote_image_details.version_id,  # type: ignore
-                    )
-                ],
-                version_type=install_specification.version_type.value,
-                reboot=reboot,
-                sync=sync,
-            )
-
-        device_type = install_specification.device_type.value
-        install_payload = InstallActionPayload(
-            action="install", input=input, devices=install_devices, device_type=device_type
-        )
-
-        if downgrade_check and devices.first().personality in (Personality.VMANAGE, Personality.EDGE):
-            self._downgrade_check(
-                install_payload.devices,
-                install_payload.input.version,  # type: ignore
-                install_specification.family.value,  # type: ignore
-            )
-
-        install_action = self.session.endpoints.configuration_device_actions.process_install_operation(
-            payload=install_payload
-        )
-
-        return Task(self.session, install_action.id)
-
-    def _downgrade_check(self, payload_devices: List[InstallDevice], version_to_upgrade: str, family: str) -> None:
-        """
-        Check if upgrade operation is not actually a downgrade opeartion.
-        If so, in some cases action is being blocked.
-
-        Args:
-            version_to_upgrade (str): version to upgrade
-            payload_devices List[InstallDevice]: list of Devices to check downgrade possibility
-
-        Raises:
-            ValueError: If for any of the devices upgrade action is denied
-        """
-        incorrect_devices = []
-        devices_versions_repo = self.repository.get_devices_versions_repository()
-        for device in payload_devices:
-            current_version = parse_vmanage_version(devices_versions_repo[device.device_id].current_version)
-            upgrade_version = parse_vmanage_version(version_to_upgrade)
-            # check if downgrade
-            if current_version > upgrade_version:
-                logger.warning(
-                    f"Requested to downgrade device: {device.device_id} from {current_version} to {upgrade_version}"
-                )
-                # allow vmanage downgrade only if major and minor version match, downgrade for other devices is allowed
-                if family == "vmanage":
-                    if not current_version.release[:2] == upgrade_version.release[:2]:
-                        logger.error(
-                            f"Blocking downgrade of device: {device.device_id} "
-                            f"from {current_version.release} to {upgrade_version.release}"
-                        )
-                        incorrect_devices.append(device)
-
-        if incorrect_devices:
-            raise ValueError(
-                f"Current version of devices with id's {incorrect_devices} is "
-                "higher than upgrade version. Action denied!"
-            )

catalystwan/api/speedtest_api.py

@@ -1,153 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-import math
-from time import sleep
-from typing import TYPE_CHECKING, cast
-from urllib.error import HTTPError
-
-from catalystwan.api.basic_api import DeviceStateAPI
-from catalystwan.dataclasses import Device, Speedtest
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class SpeedtestAPI:
-    """
-    API methods to perform speedtest between 2 edge devices.
-
-    Example:
-        session = create_manager_session(...)
-        devices = session.api.basic_api.devices
-        speedtest = session.api.speedtest.speedtest(devices[0], devices[1])
-
-        print(f"Upload speed from {speedtest.device_name} is {speedtest.up_speed} Mbps.)
-
-        # example output: Upload speed from vm2 is 217.82 Mbps.
-
-        speedtest is a Speedtest object containing source and destination device info and
-            upload and download speed between them
-    """
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-
-    def speedtest(
-        self,
-        source_device: Device,
-        destination_device: Device,
-        test_duration_seconds: int = 300,
-    ) -> Speedtest:
-        """
-        Performs speedtest between 2 edge devices.
-
-        Args:
-            source_device (Device): device from which the speed will be measured
-            destination_device (Device): device to which the speed will be measured
-            test_duration_seconds (int): duration of the speed measuring in seconds, defaults to 300 (5 minutes)
-        """
-
-        source_color = DeviceStateAPI(self.session).get_colors(source_device.id)[0]
-        destination_color = DeviceStateAPI(self.session).get_colors(destination_device.id)[0]
-
-        self.speedtest_output = Speedtest(
-            device_ip=source_device.local_system_ip,
-            device_name=source_device.hostname,
-            destination_ip=destination_device.local_system_ip,
-            destination_name=destination_device.hostname,
-            status="",
-            up_speed=0.0,
-            down_speed=0.0,
-        )  # type: ignore
-
-        if source_device.is_reachable and destination_device.is_reachable:
-            with DeviceStateAPI(self.session).enable_data_stream():
-                try:
-                    self.__perform(
-                        source_device,
-                        destination_device,
-                        source_color,
-                        destination_color,
-                        test_duration_seconds,
-                    )
-                except HTTPError as e:
-                    self.speedtest_output.status = str(e)
-        else:
-            self.speedtest_output.status = (
-                f"Source is {source_device.reachability.value} and "
-                f"destination device is {destination_device.reachability.value}"
-            )
-
-        return self.speedtest_output
-
-    def __perform(
-        self,
-        source_device: Device,
-        destination_device: Device,
-        source_color: str,
-        destination_color: str,
-        test_duration_seconds: int = 300,
-    ) -> None:
-        start_query = {
-            "deviceUUID": f"{source_device.uuid}",
-            "sourceIp": f"{source_device.local_system_ip}",
-            "sourceColor": f"{source_color}",
-            "destinationIp": f"{destination_device.local_system_ip}",
-            "destinationColor": f"{destination_color}",
-            "port": "80",
-        }
-        url_path = "/dataservice/stream/device/speed"
-        setup_speedtest = self.session.post(url_path, json=start_query).json()
-
-        speedtest_session = setup_speedtest["sessionId"]
-
-        self.session.get_json(f"/dataservice/stream/device/speed/start/{speedtest_session}")
-
-        duration = math.ceil(test_duration_seconds / 5)
-        for _ in range(duration):
-            self.session.get_json(f"/dataservice/stream/device/speed/{speedtest_session}?logId=2")
-            sleep(5)
-
-        disable_speedtest = cast(
-            dict,
-            self.session.get_json(f"/dataservice/stream/device/speed/disable/{speedtest_session}"),
-        )
-
-        end_query = {
-            "query": {
-                "condition": "AND",
-                "rules": [
-                    {
-                        "value": [f"{source_device.local_system_ip}"],
-                        "field": "source_local_ip",
-                        "type": "string",
-                        "operator": "in",
-                    },
-                    {
-                        "value": ["completed"],
-                        "field": "status",
-                        "type": "string",
-                        "operator": "in",
-                    },
-                ],
-            },
-            "size": 10000,
-        }
-        url_path = "/dataservice/statistics/speedtest"
-        post_speedtest = self.session.post(url_path, json=end_query).json()
-
-        try:
-            self.speedtest_output.status = disable_speedtest["status"]
-            self.speedtest_output.up_speed = post_speedtest["data"][0]["up_speed"]
-            self.speedtest_output.down_speed = post_speedtest["data"][0]["down_speed"]
-
-            logger.info(
-                f"Speedtest from {source_device.local_system_ip} " f"to {destination_device.local_system_ip} succeeded."
-            )
-        except IndexError:
-            self.speedtest_output.status = "No speed received"

catalystwan/api/task_status_api.py

@@ -1,171 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, List, cast
-
-from tenacity import retry, retry_if_result, stop_after_attempt, wait_fixed  # type: ignore
-
-from catalystwan.exceptions import TaskValidationError
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-from catalystwan.endpoints.configuration_dashboard_status import (
-    ConfigurationDashboardStatus,
-    SubTaskData,
-    TaskData,
-    TaskResult,
-)
-from catalystwan.utils.operation_status import OperationStatus, OperationStatusId
-
-logger = logging.getLogger(__name__)
-
-
-class Task:
-    """
-    API class for getting data about task/sub-tasks
-    """
-
-    def __init__(self, session: ManagerSession, task_id: str):
-        self.session = session
-        self.task_id = task_id
-        self.url = f"/dataservice/device/action/status/{self.task_id}"
-        self.task_data: List[SubTaskData]
-
-    def __check_validation_status(self, task: TaskData):
-        if not task.validation:
-            return None
-        if task.validation.status in (OperationStatus.FAILURE, OperationStatus.VALIDATION_FAILURE):
-            raise TaskValidationError(
-                f"Task status validation failed, validation status is: {task.validation.status}"
-                f"\n{task.validation.activity}"
-            )
-
-    def wait_for_completed(
-        self,
-        timeout_seconds: int = 300,
-        interval_seconds: int = 5,
-        success_statuses: List[OperationStatus] = [
-            OperationStatus.SUCCESS,
-        ],
-        failure_statuses: List[OperationStatus] = [
-            OperationStatus.FAILURE,
-        ],
-        success_statuses_ids: List[OperationStatusId] = [
-            OperationStatusId.SUCCESS,
-        ],
-        failure_statuses_ids: List[OperationStatusId] = [
-            OperationStatusId.FAILURE,
-        ],
-    ) -> TaskResult:
-        """
-        Method to check subtasks statuses of the task
-
-        Example:
-            # create session
-            session = create_manager_session(ip_address,admin_username,password,port=port)
-            devices = DevicesAPI(session).get()
-            vsmart = devices.filter(personality= Personality.VSMART]).single_or_default()
-
-            # Prepare some action, and get it's id
-            upgrade_id = SoftwareAction().upgrade_software()
-
-            # Keep asking for reboot status until it's not in exit_statuses (Failure or Success)
-            or timeout is not achieved (3000s)
-            task = Task(session,upgrade_id).wait_for_completed()
-            if task.result:
-                #do something
-            else:
-                #do something else
-
-        Args:
-
-
-            timeout_seconds (int): After this time, function will stop requesting action status
-            interval_seconds (int): interval between action status requests
-            validation_timeout_seconds (int): After this time, task validation call will be send
-            delay_seconds (int): if Vmanage didn't report task status, after this time api call would be repeated
-            success_statuses (Union[List[OperationStatus], str]): list of positive sub-tasks statuses
-            success_statuses_ids (Union[List[OperationStatus], str]): list of positive sub-tasks statuses id's
-            fails_statuses_id (Union[List[OperationStatusId], str]): list of negative sub-tasks statuses
-            fails_statuses_ids (Union[List[OperationStatusId], str]): list of negative sub-tasks statuses id's
-
-        Returns:
-            TaskResult(): result attr is True if all subtasks are success
-             or is False if at least one is failed
-        """
-        success_statuses = [cast(OperationStatus, exit_status.value) for exit_status in success_statuses]
-        failure_statuses = [cast(OperationStatus, exit_status.value) for exit_status in failure_statuses]
-        success_statuses_ids = [
-            cast(OperationStatusId, exit_status_id.value) for exit_status_id in success_statuses_ids
-        ]
-        failure_statuses_ids = [
-            cast(OperationStatusId, exit_status_id.value) for exit_status_id in failure_statuses_ids
-        ]
-
-        def check_status(task_data: List[SubTaskData]) -> bool:
-            """
-            Function checks if condition is met. If so,
-            wait_for_completed stops asking for task status
-
-            Args:
-                task_data (List[SubTaskData]): list of all sub_tasks
-
-            Returns:
-                bool: False if condition is met
-            """
-            if not task_data:
-                return True
-            task_statuses_success = [task.status in success_statuses for task in task_data]
-            task_statuses_failure = [task.status in failure_statuses for task in task_data]
-            task_statuses_id_success = [task.status_id in success_statuses_ids for task in task_data]
-            task_statuses_id_failure = [task.status_id in failure_statuses_ids for task in task_data]
-
-            all_subtasks_completed_status: List[bool] = [
-                any(task_status) for task_status in zip(task_statuses_success, task_statuses_failure)
-            ]
-            all_subtasks_completed_status_id: List[bool] = [
-                any(task_status_id) for task_status_id in zip(task_statuses_id_success, task_statuses_id_failure)
-            ]
-            if all(all_subtasks_completed_status) or all(all_subtasks_completed_status_id):
-                return False
-            return True
-
-        def log_exception(self) -> None:
-            logger.error("Operation status not achieved in given time")
-
-        @retry(
-            wait=wait_fixed(interval_seconds),
-            stop=stop_after_attempt(int(timeout_seconds / interval_seconds)),
-            retry=retry_if_result(check_status),
-            retry_error_callback=log_exception,
-        )
-        def wait_for_action_finish() -> List[SubTaskData]:
-            """
-            Keep asking for task status, status_id,
-            activity(optional), untill check_status is True
-
-            Returns:
-                List[SubTaskData]
-            """
-            task = ConfigurationDashboardStatus(self.session).find_status(self.task_id)
-            self.__check_validation_status(task)
-            self.task_data = task.data
-            sub_task_statuses = [task.status for task in self.task_data]
-            sub_task_statuses_id = [task.status_id for task in self.task_data]
-            sub_task_activities = [task.activity for task in self.task_data]
-            logger.info(
-                f"Sub-tasks data for task {self.task_id}: \n "
-                f"statuses: {sub_task_statuses}, status_ids: {sub_task_statuses_id}, activities: {sub_task_activities}."
-            )
-            return self.task_data
-
-        wait_for_action_finish()
-        result = all([sub_task.status in success_statuses for sub_task in self.task_data])
-        if result:
-            logger.info("Task polling finished, because all subtasks successfully finished.")
-        else:
-            logger.info("Task polling finished, because at least one subtask failed or task is timeout.")
-        return TaskResult(result=result, sub_tasks_data=self.task_data)