catalystwan 0.33.7.dev0__tar.gz → 0.33.7.dev2__tar.gz

{catalystwan-0.33.7.dev0 → catalystwan-0.33.7.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: catalystwan
-Version: 0.33.7.dev0
+Version: 0.33.7.dev2
 Summary: Cisco Catalyst WAN SDK for Python
 Home-page: https://github.com/cisco-open/cisco-catalyst-wan-sdk
 Author: kagorski

{catalystwan-0.33.7.dev0 → catalystwan-0.33.7.dev2}/catalystwan/api/builders/feature_profiles/report.py

@@ -1,13 +1,13 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
 import functools
 from typing import Any, List, Optional, Tuple, Union
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
+from requests import Response
 
 from catalystwan.exceptions import ManagerErrorInfo, ManagerHTTPError
-from catalystwan.models.configuration.feature_profile.parcel import AnyParcel, ParcelType
-
-ParcelName = str
+from catalystwan.models.configuration.feature_profile.parcel import AnyParcel
 
 
 def handle_build_report(func):
@@ -37,11 +37,18 @@ class FailedRequestDetails(BaseModel):
     headers: str
     body: str
 
+    @staticmethod
+    def from_response(response: Response):
+        request = response.request
+        FailedRequestDetails(
+            method=str(request.method), url=str(request.url), headers=str(request.headers), body=str(request.body)
+        )
+
 
 class FailedParcel(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
-    parcel_name: ParcelName = Field(serialization_alias="parcelName", validation_alias="parcelName")
-    parcel_type: ParcelType = Field(serialization_alias="parcelType", validation_alias="parcelType")
+    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="failedRequest", validation_alias="failedRequest"
@@ -52,20 +59,20 @@ 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[ParcelName, UUID]] = Field(
+    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: ParcelName, parcel_uuid: UUID) -> None:
+    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: ParcelName,
-        parcel_type: ParcelType,
+        parcel_name: str,
+        parcel_type: str,
         error_info: Union[ManagerErrorInfo, str],
         request: Optional[Any] = None,
     ) -> None:
@@ -82,3 +89,16 @@ class FeatureProfileBuildReport(BaseModel):
                 parcel_name=parcel_name, parcel_type=parcel_type, error_info=error_info, request_details=request
             )
         )
