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

catalystwan/api/administration.py

@@ -1,434 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from http import HTTPStatus
-from typing import TYPE_CHECKING, List, Union, cast, overload
-
-from requests import Response
-from typing_extensions import deprecated
-
-from catalystwan.dataclasses import (
-    Certificate,
-    CloudConnectorData,
-    CloudServicesSettings,
-    Organization,
-    Password,
-    ServiceConfigurationData,
-    SoftwareInstallTimeout,
-    Vbond,
-)
-from catalystwan.endpoints.administration_user_and_group import (
-    ActiveSession,
-    AdministrationUserAndGroup,
-    InvalidateSessionMessage,
-    ResourceGroup,
-    ResourceGroupSwitchRequest,
-    ResourceGroupUpdateRequest,
-    SessionsDeleteRequest,
-    User,
-    UserGroup,
-    UserResetRequest,
-    UserRole,
-    UserUpdateRequest,
-)
-from catalystwan.exceptions import CatalystwanDeprecationWarning, CatalystwanException
-from catalystwan.models.settings import ThreatGridApi
-from catalystwan.typed_list import DataSequence
-from catalystwan.utils.creation_tools import asdict, create_dataclass
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-
-class UsersAPI:
-    """Class implementing methods for user managment.
-
-    Attributes:
-        session: logged in API client session
-
-    Usage example:
-        # Create session
-        session = create_manager_session(...)
-        # Get information about all users
-        all_users = session.api.users.get()
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-        self._endpoints = AdministrationUserAndGroup(session)
-
-    def get(self) -> DataSequence[User]:
-        """List all users
-
-        Returns:
-            DataSequence[User]: List-like object representing users
-        """
-        return self._endpoints.find_users()
-
-    def get_role(self) -> UserRole:
-        """Get currently logged user role
-
-        Returns:
-            UserRole: Currently logged user role information
-        """
-        return self._endpoints.find_user_role()
-
-    def get_auth_type(self) -> str:
-        """Get currently logged user authentication type
-
-        Returns:
-            str: Currently logged user authentication type
-        """
-        return self._endpoints.find_user_auth_type().user_auth_type
-
-    def create(self, user: User):
-        """Creates a new user
-
-        Args:
-            user (User): Definition of new user to be created
-        """
-        self._endpoints.create_user(user)
-
-    def update(self, user_update_request: UserUpdateRequest):
-        """Updates existing user
-
-        Args:
-            user_update_request (UserUpdateRequest): User attributes to be updated
-        """
-        self._endpoints.update_user(user_update_request.username, user_update_request)
-
-    def update_password(self, username: str, new_password: str, current_user_password: str):
-        """Updates exisiting user password
-
-        Args:
-            username (str): Name of the user
-            new_password (str): New password for given user
-        """
-        update_password_request = UserUpdateRequest(
-            username=username, password=new_password, current_user_password=current_user_password
-        )
-        self._endpoints.update_password(username, update_password_request)
-
-    def reset(self, username: str):
-        """Resets given user (unlocks blocked user eg. after number of unsuccessfull login attempts)
-
-        Args:
-            username (str): Name of the user to be unlocked
-        """
-        self._endpoints.reset_user(UserResetRequest(username=username))
-
-    def delete(self, username: str):
-        """Deletes given user
-
-        Args:
-            username (str): Name of the user to be deleted
-        """
-        self._endpoints.delete_user(username)
-
-
-class UserGroupsAPI:
-    """Class implementing methods for user group management."""
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-        self._endpoints = AdministrationUserAndGroup(session)
-
-    def get(self) -> DataSequence[UserGroup]:
-        """List all user groups
-
-        Returns:
-            DataSequence[UserGroup]: List-like object representing user groups
-        """
-        return self._endpoints.find_user_groups()
-
-    def create(self, user_group: UserGroup):
-        """Creates a new user group
-
-        Args:
-            user_group (UserGroup): Definition of user group to be created
-        """
-        self._endpoints.create_user_group(user_group)
-
-    def update(self, user_group: UserGroup):
-        """Updates existing user group
-
-        Args:
-            user_group (UserGroup): User group attributes to be updated
-        """
-        self._endpoints.update_user_group(user_group.group_name, user_group)
-
-    def delete(self, group_name: str):
-        """Deletes given user group
-
-        Args:
-            group_name (str): Name of the user group to be deleted
-        """
-        self._endpoints.delete_user_group(group_name)
-
-
-class ResourceGroupsAPI:
-    """Class implementing methods for resource groups management."""
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-        self._endpoints = AdministrationUserAndGroup(session)
-
-    def get(self) -> DataSequence[ResourceGroup]:
-        """List all resource groups
-
-        Returns:
-            DataSequence[ResourceGroup]: List-like object containing user groups information
-        """
-        return self._endpoints.find_resource_groups()
-
-    def create(self, resource_group: ResourceGroup):
-        """Creates a new resource group
-
-        Args:
-            resource_group (ResourceGroup): Definition of new resource group to be created
-        """
-        self._endpoints.create_resource_group(resource_group)
-
-    def update(self, resource_group_update_request: ResourceGroupUpdateRequest):
-        """Updates existing resource group
-
-        Args:
-            resource_group_update_request (ResourceGroupUpdateRequest): Object containing existing
-            resource group id and attributes to be updated
-        """
-        self._endpoints.update_resource_group(resource_group_update_request.id, resource_group_update_request)
-
-    def switch(self, resource_group_name: str):
-        """Switch to view only a specific resource group (for global admin only)
-
-        Args:
-            resource_group_name (str): Name of resource group to switch view
-        """
-        switch_request = ResourceGroupSwitchRequest(resource_group_name=resource_group_name)
-        self._endpoints.switch_resource_group(switch_request)
-
-    def delete(self, resource_group_id: str):
-        """Deletes a given resource group
-
-        Args:
-            resource_group_id (str): Resource group id
-        """
-        self._endpoints.delete_resource_group(resource_group_id)
-
-
-class SessionsAPI:
-    """Class implementing methods for vmanage sessions management."""
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-        self._endpoints = AdministrationUserAndGroup(session)
-
-    def get(self) -> DataSequence[ActiveSession]:
-        """List all active sessions
-
-        Returns:
-            DataSequence[ActiveSession]: List-like object representing active user sessions
-        """
-        return self._endpoints.get_active_sessions()
-
-    def invalidate(self, sessions: List[ActiveSession]) -> InvalidateSessionMessage:
-        """Invalidates given sessions
-
-        Args:
-            sessions (List[ActiveSession]): List of active sessions
-
-        Returns:
-            InvalidateSessionMessage: Information about invalidation result
-        """
-        sessions_delete_request = SessionsDeleteRequest.from_active_session_list(sessions)
-        return self._endpoints.remove_sessions(sessions_delete_request)
-
-
-class ClusterManagementAPI:
-    """Covers clusterManagement API calls.
-
-    Attributes:
-        session: logged in API admin session
-
-    Example usage:
-        # Create session
-        session = create_manager_session(...)
-        # Get health status
-        health_status = session.api.cluster_management.get_cluster_management_health_status()
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        self.session = session
-
-    def modify_cluster_setup(self, service_configuration: ServiceConfigurationData) -> bool:
-        """Updates vManage cluster configuration.
-
-        Args:
-            service_configuration: vManage cluster config
-        """
-        url_path = "/dataservice/clusterManagement/setup"
-        data = asdict(service_configuration)  # type: ignore
-        response = self.session.put(url_path, json=data)
-        return True if response.status_code == 200 else False
-
-    def get_cluster_management_health_status(self) -> Union[dict, list]:
-        """Gets Cluster Management Service Reachability health status.
-
-        Returns:
-            TODO return health status dataclass
-        """
-        url_path = "/dataservice/clusterManagement/health/status"
-        return self.session.get_data(url_path)
-
-
-class AdministrationSettingsAPI:
-    def __init__(self, session: ManagerSession) -> None:
-        """Covers Administration Settings API calls.
-
-        Args:
-            session: logged in API admin session
-
-        Example usage:
-            - to update e.g. password:
-                password = Password(old_password="qwer1234", new_password="asdf9876")
-                AdministrationSettingsAPI(session).update(password)
-        """
-        self.session = session
-
-    def get_sdavc_cloud_connector_config(self) -> CloudConnectorData:
-        """Gets SD-AVC Cloud Connector Config.
-
-        Returns:
-            CloudConnector dataclass config
-        """
-        url_path = "/dataservice/sdavc/cloudconnector"
-        response = cast(dict, self.session.get_json(url_path))
-        return create_dataclass(CloudConnectorData, response)
-
-    def enable_sdavc_cloud_connector(self, cloud_connector: CloudConnectorData) -> bool:
-        """Enables SD-AVC Cloud Connector on vManage."""
-        url_path = "/dataservice/sdavc/cloudconnector"
-        data = asdict(cloud_connector)  # type: ignore
-        response = self.session.post(url_path, json=data)
-        return True if response.status_code == 200 else False
-
-    def disable_sdavc_cloud_connector(self) -> bool:
-        """Disables SD-AVC Cloud Connector on vManage."""
-        url_path = "/dataservice/sdavc/cloudconnector"
-        data = {"cloudEnabled": False}
-        response = self.session.put(url_path, data)
-        return True if response.status_code == 200 else False
-
-    def get_cloud_services(self) -> CloudServicesSettings:
-        url_path = "/dataservice/settings/configuration/cloudservices"
-        data = self.session.get_data(url_path)[0]
-        return create_dataclass(CloudServicesSettings, data)
-
-    def set_cloud_services(self, config: CloudServicesSettings) -> bool:
-        url_path = "/dataservice/settings/configuration/cloudservices"
-        response = self.session.post(url_path, asdict(config))  # type: ignore
-        return True if response.status_code == 200 else False
-
-    def get_cloud_on_ramp_for_saas_mode(self):
-        """Get information about Cloud on Ramp for Saas mode"""
-        url_path = "/dataservice/settings/configuration/cloudx"
-        return self.session.get_data(url_path)
-
-    def enable_cloud_on_ramp_for_saas_mode(self, disable=False):
-        """Enable or disable COR for SaaS"""
-        url_path = "/dataservice/settings/configuration/cloudx"
-        data = {"mode": "on"} if not disable else {"mode": "off"}
-        response = self.session.put(url_path, data)
-        return True if response.status_code == 200 else False
-
-    @deprecated(
-        "Use .endpoints.configuration_settings.get_organizations() instead", category=CatalystwanDeprecationWarning
-    )
-    def get_organization(self) -> Organization:
-        endpoint = "/dataservice/settings/configuration/organization"
-
-        return create_dataclass(Organization, self.session.get_data(endpoint)[0])
-
-    def get_software_install_timeout(self) -> SoftwareInstallTimeout:
-        url_path = "/settings/configuration/softwareMaintenance"
-
-        return create_dataclass(SoftwareInstallTimeout, self.session.get_data(url_path)[0])
-
-    def set_software_install_timeout(self, download_timeout_min: int, activate_timeout_min: int):
-        MINIMAL_DOWNLOAD_TIMEOUT_MIN = 60
-        MINIMAL_ACTIVATE_TIMEOUT_MIN = 30
-        assert download_timeout_min >= MINIMAL_DOWNLOAD_TIMEOUT_MIN
-        assert activate_timeout_min >= MINIMAL_ACTIVATE_TIMEOUT_MIN
-
-        url_path = "/settings/configuration/softwareMaintenance"
-        data = asdict(SoftwareInstallTimeout(download_timeout_min, activate_timeout_min))  # type: ignore
-        response = self.session.post(url_path, json=data)
-        return True if response.status_code == 200 else False
-
-    @overload
-    def update(self, payload: Password) -> bool:
-        ...
-
-    @overload
-    def update(self, payload: Certificate) -> bool:
-        ...
-
-    @overload
-    def update(self, payload: Vbond) -> bool:
-        ...
-
-    @overload
-    def update(self, payload: Organization) -> bool:
-        ...
-
-    @overload
-    def update(self, payload: ThreatGridApi) -> bool:
-        ...
-
-    def update(self, payload: Union[Organization, Certificate, Password, Vbond, ThreatGridApi]) -> bool:
-        if isinstance(payload, ThreatGridApi):
-            created_threat = self.__update_thread_grid_api(payload)
-            return created_threat is not None
-        json_payload = asdict(payload)  # type: ignore
-        if isinstance(payload, Organization):
-            response = self.__update_organization(json_payload)
-        elif isinstance(payload, Certificate):
-            response = self.__update_certificate(payload)
-        elif isinstance(payload, Password):
-            response = self.__update_password(json_payload)
-        elif isinstance(payload, Vbond):
-            response = self.__update_vbond(json_payload)
-        else:
-            raise CatalystwanException(f"Not supported payload type: {type(payload).__name__}")
-
-        return True if response.status_code == HTTPStatus.OK else False
-
-    def __update_password(self, payload: dict) -> Response:
-        endpoint = "/dataservice/admin/user/profile/password"
-        response = self.session.put(endpoint, json=payload)
-        logger.info("Password changed.")
-        return response
-
-    def __update_certificate(self, payload: Certificate) -> Response:
-        json_payload = asdict(payload)  # type: ignore
-        endpoint = "/dataservice/settings/configuration/certificate"
-        return self.session.put(endpoint, json=json_payload)
-
-    def __update_vbond(self, payload: dict) -> Response:
-        endpoint = "/dataservice/settings/configuration/device"
-        return self.session.post(endpoint, json=payload)
-
-    def __update_thread_grid_api(self, payload: ThreatGridApi) -> DataSequence[ThreatGridApi]:
-        return self.session.endpoints.configuration_settings.edit_threat_grid_api_key(payload)
-
-    @deprecated(
-        "Use .endpoints.configuration_settings.edit_organizations() instead", category=CatalystwanDeprecationWarning
-    )
-    def __update_organization(self, payload: dict) -> Response:
-        endpoint = "/dataservice/settings/configuration/organization"
-        del payload["controlConnectionUp"]
-        return self.session.put(endpoint, json=payload)

