API Modules

This page is rendered directly from the module’s Python source using Sphinx autodoc.

dxaws_dns.manager

Manager for dxaws-dns record sets.

class dxaws_dns.manager.ApplyOptions(*, emit_events: 'bool' = True)

Bases: object

emit_events: bool

class dxaws_dns.manager.DnsManager(*, provider: 'DnsRecordProvider | None' = None, o11y: 'O11y' = <factory>)

Bases: object

apply(plan: DnsRecordPlan, *, options: ApplyOptions | None = None)

ensure_records(*, records: Sequence[Any], zone_id: str | None = None) → None

Idempotently ensure a batch of records exists.

Records are preferred to be fully qualified. If zone_id is omitted, the manager resolves the authoritative hosted zone internally.

execute(desired: DnsRecordDesired, *, options: ExecuteOptions | None = None) → DnsManagerResult

get_current(desired: DnsRecordDesired) → DnsRecordCurrent

o11y: O11y

plan(desired: DnsRecordDesired, current: DnsRecordCurrent | None = None) → DnsRecordPlan

provider: DnsRecordProvider | None

resolve_zone_for_fqdn(fqdn: str) → str

Return the hosted zone id that authoritatively covers fqdn (longest-suffix match).

This is intended for composed modules (e.g. dxaws-acm) that are given a full record FQDN (like _abc.foo.example.com.) and need to know which hosted zone to write into.

The provider may implement a specialized resolver. If not, we fall back to listing zones (if the provider supports it) and selecting the longest suffix match.

class dxaws_dns.manager.ExecuteOptions(*, apply_options: 'ApplyOptions | None' = None, emit_events: 'bool' = True)

Bases: object

apply_options: ApplyOptions | None

emit_events: bool

dxaws_dns.models

dxaws-dns models for record-set management.

class dxaws_dns.models.DnsManagerResult(*, desired: 'DnsRecordDesired', current: 'DnsRecordCurrent', plan: 'DnsRecordPlan', outputs: 'DnsRecordOutputs | None', outcome: 'str')

Bases: object

current: DnsRecordCurrent

desired: DnsRecordDesired

outcome: str

outputs: DnsRecordOutputs | None

plan: DnsRecordPlan

class dxaws_dns.models.DnsRecordCurrent(*, exists: bool, ttl: int | None = None, values: list[str] = <factory>)

Bases: object

Observed state for a record set.

exists: bool

ttl: int | None

values: list[str]

class dxaws_dns.models.DnsRecordDesired(*, zone_id: str | None = None, record_name: str, record_type: str, ttl: int | None = None, values: list[str] = <factory>, state: Literal['present', 'absent']='present', zone_name: str | None = None)

Bases: object

Desired state for a single record set.

record_name: str

record_type: str

state: Literal['present', 'absent']

ttl: int | None

values: list[str]

zone_id: str | None

zone_name: str | None

class dxaws_dns.models.DnsRecordOutputs(*, record_fqdn: 'str', zone_id: 'str', change_id: 'str | None')

Bases: object

change_id: str | None

record_fqdn: str

zone_id: str

class dxaws_dns.models.DnsRecordPlan(*, desired: 'DnsRecordDesired', current: 'DnsRecordCurrent', action: 'PlanAction', record_fqdn: 'str', record_type: 'str', changes: 'dict[str, Any]'=<factory>)

Bases: object

action: Literal['noop', 'upsert', 'delete']

changes: dict[str, Any]

current: DnsRecordCurrent

desired: DnsRecordDesired

property is_noop: bool

record_fqdn: str

record_type: str

dxaws_dns.planner

dxaws_dns.planner.plan_records(*, provider: Route53Provider, desired: list[DnsRecordSpec]) → RecordPlan

Plan record convergence within existing hosted zones.

Supports both:

• Non-alias records: TTL + values

• Alias records: A/AAAA with AliasTarget (dns_name + hosted_zone_id)

dxaws_dns.planner.plan_zones(*, provider: Route53Provider, desired: list[DnsZoneSpec]) → ZonePlan

dxaws_dns.executor

class dxaws_dns.executor.RecordApplyResult(*, records: 'dict[tuple[str, str], RecordSetInfo]', upserted: 'list[tuple[str, str]]', noop: 'list[tuple[str, str]]')

Bases: object

noop: list[tuple[str, str]]

records: dict[tuple[str, str], RecordSetInfo]

upserted: list[tuple[str, str]]

class dxaws_dns.executor.ZoneApplyResult(*, zones: 'dict[str, ZoneInfo]', created: 'list[str]', noop: 'list[str]')

Bases: object

created: list[str]

noop: list[str]

zones: dict[str, ZoneInfo]

dxaws_dns.executor.apply_records(*, provider: Route53Provider, plan: RecordPlan) → RecordApplyResult

Apply a record convergence plan.

Supports:

• Non-alias records: UPSERT with TTL + values

• Alias records: UPSERT with AliasTarget (dns_name + hosted_zone_id)

The planner controls what steps exist; executor simply performs them.

dxaws_dns.executor.apply_zones(*, provider: Route53Provider, plan: ZonePlan) → ZoneApplyResult

dxaws_dns.types

class dxaws_dns.types.RecordPlan(*, desired: "list['DnsRecordSpec']", steps: 'list[RecordStep]', observed: "dict[tuple[str, str], 'RecordSetInfo']")

Bases: object

desired: list['DnsRecordSpec']

observed: dict[tuple[str, str], 'RecordSetInfo']

steps: list[RecordStep]

class dxaws_dns.types.RecordStep(*, action: 'StepAction', zone_name: 'str', fqdn: 'str', record_type: 'str', summary: 'str')

Bases: object

action: StepAction

fqdn: str

record_type: str

summary: str

zone_name: str

class dxaws_dns.types.StepAction(*values)

Bases: str, Enum

CREATE_PUBLIC_ZONE = 'create_public_zone'

NOOP = 'noop'

NOOP_RECORD = 'noop_record'

UPSERT_RECORD = 'upsert_record'

class dxaws_dns.types.ZonePlan(*, desired: "list['DnsZoneSpec']", steps: 'list[ZoneStep]', observed: "dict[str, 'ZoneInfo']")

Bases: object

desired: list['DnsZoneSpec']

observed: dict[str, 'ZoneInfo']

steps: list[ZoneStep]

class dxaws_dns.types.ZoneStep(*, action: 'StepAction', zone_name: 'str', summary: 'str')

Bases: object

action: StepAction

summary: str

zone_name: str

class dxaws_dns.types.ZoneVisibility(*values)

Bases: str, Enum

PRIVATE = 'private'

PUBLIC = 'public'

dxaws_dns.providers.base

Provider interfaces for dxaws-dns record management.

class dxaws_dns.providers.base.DnsRecordProvider(*args, **kwargs)

Bases: Protocol

delete_record(*, zone_id: str, record_fqdn: str, record_type: str, ttl: int, values: list[str]) → str | None

Delete a record set and return a provider change id, if available.

get_record_current(*, zone_id: str, record_fqdn: str, record_type: str) → DnsRecordCurrent

Return the current record state for a zone/name/type.

upsert_record(*, zone_id: str, record_fqdn: str, record_type: str, ttl: int, values: list[str]) → str | None

Upsert a record set and return a provider change id, if available.

dxaws_dns.providers.route53