+
+
+def handle_build_report_for_failed_subparcel(
+    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.add_failed_parcel(
+        parcel_name=subparcel.parcel_name,
+        parcel_type=subparcel._get_parcel_type(),
+        error_info=parent_failed_to_create_message,
+    )

{catalystwan-0.33.7.dev0 → catalystwan-0.33.7.dev2}/catalystwan/api/builders/feature_profiles/service.py

@@ -1,3 +1,4 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
 from __future__ import annotations
 
 import logging
@@ -8,10 +9,16 @@ from uuid import UUID, uuid4
 from pydantic import Field
 from typing_extensions import Annotated
 
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_build_report
+from catalystwan.api.builders.feature_profiles.report import (
+    FeatureProfileBuildReport,
+    handle_build_report,
+    handle_build_report_for_failed_subparcel,
+)
 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,
@@ -54,7 +61,9 @@ class ServiceFeatureProfileBuilder:
         self._endpoints = ServiceFeatureProfile(session)
         self._independent_items: List[IndependedParcels] = []
         self._independent_items_vpns: Dict[UUID, LanVpnParcel] = {}
-        self._depended_items_on_vpns: Dict[UUID, List[DependedVpnSubparcels]] = defaultdict(list)
+        self._dependent_items_on_vpns: Dict[UUID, List[DependedVpnSubparcels]] = defaultdict(list)
+        self._dependent_routing_items_on_vpns: Dict[UUID, List[AnyRoutingParcel]] = defaultdict(list)
+        self._interfaces_with_attached_dhcp_server: Dict[str, LanVpnDhcpServerParcel] = {}
 
     def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
         """
@@ -96,19 +105,47 @@ class ServiceFeatureProfileBuilder:
         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) -> None:
         """
         Adds an subparcel parcel dependent on a VPN to the builder.
 
         Args:
             vpn_tag (UUID): The UUID of the VPN.
-            parcel (DependedInterfaceParcels): The interface parcel to add.
+            parcel (DependedVpnSubparcels): The interface parcel to add.
 
         Returns:
             None
         """
         logger.debug(f"Adding subparcel parcel {parcel.parcel_name} to VPN {vpn_tag}")
-        self._depended_items_on_vpns[vpn_tag].append(parcel)
+        self._dependent_items_on_vpns[vpn_tag].append(parcel)
+
+    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 build(self) -> FeatureProfileBuildReport:
         """
@@ -124,21 +161,50 @@ class ServiceFeatureProfileBuilder:
             self._create_parcel(profile_uuid, parcel)
         for vpn_tag, vpn_parcel in self._independent_items_vpns.items():
             vpn_uuid = self._create_parcel(profile_uuid, vpn_parcel)
-            if vpn_uuid is None:
-                for sub_parcel in self._depended_items_on_vpns[vpn_tag]:
-                    subparcel_fail_message = (
-                        f"Parent parcel: {vpn_parcel.parcel_name} failed to create. This subparcel is dependent on it."
+
+            for routing_parcel in self._dependent_routing_items_on_vpns[vpn_tag]:
+                if vpn_uuid is None:
+                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, routing_parcel)
+                else:
+                    routing_uuid = self._create_parcel(profile_uuid, routing_parcel)
+                    if not routing_uuid:
+                        continue
+                    self._endpoints.associate_with_vpn(
+                        profile_uuid,
+                        vpn_uuid,
+                        routing_parcel._get_parcel_type(),
+                        payload=ParcelAssociationPayload(parcel_id=routing_uuid),
                     )
-                    self.build_report.add_failed_parcel(
-                        sub_parcel.parcel_name,
-                        sub_parcel._get_parcel_type(),  # type: ignore
-                        subparcel_fail_message
-                        # incompatible type "str"; expected ParcelType, we will fix _get_parcel_type()
-                        # to return ParcelType but for now it gives circular import
+
+            for sub_parcel in self._dependent_items_on_vpns[vpn_tag]:
+                if vpn_uuid is None:
+                    handle_build_report_for_failed_subparcel(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 dhcp_server is None:
+                        # The interface does not have a DHCP server attached
+                        continue
+
+                    if parcel_uuid is None:
+                        # The parent could not be created
+                        handle_build_report_for_failed_subparcel(self.build_report, sub_parcel, dhcp_server)
+                        continue
+
+                    dhcp_server_uuid = self._create_parcel(profile_uuid, dhcp_server)
+
+                    if dhcp_server_uuid is None:
+                        # The DHCP server could not be created
+                        continue
+
+                    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),
                     )
-            else:
-                for sub_parcel in self._depended_items_on_vpns[vpn_tag]:
-                    self._create_parcel(profile_uuid, sub_parcel, vpn_uuid)
 
         return self.build_report
 

catalystwan-0.33.7.dev2/catalystwan/api/builders/feature_profiles/transport.py

@@ -0,0 +1,214 @@
+# 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, Union
+from uuid import UUID, uuid4
+
+from catalystwan.api.builders.feature_profiles.report import (
+    FeatureProfileBuildReport,
+    handle_build_report,
+    handle_build_report_for_failed_subparcel,
+)
+from catalystwan.api.feature_profile_api import TransportFeatureProfileAPI
+from catalystwan.endpoints.configuration.feature_profile.sdwan.transport import TransportFeatureProfile
+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.transport import (
+    AnyTransportParcel,
+    AnyTransportSuperParcel,
+    AnyTransportVpnParcel,
+    AnyTransportVpnSubParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.cellular_controller import (
+    CellularControllerParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.cellular_profile import CellularProfileParcel
+from catalystwan.models.configuration.feature_profile.sdwan.transport.gps import GpsParcel
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from catalystwan.session import ManagerSession
+
+
+class TransportAndManagementProfileBuilder:
+    """
+    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 = TransportFeatureProfileAPI(session)
+        self._endpoints = TransportFeatureProfile(session)
+        self._independent_items: List[AnyTransportSuperParcel] = []
+        self._independent_items_vpns: Dict[UUID, AnyTransportVpnParcel] = {}
+        self._independent_items_cellular_controllers: Dict[UUID, CellularControllerParcel] = {}
+        self._dependent_items_on_vpns: Dict[UUID, List[AnyTransportVpnSubParcel]] = defaultdict(list)
+        self._dependent_routing_items_on_vpns: Dict[UUID, List[AnyRoutingParcel]] = defaultdict(list)
+        self._dependent_items_on_cellular_controllers: Dict[
+            UUID, List[Union[CellularProfileParcel, GpsParcel]]
+        ] = defaultdict(list)
+
+    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: AnyTransportSuperParcel) -> None:
+        """
+        Adds a parcel to the feature profile.
+
+        Args:
+            parcel (AnyTransportSuperParcel): The parcel to add.
+
+        Returns:
+            None
+        """
+        self._independent_items.append(parcel)
+
+    def add_parcel_routing_attached(self, vpn_tag: UUID, parcel: AnyRoutingParcel) -> None:
+        """
+        Adds a routing parcel to the feature profile.
+
+        Args:
+            parcel (AnyRoutingParcel): The parcel to add.
+
+        Returns:
+            None
+        """
+        logger.debug(f"Attaching routing {parcel.parcel_name} with to VPN with tag {vpn_tag}")
+        self._dependent_routing_items_on_vpns[vpn_tag].append(parcel)
+
+    def add_parcel_vpn(self, parcel: AnyTransportVpnParcel) -> 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_cellular_controller(self, parcel: CellularControllerParcel) -> UUID:
+        """
+        Adds a cellular controller parcel to the builder.
+
+        Args:
+            parcel (CellularControllerParcel): The cellular controller parcel to add.
+
+        Returns:
+            UUID: The UUID tag of the added cellular controller parcel.
+        """
+        cellular_controller_tag = uuid4()
+        logger.debug(f"Adding cellular controller parcel {parcel.parcel_name} with tag {cellular_controller_tag}")
+        self._independent_items_cellular_controllers[cellular_controller_tag] = parcel
+        return cellular_controller_tag
+
+    def add_cellular_controller_subparcel(
+        self, cellular_controller_tag: UUID, parcel: Union[CellularProfileParcel, GpsParcel]
+    ) -> None:
+        """
+        Adds a subparcel to the cellular controller parcel.
+
+        Args:
+            cellular_controller_tag (UUID): The UUID of the cellular controller.
+            parcel (Union[CellularProfileParcel, GpsParcel]): The subparcel to add.
+
+        Returns:
+            None
+        """
+        self._dependent_items_on_cellular_controllers[cellular_controller_tag].append(parcel)
+
+    def add_vpn_subparcel(self, vpn_tag: UUID, parcel: AnyTransportVpnSubParcel) -> None:
+        """
+        Adds a parcel to the feature profile.
+
+        Args:
+            parcel (AnyTransportVpnSubParcel): The parcel to add.
+
+        Returns:
+            None
+        """
+        self._dependent_items_on_vpns[vpn_tag].append(parcel)
+
+    def build(self) -> FeatureProfileBuildReport:
+        """
+        Builds the feature profile.
+
+        Returns:
+            UUID: The UUID of the created feature profile.
+        """
+
+        profile_uuid = self._endpoints.create_transport_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)
+
+        for vpn_tag, vpn_parcel in self._independent_items_vpns.items():
+            vpn_uuid = self._create_parcel(profile_uuid, vpn_parcel)
+            for vpn_subparcel in self._dependent_items_on_vpns[vpn_tag]:
+                if vpn_uuid is None:
+                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, vpn_subparcel)
+                else:
+                    self._create_parcel(profile_uuid, vpn_subparcel, vpn_uuid)
+
+            for routing_parcel in self._dependent_routing_items_on_vpns[vpn_tag]:
+                if vpn_uuid is None:
+                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, routing_parcel)
+                else:
+                    routing_uuid = self._create_parcel(profile_uuid, routing_parcel)
+                    if not routing_uuid:
+                        continue
+                    self._endpoints.associate_with_vpn(
+                        profile_uuid,
+                        vpn_uuid,
+                        routing_parcel._get_parcel_type(),
+                        payload=ParcelAssociationPayload(parcel_id=routing_uuid),
+                    )
+
+        for cellular_controller_tag, cellular_controller_parcel in self._independent_items_cellular_controllers.items():
+            controller_uuid = self._create_parcel(profile_uuid, cellular_controller_parcel)
+            for cellular_subparcel in self._dependent_items_on_cellular_controllers[cellular_controller_tag]:
+                if controller_uuid is None:
+                    handle_build_report_for_failed_subparcel(
+                        self.build_report, cellular_controller_parcel, cellular_subparcel
+                    )
+                else:
+                    parcel_uuid = self._create_parcel(profile_uuid, cellular_subparcel)
+                    if not parcel_uuid:
+                        continue
+                    self._endpoints.associate_with_cellular_controller(
+                        profile_uuid,
+                        controller_uuid,
+                        cellular_subparcel._get_parcel_type(),
+                        ParcelAssociationPayload(parcel_id=parcel_uuid),
+                    )
+
+        return self.build_report
+
+    @handle_build_report
+    def _create_parcel(self, profile_uuid: UUID, parcel: AnyTransportParcel, vpn_uuid: Optional[None] = None) -> UUID:
+        return self._api.create_parcel(profile_uuid, parcel, vpn_uuid).id