catalystwan/api/alarms_api.py

@@ -1,186 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set
-
-from tenacity import retry, retry_if_result, stop_after_attempt, wait_fixed  # type: ignore
-
-from catalystwan.dataclasses import AlarmData
-from catalystwan.typed_list import DataSequence
-from catalystwan.utils.creation_tools import create_dataclass, flatten_dict
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-
-class AlarmsAPI:
-    """API methods of vManage for Alarms.
-
-    Attributes:
-        session: logged in API client session
-    """
-
-    URL = "/dataservice/alarms"
-
-    def __init__(self, session: ManagerSession):
-        self.session = session
-
-    def get(self, from_time: Optional[int] = None) -> DataSequence[AlarmData]:
-        """Data sequence of alarms.
-
-        Args:
-            from_time: Gets alarms from time in hour. Defaults to None - gets all alrams.
-
-        Returns:
-            DataSequence[AlarmData] of getted alarms.
-
-        Examples:
-            Get all alarms:
-            >>> alarms = AlarmsAPI(session).get()
-
-            Get all alarms from 3 hours:
-            >>> alarms = AlarmsAPI(session).get(from_time=3)
-
-            Get all not viewed alarms:
-            >>> alarms = AlarmsAPI(session).get()
-            >>> not_viewed_alarms = alarms.filter(viewed=False)
-
-            Get all critical alarms:
-            >>> alarms = AlarmsAPI(session).get()
-            >>> critical_alarms = alarms.filter(severity=Severity.CRITICAL)
-        """
-        query: Dict[str, Any] = {
-            "query": {
-                "condition": "AND",
-                "rules": [{"field": "active", "type": "boolean", "value": ["true"], "operator": "equal"}],
-            }
-        }
-        if from_time:
-            query["query"]["rules"].append(
-                {
-                    "value": [str(from_time)],
-                    "field": "entry_time",
-                    "type": "date",
-                    "operator": "last_n_hours",
-                }
-            )
-
-        response = self.session.post(url=AlarmsAPI.URL, json=query).json()["data"]
-        alarms = [create_dataclass(AlarmData, flatten_dict(alarm)) for alarm in response]
-        logger.info("Current alarms collected successfully.")
-
-        return DataSequence(AlarmData, alarms)
-
-    def mark_all_as_viewed(self) -> None:
-        """Marks all alarms as viewed."""
-
-        self.session.post(f"{AlarmsAPI.URL}/markallasviewed")
-        logger.info("Alarms mark as viewed.")
-
-    def check_alarms(
-        self,
-        expected: List[Dict[str, str]],
-        timeout_seconds: int = 240,
-        sleep_seconds: int = 5,
-    ) -> Dict[str, set]:
-        """Checks if alarms have occurred.
-
-        For a specified period of time, the method queries the API about unread alarms and
-        checks if they occur in the expected ones. If all alarms occur before the time expires,
-        it will not poll any further.
-
-        Args:
-          expected(list): The list of expected alarms.
-          timeout_seconds (int): Failure timeout.
-          sleep_seconds (int): Sleep time.
-
-        Returns:
-          The dictionary with alarms that occurred (key 'found') and did not (key 'no-found')
-
-        Examples:
-            >>> expected_alarms = [{
-                "type": "memory-usage",
-                "rulename": "memory-usage",
-                "component": "System",
-                "severity": "Medium",
-                "system_ip": "192.168.1.2",
-                "acknowledged": true,
-                "active": true,
-                }]
-            >>> result = AlarmsAPI(session).check_alarms(expected = expected_alarms)
-        """
-
-        alarms_expected = {create_dataclass(AlarmData, flatten_dict(expected_alarm)) for expected_alarm in expected}
-
-        verification = AlarmVerification(logger, self.get)
-        verification.verify(alarms_expected, timeout_seconds, sleep_seconds)
-
-        logger.info(f"found alarms: {verification.found}")
-        logger.info(f"not-found alarms: {verification.not_found}")
-
-        return {"found": verification.found, "not-found": verification.not_found}
-
-
-class AlarmVerification:
-    """The Alarms verification class
-
-    Attributes:
-        alarms_getter (Callable): The function that returns a set of current alarms.
-        logger (Logger): Logger.
-    """
-
-    def __init__(self, logger: logging.Logger, alarms_getter: Callable[[], DataSequence[AlarmData]]) -> None:
-        self.alarms_getter = alarms_getter
-        self.logger = logger
-
-    def __check(self, expected: AlarmData) -> bool:
-        """The checking if the expected alarm is included in the alarm set.
-
-        Args:
-          expected(AlarmData): The expected alarm.
-
-        Returns:
-          True if the requested alarm appears in the current alarm set.
-        """
-        not_viewed_alarms = self.alarms_getter().filter(viewed=False)
-        checked = {expected.lowercase().issubset(actual.lowercase()) for actual in not_viewed_alarms}
-        return any(checked)
-
-    def verify(self, expected: Set[AlarmData], timeout_seconds: int, sleep_seconds: int):
-        """The verifying if the expected alarms is included in the actual alarms set.
-
-        Args:
-          expected(Set[AlarmData]): The set expected alarms.
-          timeout_seconds (int): Failure timeout.
-          sleep_seconds (int): Sleep time.
-
-        """
-        self.found: Set[AlarmData] = set()
-        self.not_found: Set[AlarmData] = set()
-
-        def _log_exception(retry_state):
-            self.logger.error(f"Cannot found alarms in {timeout_seconds}.")
-            self.logger.error(f"Original exception: {retry_state.outcome.exception()}.")
-
-        def check(founds):
-            return expected != founds
-
-        @retry(
-            wait=wait_fixed(sleep_seconds),
-            stop=stop_after_attempt(int(timeout_seconds / sleep_seconds)),
-            retry=retry_if_result(check),
-            retry_error_callback=_log_exception,
-        )
-        def wait_for_alarms():
-            self.logger.info(f"waiting for alarms: {expected ^ self.found}")
-            for expected_alarm in expected ^ self.found:
-                if self.__check(expected_alarm):
-                    self.found.add(expected_alarm)
-            self.not_found = expected ^ self.found
-            return self.found
-
-        wait_for_alarms()

catalystwan/api/api_container.py

@@ -1,73 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from catalystwan.api.admin_tech_api import AdminTechAPI
-from catalystwan.api.administration import (
-    AdministrationSettingsAPI,
-    ClusterManagementAPI,
-    ResourceGroupsAPI,
-    SessionsAPI,
-    UserGroupsAPI,
-    UsersAPI,
-)
-from catalystwan.api.alarms_api import AlarmsAPI
-from catalystwan.api.basic_api import DevicesAPI, DeviceStateAPI
-from catalystwan.api.builders import BuilderAPI
-from catalystwan.api.config_device_inventory_api import ConfigurationDeviceInventoryAPI
-from catalystwan.api.config_group_api import ConfigGroupAPI
-from catalystwan.api.dashboard_api import DashboardAPI
-from catalystwan.api.feature_profile_api import SDRoutingFeatureProfilesAPI, SDWANFeatureProfilesAPI
-from catalystwan.api.logs_api import LogsAPI
-from catalystwan.api.omp_api import OmpAPI
-from catalystwan.api.packet_capture_api import PacketCaptureAPI
-from catalystwan.api.partition_manager_api import PartitionManagerAPI
-from catalystwan.api.policy_api import PolicyAPI
-from catalystwan.api.resource_pool_api import ResourcePoolAPI
-from catalystwan.api.software_action_api import SoftwareActionAPI
-from catalystwan.api.speedtest_api import SpeedtestAPI
-from catalystwan.api.template_api import TemplatesAPI
-from catalystwan.api.tenant_backup_restore_api import TenantBackupRestoreAPI
-from catalystwan.api.tenant_management_api import TenantManagementAPI
-from catalystwan.api.tenant_migration_api import TenantMigrationAPI
-from catalystwan.api.versions_utils import RepositoryAPI
-from catalystwan.api.virtual_image_action_api import LxcActionAPI
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class APIContainer:
-    def __init__(self, session: ManagerSession):
-        self.tenant_management = TenantManagementAPI(session)
-        self.admin_tech = AdminTechAPI(session)
-        self.administration_settings = AdministrationSettingsAPI(session)
-        self.alarms = AlarmsAPI(session)
-        self.config_device_inventory_api = ConfigurationDeviceInventoryAPI(session)
-        self.config_group = ConfigGroupAPI(session)
-        self.dashboard = DashboardAPI(session)
-        self.devices = DevicesAPI(session)
-        self.device_state = DeviceStateAPI(session)
-        self.logs = LogsAPI(session)
-        self.omp = OmpAPI(session)
-        self.packet_capture = PacketCaptureAPI(session)
-        self.speedtest = SpeedtestAPI(session)
-        self.templates = TemplatesAPI(session)
-        self.tenant_backup = TenantBackupRestoreAPI(session)
-        self.tenant_migration = TenantMigrationAPI(session)
-        self.repository = RepositoryAPI(session)
-        self.resource_pool = ResourcePoolAPI(session)
-        self.software = SoftwareActionAPI(session)
-        self.lxcsoftware = LxcActionAPI(session)
-        self.partition = PartitionManagerAPI(session)
-        self.users = UsersAPI(session)
-        self.cluster_management = ClusterManagementAPI(session)
-        self.user_groups = UserGroupsAPI(session)
-        self.resource_groups = ResourceGroupsAPI(session)
-        self.sessions = SessionsAPI(session)
-        self.policy = PolicyAPI(session)
-        self.sd_routing_feature_profiles = SDRoutingFeatureProfilesAPI(session)
-        self.sdwan_feature_profiles = SDWANFeatureProfilesAPI(session)
-        self.builders = BuilderAPI(session)