catalystwan 0.41.2__py3-none-any.whl → 0.41.2.dev0__py3-none-any.whl

catalystwan/models/policy/{definitions → definition}/traffic_data.py

@@ -1,15 +1,26 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
-from ipaddress import IPv4Address, IPv4Network
-from typing import Any, List, Literal, Optional, Set, Tuple, Union, overload
+from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network
+from typing import List, Literal, Optional, Set, Tuple, Union, overload
 from uuid import UUID
 
 from pydantic import ConfigDict, Field
 from typing_extensions import Annotated
 
-from catalystwan.models.common import ServiceChainNumber, TLOCColor
-from catalystwan.models.policy.lists_entries import EncapType
+from catalystwan.models.common import (
+    AcceptDropActionType,
+    DestinationRegion,
+    DNSEntryType,
+    EncapType,
+    IcmpMsgType,
+    SequenceIpType,
+    ServiceChainNumber,
+    ServiceType,
+    TLOCColor,
+    TrafficTargetType,
+)
 from catalystwan.models.policy.policy_definition import (
+    ActionSet,
     AppListEntry,
     CFlowDAction,
     CountAction,
@@ -17,6 +28,7 @@ from catalystwan.models.policy.policy_definition import (
     DestinationDataIPv6PrefixListEntry,
     DestinationDataPrefixListEntry,
     DestinationIPEntry,
+    DestinationIPv6Entry,
     DestinationPortEntry,
     DestinationRegionEntry,
     DNSAppListEntry,
@@ -26,6 +38,7 @@ from catalystwan.models.policy.policy_definition import (
     DSCPEntry,
     FallBackToRoutingAction,
     ForwardingClassEntry,
+    ICMPMessageEntry,
     LocalTLOCListEntry,
     LocalTLOCListEntryValue,
     LogAction,
@@ -35,13 +48,17 @@ from catalystwan.models.policy.policy_definition import (
     LossProtectionType,
     Match,
     NATAction,
-    NextHopEntry,
+    NextHopActionEntry,
+    NextHopIpv6ActionEntry,
     NextHopLooseEntry,
     PacketLengthEntry,
     PLPEntry,
+    PLPEntryType,
     PolicerListEntry,
-    PolicyActionType,
+    PolicyAcceptDropAction,
     PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
     PolicyDefinitionSequenceBase,
     PrefferedColorGroupListEntry,
     ProtocolEntry,
@@ -49,10 +66,13 @@ from catalystwan.models.policy.policy_definition import (
     SecureInternetGatewayAction,
     ServiceChainEntry,
     ServiceChainEntryValue,
+    ServiceEntry,
+    ServiceEntryValue,
     ServiceNodeGroupAction,
     SourceDataIPv6PrefixListEntry,
     SourceDataPrefixListEntry,
     SourceIPEntry,
+    SourceIPv6Entry,
     SourcePortEntry,
     TCPEntry,
     TCPOptimizationAction,
@@ -66,29 +86,50 @@ from catalystwan.models.policy.policy_definition import (
 
 TrafficDataPolicySequenceEntry = Annotated[
     Union[
+        AppListEntry,
+        DestinationDataIPv6PrefixListEntry,
+        DestinationDataPrefixListEntry,
+        DestinationIPEntry,
+        DestinationIPv6Entry,
+        DestinationPortEntry,
+        DestinationRegionEntry,
+        DNSAppListEntry,
+        DNSEntry,
+        DSCPEntry,
+        ICMPMessageEntry,
         PacketLengthEntry,
         PLPEntry,
         ProtocolEntry,
-        DSCPEntry,
+        SourceDataIPv6PrefixListEntry,
+        SourceDataPrefixListEntry,
         SourceIPEntry,
+        SourceIPv6Entry,
         SourcePortEntry,
-        DestinationIPEntry,
-        DestinationPortEntry,
         TCPEntry,
-        DNSEntry,
         TrafficToEntry,
-        SourceDataPrefixListEntry,
-        DestinationDataPrefixListEntry,
-        SourceDataIPv6PrefixListEntry,
-        DestinationDataIPv6PrefixListEntry,
-        DestinationRegionEntry,
-        DNSAppListEntry,
-        AppListEntry,
     ],
     Field(discriminator="field"),
 ]
 
-TrafficDataPolicySequenceActions = Any  # TODO
+TrafficDataPolicySequenceActionEntry = Annotated[
+    Union[
+        ActionSet,
+        CFlowDAction,
+        CountAction,
+        DREOptimizationAction,
+        FallBackToRoutingAction,
+        LogAction,
+        LossProtectionAction,
+        LossProtectionFECAction,
+        LossProtectionPacketDuplicationAction,
+        NATAction,
+        RedirectDNSAction,
+        SecureInternetGatewayAction,
+        ServiceNodeGroupAction,
+        TCPOptimizationAction,
+    ],
+    Field(discriminator="type"),
+]
 
 
 class TrafficDataPolicyHeader(PolicyDefinitionBase):
@@ -100,63 +141,61 @@ class TrafficDataPolicySequenceMatch(Match):
 
 
 class TrafficDataPolicySequence(PolicyDefinitionSequenceBase):
-    sequence_type: Literal["data"] = Field(
+    sequence_type: Literal["applicationFirewall", "qos", "serviceChaining", "trafficEngineering", "data"] = Field(
         default="data", serialization_alias="sequenceType", validation_alias="sequenceType"
     )
+    base_action: AcceptDropActionType = Field(serialization_alias="baseAction", validation_alias="baseAction")
     match: TrafficDataPolicySequenceMatch = TrafficDataPolicySequenceMatch()
-    actions: List[TrafficDataPolicySequenceActions] = []
+    actions: List[TrafficDataPolicySequenceActionEntry] = []
     model_config = ConfigDict(populate_by_name=True)
 
     def match_app_list(self, app_list_id: UUID) -> None:
-        self._insert_match(AppListEntry(ref=app_list_id))
+        self._insert_match(AppListEntry(ref=[app_list_id]))
 
     def match_dns_app_list(self, dns_app_list_id: UUID) -> None:
         self._insert_match(DNSAppListEntry(ref=dns_app_list_id))
 
-    def match_dns_request(self) -> None:
-        self._insert_match(DNSEntry(value="request"))
+    def match_dns(self, dns: DNSEntryType) -> None:
+        self._insert_match(DNSEntry(value=dns))
 
-    def match_dns_response(self) -> None:
-        self._insert_match(DNSEntry(value="response"))
+    def match_dscp(self, dscp: List[int]) -> None:
+        self._insert_match(DSCPEntry(value=dscp))
 
-    def match_dscp(self, dscp: int) -> None:
-        self._insert_match(DSCPEntry(value=str(dscp)))
+    def match_icmp(self, icmp_message_types: List[IcmpMsgType]) -> None:
+        self._insert_match(ICMPMessageEntry(value=icmp_message_types))
 
     def match_packet_length(self, packet_lengths: Tuple[int, int]) -> None:
         self._insert_match(PacketLengthEntry.from_range(packet_lengths))
 
-    def match_low_plp(self) -> None:
-        self._insert_match(PLPEntry(value="low"))
-
-    def match_high_plp(self) -> None:
-        self._insert_match(PLPEntry(value="high"))
+    def match_plp(self, plp: PLPEntryType) -> None:
+        self._insert_match(PLPEntry(value=plp))
 
     def match_protocols(self, protocols: Set[int]) -> None:
         self._insert_match(ProtocolEntry.from_protocol_set(protocols))
 
     def match_source_data_prefix_list(self, data_prefix_list_id: UUID) -> None:
-        self._insert_match(SourceDataPrefixListEntry(ref=data_prefix_list_id))
+        self._insert_match(SourceDataPrefixListEntry(ref=[data_prefix_list_id]))
 
     def match_source_ip(self, networks: List[IPv4Network]) -> None:
         self._insert_match(SourceIPEntry.from_ipv4_networks(networks))
 
+    def match_source_ipv6(self, networks: List[IPv6Network]) -> None:
+        self._insert_match(SourceIPv6Entry.from_ipv6_networks(networks))
+
     def match_source_port(self, ports: Set[int] = set(), port_ranges: List[Tuple[int, int]] = []) -> None:
         self._insert_match(SourcePortEntry.from_port_set_and_ranges(ports, port_ranges))
 
     def match_destination_data_prefix_list(self, data_prefix_list_id: UUID) -> None:
-        self._insert_match(DestinationDataPrefixListEntry(ref=data_prefix_list_id))
+        self._insert_match(DestinationDataPrefixListEntry(ref=[data_prefix_list_id]))
 
     def match_destination_ip(self, networks: List[IPv4Network]) -> None:
         self._insert_match(DestinationIPEntry.from_ipv4_networks(networks))
 
-    def match_primary_destination_region(self) -> None:
-        self._insert_match(DestinationRegionEntry(value="primary-region"))
+    def match_destination_ipv6(self, networks: List[IPv6Network]) -> None:
+        self._insert_match(DestinationIPv6Entry.from_ipv6_networks(networks))
 
-    def match_secondary_destination_region(self) -> None:
-        self._insert_match(DestinationRegionEntry(value="secondary-region"))
-
-    def match_other_destination_region(self) -> None:
-        self._insert_match(DestinationRegionEntry(value="other-region"))
+    def match_destination_region(self, region: DestinationRegion) -> None:
+        self._insert_match(DestinationRegionEntry(value=region))
 
     def match_destination_port(self, ports: Set[int] = set(), port_ranges: List[Tuple[int, int]] = []) -> None:
         self._insert_match(DestinationPortEntry.from_port_set_and_ranges(ports, port_ranges))
@@ -164,14 +203,8 @@ class TrafficDataPolicySequence(PolicyDefinitionSequenceBase):
     def match_tcp(self) -> None:
         self._insert_match(TCPEntry())
 
-    def match_traffic_to_access(self) -> None:
-        self._insert_match(TrafficToEntry(value="access"))
-
-    def match_traffic_to_core(self) -> None:
-        self._insert_match(TrafficToEntry(value="core"))
-
-    def match_traffic_to_service(self) -> None:
-        self._insert_match(TrafficToEntry(value="service"))
+    def match_traffic_to(self, traffic_to: TrafficTargetType) -> None:
+        self._insert_match(TrafficToEntry(value=traffic_to))
 
     def associate_count_action(self, counter_name: str) -> None:
         self._insert_action(CountAction(parameter=counter_name))
@@ -181,14 +214,14 @@ class TrafficDataPolicySequence(PolicyDefinitionSequenceBase):
 
     @accept_action
     def associate_dscp_action(self, dscp: int) -> None:
-        self._insert_action_in_set(DSCPEntry(value=str(dscp)))
+        self._insert_action_in_set(DSCPEntry(value=[dscp]))
 
     @accept_action
     def associate_forwarding_class_action(self, fwclass: str) -> None:
         self._insert_action_in_set(ForwardingClassEntry(value=fwclass))
 
     @accept_action
-    def associate_local_tloc_action(self, color: TLOCColor, encap: EncapType, restrict: bool = False) -> None:
+    def associate_local_tloc_action(self, color: List[TLOCColor], encap: EncapType, restrict: bool = False) -> None:
         tloc_entry = LocalTLOCListEntry(
             value=LocalTLOCListEntryValue(
                 color=color,
@@ -207,25 +240,47 @@ class TrafficDataPolicySequence(PolicyDefinitionSequenceBase):
         self._insert_action(CFlowDAction())
 
     @overload
-    def associate_nat_action(self, *, nat_pool: int) -> None:
+    def associate_nat_action(self, *, nat_pool: int = 0) -> None:
         ...
 
     @overload
-    def associate_nat_action(self, *, vpn_fallback: bool = False, vpn: int = 0) -> None:
+    def associate_nat_action(
+        self,
+        *,
+        use_vpn: int = 0,
+        fallback: bool = False,
+        bypass: bool = False,
+        dia_pool: List[int] = [],
+        dia_interface: List[str] = []
+    ) -> None:
         ...
 
     @accept_action
-    def associate_nat_action(self, *, nat_pool: Optional[int] = None, vpn_fallback: bool = False, vpn: int = 0) -> None:
+    def associate_nat_action(
+        self,
+        *,
+        nat_pool: Optional[int] = None,
+        use_vpn: int = 0,
+        fallback: bool = False,
+        bypass: bool = False,
+        dia_pool: List[int] = [],
+        dia_interface: List[str] = []
+    ) -> None:
         if nat_pool:
             nat_action = NATAction.from_nat_pool(nat_pool=nat_pool)
         else:
-            nat_action = NATAction.from_nat_vpn(fallback=vpn_fallback, vpn=vpn)
+            nat_action = NATAction.from_nat_vpn(
+                use_vpn=use_vpn, fallback=fallback, bypass=bypass, dia_pool=dia_pool, dia_interface=dia_interface
+            )
         self._insert_action(nat_action)
 
     @accept_action
-    def associate_next_hop_action(self, next_hop: IPv4Address, loose: bool = False) -> None:
-        self._insert_action_in_set(NextHopEntry(value=next_hop))
-        self._insert_action_in_set(NextHopLooseEntry(value="true" if loose else "false"))
+    def associate_next_hop_action(self, next_hop: Union[IPv4Address, IPv6Address], loose: bool = False) -> None:
+        if isinstance(next_hop, IPv6Address):
+            self._insert_action_in_set(NextHopIpv6ActionEntry(value=next_hop))
+        else:
+            self._insert_action_in_set(NextHopActionEntry(value=next_hop))
+        self._insert_action_in_set(NextHopLooseEntry(value=loose))
 
     @accept_action
     def associate_policer_list_action(self, policer_list_id: UUID) -> None:
@@ -356,18 +411,86 @@ class TrafficDataPolicySequence(PolicyDefinitionSequenceBase):
         else:
             self._remove_action(FallBackToRoutingAction().type)
 
+    @overload
+    def associate_service_action(
+        self,
+        service_type: ServiceType,
+        vpn: Optional[int] = None,
+        *,
+        tloc_list_id: UUID,
+        local: bool = False,
+        restrict: bool = False
+    ) -> None:
+        ...
+
+    @overload
+    def associate_service_action(
+        self,
+        service_type: ServiceType,
+        vpn: int,
+        *,
+        ip: IPv4Address,
+        color: TLOCColor,
+        encap: EncapType,
+        local: bool = False,
+        restrict: bool = False
+    ) -> None:
+        ...
+
+    @accept_action
+    def associate_service_action(
+        self,
+        service_type=None,
+        vpn=None,
+        *,
+        tloc_list_id=None,
+        ip=None,
+        color=None,
+        encap=None,
+        local=None,
+        restrict=None
+    ) -> None:
+        if tloc_list_id is None:
+            tloc_entry = TLOCEntryValue(ip=ip, color=color, encap=encap)
+            tloc_list_entry = None
+        else:
+            tloc_entry = None
+            tloc_list_entry = TLOCListEntry(ref=tloc_list_id)
+        _local = "" if local else None
+        _restrict = "" if restrict else None
+        service_value = ServiceEntryValue(
+            type=service_type, vpn=vpn, tloc=tloc_entry, tloc_list=tloc_list_entry, local=_local, restrict=_restrict
+        )
+        self._insert_action_in_set(ServiceEntry(value=service_value))
+
 
 class TrafficDataPolicy(TrafficDataPolicyHeader, DefinitionWithSequencesCommonBase):
     sequences: List[TrafficDataPolicySequence] = []
+    default_action: PolicyAcceptDropAction = Field(
+        default=PolicyAcceptDropAction(type="drop"),
+        serialization_alias="defaultAction",
+        validation_alias="defaultAction",
+    )
     model_config = ConfigDict(populate_by_name=True)
 
-    def add_ipv4_sequence(
-        self, name: str = "Custom", base_action: PolicyActionType = "drop", log: bool = False
+    def add_sequence(
+        self,
+        name: str = "Custom",
+        base_action: AcceptDropActionType = "drop",
+        sequence_ip_type: SequenceIpType = "ipv4",
     ) -> TrafficDataPolicySequence:
         seq = TrafficDataPolicySequence(
             sequence_name=name,
             base_action=base_action,
-            sequence_ip_type="ipv4",
+            sequence_ip_type=sequence_ip_type,
         )
         self.add(seq)
         return seq
+
+
+class TrafficDataPolicyEditPayload(TrafficDataPolicy, PolicyDefinitionId):
+    pass
+
+
+class TrafficDataPolicyGetResponse(TrafficDataPolicy, PolicyDefinitionGetResponse):
+    pass

catalystwan/models/policy/definition/url_filtering.py

@@ -0,0 +1,70 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from catalystwan.models.common import PolicyModeType, VpnId, WebCategory, WebReputation
+from catalystwan.models.policy.policy_definition import (
+    PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
+    Reference,
+)
+
+BLOCK_PAGE_CONTENT_HEADER = "Access to the requested page has been denied."
+
+BlockPageAction = Literal["text", "redirectUrl"]
+UrlFilteringAlerts = Literal["blacklist", "whitelist", "categories-reputation"]
+WebCategoriesAction = Literal["allow", "block"]
+
+
+class UrlFilteringDefinition(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    web_categories_action: WebCategoriesAction = Field(
+        validation_alias="webCategoriesAction", serialization_alias="webCategoriesAction"
+    )
+    web_categories: List[WebCategory] = Field(validation_alias="webCategories", serialization_alias="webCategories")
+    web_reputation: WebReputation = Field(validation_alias="webReputation", serialization_alias="webReputation")
+    url_white_list: Optional[Reference] = Field(
+        default=None, validation_alias="urlWhiteList", serialization_alias="urlWhiteList"
+    )
+    url_black_list: Optional[Reference] = Field(
+        default=None, validation_alias="urlBlackList", serialization_alias="urlBlackList"
+    )
+    block_page_action: BlockPageAction = Field(
+        validation_alias="blockPageAction", serialization_alias="blockPageAction"
+    )
+    block_page_contents: str = Field(
+        default=BLOCK_PAGE_CONTENT_HEADER, validation_alias="blockPageContents", serialization_alias="blockPageContents"
+    )
+    logging: List[str] = Field(default_factory=list)
+    enable_alerts: bool = Field(validation_alias="enableAlerts", serialization_alias="enableAlerts")
+    alerts: Set[UrlFilteringAlerts] = Field(
+        default_factory=set, validation_alias="alerts", serialization_alias="alerts"
+    )
+    target_vpns: List[VpnId] = Field(
+        default_factory=list, validation_alias="targetVpns", serialization_alias="targetVpns"
+    )
+
+    @field_validator("url_black_list", "url_white_list", mode="before")
+    @classmethod
+    def convert_empty_dict_to_none(cls, value):
+        if not value:
+            return None
+
+        return value
+
+
+class UrlFilteringPolicy(PolicyDefinitionBase):
+    type: Literal["urlFiltering"] = "urlFiltering"
+    mode: PolicyModeType = "security"
+    definition: UrlFilteringDefinition
+
+
+class UrlFilteringPolicyEditPayload(UrlFilteringPolicy, PolicyDefinitionId):
+    pass
+
+
+class UrlFilteringPolicyGetResponse(UrlFilteringPolicy, PolicyDefinitionGetResponse):
+    pass

catalystwan/models/policy/{definitions → definition}/vpn_membership.py

@@ -5,7 +5,11 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from catalystwan.models.policy.policy_definition import PolicyDefinitionBase
+from catalystwan.models.policy.policy_definition import (
+    PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
+)
 
 
 class Site(BaseModel):
@@ -28,3 +32,11 @@ class VPNMembershipPolicy(PolicyDefinitionBase):
         site = Site(site_list=site_list, vpn_list=vpn_lists)
         self.definition.sites.append(site)
         return site
+
+
+class VPNMembershipPolicyEditPayload(VPNMembershipPolicy, PolicyDefinitionId):
+    pass
+
+
+class VPNMembershipPolicyGetResponse(VPNMembershipPolicy, PolicyDefinitionGetResponse):
+    pass

catalystwan/models/policy/definition/vpn_qos_map.py

@@ -0,0 +1,46 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import List, Literal, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from catalystwan.models.common import IntStr
+from catalystwan.models.policy.policy_definition import (
+    PolicyDefinitionBase,
+    PolicyDefinitionGetResponse,
+    PolicyDefinitionId,
+)
+
+
+class VPNQoSScheduler(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    child_map_ref: UUID = Field(validation_alias="childMapRef", serialization_alias="childMapRef")
+    vpn_list_ref: Optional[UUID] = Field(default=None, validation_alias="vpnListRef", serialization_alias="vpnListRef")
+    bandwidth_rate: Optional[IntStr] = Field(
+        default=None, validation_alias="bandwidthRate", serialization_alias="bandwidthRate", ge=8, le=100_000_000
+    )
+    shaping_rate: Optional[IntStr] = Field(
+        default=None, validation_alias="shapingRate", serialization_alias="shapingRate", ge=8, le=100_000_000
+    )
+
+
+class VPNQoSMapPolicyDefinition(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    vpn_qos_schedulers: List[VPNQoSScheduler] = Field(
+        validation_alias="vpnQosSchedulers", serialization_alias="vpnQosSchedulers"
+    )
+
+
+class VPNQoSMapPolicy(PolicyDefinitionBase):
+    model_config = ConfigDict(populate_by_name=True)
+    type: Literal["vpnQosMap", "vpnQoSMap"] = "vpnQosMap"
+    definition: VPNQoSMapPolicyDefinition
+
+
+class VPNQoSMapPolicyEditPayload(VPNQoSMapPolicy, PolicyDefinitionId):
+    pass
+
+
+class VPNQoSMapPolicyGetResponse(VPNQoSMapPolicy, PolicyDefinitionGetResponse):
+    pass