catalystwan 0.41.0.dev1__tar.gz → 0.41.0.dev3__tar.gz

{catalystwan-0.41.0.dev1 → catalystwan-0.41.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: catalystwan
-Version: 0.41.0.dev1
+Version: 0.41.0.dev3
 Summary: Cisco Catalyst WAN SDK for Python
 Author: kagorski
 Author-email: kagorski@cisco.com

{catalystwan-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/application_priority.py

@@ -5,7 +5,7 @@ import logging
 from typing import TYPE_CHECKING, List
 from uuid import UUID
 
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_build_report
+from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_create_parcel
 from catalystwan.api.feature_profile_api import ApplicationPriorityFeatureProfileAPI
 from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
 from catalystwan.models.configuration.feature_profile.sdwan.application_priority import AnyApplicationPriorityParcel
@@ -53,6 +53,6 @@ class ApplicationPriorityFeatureProfileBuilder:
             self._create_parcel(profile_uuid, parcel)
         return self.build_report
 
-    @handle_build_report
+    @handle_create_parcel
     def _create_parcel(self, profile_uuid: UUID, parcel: AnyApplicationPriorityParcel) -> UUID:
         return self._api.create_parcel(profile_uuid, parcel).id

{catalystwan-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/cli.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, List
 from uuid import UUID
 
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_build_report
+from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_create_parcel
 from catalystwan.api.feature_profile_api import CliFeatureProfileAPI
 from catalystwan.endpoints.configuration.feature_profile.sdwan.cli import CliFeatureProfile
 from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
@@ -71,6 +71,6 @@ class CliFeatureProfileBuilder:
             self._create_parcel(profile_uuid, config_parcel)
         return self.build_report
 
-    @handle_build_report
+    @handle_create_parcel
     def _create_parcel(self, profile_uuid: UUID, parcel: AnyCliParcel) -> UUID:
         return self._api.create_parcel(profile_uuid, parcel).id

catalystwan-0.41.0.dev3/catalystwan/api/builders/feature_profiles/mixins.py

@@ -0,0 +1,44 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+from __future__ import annotations
+
+from typing import Dict, List, Set, Tuple
+from uuid import UUID
+
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import Tracker, TrackerGroup
+
+
+class TrackerMixin:
+    def init_tracker(self) -> None:
+        self._shared_trackers: Dict[str, UUID] = {}
+        self._trackers: List[Tuple[Set[UUID], Tracker]] = []
+        self._tracker_groups: List[Tuple[Set[UUID], TrackerGroup, List[Tracker]]] = []
+        self._interface_tag_to_existing_tracker: Dict[UUID, Tuple[UUID, str]] = {}
+
+    def _create_parcel(self, profile_uuid: UUID, tracker: Tracker | TrackerGroup) -> UUID:
+        raise NotImplementedError()
+
+    def create_trackers(self, profile_uuid: UUID) -> None:
+        for tracker_group_tags, tracker_group, trackers in self._tracker_groups:
+            trackers_uuids: List[UUID] = []
+            for tracker_ in trackers:
+                tracker_uuid = self._create_parcel(profile_uuid, tracker_)
+                if tracker_uuid:
+                    trackers_uuids.append(tracker_uuid)
+                    self._shared_trackers[tracker_.parcel_name] = tracker_uuid
+
+            for tracker_uuid in trackers_uuids:
+                tracker_group.add_ref(tracker_uuid)
+
+            tracker_group_uuid = self._create_parcel(profile_uuid, tracker_group)
+            if tracker_group_uuid:
+                for tag in tracker_group_tags:
+                    self._interface_tag_to_existing_tracker[tag] = tracker_group_uuid, tracker_group._get_parcel_type()
+
+        for tracker_tags, tracker in self._trackers:
+            if tracker.parcel_name in self._shared_trackers:
+                created_tracker_uuid = self._shared_trackers[tracker.parcel_name]
+            else:
+                created_tracker_uuid = self._create_parcel(profile_uuid, tracker)
+            if created_tracker_uuid:
+                for tag in tracker_tags:
+                    self._interface_tag_to_existing_tracker[tag] = (created_tracker_uuid, tracker._get_parcel_type())

{catalystwan-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/other.py

@@ -5,7 +5,7 @@ import logging
 from typing import TYPE_CHECKING, List
 from uuid import UUID
 
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_build_report
+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
@@ -74,6 +74,6 @@ class OtherFeatureProfileBuilder:
             self._create_parcel(profile_uuid, parcel)
         return self.build_report
 
-    @handle_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-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/report.py

@@ -1,5 +1,6 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 import functools
+import logging
 from typing import Any, List, Optional, Tuple, Union
 from uuid import UUID
 
@@ -9,10 +10,10 @@ 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_build_report(func):
-    """Wrapper to make creating report simple and keep it DRY."""
 
+def handle_create_parcel(func):
     @functools.wraps(func)
     def wrapper(self, profile_uuid: UUID, parcel: AnyParcel, *args, **kwargs) -> Optional[UUID]:
         try:
@@ -122,9 +123,7 @@ class FeatureProfileBuildReport(BaseModel):
         )
 
 
-def handle_build_report_for_failed_subparcel(
-    build_report: FeatureProfileBuildReport, parent: AnyParcel, subparcel: AnyParcel
-) -> None:
+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."
     )
@@ -135,3 +134,22 @@ def handle_build_report_for_failed_subparcel(
             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-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/service.py

@@ -9,10 +9,12 @@ 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,
-    handle_build_report,
-    handle_build_report_for_failed_subparcel,
+    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
@@ -30,7 +32,7 @@ from catalystwan.models.configuration.feature_profile.sdwan.service import (
     LanVpnParcel,
 )
 from catalystwan.models.configuration.feature_profile.sdwan.service.multicast import MulticastParcel
-from catalystwan.models.configuration.feature_profile.sdwan.trackers import AnyTrackerParcel, Tracker, TrackerGroup
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import Tracker, TrackerGroup
 
 if TYPE_CHECKING:
     from catalystwan.session import ManagerSession
@@ -44,7 +46,7 @@ DependedVpnSubparcels = Annotated[
 ]
 
 
-class ServiceFeatureProfileBuilder:
+class ServiceFeatureProfileBuilder(TrackerMixin):
     """
     A class for building service feature profiles.
     """
@@ -65,9 +67,8 @@ class ServiceFeatureProfileBuilder:
         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] = {}
-        self._trackers: List[Tuple[Set[UUID], AnyTrackerParcel]] = []
-        self._tracker_groups: List[Tuple[Set[UUID], TrackerGroup, List[Tracker]]] = []
-        self._interface_tag_to_existing_tracker: Dict[UUID, Tuple[UUID, str]] = {}
+        # Trackers
+        self.init_tracker()
 
     def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
         """
@@ -154,18 +155,18 @@ class ServiceFeatureProfileBuilder:
         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], parcel: AnyTrackerParcel) -> None:
+    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.
-            parcel (AnyTrackerParcel): The tracker parcel to add.
+            tracker (Tracker): The tracker parcel to add.
 
         Returns:
             None
         """
-        self._trackers.append((associate_tags, parcel))
+        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))
@@ -183,82 +184,65 @@ class ServiceFeatureProfileBuilder:
         for parcel in self._independent_items:
             self._create_parcel(profile_uuid, parcel)
 
