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

catalystwan/models/configuration/feature_profile/parcel.py

@@ -0,0 +1,238 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from functools import lru_cache
+from typing import Generic, List, Literal, Optional, Sequence, TypeVar, Union, cast
+from uuid import UUID
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field, model_validator
+from typing_extensions import Annotated
+
+from catalystwan.models.configuration.feature_profile.sdwan.application_priority import AnyApplicationPriorityParcel
+from catalystwan.models.configuration.feature_profile.sdwan.cli import AnyCliParcel
+from catalystwan.models.configuration.feature_profile.sdwan.dns_security import AnyDnsSecurityParcel
+from catalystwan.models.configuration.feature_profile.sdwan.embedded_security import AnyEmbeddedSecurityParcel
+from catalystwan.models.configuration.feature_profile.sdwan.other import AnyOtherParcel
+from catalystwan.models.configuration.feature_profile.sdwan.policy_object import AnyPolicyObjectParcel
+from catalystwan.models.configuration.feature_profile.sdwan.routing import AnyRoutingParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service import AnyServiceParcel
+from catalystwan.models.configuration.feature_profile.sdwan.sig_security import AnySIGSecurityParcel
+from catalystwan.models.configuration.feature_profile.sdwan.system import AnySystemParcel
+from catalystwan.models.configuration.feature_profile.sdwan.topology import AnyTopologyParcel
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import AnyTrackerParcel
+from catalystwan.models.configuration.feature_profile.sdwan.transport import AnyTransportParcel
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice import AnyUcVoiceParcel
+from catalystwan.models.configuration.network_hierarchy import AnyNetworkHierarchyParcel
+from catalystwan.utils.model import resolve_nested_base_model_unions
+
+ParcelType = Literal[
+    "aaa",
+    "analog-interface",
+    "app-list",
+    "app-probe",
+    "appqoe",
+    "as-path",
+    "banner",
+    "basic",
+    "bfd",
+    "bgp",
+    "call-routing",
+    "cellular-controller",
+    "cellular-profile",
+    "cflowd",
+    "class",
+    "color",
+    "config",
+    "custom-control",
+    "data-ipv6-prefix",
+    "data-prefix",
+    "dhcp-server",
+    "digital-interface",
+    "dns",
+    "dsp-farm",
+    "expanded-community",
+    "ext-community",
+    "full-config",
+    "global",
+    "gps",
+    "hubspoke",
+    "ipv4-acl",
+    "ipv6-acl",
+    "ipv6-prefix",
+    "lan/vpn",
+    "lan/vpn/interface/ethernet",
+    "lan/vpn/interface/gre",
+    "lan/vpn/interface/ipsec",
+    "lan/vpn/interface/multilink",
+    "lan/vpn/interface/svi",
+    "logging",
+    "management/vpn",
+    "management/vpn/interface/ethernet",
+    "media-profile",
+    "mesh",
+    "mirror",
+    "mrf",
+    "ntp",
+    "omp",
+    "policer",
+    "policy-settings",
+    "policy",
+    "preferred-color-group",
+    "prefix",
+    "qos-policy",
+    "route-policy",
+    "routing/bgp",
+    "routing/eigrp",
+    "routing/multicast",
+    "routing/ospf",
+    "routing/ospfv3/ipv4",
+    "routing/ospfv3/ipv6",
+    "security-data-ip-prefix",
+    "security-fqdn",
+    "security-geolocation",
+    "security-identity",
+    "security-ipssignature",
+    "security-localapp",
+    "security-localdomain",
+    "security-port",
+    "security-protocolname",
+    "security-scalablegrouptag",
+    "security-urllist",
+    "security-zone",
+    "security",
+    "server-group",
+    "sig",
+    "sla-class",
+    "snmp",
+    "standard-community",
+    "strt",
+    "supervisory-disconnect",
+    "switchport",
+    "t1-e1-controller",
+    "tloc",
+    "tracker",
+    "trackergroup",
+    "ipv6-tracker",
+    "ipv6-trackergroup",
+    "traffic-policy",
+    "trunk-group",
+    "unified/advanced-inspection-profile",
+    "unified/advanced-malware-protection",
+    "unified/intrusion-prevention",
+    "unified/ngfirewall",
+    "unified/ssl-decryption-profile",
+    "unified/ssl-decryption",
+    "unified/url-filtering",
+    "voice-global",
+    "voice-tenant",
+    "wan/vpn",
+    "wan/vpn/interface/cellular",
+    "wan/vpn/interface/dsl-ipoe",
+    "wan/vpn/interface/dsl-pppoa",
+    "wan/vpn/interface/dsl-pppoe",
+    "wan/vpn/interface/ethernet",
+    "wan/vpn/interface/ethpppoe",
+    "wan/vpn/interface/gre",
+    "wan/vpn/interface/ipsec",
+    "wan/vpn/interface/multilink",
+    "wan/vpn/interface/serial",
+    "wirelesslan",
+]
+
+
+AnyParcel = Annotated[
+    Union[
+        AnyApplicationPriorityParcel,
+        AnyCliParcel,
+        AnyDnsSecurityParcel,
+        AnyEmbeddedSecurityParcel,
+        AnyNetworkHierarchyParcel,
+        AnyOtherParcel,
+        AnyPolicyObjectParcel,
+        AnyRoutingParcel,
+        AnyTrackerParcel,
+        AnyServiceParcel,
+        AnySIGSecurityParcel,
+        AnySystemParcel,
+        AnyTopologyParcel,
+        AnyTransportParcel,
+        AnyUcVoiceParcel,
+    ],
+    Field(discriminator="type_"),
+]
+
+T = TypeVar("T", bound=AnyParcel)
+
+
+class Parcel(BaseModel, Generic[T]):
+    parcel_id: UUID = Field(alias="parcelId")
+    parcel_type: ParcelType = Field(alias="parcelType")
+    created_by: str = Field(alias="createdBy")
+    last_updated_by: Optional[str] = Field(default=None, alias="lastUpdatedBy")
+    created_on: int = Field(alias="createdOn")
+    last_updated_on: Optional[int] = Field(default=None, alias="lastUpdatedOn")
+    origin: Optional[str] = Field(default=None)
+    payload: T
+
+    @model_validator(mode="before")
+    def validate_payload(cls, data):
+        if not isinstance(data, dict):
+            return data
+        type_ = data.get("parcelType") or data.get("type")
+        id_ = data.get("parcelId") or data.get("id")
+        assert type_ is not None
+        assert id_ is not None
+        data["parcelType"] = type_
+        data["payload"]["type_"] = type_
+        data["parcelId"] = id_
+        return data
+
+    def model_post_init(self, __context):
+        """We do not want to store the JSON as dict data in the 'data' field, as it is already deserialized"""
+        self.payload.data = None
+
+
+class Header(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    generated_on: int = Field(alias="generatedOn")
+
+
+class ParcelInfo(BaseModel, Generic[T]):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    header: Header
+    data: List[Parcel[T]]
+
+
+class ParcelSequence(BaseModel, Generic[T]):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    header: Header
+    data: List[Parcel[T]]
+
+
+class ParcelCreationResponse(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: UUID = Field(validation_alias=AliasChoices("parcelId", "featureId"))  # Accept both keys
+
+
+class ParcelAssociationPayload(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    parcel_id: UUID = Field(serialization_alias="parcelId", validation_alias="parcelId")
+
+
+class ParcelId(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    id: UUID = Field(serialization_alias="parcelId", validation_alias="parcelId")
+
+
+@lru_cache
+def list_types(any_union: T) -> Sequence[T]:
+    return cast(Sequence[T], resolve_nested_base_model_unions(any_union))
+
+
+@lru_cache
+def find_type(name: str, any_union: T) -> T:
+    parcel_types = list_types(any_union)
+    parcel_type = next(t for t in parcel_types if t._get_parcel_type() == name)
+    return cast(T, parcel_type)

catalystwan/models/configuration/feature_profile/sdwan/acl/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+from typing import Union
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from .ipv4acl import Ipv4AclParcel
+from .ipv6acl import Ipv6AclParcel
+
+AnyAclParcel = Annotated[
+    Union[Ipv4AclParcel, Ipv6AclParcel],
+    Field(discriminator="type_"),
+]

catalystwan/models/configuration/feature_profile/sdwan/acl/ipv4acl.py

@@ -0,0 +1,298 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from ipaddress import IPv4Address, IPv4Interface
+from typing import List, Literal, Optional, Tuple, Union
+from uuid import UUID
+
+from pydantic import AliasPath, BaseModel, ConfigDict, Field, model_validator
+
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, _ParcelBase, as_global, as_variable
+from catalystwan.models.common import AcceptDropActionType, IcmpMsgType, check_fields_exclusive
+from catalystwan.models.configuration.feature_profile.common import RefIdItem
+
+
+class SourceDataPrefixList(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    source_data_prefix_list: Optional[RefIdItem] = Field(
+        default=None, validation_alias="sourceDataPrefixList", serialization_alias="sourceDataPrefixList"
+    )
+
+
+class SourceDataPrefix(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    source_ip_prefix: Union[Variable, Global[str]] = Field(
+        validation_alias="sourceIpPrefix", serialization_alias="sourceIpPrefix"
+    )
+
+
+class SourcePorts(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    source_port: Union[Global[str], Global[int], None] = Field(
+        default=None, validation_alias="sourcePort", serialization_alias="sourcePort"
+    )
+
+
+class DestinationDataPrefixList(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    destination_data_prefix_list: Optional[RefIdItem] = Field(
+        default=None, validation_alias="destinationDataPrefixList", serialization_alias="destinationDataPrefixList"
+    )
+
+
+class DestinationDataPrefix(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    destination_ip_prefix: Union[Variable, Global[str]] = Field(
+        validation_alias="destinationIpPrefix", serialization_alias="destinationIpPrefix"
+    )
+
+
+class DestinationPorts(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    destination_port: Union[Global[str], Global[int], None] = Field(
+        default=None, validation_alias="destinationPort", serialization_alias="destinationPort"
+    )
+
+
+class MatchEntry(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
+    destination_data_prefix: Union[DestinationDataPrefix, DestinationDataPrefixList, None] = Field(
+        default=None, validation_alias="destinationDataPrefix", serialization_alias="destinationDataPrefix"
+    )
+    destination_ports: Optional[List[DestinationPorts]] = Field(
+        default=None,
+        validation_alias="destinationPorts",
+        serialization_alias="destinationPorts",
+        description="Destination Port List",
+    )
+    dscp: Optional[Global[List[int]]] = Field(default=None)
+    icmp_msg: Optional[Global[List[IcmpMsgType]]] = Field(
+        default=None, validation_alias="icmpMsg", serialization_alias="icmpMsg"
+    )
+    packet_length: Union[Global[str], Global[int], None] = Field(
+        default=None, validation_alias="packetLength", serialization_alias="packetLength"
+    )
+    protocol: Optional[Global[List[int]]] = Field(default=None)
+    source_data_prefix: Union[SourceDataPrefix, SourceDataPrefixList, None] = Field(
+        default=None, validation_alias="sourceDataPrefix", serialization_alias="sourceDataPrefix"
+    )
+    source_ports: Optional[List[SourcePorts]] = Field(
+        default=None,
+        validation_alias="sourcePorts",
+        serialization_alias="sourcePorts",
+        description="Source Port List",
+    )
+    tcp: Optional[Global[Literal["syn"]]] = Field(default=None)
+
+
+class Accept(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    counter_name: Optional[Global[str]] = Field(
+        default=None, validation_alias="counterName", serialization_alias="counterName"
+    )
+    log: Optional[Union[Global[bool], Default[bool]]] = Field(default=None)
+    mirror: Optional[RefIdItem] = Field(default=None)
+    policer: Optional[RefIdItem] = Field(default=None)
+    set_dscp: Optional[Global[int]] = Field(default=None, validation_alias="setDscp", serialization_alias="setDscp")
+    set_next_hop: Optional[Global[str]] = Field(
+        default=None, validation_alias="setNextHop", serialization_alias="setNextHop"
+    )
+
+
+class AcceptAction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
+    accept: Accept = Field(description="Accept Action")
+
+
+class Drop(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    counter_name: Optional[Global[str]] = Field(
+        default=None, validation_alias="counterName", serialization_alias="counterName"
+    )
+    log: Optional[Union[Global[bool], Default[bool]]] = Field(default=None)
+
+
+class DropAction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
+    drop: Drop = Field(description="Drop Action")
+
+
+class Sequence(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    actions: Optional[List[Union[AcceptAction, DropAction]]] = Field(
+        default=None, description="Define list of actions", max_length=1, min_length=1
+    )
+    base_action: Optional[Union[Global[AcceptDropActionType], Default[Literal["accept"]]]] = Field(
+        default=None, validation_alias="baseAction", serialization_alias="baseAction"
+    )
+    match_entries: Optional[List[MatchEntry]] = Field(
+        default=None,
+        validation_alias="matchEntries",
+        serialization_alias="matchEntries",
+        description="Define match conditions",
+        max_length=1,
+        min_length=1,
+    )
+    sequence_id: Optional[Global[int]] = Field(
+        default=None, validation_alias="sequenceId", serialization_alias="sequenceId"
+    )
+    sequence_name: Optional[Global[str]] = Field(
+        default=None, validation_alias="sequenceName", serialization_alias="sequenceName"
+    )
+
+    @model_validator(mode="after")
+    def check_base_action_xor_actions(self):
+        check_fields_exclusive(self.__dict__, {"base_action", "actions"}, True)
+        return self
+
+    def _action(self, mode: Optional[AcceptDropActionType] = None) -> Union[AcceptAction, DropAction]:
+        if mode is None and self.base_action is not None:
+            _mode = self.base_action.value
+        else:
+            _mode = mode
+        self.base_action = None
+        if self.actions is None:
+            if _mode == "drop":
+                self.actions = [(DropAction(drop=Drop()))]
+            else:
+                self.actions = [(AcceptAction(accept=Accept()))]
+        return self.actions[0]
+
+    @property
+    def _accept_action(self) -> Accept:
+        action = self._action("accept")
+        assert isinstance(action, AcceptAction), "Sequence action must be set to accept"
+        return action.accept
+
+    @property
+    def _drop_action(self) -> Drop:
+        action = self._action("drop")
+        assert isinstance(action, DropAction), "Sequence action must be set to drop"
+        return action.drop
+
+    @property
+    def _entry(self) -> MatchEntry:
+        if self.match_entries is None:
+            self.match_entries = [MatchEntry()]
+        return self.match_entries[0]
+
+    def match_destination_data_prefix(self, prefix: IPv4Interface):
+        value = as_global(str(prefix))
+        self._entry.destination_data_prefix = DestinationDataPrefix(destination_ip_prefix=value)
+
+    def match_destination_data_prefix_variable(self, prefix: str):
+        value = as_variable(prefix)
+        self._entry.destination_data_prefix = DestinationDataPrefix(destination_ip_prefix=value)
+
+    def match_destination_data_prefix_list(self, prefix: UUID):
+        self._entry.destination_data_prefix = DestinationDataPrefixList(
+            destination_data_prefix_list=RefIdItem.from_uuid(prefix)
+        )
+
+    def match_destination_ports(self, ports: List[Union[int, Tuple[int, int]]]):
+        """
+        ports argument example: [1, 3, (10,100), (50,200), 600]
+        """
+        destination_ports = []
+        for port in ports:
+            if isinstance(port, int):
+                value = as_global(port)
+            else:
+                value = as_global(f"{port[0]}-{port[1]}")
+            destination_ports.append(DestinationPorts(destination_port=value))
+        self._entry.destination_ports = destination_ports
+
+    def match_dscp(self, dscp: List[int]):
+        self._entry.dscp = as_global(dscp)
+
+    def match_icmp_msg(self, icmp: List[IcmpMsgType]):
+        self._entry.icmp_msg = Global[List[IcmpMsgType]](value=icmp)
+
+    def match_packet_length(self, len: Union[int, Tuple[int, int]]):
+        if isinstance(len, int):
+            value = as_global(len)
+        else:
+            value = as_global(f"{len[0]}-{len[1]}")
+        self._entry.packet_length = value
+
+    def match_protocol(self, protocols: List[int]):
+        self._entry.protocol = as_global(protocols)
+
+    def match_source_data_prefix(self, prefix: IPv4Interface):
+        value = as_global(str(prefix))
+        self._entry.source_data_prefix = SourceDataPrefix(source_ip_prefix=value)
+
+    def match_source_data_prefix_variable(self, prefix: str):
+        value = as_variable(prefix)
+        self._entry.source_data_prefix = SourceDataPrefix(source_ip_prefix=value)
+
+    def match_source_data_prefix_list(self, prefix: UUID):
+        self._entry.source_data_prefix = SourceDataPrefixList(source_data_prefix_list=RefIdItem.from_uuid(prefix))
+
+    def match_source_ports(self, ports: List[Union[int, Tuple[int, int]]]):
+        """
+        ports argument example: [1, 3, (10,100), (50,200), 600]
+        """
+        source_ports = []
+        for port in ports:
+            if isinstance(port, int):
+                value = as_global(port)
+            else:
+                value = as_global(f"{port[0]}-{port[1]}")
+            source_ports.append(SourcePorts(source_port=value))
+        self._entry.source_ports = source_ports
+
+    def match_tcp(self):
+        self._entry.tcp = as_global("syn", Literal["syn"])
+
+    def associate_log_action(self):
+        if isinstance(self._action(), DropAction):
+            self._drop_action.log = as_global(True)
+        else:
+            self._accept_action.log = as_global(True)
+
+    def associate_counter_action(self, name: str):
+        if isinstance(self._action(), DropAction):
+            self._drop_action.counter_name = as_global(name)
+        else:
+            self._accept_action.counter_name = as_global(name)
+
+    def associate_mirror_action(self, mirror: UUID):
+        self._accept_action.mirror = RefIdItem(ref_id=as_global(str(mirror)))
+
+    def associate_policer_action(self, policer: UUID):
+        self._accept_action.policer = RefIdItem(ref_id=as_global(str(policer)))
+
+    def associate_set_dscp_action(self, dscp: int):
+        self._accept_action.set_dscp = as_global(dscp)
+
+    def associate_set_next_hop_action(self, next_hop: IPv4Address):
+        self._accept_action.set_next_hop = as_global(str(next_hop))
+
+
+class Ipv4AclParcel(_ParcelBase):
+    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
+    type_: Literal["ipv4-acl"] = Field(default="ipv4-acl", exclude=True)
+    default_action: Union[Global[AcceptDropActionType], Default[Literal["drop"]]] = Field(
+        default=Default[Literal["drop"]](value="drop"), validation_alias=AliasPath("data", "defaultAction")
+    )
+    sequences: List[Sequence] = Field(
+        default_factory=list, validation_alias=AliasPath("data", "sequences"), description="Access Control List"
+    )
+
+    def set_default_action(self, action: AcceptDropActionType):
+        self.default_action = as_global(action, AcceptDropActionType)
+
+    def add_sequence(self, name: str, id_: int, base_action: Optional[AcceptDropActionType] = None) -> Sequence:
+        if base_action is not None:
+            _base_action = as_global(base_action, AcceptDropActionType)
+        else:
+            _base_action = Default[Literal["accept"]](value="accept")
+        seq = Sequence(
+            base_action=_base_action,
+            sequence_id=as_global(id_),
+            sequence_name=as_global(name),
+        )
+        if self.sequences is None:
+            self.sequences = [seq]
+        else:
+            self.sequences.append(seq)
+        return seq