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.
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 errorfrom scm.models.deployment import InternalDnsServersCreateModel
# Error: empty domain_nametry:
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 listdns_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"]
# Error: empty domain_nametry:
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 listdns_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 errorfrom scm.models.deployment import InternalDnsServersUpdateModel
# Error: no fields to updatetry:
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"
# Error: no fields to updatetry:
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
# Using dictionary with DNS servicefrom scm.config.deployment import InternalDnsServers
dns_dict = {
"name": "main-dns-server",
"domain_name": ["example.com", "internal.example.com"],
"primary": "192.168.1.10",
"secondary": "192.168.1.11"
}
dns_servers = InternalDnsServers(api_client)
response = dns_servers.create(dns_dict)
# Using model directlyfrom scm.models.deployment import InternalDnsServersCreateModel
dns_model = InternalDnsServersCreateModel(
name="main-dns-server",
domain_name=["example.com", "internal.example.com"],
primary="192.168.1.10",
secondary="192.168.1.11"
)
payload = dns_model.model_dump(exclude_unset=True, by_alias=True)
response = dns_servers.create(payload)
dns_dict = {
"name": "main-dns-server",
"domain_name": ["example.com", "internal.example.com"],
"primary": "192.168.1.10",
"secondary": "192.168.1.11"
}
dns_servers = InternalDnsServers(api_client)
response = dns_servers.create(dns_dict)
# Using model directlyfrom scm.models.deployment import InternalDnsServersCreateModel
dns_model = InternalDnsServersCreateModel(
name="main-dns-server",
domain_name=["example.com", "internal.example.com"],
primary="192.168.1.10",
secondary="192.168.1.11"
)
payload = dns_model.model_dump(exclude_unset=True, by_alias=True)
response = dns_servers.create(payload)
Updating an Internal DNS Server
# Using dictionary with DNS servicefrom uuid import UUID
from scm.config.deployment import InternalDnsServers
dns_id = "123e4567-e89b-12d3-a456-426655440000"
update_dict = {
"id": dns_id,
"domain_name": ["example.com", "updated.example.com"],
"secondary": "192.168.1.12"
}
dns_servers = InternalDnsServers(api_client)
response = dns_servers.update(update_dict)
# Using model directlyfrom scm.models.deployment import InternalDnsServersUpdateModel
update_model = InternalDnsServersUpdateModel(
id=UUID(dns_id),
domain_name=["example.com", "updated.example.com"],
secondary="192.168.1.12"
)
response = dns_servers.update(update_model)
from scm.config.deployment import InternalDnsServers
dns_id = "123e4567-e89b-12d3-a456-426655440000"
update_dict = {
"id": dns_id,
"domain_name": ["example.com", "updated.example.com"],
"secondary": "192.168.1.12"
}
dns_servers = InternalDnsServers(api_client)
response = dns_servers.update(update_dict)
# Using model directlyfrom scm.models.deployment import InternalDnsServersUpdateModel
update_model = InternalDnsServersUpdateModel(
id=UUID(dns_id),
domain_name=["example.com", "updated.example.com"],
secondary="192.168.1.12"
)
response = dns_servers.update(update_model)
Working with Response Model
from scm.client import ScmClient
# Initialize clientclient = ScmClient(
client_id="your_client_id",
client_secret="your_client_secret",
tsg_id="your_tsg_id"
)
# Get an existing DNS serverdns_server = client.internal_dns_servers.fetch(name="main-dns-server")
# Access response model attributesprint(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}")
# Use the response model to create an update modelfrom scm.models.deployment import InternalDnsServersUpdateModel
update_model = InternalDnsServersUpdateModel(
id=dns_server.id,
domain_name=dns_server.domain_name + ["new-domain.example.com"]
)
# Update the DNS serverupdated = client.internal_dns_servers.update(update_model)
# Initialize clientclient = ScmClient(
client_id="your_client_id",
client_secret="your_client_secret",
tsg_id="your_tsg_id"
)
# Get an existing DNS serverdns_server = client.internal_dns_servers.fetch(name="main-dns-server")
# Access response model attributesprint(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}")
# Use the response model to create an update modelfrom scm.models.deployment import InternalDnsServersUpdateModel
update_model = InternalDnsServersUpdateModel(
id=dns_server.id,
domain_name=dns_server.domain_name + ["new-domain.example.com"]
)
# Update the DNS serverupdated = client.internal_dns_servers.update(update_model)
Model Serialization
from scm.models.deployment import InternalDnsServersCreateModel
# Create a model instancedns_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 fieldsmodel_dict_exclude_unset = dns_model.model_dump(exclude_unset=True)
print(model_dict_exclude_unset)
# Convert to dictionary, using field aliases if definedmodel_dict_by_alias = dns_model.model_dump(by_alias=True)
print(model_dict_by_alias)
# Convert to JSON stringmodel_json = dns_model.model_dump_json()
print(model_json)
# IP addresses are serialized as strings for JSON compatibilityprint(f"Primary DNS type: {type(dns_model.primary)}") # IPvAnyAddress
print(f"Serialized primary DNS: {model_dict['primary']}") # String
# Create a model instancedns_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 fieldsmodel_dict_exclude_unset = dns_model.model_dump(exclude_unset=True)
print(model_dict_exclude_unset)
# Convert to dictionary, using field aliases if definedmodel_dict_by_alias = dns_model.model_dump(by_alias=True)
print(model_dict_by_alias)
# Convert to JSON stringmodel_json = dns_model.model_dump_json()
print(model_json)
# IP addresses are serialized as strings for JSON compatibilityprint(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 serializationvalidate_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