-        for tracker_group_tags, tracker_group, trackers in self._tracker_groups:
-            trackers_uuids: List[UUID] = []
-            for tracker_ in trackers:
-                tracker_uuid = self._create_parcel(profile_uuid, tracker_)
-                if tracker_uuid:
-                    trackers_uuids.append(tracker_uuid)
-
-            for tracker_uuid in trackers_uuids:
-                tracker_group.add_ref(tracker_uuid)
-
-            tracker_group_uuid = self._create_parcel(profile_uuid, tracker_group)
-            if tracker_group_uuid:
-                for tag in tracker_group_tags:
-                    self._interface_tag_to_existing_tracker[tag] = tracker_group_uuid, tracker_group._get_parcel_type()
-
-        for tracker_tags, tracker in self._trackers:
-            tracker_uuid = self._create_parcel(profile_uuid, tracker)
-            if tracker_uuid:
-                for tag in tracker_tags:
-                    self._interface_tag_to_existing_tracker[tag] = (tracker_uuid, tracker._get_parcel_type())
+        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:
-                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, routing_parcel)
+                    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
-                    self._endpoints.associate_with_vpn(
-                        profile_uuid,
-                        vpn_uuid,
-                        routing_parcel._get_parcel_type(),
-                        payload=ParcelAssociationPayload(parcel_id=routing_uuid),
-                    )
+                    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:
-                    handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, sub_parcel)
+                    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
-                        handle_build_report_for_failed_subparcel(self.build_report, sub_parcel, dhcp_server)
+                        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:
-                            # The DHCP server could not be created
-                            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),
-                            )
+                            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/", "")
-                        self._endpoints.associate_tracker_with_vpn_interface(
-                            profile_uuid,
-                            vpn_uuid,
-                            sub_parcel_type,
-                            parcel_uuid,
-                            tracker_type,
-                            ParcelAssociationPayload(parcel_id=tracker_uuid),
-                        )
+                        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_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-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/system.py

