catalystwan 0.41.2.dev9__py3-none-any.whl → 0.41.3__py3-none-any.whl

catalystwan/api/builders/feature_profiles/other.py

@@ -1,79 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, List
-from uuid import UUID
-
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_create_parcel
-from catalystwan.api.feature_profile_api import OtherFeatureProfileAPI
-from catalystwan.endpoints.configuration.feature_profile.sdwan.other import OtherFeatureProfile
-from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
-from catalystwan.models.configuration.feature_profile.sdwan.other import AnyOtherParcel
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class OtherFeatureProfileBuilder:
-    """
-    A class for building Other feature profiles.
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        """
-        Initialize a new instance of the Service class.
-
-        Args:
-            session (ManagerSession): The ManagerSession object used for API communication.
-            profile_uuid (UUID): The UUID of the profile.
-        """
-        self._profile: FeatureProfileCreationPayload
-        self._api = OtherFeatureProfileAPI(session)
-        self._endpoints = OtherFeatureProfile(session)
-        self._independent_items: List[AnyOtherParcel] = []
-
-    def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
-        """
-        Adds a name and description to the feature profile.
-
-        Args:
-            name (str): The name of the feature profile.
-            description (str): The description of the feature profile.
-
-        Returns:
-            None
-        """
-        self._profile = feature_profile
-
-    def add_parcel(self, parcel: AnyOtherParcel) -> None:
-        """
-        Adds a parcel to the feature profile.
-
-        Args:
-            parcel (AnySystemParcel): The parcel to add.
-
-        Returns:
-            None
-        """
-        self._independent_items.append(parcel)
-
-    def build(self) -> FeatureProfileBuildReport:
-        """
-        Builds the feature profile.
-
-        Returns:
-            UUID: The UUID of the created feature profile.
-        """
-
-        profile_uuid = self._endpoints.create_sdwan_other_feature_profile(self._profile).id
-        self.build_report = FeatureProfileBuildReport(profile_uuid=profile_uuid, profile_name=self._profile.name)
-        for parcel in self._independent_items:
-            self._create_parcel(profile_uuid, parcel)
-        return self.build_report
-
-    @handle_create_parcel
-    def _create_parcel(self, profile_uuid: UUID, parcel: AnyOtherParcel) -> UUID:
-        return self._api.create_parcel(profile_uuid, parcel).id

catalystwan/api/builders/feature_profiles/report.py

@@ -1,155 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-import functools
-import logging
-from typing import Any, List, Optional, Tuple, Union
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict, Field
-from requests import PreparedRequest, Request, Response
-
-from catalystwan.exceptions import ManagerErrorInfo, ManagerHTTPError
-from catalystwan.models.configuration.feature_profile.parcel import AnyParcel
-
-logger = logging.getLogger(__name__)
-
-
-def handle_create_parcel(func):
-    @functools.wraps(func)
-    def wrapper(self, profile_uuid: UUID, parcel: AnyParcel, *args, **kwargs) -> Optional[UUID]:
-        try:
-            uuid = func(self, profile_uuid, parcel, *args, **kwargs)
-            self.build_report.add_created_parcel(parcel.parcel_name, uuid)
-            return uuid
-        except ManagerHTTPError as e:
-            self.build_report.add_failed_parcel(
-                parcel_name=parcel.parcel_name,
-                parcel_type=parcel._get_parcel_type(),
-                error=e,
-            )
-            return None
-
-    return wrapper
-
-
-class FailedRequestDetails(BaseModel):
-    method: str
-    url: str
-    body: str
-
-    @classmethod
-    def from_request(cls, request: Union[Request, PreparedRequest, Any]) -> "FailedRequestDetails":
-        if isinstance(request, (Request, PreparedRequest)):
-            return cls(
-                method=str(request.method),
-                url=str(request.url),
-                body=str(request.body if hasattr(request, "body") else ""),
-            )
-        return cls.as_empty()
-
-    @classmethod
-    def as_empty(cls) -> "FailedRequestDetails":
-        return cls(method="", url="", body="")
-
-
-class ResponseDetails(BaseModel):
-    status_code: int
-    reason: str
-
-    @classmethod
-    def from_response(cls, response: Union[Response, Any]) -> "ResponseDetails":
-        if isinstance(response, Response):
-            return cls(status_code=response.status_code, reason=response.reason)
-        return cls.as_empty()
-
-    @classmethod
-    def as_empty(cls) -> "ResponseDetails":
-        return cls(status_code=-1, reason="")
-
-
-class FailedParcel(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    parcel_name: str = Field(serialization_alias="parcelName", validation_alias="parcelName")
-    parcel_type: str = Field(serialization_alias="parcelType", validation_alias="parcelType")
-    error_info: Union[ManagerErrorInfo, str] = Field(serialization_alias="errorInfo", validation_alias="errorInfo")
-    request_details: Optional[FailedRequestDetails] = Field(
-        default=None, serialization_alias="requestDetails", validation_alias="requestDetails"
-    )
-    response_details: Optional[ResponseDetails] = Field(
-        default=None, serialization_alias="responseDetails", validation_alias="responseDetails"
-    )
-
-    @classmethod
-    def from_error(
-        cls,
-        parcel_name: str,
-        parcel_type: str,
-        error: ManagerHTTPError,
-    ):
-        return cls(
-            parcel_name=parcel_name,
-            parcel_type=parcel_type,
-            error_info=error.info,
-            request_details=FailedRequestDetails.from_request(error.request),
-            response_details=ResponseDetails.from_response(error.response),
-        )
-
-
-class FeatureProfileBuildReport(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    profile_name: str = Field(serialization_alias="profileName", validation_alias="profileName")
-    profile_uuid: UUID = Field(serialization_alias="profileUuid", validation_alias="profileUuid")
-    created_parcels: List[Tuple[str, UUID]] = Field(
-        default_factory=list, serialization_alias="createdParcels", validation_alias="createdParcels"
-    )
-    failed_parcels: List[FailedParcel] = Field(
-        default_factory=list, serialization_alias="failedParcels", validation_alias="failedParcels"
-    )
-
-    def add_created_parcel(self, parcel_name: str, parcel_uuid: UUID) -> None:
-        self.created_parcels.append((parcel_name, parcel_uuid))
-
-    def add_failed_parcel(
-        self,
-        parcel_name: str,
-        parcel_type: str,
-        error: ManagerHTTPError,
-    ) -> None:
-        self.failed_parcels.append(
-            FailedParcel.from_error(
-                parcel_name=parcel_name,
-                parcel_type=parcel_type,
-                error=error,
-            )
-        )
-
-
-def hande_failed_sub_parcel(build_report: FeatureProfileBuildReport, parent: AnyParcel, subparcel: AnyParcel) -> None:
-    parent_failed_to_create_message = (
-        f"Parent parcel: {parent.parcel_name} failed to create. This subparcel is dependent on it."
-    )
-    build_report.failed_parcels.append(
-        FailedParcel(
-            parcel_name=subparcel.parcel_name,
-            parcel_type=subparcel._get_parcel_type(),
-            error_info=parent_failed_to_create_message,
-        ),
-    )
-
-
-class handle_association_request:
-    def __init__(self, build_report: FeatureProfileBuildReport, parcel: AnyParcel) -> None:
-        self.build_report = build_report
-        self.parcel = parcel
-
-    def __enter__(self) -> "handle_association_request":
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is not None:
-            if issubclass(exc_type, ManagerHTTPError):
-                self.build_report.add_failed_parcel(
-                    parcel_name=self.parcel.parcel_name, parcel_type=self.parcel._get_parcel_type(), error=exc_val
-                )
-            else:
-                logger.exception(exc_val)
-        return True

catalystwan/api/builders/feature_profiles/service.py

@@ -1,248 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-from __future__ import annotations
-
-import logging
-from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union
-from uuid import UUID, uuid4
-
-from pydantic import Field
-from typing_extensions import Annotated
-
-from catalystwan.api.builders.feature_profiles.mixins import TrackerMixin
-from catalystwan.api.builders.feature_profiles.report import (
-    FeatureProfileBuildReport,
-    hande_failed_sub_parcel,
-    handle_association_request,
-    handle_create_parcel,
-)
-from catalystwan.api.feature_profile_api import ServiceFeatureProfileAPI
-from catalystwan.endpoints.configuration.feature_profile.sdwan.service import ServiceFeatureProfile
-from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
-from catalystwan.models.configuration.feature_profile.parcel import ParcelAssociationPayload
-from catalystwan.models.configuration.feature_profile.sdwan.routing import AnyRoutingParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service import (
-    AnyServiceParcel,
-    AppqoeParcel,
-    InterfaceEthernetParcel,
-    InterfaceGreParcel,
-    InterfaceIpsecParcel,
-    InterfaceSviParcel,
-    LanVpnDhcpServerParcel,
-    LanVpnParcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.multicast import MulticastParcel
-from catalystwan.models.configuration.feature_profile.sdwan.trackers import Tracker, TrackerGroup
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-logger = logging.getLogger(__name__)
-
-IndependedParcels = Annotated[Union[AppqoeParcel, LanVpnDhcpServerParcel], Field(discriminator="type_")]
-DependedVpnSubparcels = Annotated[
-    Union[InterfaceGreParcel, InterfaceSviParcel, InterfaceEthernetParcel, InterfaceIpsecParcel, MulticastParcel],
-    Field(discriminator="type_"),
-]
-
-
-class ServiceFeatureProfileBuilder(TrackerMixin):
-    """
-    A class for building service feature profiles.
-    """
-
-    def __init__(self, session: ManagerSession):
-        """
-        Initialize a new instance of the Service class.
-
-        Args:
-            session (ManagerSession): The ManagerSession object used for API communication.
-            profile_uuid (UUID): The UUID of the profile.
-        """
-        self._profile: FeatureProfileCreationPayload
-        self._api = ServiceFeatureProfileAPI(session)
-        self._endpoints = ServiceFeatureProfile(session)
-        self._independent_items: List[IndependedParcels] = []
-        self._independent_items_vpns: Dict[UUID, LanVpnParcel] = {}
-        self._dependent_items_on_vpns: Dict[UUID, List[Tuple[UUID, DependedVpnSubparcels]]] = defaultdict(list)
-        self._dependent_routing_items_on_vpns: Dict[UUID, List[AnyRoutingParcel]] = defaultdict(list)
-        self._interfaces_with_attached_dhcp_server: Dict[str, LanVpnDhcpServerParcel] = {}
-        # Trackers
-        self.init_tracker()
-
-    def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
-        """
-        Adds a name and description to the feature profile.
-
-        Args:
-            name (str): The name of the feature profile.
-            description (str): The description of the feature profile.
-
-        Returns:
-            None
-        """
-        self._profile = feature_profile
-
-    def add_parcel(self, parcel: IndependedParcels) -> None:
-        """
-        Adds an independent parcel to the builder.
-
-        Args:
-            parcel (IndependedParcels): The independent parcel to add.
-
-        Returns:
-            None
-        """
-        self._independent_items.append(parcel)
-
-    def add_parcel_vpn(self, parcel: LanVpnParcel) -> UUID:
-        """
-        Adds a VPN parcel to the builder.
-
-        Args:
-            parcel (LanVpnParcel): The VPN parcel to add.
-
-        Returns:
-            UUID: The UUID tag of the added VPN parcel.
-        """
-        vpn_tag = uuid4()
-        logger.debug(f"Adding VPN parcel {parcel.parcel_name} with tag {vpn_tag}")
-        self._independent_items_vpns[vpn_tag] = parcel
-        return vpn_tag
-
-    def add_parcel_routing_attached(self, vpn_tag: UUID, parcel: AnyRoutingParcel) -> None:
-        """
-        Adds a routing parcel to the builder.
-
-        Args:
-            vpn_tag (UUID): The UUID of the VPN.
-            parcel (AnyServiceParcel): The routing parcel to add.
-
-        Returns:
-            None
-        """
-        logger.debug(f"Adding routing parcel {parcel.parcel_name} to VPN {vpn_tag}")
-        self._dependent_routing_items_on_vpns[vpn_tag].append(parcel)
-
-    def add_parcel_vpn_subparcel(self, vpn_tag: UUID, parcel: DependedVpnSubparcels) -> UUID:
-        """
-        Adds an subparcel parcel dependent on a VPN to the builder.
-
-        Args:
-            vpn_tag (UUID): The UUID of the VPN.
-            parcel (DependedVpnSubparcels): The interface parcel to add.
-
-        Returns:
-            None
-        """
-
-        subparcel_tag = uuid4()
-        logger.debug(f"Adding vpn sub-parcel {parcel.parcel_name} with tag {subparcel_tag}")
-        self._dependent_items_on_vpns[vpn_tag].append((subparcel_tag, parcel))
-        return subparcel_tag
-
-    def add_parcel_dhcp_server(self, interface_parcel_name: str, parcel: LanVpnDhcpServerParcel) -> None:
-        """
-        Adds a DHCP server parcel to the builder.
-
-        Args:
-            interface_tag (UUID): The UUID of the interface.
-            parcel (LanVpnDhcpServerParcel): The DHCP server parcel to add.
-
-        Returns:
-            UUID: The UUID tag of the added DHCP server parcel.
-        """
-        logger.debug(f"Adding DHCP server parcel {parcel.parcel_name} to interface {interface_parcel_name}")
-        self._interfaces_with_attached_dhcp_server[interface_parcel_name] = parcel
-
-    def add_tracker(self, associate_tags: Set[UUID], tracker: Tracker) -> None:
-        """
-        Adds a tracker parcel to the feature profile.
-
-        Args:
-            associate_tags (Set[UUID]): The UUIDs of the interfaces to which the tracker should be added.
-            tracker (Tracker): The tracker parcel to add.
-
-        Returns:
-            None
-        """
-        self._trackers.append((associate_tags, tracker))
-
-    def add_tracker_group(self, associate_tags: Set[UUID], group: TrackerGroup, trackers: List[Tracker]) -> None:
-        self._tracker_groups.append((associate_tags, group, trackers))
-
-    def build(self) -> FeatureProfileBuildReport:
-        """
-        Builds the feature profile by creating parcels for independent items,
-        VPNs, and sub-parcels dependent on VPNs.
-
-        Returns:
-            Service feature profile UUID
-        """
-        profile_uuid = self._endpoints.create_sdwan_service_feature_profile(self._profile).id
-        self.build_report = FeatureProfileBuildReport(profile_uuid=profile_uuid, profile_name=self._profile.name)
-        for parcel in self._independent_items:
-            self._create_parcel(profile_uuid, parcel)
-
-        self.create_trackers(profile_uuid=profile_uuid)
-
-        for vpn_tag, vpn_parcel in self._independent_items_vpns.items():
-            vpn_uuid = self._create_parcel(profile_uuid, vpn_parcel)
-
-            for routing_parcel in self._dependent_routing_items_on_vpns[vpn_tag]:
-                if vpn_uuid is None:
-                    hande_failed_sub_parcel(self.build_report, vpn_parcel, routing_parcel)
-                else:
-                    routing_uuid = self._create_parcel(profile_uuid, routing_parcel)
-                    if not routing_uuid:
-                        continue
-                    with handle_association_request(self.build_report, routing_parcel):
-                        self._endpoints.associate_with_vpn(
-                            profile_uuid,
-                            vpn_uuid,
-                            routing_parcel._get_parcel_type(),
-                            payload=ParcelAssociationPayload(parcel_id=routing_uuid),
-                        )
-
-            for subparcel_tag, sub_parcel in self._dependent_items_on_vpns[vpn_tag]:
-                if vpn_uuid is None:
-                    hande_failed_sub_parcel(self.build_report, vpn_parcel, sub_parcel)
-                else:
-                    parcel_uuid = self._create_parcel(profile_uuid, sub_parcel, vpn_uuid)
-                    dhcp_server = self._interfaces_with_attached_dhcp_server.get(sub_parcel.parcel_name)
-                    if parcel_uuid is None and dhcp_server:
-                        # The parent could not be created
-                        hande_failed_sub_parcel(self.build_report, sub_parcel, dhcp_server)
-                        continue
-
-                    if dhcp_server:
-                        dhcp_server_uuid = self._create_parcel(profile_uuid, dhcp_server)
-                        if dhcp_server_uuid is not None:
-                            with handle_association_request(self.build_report, sub_parcel):
-                                self._endpoints.associate_dhcp_server_with_vpn_interface(
-                                    profile_uuid=profile_uuid,
-                                    vpn_uuid=vpn_uuid,
-                                    interface_parcel_type=sub_parcel._get_parcel_type().replace("lan/vpn/", ""),
-                                    interface_uuid=parcel_uuid,
-                                    payload=ParcelAssociationPayload(parcel_id=dhcp_server_uuid),
-                                )
-
-                    # Associate tracker with VPN interface if it exists
-                    if subparcel_tag in self._interface_tag_to_existing_tracker and parcel_uuid:
-                        tracker_uuid, tracker_type = self._interface_tag_to_existing_tracker[subparcel_tag]
-                        sub_parcel_type = sub_parcel._get_parcel_type().replace("lan/vpn/", "")
-                        with handle_association_request(self.build_report, sub_parcel):
-                            self._endpoints.associate_tracker_with_vpn_interface(
-                                profile_uuid,
-                                vpn_uuid,
-                                sub_parcel_type,
-                                parcel_uuid,
-                                tracker_type,
-                                ParcelAssociationPayload(parcel_id=tracker_uuid),
-                            )
-
-        return self.build_report
-
-    @handle_create_parcel
-    def _create_parcel(self, profile_uuid: UUID, parcel: AnyServiceParcel, vpn_uuid: Optional[None] = None) -> UUID:
-        return self._api.create_parcel(profile_uuid, parcel, vpn_uuid).id

catalystwan/api/builders/feature_profiles/system.py

@@ -1,80 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, List
-from uuid import UUID
-
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_create_parcel
-from catalystwan.api.feature_profile_api import SystemFeatureProfileAPI
-from catalystwan.endpoints.configuration.feature_profile.sdwan.system import SystemFeatureProfile
-from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
-from catalystwan.models.configuration.feature_profile.sdwan.system import AnySystemParcel
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from catalystwan.session import ManagerSession
-
-
-class SystemFeatureProfileBuilder:
-    """
-    A class for building system feature profiles.
-    """
-
-    def __init__(self, session: ManagerSession) -> None:
-        """
-        Initialize a new instance of the Service class.
-
-        Args:
-            session (ManagerSession): The ManagerSession object used for API communication.
-            profile_uuid (UUID): The UUID of the profile.
-        """
-
-        self._profile: FeatureProfileCreationPayload
-        self._api = SystemFeatureProfileAPI(session)
-        self._endpoints = SystemFeatureProfile(session)
-        self._independent_items: List[AnySystemParcel] = []
-
-    def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
-        """
-        Adds a name and description to the feature profile.
-
-        Args:
-            name (str): The name of the feature profile.
-            description (str): The description of the feature profile.
-
-        Returns:
-            None
-        """
-        self._profile = feature_profile
-
-    def add_parcel(self, parcel: AnySystemParcel) -> None:
-        """
-        Adds a parcel to the feature profile.
-
-        Args:
-            parcel (AnySystemParcel): The parcel to add.
-
-        Returns:
-            None
-        """
-        self._independent_items.append(parcel)
-
-    def build(self) -> FeatureProfileBuildReport:
-        """
-        Builds the feature profile.
-
-        Returns:
-            UUID: The UUID of the created feature profile.
-        """
-
-        profile_uuid = self._endpoints.create_sdwan_system_feature_profile(self._profile).id
-        self.build_report = FeatureProfileBuildReport(profile_uuid=profile_uuid, profile_name=self._profile.name)
-        for parcel in self._independent_items:
-            self._create_parcels(profile_uuid, parcel)
-        return self.build_report
-
-    @handle_create_parcel
-    def _create_parcels(self, profile_uuid: UUID, parcel: AnySystemParcel) -> UUID:
-        return self._api.create_parcel(profile_uuid, parcel).id