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

catalystwan/api/templates/device_template/device_template.py

@@ -3,28 +3,37 @@
 from __future__ import annotations
 
 import logging
-from pathlib import Path
-from typing import TYPE_CHECKING, Final, List
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
+from uuid import UUID
 
-from jinja2 import DebugUndefined, Environment, FileSystemLoader, meta  # type: ignore
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
-from catalystwan.utils.device_model import DeviceModel
-
 if TYPE_CHECKING:
     from catalystwan.session import ManagerSession
 
 logger = logging.getLogger(__name__)
 
 
+TemplateType = Literal["file", "template"]  # file == cli, template == feature
+
+
+def str_to_uuid(s: str) -> Optional[UUID]:
+    try:
+        return UUID(s)
+    except ValueError:
+        return None
+
+
 class GeneralTemplate(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    name: str = ""
-    subTemplates: List[GeneralTemplate] = []
+    name: str = Field(default="")
 
-    templateId: str = ""
-    templateType: str = ""
+    sub_templates: List[GeneralTemplate] = Field(
+        default=[], serialization_alias="subTemplates", validation_alias="subTemplates"
+    )
+    template_id: str = Field(default="", serialization_alias="templateId", validation_alias="templateId")
+    template_type: str = Field(default="", serialization_alias="templateType", validation_alias="templateType")
 
 
 class DeviceTemplate(BaseModel):
@@ -44,28 +53,67 @@ class DeviceTemplate(BaseModel):
     >>> session.api.templates.create(device_template)
     """
 
-    template_name: str = Field(alias="templateName")
-    template_description: str = Field(alias="templateDescription")
-    general_templates: List[GeneralTemplate] = Field(alias="generalTemplates")
-    device_role: str = Field(default="sdwan-edge", alias="deviceRole")
-    device_type: DeviceModel = Field(alias="deviceType")
-    security_policy_id: str = Field(default="", alias="securityPolicyId")
-    policy_id: str = Field(default="", alias="policyId")
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    template_name: str = Field(serialization_alias="templateName", validation_alias="templateName")
+    template_description: str = Field(serialization_alias="templateDescription", validation_alias="templateDescription")
+    device_type: str = Field(serialization_alias="deviceType", validation_alias="deviceType")
+    device_role: str = Field(default="sdwan-edge", serialization_alias="deviceRole", validation_alias="deviceRole")
+    config_type: Optional[str] = Field(
+        default="template", serialization_alias="configType", validation_alias="configType"
+    )
+    factory_default: Optional[bool] = Field(
+        default=False, serialization_alias="factoryDefault", validation_alias="factoryDefault"
+    )
+    policy_id: str = Field(default="", serialization_alias="policyId", validation_alias="policyId")
+    feature_template_uid_range: Optional[List] = Field(
+        default=[], serialization_alias="featureTemplateUidRange", validation_alias="featureTemplateUidRange"
+    )
+
+    connection_preference_required: Optional[bool] = Field(
+        default=True,
+        serialization_alias="connectionPreferenceRequired",
+        validation_alias="connectionPreferenceRequired",
+    )
+    connection_preference: Optional[bool] = Field(
+        default=True, serialization_alias="connectionPreference", validation_alias="connectionPreference"
+    )
+
+    general_templates: List[GeneralTemplate] = Field(
+        default=[], serialization_alias="generalTemplates", validation_alias="generalTemplates"
+    )
+    security_policy_id: str = Field(
+        default="", serialization_alias="securityPolicyId", validation_alias="securityPolicyId"
+    )
+    voice_policy_id: Optional[str] = Field(
+        default=None, serialization_alias="voicePolicyId", validation_alias="voicePolicyId"
+    )
+    template_configuration_edited: Optional[str] = Field(
+        default=None, serialization_alias="templateConfigurationEdited", validation_alias="templateConfigurationEdited"
+    )
+    template_configuration: Optional[str] = Field(
+        default=None, serialization_alias="templateConfiguration", validation_alias="templateConfiguration"
+    )
+    rid: Optional[int] = Field(default=None, serialization_alias="@rid", validation_alias="@rid")
+    cli_type: Optional[str] = Field(default=None, serialization_alias="cliType", validation_alias="cliType")
+    copy_edited: Optional[bool] = Field(default=None, serialization_alias="copyEdited", validation_alias="copyEdited")
+
+    def get_security_policy_uuid(self) -> Optional[UUID]:
+        return str_to_uuid(self.security_policy_id)
+
+    def get_policy_uuid(self) -> Optional[UUID]:
+        return str_to_uuid(self.policy_id)
+
+    def get_voice_policy_uuid(self) -> Optional[UUID]:
+        if self.voice_policy_id is None:
+            return None
+        return str_to_uuid(self.voice_policy_id)
+
+    def has_any_policy(self) -> bool:
+        return any((self.policy_id, self.security_policy_id, self.voice_policy_id))
 
     def generate_payload(self) -> str:
-        env = Environment(
-            loader=FileSystemLoader(self.payload_path.parent),
-            trim_blocks=True,
-            lstrip_blocks=True,
-            undefined=DebugUndefined,
-        )
-        template = env.get_template(self.payload_path.name)
-        output = template.render(self.model_dump())
-
-        ast = env.parse(output)
-        if meta.find_undeclared_variables(ast):
-            logger.info(meta.find_undeclared_variables(ast))
-            raise Exception("There are undeclared variables.")
+        output = self.model_dump_json(by_alias=True)
         return output
 
     @field_validator("general_templates", mode="before")
@@ -79,16 +127,63 @@ class DeviceTemplate(BaseModel):
                 output.append(template)
         return output
 
-    payload_path: Final[Path] = Path(__file__).parent / "device_template_payload.json.j2"
-
     @classmethod
     def get(self, name: str, session: ManagerSession) -> DeviceTemplate:
         device_template = session.api.templates.get(DeviceTemplate).filter(name=name).single_or_default()
         resp = session.get(f"dataservice/template/device/object/{device_template.id}").json()
         return DeviceTemplate(**resp)
 
+    def associate_feature_template(self, template_type: str, template_uuid: UUID) -> None:
+        self.general_templates.append(
+            GeneralTemplate(name="", template_id=str(template_uuid), template_type=template_type)
+        )
+
+    def associate_security_policy(self, security_policy_uuid: UUID) -> None:
+        self.security_policy_id = str(security_policy_uuid)
+
+    def associate_policy(self, policy_uuid: UUID) -> None:
+        self.policy_id = str(policy_uuid)
+
     model_config = ConfigDict(populate_by_name=True, use_enum_values=True)
 
 
 class DeviceSpecificValue(BaseModel):
     property: str
+
+
+class DeviceTemplateConfigAttached(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    host_name: Optional[str] = Field(None, serialization_alias="host-name", validation_alias="host-name")
+    device_ip: Optional[str] = Field(None, serialization_alias="deviceIP", validation_alias="deviceIP")
+    local_system_ip: Optional[str] = Field(
+        None, serialization_alias="local-system-ip", validation_alias="local-system-ip"
+    )
+    site_id: Optional[str] = Field(None, serialization_alias="site-id", validation_alias="site-id")
+    device_groups: Optional[List[str]] = Field(
+        None, serialization_alias="device-groups", validation_alias="device-groups"
+    )
+    uuid: Optional[str] = Field(None, serialization_alias="uuid", validation_alias="uuid")
+    personality: Optional[str] = Field(None, serialization_alias="personality", validation_alias="personality")
+    config_cloudx_mode: Optional[str] = Field(
+        None, serialization_alias="configCloudxMode", validation_alias="configCloudxMode"
+    )
+
+
+class CreateDeviceInputPayload(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    template_id: str = Field(serialization_alias="templateId", validation_alias="templateId")
+    device_ids: List[str] = Field(serialization_alias="deviceIds", validation_alias="deviceIds")
+    is_edited: bool = Field(serialization_alias="isEdited", validation_alias="isEdited")
+    is_master_edited: bool = Field(serialization_alias="isMasterEdited", validation_alias="isMasterEdited")
+
+
+class DeviceInputValues(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    csv_device_ip: str = Field(validation_alias="csv-deviceIP", serialization_alias="csv-deviceIP")
+    csv_device_id: str = Field(validation_alias="csv-deviceId", serialization_alias="csv-deviceId")
+    csv_host_name: str = Field(validation_alias="csv-host-name", serialization_alias="csv-host-name")
+    csv_status: str = Field(validation_alias="csv-status", serialization_alias="csv-status")
+
+    @property
+    def values(self) -> Dict[str, Any]:
+        return self.__pydantic_extra__ or dict()

catalystwan/api/templates/feature_template.py

@@ -11,7 +11,7 @@ from jinja2 import DebugUndefined, Environment, FileSystemLoader, meta  # type:
 from pydantic import BaseModel, model_validator
 
 from catalystwan.api.templates.device_variable import DeviceVariable
-from catalystwan.utils.device_model import DeviceModel
+from catalystwan.models.common import DeviceModel
 from catalystwan.utils.dict import FlattenedDictValue, flatten_dict
 from catalystwan.utils.feature_template.find_template_values import find_template_values
 from catalystwan.utils.pydantic_field import get_extra_field
@@ -118,7 +118,7 @@ class FeatureTemplate(FeatureTemplateValidator, ABC):
         template_info = (
             session.api.templates._get_feature_templates(summary=False).filter(name=name).single_or_default()
         )
-        template_definition_as_dict = json.loads(cast(str, template_info.template_definiton))
+        template_definition_as_dict = json.loads(cast(str, template_info.template_definition))
 
         feature_template_model = choose_model(type_value=template_info.template_type)
 
@@ -128,6 +128,6 @@ class FeatureTemplate(FeatureTemplateValidator, ABC):
         return feature_template_model(
             template_name=template_info.name,
             template_description=template_info.description,
-            device_models=[DeviceModel(model) for model in template_info.device_type],
+            device_models=[model for model in template_info.device_type],
             **flattened_values,
         )

catalystwan/api/templates/models/aaa_model.py

@@ -0,0 +1,387 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+
+from pathlib import Path
+from typing import ClassVar, List, Literal, Optional
+
+from pydantic import ConfigDict, Field, field_validator
+
+from catalystwan.api.templates.bool_str import BoolStr
+from catalystwan.api.templates.feature_template import FeatureTemplate, FeatureTemplateValidator
+
+Privilage = Literal["1", "15"]
+AuthenticationOrder = Literal["local", "radius", "tacacs"]
+TacacsAuthType = Literal["pap", "ascii"]
+TaskPermission = Literal["read", "write"]
+DefaultAction = Literal["accept", "deny"]
+TaskMode = Literal["system", "interface", "policy", "routing", "security"]
+
+
+class Command(FeatureTemplateValidator):
+    model_config = ConfigDict(populate_by_name=True, coerce_numbers_to_str=True)
+
+    command: str = Field(description="Define command", json_schema_extra={"vmanage_key": "command"})
+
+
+class Task(FeatureTemplateValidator):
+    model_config = ConfigDict(populate_by_name=True, coerce_numbers_to_str=True)
+
+    name: str = Field(description="The name of the user", json_schema_extra={"vmanage_key": "name"})
+    config_default_action: DefaultAction = Field(
+        json_schema_extra={
+            "vmanage_key": "default-action",
+            "data_path": ["config"],
+        },
+        description="Define config default action",
+    )
+    oper_exec_default_action: DefaultAction = Field(
+        json_schema_extra={
+            "vmanage_key": "default-action",
+            "data_path": ["oper-exec"],
+        },
+        description="Define oper-exec default action",
+    )
+    oper_exec_accept_action: Optional[List[Command]] = Field(
+        default=None,
+        json_schema_extra={
+            "vmanage_key": "accept",
+            "data_path": ["oper-exec"],
+        },
+        description="List of oper-exec commands to allow",
+    )
+    oper_exec_deny_action: Optional[List[Command]] = Field(
+        default=None,
+        json_schema_extra={
+            "vmanage_key": "deny",
+            "data_path": ["oper-exec"],
+        },
+        description="List of oper-exec commands to deny",
+    )
+    config_accept_action: Optional[List[Command]] = Field(
+        default=None,
+        json_schema_extra={
+            "vmanage_key": "accept",
+            "data_path": ["config"],
+        },
+        description="List of config commands to allow",
+    )
+    config_deny_action: Optional[List[Command]] = Field(
+        default=None,
+        json_schema_extra={
+            "vmanage_key": "deny",
+            "data_path": ["config"],
+        },
+        description="List of config commands to deny",
+    )
+
+    password: Optional[str] = Field(default=None, description="The password for the user")
+    secret: Optional[str] = Field(default=None, description="The secret for the user")
+    privilege: Optional[Privilage] = Field(default="15", description="The privilege level for the user")
+
+
+class PubkeyChain(FeatureTemplateValidator):
+    model_config = ConfigDict(populate_by_name=True, coerce_numbers_to_str=True)
+
+    usertag: str = Field(
+        description="User Tag",
+        json_schema_extra={"vmanage_key": "usertag"},
+    )
+    key_string: str = Field(
+        description="Set the RSA key string",
+        json_schema_extra={"vmanage_key": "key-string"},
+    )
+    key_type: Optional[str] = Field(
+        default="ssh-rsa",
+        description="Only RSA is supported",
+        json_schema_extra={"vmanage_key": "key-type"},
+    )
+
+
+class User(FeatureTemplateValidator):
+    model_config = ConfigDict(populate_by_name=True, coerce_numbers_to_str=True)
+
+    name: str = Field(description="The name of the user")
+    password: Optional[str] = Field(default=None, description="The password for the user")
+    secret: Optional[str] = Field(default=None, description="The secret for the user")
+    description: Optional[str] = Field(default=None, description="Add a description of the user")
+    group: Optional[List[str]] = Field(default=None, description="Configure the groups that the user is part of")
+    pubkey_chain: Optional[List[PubkeyChain]] = Field(
+        default=None,
+        description="List of public keys for the user",
+        json_schema_extra={"vmanage_key": "pubkey-chain"},
+    )
+
+
+class RadiusServer(FeatureTemplateValidator):
+    model_config = ConfigDict(populate_by_name=True, coerce_numbers_to_str=True)
+
+    address: str = Field(description="The IP address or hostname of the RADIUS server")
+    auth_port: Optional[int] = Field(
+        default=1812,
+        json_schema_extra={"vmanage_key": "auth-port"},
+        description="The authentication port for the RADIUS server",
+    )
+    tag: Optional[str] = Field(
+        default=None,
+        json_schema_extra={"vmanage_key": "tag"},
+        description="Reference tag/name for the server",
+    )
+    acct_port: Optional[int] = Field(
+        default=1813,
+        json_schema_extra={"vmanage_key": "acct-port"},
+        description="The accounting port for the RADIUS server",
+    )
+    vpn: Optional[str] = Field(
+        default="0",
+        json_schema_extra={"vmanage_key": "vpn"},
+        description="Set VPN in which RADIUS server is located",
+    )
+    source_interface: Optional[str] = Field(
+        default=None,
+        json_schema_extra={"vmanage_key": "source-interface"},
+        description="Set interface to use to reach RADIUS server",
+    )
+    key: Optional[str] = Field(default=None, description="Set the password to access the RADIUS server")
+    secret_key: Optional[str] = Field(
+        default=None,
+        json_schema_extra={"vmanage_key": "secret-key"},
+        description="Set the AES encrypted key to access the RADIUS server",
+    )
+    priority: int = Field(default=0, description="RADIUS server priority <0..7>")
+
+
+class TacacsServer(FeatureTemplateValidator):
+    model_config = ConfigDict(populate_by_name=True, coerce_numbers_to_str=True)
+
+    address: str = Field(description="The IP address or hostname of the TACACS+ server")
+    auth_port: Optional[int] = Field(
+        default=49,
+        json_schema_extra={"vmanage_key": "auth-port"},
+        description="The authentication port for the TACACS+ server",
+    )
+    vpn: Optional[str] = Field(
+        default="0",
+        json_schema_extra={"vmanage_key": "vpn"},
+        description="Set VPN in which TACACS+ server is located",
+    )
+    source_interface: Optional[str] = Field(
+        default=None,
+        json_schema_extra={"vmanage_key": "source-interface"},
+        description="Set interface to use to reach TACACS+ server",
+    )
+    key: Optional[str] = Field(default=None, description="Set the password to access the TACACS+ server")
+    secret_key: Optional[str] = Field(
+        default=None,
+        json_schema_extra={"vmanage_key": "secret-key"},
+        description="Set the AES encrypted key to access the TACACS+ server",
+    )
+    priority: int = Field(default=0, description="TACACS+ server priority <0..7>")
+
+
+class TaskPermissions(FeatureTemplateValidator):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    mode: TaskMode = Field(
+        json_schema_extra={"vmanage_key": "mode"},
+        description="Select the task to set privileges for",
+    )
+    permission: List[TaskPermission] = Field(
+        default=["read"],  # type: ignore
+        json_schema_extra={
+            "vmanage_key": "permission",
+        },
+        description="Set read or write permission for the task",
+    )
+
+    @field_validator("permission")
+    def convert_permission_field(cls, val: List[TaskPermission]) -> List:
+        permission_list = []
+        for value in val:
+            permission_list.append({"vipType": "constant", "vipValue": f"{value}", "vipObjectType": "object"})
+        return permission_list
+
+
+class UserGroup(FeatureTemplateValidator):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    name: str = Field(
+        json_schema_extra={"vmanage_key": "name"},
+        description="Set name of user group",
+    )
+    task: Optional[List[TaskPermissions]] = Field(
+        default=None,
+        json_schema_extra={"vmanage_key": "task", "priority_order": ["mode", "permission"]},
+        description="Set the user group's tasks and task privileges. Skipping tasks sets all as read and write",
+    )
+
+
+class AAAModel(FeatureTemplate):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    _docs_description: str = "AAA Feature Template configuration"
+
+    auth_order: Optional[List[AuthenticationOrder]] = Field(
+        validate_default=True,
+        default=["local", "radius", "tacacs"],  # type: ignore
+        json_schema_extra={"vmanage_key": "auth-order", "data_path": ["aaa"]},
+        description="ServerGroups authentication order to user access",
+    )
+
+    @field_validator("auth_order")
+    def convert_to_auth_order_field(cls, val: Optional[List[AuthenticationOrder]]) -> List:
+        auth_order_list = []
+        if val:
+            for value in val:
+                auth_order_list.append({"vipType": "constant", "vipValue": f"{value}", "vipObjectType": "object"})
+        return auth_order_list
+
+    auth_fallback: Optional[BoolStr] = Field(
+        default=False,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "auth-fallback",
+        },
+        description="Authenticate admin user as per auth-order",
+    )
+    admin_auth_order: Optional[BoolStr] = Field(
+        default=False,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "admin-auth-order",
+        },
+        description="Fall back if higher-priority authentication fails",
+    )
+    netconf_disable: Optional[BoolStr] = Field(
+        default=False,
+        json_schema_extra={
+            "data_path": ["aaa", "logs"],
+            "vmanage_key": "netconf-disable",
+        },
+        description="Disable Netconf logs",
+    )
+    audit_disable: Optional[BoolStr] = Field(
+        default=False,
+        json_schema_extra={
+            "data_path": ["aaa", "logs"],
+            "vmanage_key": "audit-disable",
+        },
+        description="Disable audit logs",
+    )
+    radius_server_list: Optional[List[str]] = Field(
+        default=None,
+        json_schema_extra={"vmanage_key": "radius-servers", "data_path": ["aaa"]},
+        description="Designate radius servers for authentication and accounting",
+    )
+    task: Optional[List[Task]] = Field(
+        default=None,
+        frozen=True,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "audit-disable",
+            "priority_order": ["name"],
+        },
+        description="Set the user group's tasks and task privileges.",
+    )
+    accounting: Optional[BoolStr] = Field(
+        default=False,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "accounting",
+        },
+        description="Enable/disable user accounting",
+    )
+    usergroup: Optional[List[UserGroup]] = Field(
+        default=None,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "usergroup",
+            "priority_order": ["name"],
+        },
+        description="Create groupings of users with the same authorization privileges. "
+        "When used, overrides existing groups(netadmin, basic, operator)",
+    )
+    user: Optional[List[User]] = Field(
+        default=None,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "user",
+        },
+        description="List of local user configurations. When used, overrides existing users",
+    )
+    cisco_tac_ro_user: Optional[BoolStr] = Field(
+        default=True,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "ciscotacro-user",
+        },
+        description="Cisco Tac Enable Read only",
+    )
+    cisco_tac_rw_user: Optional[BoolStr] = Field(
+        default=True,
+        json_schema_extra={
+            "data_path": ["aaa"],
+            "vmanage_key": "ciscotacrw-user",
+        },
+        description="Cisco Tac Enable Read and Write",
+    )
+    tacacs_timeout: Optional[int] = Field(
+        default=5,
+        json_schema_extra={
+            "data_path": ["tacacs"],
+            "vmanage_key": "timeout",
+        },
+        description="The timeout period in seconds for the TACACS+ server",
+    )
+    tacacs_authentication: Optional[TacacsAuthType] = Field(
+        default="pap",
+        json_schema_extra={
+            "data_path": ["tacacs"],
+            "vmanage_key": "authentication",
+        },
+        description="TACACS authentication type",
+    )
+    tacacs_server: Optional[List[TacacsServer]] = Field(
+        default=None,
+        json_schema_extra={
+            "data_path": ["tacacs"],
+            "priority_order": ["address", "auth-port", "vpn", "source-interface", "secret-key", "priority"],
+            "vmanage_key": "server",
+        },
+        description="The list of TACACS+ servers",
+    )
+    radius_timeout: Optional[int] = Field(
+        default=5,
+        json_schema_extra={
+            "data_path": ["radius"],
+            "vmanage_key": "timeout",
+        },
+        description="The timeout period in seconds for the RADIUS server",
+    )
+    radius_retransmit: Optional[int] = Field(
+        default=3,
+        json_schema_extra={
+            "data_path": ["radius"],
+            "vmanage_key": "retransmit",
+        },
+        description="The number of retransmit attempts for the RADIUS server",
+    )
+    radius_server: Optional[List[RadiusServer]] = Field(
+        default=None,
+        json_schema_extra={
+            "data_path": ["radius"],
+            "priority_order": [
+                "address",
+                "auth-port",
+                "vpn",
+                "source-interface",
+                "key",
+                "secret-key",
+                "priority",
+                "tag",
+                "acct-port",
+            ],
+            "vmanage_key": "server",
+        },
+        description="The list of RADIUS servers",
+    )
+
+    payload_path: ClassVar[Path] = Path(__file__).parent / "DEPRECATED"
+    type: ClassVar[str] = "aaa"