@@ -5,7 +5,7 @@ import logging
 from typing import TYPE_CHECKING, List
 from uuid import UUID
 
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_build_report
+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
@@ -75,6 +75,6 @@ class SystemFeatureProfileBuilder:
             self._create_parcels(profile_uuid, parcel)
         return self.build_report
 
-    @handle_build_report
+    @handle_create_parcel
     def _create_parcels(self, profile_uuid: UUID, parcel: AnySystemParcel) -> UUID:
         return self._api.create_parcel(profile_uuid, parcel).id

{catalystwan-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/transport.py

@@ -6,10 +6,12 @@ from collections import defaultdict
 from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union
 from uuid import UUID, uuid4
 
+from catalystwan.api.builders.feature_profiles.mixins import TrackerMixin
 from catalystwan.api.builders.feature_profiles.report import (
     FeatureProfileBuildReport,
-    handle_build_report,
-    handle_build_report_for_failed_subparcel,
+    hande_failed_sub_parcel,
+    handle_association_request,
+    handle_create_parcel,
 )
 from catalystwan.api.feature_profile_api import TransportFeatureProfileAPI
 from catalystwan.endpoints.configuration.feature_profile.sdwan.transport import TransportFeatureProfile
@@ -35,7 +37,7 @@ if TYPE_CHECKING:
     from catalystwan.session import ManagerSession
 
 
-class TransportAndManagementProfileBuilder:
+class TransportAndManagementProfileBuilder(TrackerMixin):
     """
     A class for building system feature profiles.
     """
@@ -59,9 +61,8 @@ class TransportAndManagementProfileBuilder:
         self._dependent_items_on_cellular_controllers: Dict[
             UUID, List[Union[CellularProfileParcel, GpsParcel]]
         ] = defaultdict(list)
-        self._trackers: List[Tuple[Set[UUID], Tracker]] = []
-        self._tracker_groups: List[Tuple[Set[UUID], TrackerGroup, List[Tracker]]] = []
-        self._interface_tag_to_existing_tracker: Dict[UUID, Tuple[UUID, str]] = {}
+        # Trackers
+        self.init_tracker()
 
     def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
         """
@@ -161,18 +162,18 @@ class TransportAndManagementProfileBuilder:
         self._dependent_items_on_vpns[vpn_tag].append((subparcel_tag, parcel))
         return subparcel_tag
 
-    def add_tracker(self, associate_tags: Set[UUID], parcel: Tracker) -> None:
+    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.
-            parcel (AnyTrackerParcel): The tracker parcel to add.
+            tracker (Tracker): The tracker parcel to add.
 
         Returns:
             None
         """
-        self._trackers.append((associate_tags, parcel))
+        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))
@@ -190,82 +191,66 @@ class TransportAndManagementProfileBuilder:
         for parcel in self._independent_items:
             self._create_parcel(profile_uuid, parcel)
 
-        for tracker_group_tags, tracker_group, trackers in self._tracker_groups:
-            trackers_uuids: List[UUID] = []
-            for tracker in trackers:
-                tracker_uuid = self._create_parcel(profile_uuid, tracker)
-                if tracker_uuid:
-                    trackers_uuids.append(tracker_uuid)
-
-            for tracker_uuid in trackers_uuids:
-                tracker_group.add_ref(tracker_uuid)
-
-            tracker_group_uuid = self._create_parcel(profile_uuid, tracker_group)
-            if tracker_group_uuid:
-                for tag in tracker_group_tags:
-                    self._interface_tag_to_existing_tracker[tag] = tracker_group_uuid, tracker_group._get_parcel_type()
-
-        for tracker_tags, tracker in self._trackers:
-            tracker_uuid = self._create_parcel(profile_uuid, tracker)
-            if tracker_uuid:
-                for tag in tracker_tags:
-                    self._interface_tag_to_existing_tracker[tag] = tracker_uuid, tracker._get_parcel_type()
+        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 vpn_subparcel_tag, 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)
+                    hande_failed_sub_parcel(self.build_report, vpn_parcel, vpn_subparcel)
                 else:
                     vpn_subparcel_uuid = self._create_parcel(profile_uuid, vpn_subparcel, vpn_uuid)
 
                     # Associate tracker with VPN interface if it exists
                     if vpn_subparcel_tag in self._interface_tag_to_existing_tracker and vpn_subparcel_uuid:
                         tracker_uuid, tracker_type = self._interface_tag_to_existing_tracker[vpn_subparcel_tag]
