Internal DNS Servers Models¶

Overview¶

The Internal DNS Servers models provide a structured way to manage DNS server configurations in Palo Alto Networks' Strata Cloud Manager. These models handle validation of inputs and outputs when interacting with the SCM API for internal DNS server resources.

Models¶

The module provides the following Pydantic models:

InternalDnsServersBaseModel: Base model with fields common to all internal DNS server operations
InternalDnsServersCreateModel: Model for creating new internal DNS servers
InternalDnsServersUpdateModel: Model for updating existing internal DNS servers
InternalDnsServersResponseModel: Response model for internal DNS server operations

All models use extra="forbid" configuration, which rejects any fields not explicitly defined in the model.

Attributes¶

Attribute	Type	Required	Default	Description
`name`	`str`	Yes	None	Name of the DNS server. Max length: 63 chars. Must match pattern: ^[0-9a-zA-Z._- ]+$
`domain_name`	`List[str]`	Yes	None	List of DNS domain names. Cannot be empty.
`primary`	`IPvAnyAddress`	Yes	None	IP address of the primary DNS server
`secondary`	`IPvAnyAddress`	No	None	IP address of the secondary DNS server
`id`	`UUID`	Yes*	None	UUID of the DNS server (required for update and response models)

* Only required for update and response models

Exceptions¶

The Internal DNS Servers models can raise the following exceptions during validation:

ValueError: Raised in several scenarios:
- When domain_name is empty
- When domain_name is neither a string nor a list
- When at least one field is not specified for updates
- When name pattern validation fails
- When IP address validation fails

Model Validators¶

Domain Name Validation¶

The models enforce that domain_name must be provided and cannot be empty:

# This will raise a validation error
from scm.models.deployment import InternalDnsServersCreateModel

# Error: empty domain_name
try:
    dns_server = InternalDnsServersCreateModel(
        name="invalid-dns-server",
        domain_name=[],
        primary="192.168.1.10"
    )
except ValueError as e:
    print(e)  # "domain_name must not be empty"

# This will convert a single string to a list
dns_server = InternalDnsServersCreateModel(
    name="valid-dns-server",
    domain_name="example.com",  # Will be converted to ["example.com"]
    primary="192.168.1.10"
)
print(dns_server.domain_name)  # ["example.com"]

Update Model Validation¶

For update operations, the model validates that at least one field other than id is provided:

# This will raise a validation error
from scm.models.deployment import InternalDnsServersUpdateModel

# Error: no fields to update
try:
    dns_server = InternalDnsServersUpdateModel(
        id="123e4567-e89b-12d3-a456-426655440000"
        # No other fields provided
    )
except ValueError as e:
    print(e)  # "At least one field must be specified for update"

Usage Examples¶

Creating an Internal DNS Server¶

from scm.client import Scm

# Initialize client
client = Scm(
    client_id="your_client_id",
    client_secret="your_client_secret",
    tsg_id="your_tsg_id"
)

# Using dictionary
dns_dict = {
    "name": "main-dns-server",
    "domain_name": ["example.com", "internal.example.com"],
    "primary": "192.168.1.10",
    "secondary": "192.168.1.11"
}

response = client.internal_dns_server.create(dns_dict)
print(f"Created DNS server: {response.name} with ID: {response.id}")

Updating an Internal DNS Server¶

# Fetch existing DNS server
existing = client.internal_dns_server.fetch(name="main-dns-server")

# Modify attributes using dot notation
existing.domain_name = ["example.com", "updated.example.com"]
existing.secondary = "192.168.1.12"

# Pass modified object to update()
updated = client.internal_dns_server.update(existing)
print(f"Updated DNS server: {updated.name}")

Working with Response Model¶

from scm.client import Scm

# Initialize client
client = Scm(
    client_id="your_client_id",
    client_secret="your_client_secret",
    tsg_id="your_tsg_id"
)

# Get an existing DNS server
dns_server = client.internal_dns_server.fetch(name="main-dns-server")

# Access response model attributes
print(f"DNS Server ID: {dns_server.id}")
print(f"DNS Server Name: {dns_server.name}")
print(f"Domain Names: {dns_server.domain_name}")
print(f"Primary DNS: {dns_server.primary}")
print(f"Secondary DNS: {dns_server.secondary}")

# Modify the response model using dot notation
dns_server.domain_name = dns_server.domain_name + ["new-domain.example.com"]

# Update the DNS server
updated = client.internal_dns_server.update(dns_server)

Model Serialization¶

from scm.models.deployment import InternalDnsServersCreateModel

# Create a model instance
dns_model = InternalDnsServersCreateModel(
    name="main-dns-server",
    domain_name=["example.com", "internal.example.com"],
    primary="192.168.1.10",
    secondary="192.168.1.11"
)

# Convert to dictionary (default)
model_dict = dns_model.model_dump()
print(model_dict)

# Convert to dictionary, excluding unset fields
model_dict_exclude_unset = dns_model.model_dump(exclude_unset=True)
print(model_dict_exclude_unset)

# Convert to dictionary, using field aliases if defined
model_dict_by_alias = dns_model.model_dump(by_alias=True)
print(model_dict_by_alias)

# Convert to JSON string
model_json = dns_model.model_dump_json()
print(model_json)

# IP addresses are serialized as strings for JSON compatibility
print(f"Primary DNS type: {type(dns_model.primary)}")  # IPvAnyAddress
print(f"Serialized primary DNS: {model_dict['primary']}")  # String

Implementation Details¶

InternalDnsServersBaseModel¶

This is the base model that contains common fields and validation logic used by all other Internal DNS Servers models.

Validators¶

serialize_ip_address: Converts IPvAnyAddress objects to strings for JSON serialization
validate_domain_name: Ensures domain_name is a list (converts single string to list)
validate_domain_name_not_empty: Ensures domain_name is not empty

InternalDnsServersCreateModel¶

Model used for creating new Internal DNS Servers.

Validators¶

validate_create_model: Performs additional validation for creation operations

InternalDnsServersUpdateModel¶

Model used for updating existing Internal DNS Servers. All fields except id are optional to support partial updates.

Validators¶

validate_update_model: Validates update requirements:
At least one field other than id must be specified for update
Ensures domain_name is not empty if provided

InternalDnsServersResponseModel¶

Model used for representing API responses for Internal DNS Servers operations.

Validators¶

validate_response_model: Ensures response data consistency