-                        vpn_subparcel_type = vpn_subparcel._get_parcel_type().replace("wan/vpn/", "")
-                        self._endpoints.associate_tracker_with_vpn_interface(
-                            profile_uuid,
-                            vpn_uuid,
-                            vpn_subparcel_type,
-                            vpn_subparcel_uuid,
-                            tracker_type,
-                            ParcelAssociationPayload(parcel_id=tracker_uuid),
+                        vpn_subparcel_type = (
+                            vpn_subparcel._get_parcel_type().replace("wan/vpn/", "").replace("management/vpn/", "")
                         )
+                        with handle_association_request(self.build_report, vpn_subparcel):
+                            self._endpoints.associate_tracker_with_vpn_interface(
+                                profile_uuid,
+                                vpn_uuid,
+                                vpn_subparcel_type,
+                                vpn_subparcel_uuid,
+                                tracker_type,
+                                ParcelAssociationPayload(parcel_id=tracker_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)
+                    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
-                    self._endpoints.associate_with_vpn(
-                        profile_uuid,
-                        vpn_uuid,
-                        routing_parcel._get_parcel_type(),
-                        payload=ParcelAssociationPayload(parcel_id=routing_uuid),
-                    )
+                    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 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
-                    )
+                    hande_failed_sub_parcel(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),
-                    )
+                    with handle_association_request(self.build_report, cellular_subparcel):
+                        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
+    @handle_create_parcel
     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

{catalystwan-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/api/builders/feature_profiles/uc_voice.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Dict, List, Optional, Union
 from uuid import UUID
 
-from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_build_report
+from catalystwan.api.builders.feature_profiles.report import FeatureProfileBuildReport, handle_create_parcel
 from catalystwan.api.configuration_groups.parcel import as_default
 from catalystwan.api.feature_profile_api import UcVoiceFeatureProfileAPI
 from catalystwan.endpoints.configuration.feature_profile.sdwan.uc_voice import UcVoiceFeatureProfile
@@ -216,7 +216,7 @@ class UcVoiceFeatureProfileBuilder:
 
         return self.build_report
 
-    @handle_build_report
+    @handle_create_parcel
     def _create_parcel(self, profile_uuid: UUID, parcel: AnyUcVoiceParcel) -> UUID:
         """
         Internal method to create a parcel.

{catalystwan-0.41.0.dev1 → catalystwan-0.41.0.dev3}/catalystwan/integration_tests/profile_builder/test_pb_service.py

@@ -94,7 +94,7 @@ class TestServiceFeatureProfileBuilder(TestCaseBase):
             interval=Global[int](value=100),
             endpoint_api_url=Global[str](value="https://example.com/api"),
         )
-        self.builder.add_tracker(associate_tags=[ethernet_tag], parcel=tracker)
+        self.builder.add_tracker(associate_tags=[ethernet_tag], tracker=tracker)
         report = self.builder.build()
 
         assert len(report.failed_parcels) == 0
@@ -140,6 +140,56 @@ class TestServiceFeatureProfileBuilder(TestCaseBase):
 
         assert len(report.failed_parcels) == 0
 
+    def test_when_shared_tracker_expect_success(self):
+        service_vpn_parcel = LanVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+            vpn_id=as_global(50),
+        )
+        ethernet_parcel_1 = InterfaceEthernetParcel(
+            parcel_name="TestEthernetParcel1",
+            parcel_description="Test Ethernet Parcel",
+            interface_name=as_global("HundredGigE"),
+            ethernet_description=as_global("Test Ethernet Description"),
+            shutdown=as_variable("{{vpn1_gi3_lan_ip_192.168.X.1/24_}}"),
+        )
+        ethernet_parcel_2 = InterfaceEthernetParcel(
+            parcel_name="TestEthernetParcel2",
+            parcel_description="Test Ethernet Parcel",
+            interface_name=as_global("HundredGigE"),
+            ethernet_description=as_global("Test Ethernet Description"),
+            shutdown=as_variable("{{vpn1_gi3_lan_ip_192.168.X.1/24_}}"),
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        ethernet_tag_1 = self.builder.add_parcel_vpn_subparcel(vpn_tag, ethernet_parcel_1)
+        ethernet_tag_2 = self.builder.add_parcel_vpn_subparcel(vpn_tag, ethernet_parcel_2)
+        tracker1 = Tracker(
+            parcel_name="TestTracker1",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker1"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker2 = Tracker(
+            parcel_name="TestTracker2",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker2"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker_group = TrackerGroup(
+            parcel_name="TestTrackerGroup",
+            parcel_description="Test Tracker Group Description",
+            tracker_refs=[],
+        )
+        self.builder.add_tracker_group(
+            associate_tags=[ethernet_tag_1], group=tracker_group, trackers=[tracker1, tracker2]
+        )
+        self.builder.add_tracker(associate_tags=[ethernet_tag_2], tracker=tracker2)
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0
+
     def tearDown(self) -> None:
         target_profile = self.api.get_profiles().filter(profile_name=self.fp_name).single_or_default()
         if target_profile: