netbox-plugin-dns 0.21.4__py3-none-any.whl → 1.4.7__py3-none-any.whl

netbox_dns/choices/zone.py

@@ -0,0 +1,119 @@
+from django.utils.translation import gettext_lazy as _
+
+from utilities.choices import ChoiceSet
+
+
+__all__ = (
+    "ZoneStatusChoices",
+    "ZoneEPPStatusChoices",
+)
+
+
+class ZoneStatusChoices(ChoiceSet):
+    key = "Zone.status"
+
+    STATUS_ACTIVE = "active"
+    STATUS_RESERVED = "reserved"
+    STATUS_DEPRECATED = "deprecated"
+    STATUS_PARKED = "parked"
+    STATUS_DYNAMIC = "dynamic"
+
+    CHOICES = [
+        (STATUS_ACTIVE, _("Active"), "blue"),
+        (STATUS_RESERVED, _("Reserved"), "cyan"),
+        (STATUS_DEPRECATED, _("Deprecated"), "red"),
+        (STATUS_PARKED, _("Parked"), "gray"),
+        (STATUS_DYNAMIC, _("Dynamic"), "orange"),
+    ]
+
+
+class ZoneEPPStatusChoices(ChoiceSet):
+    """
+    Reflects the EPP status of a zone registered as a domain. See
+    https://www.icann.org/resources/pages/epp-status-codes-2014-06-16-en
+    for details.
+    """
+
+    key = "Zone.epp_status"
+
+    EPP_STATUS_ADD_PERIOD = "addPeriod"
+    EPP_STATUS_AUTO_RENEW_PERIOD = "autoRenewPeriod"
+    EPP_STATUS_INACTIVE = "inactive"
+    EPP_STATUS_OK = "ok"
+    EPP_STATUS_PENDING_CREATE = "pendingCreate"
+    EPP_STATUS_PENDING_DELETE = "pendingDelete"
+    EPP_STATUS_PENDING_RENEW = "pendingRenew"
+    EPP_STATUS_PENDING_RESTORE = "pendingRestore"
+    EPP_STATUS_PENDING_TRANSFER = "pendingTransfer"
+    EPP_STATUS_PENDING_UPDATE = "pendingUpdate"
+    EPP_STATUS_REDEMPTION_PERIOD = "redemptionPeriod"
+    EPP_STATUS_RENEW_PERIOD = "renewPeriod"
+    EPP_STATUS_SERVER_DELETE_PROHIBITED = "serverDeleteProhibited"
+    EPP_STATUS_SERVER_HOLD = "serverHold"
+    EPP_STATUS_SERVER_RENER_PROHIBITED = "serverRenewProhibited"
+    EPP_STATUS_SERVER_TRANSFER_PROHIBITED = "serverTransferProhibited"
+    EPP_STATUS_SERVER_UPDATE_PROHIBITED = "serverUpdateProhibited"
+    EPP_STATUS_TRANSFER_PERIOD = "transferPeriod"
+    EPP_STATUS_CLIENT_DELETE_PROHIBITED = "clientDeleteProhibited"
+    EPP_STATUS_CLIENT_HOLD = "clientHold"
+    EPP_STATUS_CLIENT_RENEW_PROHIBITED = "clientRenewProhibited"
+    EPP_STATUS_CLIENT_TRANSFER_PROHIBITED = "clientTransferProhibited"
+    EPP_STATUS_CLIENT_UPDATE_PROHIBITED = "clientUpdateProhibited"
+
+    CHOICES = [
+        (EPP_STATUS_ADD_PERIOD, EPP_STATUS_ADD_PERIOD, "blue"),
+        (EPP_STATUS_AUTO_RENEW_PERIOD, EPP_STATUS_AUTO_RENEW_PERIOD, "blue"),
+        (EPP_STATUS_INACTIVE, EPP_STATUS_INACTIVE, "blue"),
+        (EPP_STATUS_OK, EPP_STATUS_OK, "blue"),
+        (EPP_STATUS_PENDING_CREATE, EPP_STATUS_PENDING_CREATE, "blue"),
+        (EPP_STATUS_PENDING_DELETE, EPP_STATUS_PENDING_DELETE, "blue"),
+        (EPP_STATUS_PENDING_RENEW, EPP_STATUS_PENDING_RENEW, "blue"),
+        (EPP_STATUS_PENDING_RESTORE, EPP_STATUS_PENDING_RESTORE, "blue"),
+        (EPP_STATUS_PENDING_TRANSFER, EPP_STATUS_PENDING_TRANSFER, "blue"),
+        (EPP_STATUS_PENDING_UPDATE, EPP_STATUS_PENDING_UPDATE, "blue"),
+        (EPP_STATUS_REDEMPTION_PERIOD, EPP_STATUS_REDEMPTION_PERIOD, "blue"),
+        (EPP_STATUS_RENEW_PERIOD, EPP_STATUS_RENEW_PERIOD, "blue"),
+        (
+            EPP_STATUS_SERVER_DELETE_PROHIBITED,
+            EPP_STATUS_SERVER_DELETE_PROHIBITED,
+            "blue",
+        ),
+        (EPP_STATUS_SERVER_HOLD, EPP_STATUS_SERVER_HOLD, "blue"),
+        (
+            EPP_STATUS_SERVER_RENER_PROHIBITED,
+            EPP_STATUS_SERVER_RENER_PROHIBITED,
+            "blue",
+        ),
+        (
+            EPP_STATUS_SERVER_TRANSFER_PROHIBITED,
+            EPP_STATUS_SERVER_TRANSFER_PROHIBITED,
+            "blue",
+        ),
+        (
+            EPP_STATUS_SERVER_UPDATE_PROHIBITED,
+            EPP_STATUS_SERVER_UPDATE_PROHIBITED,
+            "blue",
+        ),
+        (EPP_STATUS_TRANSFER_PERIOD, EPP_STATUS_TRANSFER_PERIOD, "blue"),
+        (
+            EPP_STATUS_CLIENT_DELETE_PROHIBITED,
+            EPP_STATUS_CLIENT_DELETE_PROHIBITED,
+            "cyan",
+        ),
+        (EPP_STATUS_CLIENT_HOLD, EPP_STATUS_CLIENT_HOLD, "cyan"),
+        (
+            EPP_STATUS_CLIENT_RENEW_PROHIBITED,
+            EPP_STATUS_CLIENT_RENEW_PROHIBITED,
+            "cyan",
+        ),
+        (
+            EPP_STATUS_CLIENT_TRANSFER_PROHIBITED,
+            EPP_STATUS_CLIENT_TRANSFER_PROHIBITED,
+            "cyan",
+        ),
+        (
+            EPP_STATUS_CLIENT_UPDATE_PROHIBITED,
+            EPP_STATUS_CLIENT_UPDATE_PROHIBITED,
+            "cyan",
+        ),
+    ]

netbox_dns/fields/__init__.py

@@ -1,2 +1,6 @@
 from .network import *
 from .address import *
+from .rfc2317 import *
+from .ipam import *
+from .choice_array import *
+from .timeperiod import *

netbox_dns/fields/address.py

@@ -1,28 +1,18 @@
-from django import forms
 from django.db import models
+from django.db.models import Lookup
 from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
 
 from netaddr import AddrFormatError, IPAddress
 
+from ipam.formfields import IPAddressFormField
 
-class AddressFormField(forms.Field):
-    def to_python(self, value):
-        if not value:
-            return None
-
-        if isinstance(value, IPAddress):
-            return value
-
-        try:
-            ip_address = IPAddress(value)
-        except AddrFormatError as exc:
-            raise ValidationError(exc)
 
-        return ip_address
+__all__ = ("AddressField",)
 
 
 class AddressField(models.Field):
-    description = "IPv4/v6 address"
+    description = _("IPv4/v6 address")
 
     def python_type(self):
         return IPAddress
@@ -51,7 +41,7 @@ class AddressField(models.Field):
         return str(self.to_python(value))
 
     def form_class(self):
-        return AddressFormField
+        return IPAddressFormField
 
     def formfield(self, **kwargs):
         defaults = {"form_class": self.form_class()}
@@ -61,3 +51,19 @@ class AddressField(models.Field):
 
     def db_type(self, connection):
         return "inet"
+
+
+class AddressContained(Lookup):
+    lookup_name = "contained"
+
+    def get_prep_lookup(self):
+        return str(self.rhs)
+
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        params = lhs_params + rhs_params
+        return f"CAST(HOST({lhs}) AS INET) <<= {rhs}", params
+
+
+AddressField.register_lookup(AddressContained)

netbox_dns/fields/choice_array.py

@@ -0,0 +1,33 @@
+from django import forms
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Transform, IntegerField
+
+
+class ArrayLength(Transform):
+    lookup_name = "length"
+    function = "cardinality"
+
+    @property
+    def output_field(self):
+        return IntegerField()
+
+
+class _TypedMultipleChoiceField(forms.TypedMultipleChoiceField):
+    def __init__(self, *args, **kwargs):
+        kwargs.pop("base_field", None)
+        kwargs.pop("max_length", None)
+
+        super().__init__(*args, **kwargs)
+
+
+class ChoiceArrayField(ArrayField):
+    def formfield(self, **kwargs):
+        return super().formfield(
+            form_class=_TypedMultipleChoiceField,
+            choices=self.base_field.choices,
+            coerce=self.base_field.to_python,
+            **kwargs,
+        )
+
+
+ChoiceArrayField.register_lookup(ArrayLength)

netbox_dns/fields/ipam.py

@@ -0,0 +1,15 @@
+from utilities.forms.fields import DynamicModelMultipleChoiceField
+from utilities.forms.widgets import APISelectMultiple
+
+
+__all__ = ("PrefixDynamicModelMultipleChoiceField",)
+
+
+class PrefixDynamicModelMultipleChoiceField(DynamicModelMultipleChoiceField):
+    widget = APISelectMultiple(api_url="/api/plugins/netbox-dns/prefixes")
+
+    def label_from_instance(self, obj):
+        if obj.vrf:
+            return f"{str(obj.prefix)} [{obj.vrf.name}]"
+
+        return str(obj.prefix)

netbox_dns/fields/network.py

@@ -1,49 +1,63 @@
 from django import forms
 from django.db import models
-from django.db.models import Lookup
+from django.db.models import Lookup, Transform, IntegerField
 from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
 
 from netaddr import AddrFormatError, IPNetwork
 
 
+__all__ = ("NetworkField",)
+
+
 class NetContains(Lookup):
     lookup_name = "net_contains"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s >> %s" % (lhs, rhs), params
+        return f"{lhs} >> {rhs}", params
 
 
 class NetContainsOrEquals(Lookup):
     lookup_name = "net_contains_or_equals"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s >>= %s" % (lhs, rhs), params
+        return f"{lhs} >>= {rhs}", params
 
 
 class NetContained(Lookup):
     lookup_name = "net_contained"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s << %s" % (lhs, rhs), params
+        return f"{lhs} << {rhs}", params
 
 
 class NetContainedOrEqual(Lookup):
     lookup_name = "net_contained_or_equal"
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         params = lhs_params + rhs_params
-        return "%s <<= %s" % (lhs, rhs), params
+        return f"{lhs} <<= {rhs}", params
+
+
+class NetOverlap(Lookup):
+    lookup_name = "net_overlap"
+
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        params = lhs_params + rhs_params
+        return f"{lhs} && {rhs}", params
 
 
 class NetworkFormField(forms.Field):
@@ -63,7 +77,7 @@ class NetworkFormField(forms.Field):
 
 
 class NetworkField(models.Field):
-    description = "IPv4/v6 network associated with a reverse lookup zone"
+    description = _("IPv4/v6 network associated with a reverse lookup zone")
 
     def python_type(self):
         return IPNetwork
@@ -104,7 +118,17 @@ class NetworkField(models.Field):
         return "cidr"
 
 
+class NetMaskLength(Transform):
+    function = "MASKLEN"
+    lookup_name = "net_mask_length"
+
+    def output_field(self):
+        return IntegerField()
+
+
 NetworkField.register_lookup(NetContains)
 NetworkField.register_lookup(NetContained)
 NetworkField.register_lookup(NetContainsOrEquals)
 NetworkField.register_lookup(NetContainedOrEqual)
+NetworkField.register_lookup(NetOverlap)
+NetworkField.register_lookup(NetMaskLength)

netbox_dns/fields/rfc2317.py

@@ -0,0 +1,97 @@
+from netaddr import IPNetwork, AddrFormatError
+
+from django import forms
+from django.db import models
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+from netbox_dns.validators import validate_ipv4, validate_prefix, validate_rfc2317
+from .network import NetContains, NetContained, NetOverlap, NetMaskLength
+
+INVALID_RFC2317 = _(
+    "RFC2317 requires an IPv4 prefix with a length of at least 25 bits."
+)
+
+
+__all__ = (
+    "RFC2317NetworkField",
+    "RFC2317NetworkFormField",
+)
+
+
+class RFC2317NetworkFormField(forms.Field):
+    def to_python(self, value):
+        if not value:
+            return None
+
+        if isinstance(value, IPNetwork):
+            if value.version == 4 and value.prefixlen > 24:
+                return value
+
+            raise ValidationError(INVALID_RFC2317)
+
+        if len(value.split("/")) != 2:
+            raise ValidationError(_("Please specify the prefix length"))
+
+        try:
+            ip_network = IPNetwork(value)
+        except AddrFormatError as exc:
+            raise ValidationError(exc)
+
+        if ip_network.version != 4 or ip_network.prefixlen <= 24:
+            raise ValidationError(INVALID_RFC2317)
+
+        return ip_network
+
+
+class RFC2317NetworkField(models.Field):
+    description = _("PostgreSQL CIDR field for an RFC2317 prefix")
+
+    default_validators = [validate_ipv4, validate_prefix, validate_rfc2317]
+
+    def python_type(self):
+        return IPNetwork
+
+    def from_db_value(self, value, expression, connection):
+        return self.to_python(value)
+
+    def to_python(self, value):
+        if not value:
+            return value
+
+        try:
+            ip_network = IPNetwork(value)
+        except (AddrFormatError, TypeError, ValueError) as exc:
+            raise ValidationError(exc)
+
+        if ip_network.version != 4:
+            raise ValidationError(INVALID_RFC2317)
+
+        return ip_network
+
+    def get_prep_value(self, value):
+        if not value:
+            return None
+
+        if isinstance(value, list):
+            return [str(self.to_python(v)) for v in value]
+
+        return str(self.to_python(value))
+
+    def form_class(self):
+        return RFC2317NetworkFormField
+
+    def formfield(self, **kwargs):
+        defaults = {"form_class": self.form_class()}
+        defaults.update(kwargs)
+
+        return super().formfield(**defaults)
+
+    def db_type(self, connection):
+        return "cidr"
+
+
+RFC2317NetworkField.register_lookup(NetContains)
+RFC2317NetworkField.register_lookup(NetContained)
+RFC2317NetworkField.register_lookup(NetOverlap)
+RFC2317NetworkField.register_lookup(NetMaskLength)

netbox_dns/fields/timeperiod.py

@@ -0,0 +1,33 @@
+from django.forms import Field, TextInput
+from django.core.exceptions import ValidationError
+
+from netbox_dns.utilities import iso8601_to_int
+
+__all__ = ("TimePeriodField",)
+
+
+class TimePeriodField(Field):
+    def __init__(self, *args, **kwargs):
+        placeholder = kwargs.pop("placeholder", None)
+
+        if placeholder is not None:
+            self.widget = TextInput(attrs={"placeholder": placeholder})
+
+        return super().__init__(*args, **kwargs)
+
+    def to_python(self, value):
+        if not value:
+            return None
+
+        try:
+            return iso8601_to_int(value)
+        except TypeError:
+            raise ValidationError(
+                "Enter a valid integer or ISO 8601 duration (W, M and Y are not supported)"
+            )
+
+    def validate(self, value):
+        super().validate(value)
+
+        if value is not None and value < 0:
+            raise ValidationError("A time period cannot be negative.")

netbox_dns/filters.py

@@ -0,0 +1,7 @@
+from django_filters import NumberFilter
+
+from netbox_dns.fields import TimePeriodField
+
+
+class TimePeriodFilter(NumberFilter):
+    field_class = TimePeriodField

netbox_dns/filtersets/__init__.py

@@ -0,0 +1,12 @@
+from .view import *
+from .zone import *
+from .nameserver import *
+from .record import *
+from .registration_contact import *
+from .registrar import *
+
+from .zone_template import *
+from .record_template import *
+
+from .dnssec_key_template import *
+from .dnssec_policy import *

netbox_dns/filtersets/dnssec_key_template.py

@@ -0,0 +1,57 @@
+import django_filters
+from django.db.models import Q
+from django.utils.translation import gettext as _
+
+from netbox.filtersets import NetBoxModelFilterSet
+from tenancy.filtersets import TenancyFilterSet
+
+from netbox_dns.models import DNSSECKeyTemplate, DNSSECPolicy
+from netbox_dns.choices import (
+    DNSSECKeyTemplateTypeChoices,
+    DNSSECKeyTemplateAlgorithmChoices,
+    DNSSECKeyTemplateKeySizeChoices,
+)
+from netbox_dns.filters import TimePeriodFilter
+
+
+__all__ = ("DNSSECKeyTemplateFilterSet",)
+
+
+class DNSSECKeyTemplateFilterSet(TenancyFilterSet, NetBoxModelFilterSet):
+    class Meta:
+        model = DNSSECKeyTemplate
+
+        fields = (
+            "id",
+            "name",
+            "description",
+        )
+
+    type = django_filters.MultipleChoiceFilter(
+        choices=DNSSECKeyTemplateTypeChoices,
+    )
+    algorithm = django_filters.MultipleChoiceFilter(
+        choices=DNSSECKeyTemplateAlgorithmChoices,
+    )
+    key_size = django_filters.MultipleChoiceFilter(
+        choices=DNSSECKeyTemplateKeySizeChoices,
+    )
+    lifetime = TimePeriodFilter()
+    policy_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="policies",
+        queryset=DNSSECPolicy.objects.all(),
+        to_field_name="id",
+        label=_("DNSSEC Policy IDs"),
+    )
+    policy = django_filters.ModelMultipleChoiceFilter(
+        field_name="policies__name",
+        queryset=DNSSECPolicy.objects.all(),
+        to_field_name="name",
+        label=_("DNSSEC Policies"),
+    )
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        qs_filter = Q(Q(name__icontains=value) | Q(description__icontains=value))
+        return queryset.filter(qs_filter)

netbox_dns/filtersets/dnssec_policy.py

@@ -0,0 +1,101 @@
+import django_filters
+
+from django.db.models import Q
+from django.utils.translation import gettext as _
+
+from netbox.filtersets import NetBoxModelFilterSet
+from tenancy.filtersets import TenancyFilterSet
+from utilities.filters import MultiValueCharFilter
+
+from netbox_dns.models import DNSSECPolicy, DNSSECKeyTemplate, Zone, ZoneTemplate
+from netbox_dns.choices import DNSSECPolicyStatusChoices
+from netbox_dns.filters import TimePeriodFilter
+
+
+__all__ = ("DNSSECPolicyFilterSet",)
+
+
+class DNSSECPolicyFilterSet(TenancyFilterSet, NetBoxModelFilterSet):
+    class Meta:
+        model = DNSSECPolicy
+
+        fields = (
+            "id",
+            "name",
+            "description",
+            "status",
+            "inline_signing",
+            "create_cdnskey",
+            "use_nsec3",
+            "nsec3_iterations",
+            "nsec3_opt_out",
+            "nsec3_salt_size",
+        )
+
+    status = django_filters.MultipleChoiceFilter(
+        choices=DNSSECPolicyStatusChoices,
+    )
+    cds_digest_types = MultiValueCharFilter(
+        method="filter_cds_digest_types",
+        label=_("CDS Digest Types"),
+    )
+    key_template = django_filters.ModelMultipleChoiceFilter(
+        field_name="key_templates__name",
+        queryset=DNSSECKeyTemplate.objects.all(),
+        to_field_name="name",
+        label=_("DNSSEC Key Templates"),
+    )
+    key_template_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="key_templates",
+        queryset=DNSSECKeyTemplate.objects.all(),
+        to_field_name="id",
+        label=_("DNSSEC Key Template IDs"),
+    )
+    dnskey_ttl = TimePeriodFilter()
+    purge_keys = TimePeriodFilter()
+    publish_safety = TimePeriodFilter()
+    retire_safety = TimePeriodFilter()
+    signatures_jitter = TimePeriodFilter()
+    signatures_refresh = TimePeriodFilter()
+    signatures_validity = TimePeriodFilter()
+    signatures_validity_dnskey = TimePeriodFilter()
+    max_zone_ttl = TimePeriodFilter()
+    zone_propagation_delay = TimePeriodFilter()
+    parent_ds_ttl = TimePeriodFilter()
+    parent_propagation_delay = TimePeriodFilter()
+    zone = django_filters.ModelMultipleChoiceFilter(
+        field_name="zones__name",
+        queryset=Zone.objects.all(),
+        to_field_name="name",
+        label=_("Zones"),
+    )
+    zone_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="zones",
+        queryset=Zone.objects.all(),
+        to_field_name="id",
+        label=_("Zone IDs"),
+    )
+    zone_template = django_filters.ModelMultipleChoiceFilter(
+        field_name="zone_templates__name",
+        queryset=ZoneTemplate.objects.all(),
+        to_field_name="name",
+        label=_("Zone Templates"),
+    )
+    zone_template_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="zone_templates",
+        queryset=ZoneTemplate.objects.all(),
+        to_field_name="id",
+        label=_("Zone Template IDs"),
+    )
+
+    def filter_cds_digest_types(self, queryset, name, value):
+        if not value:
+            return queryset
+
+        return queryset.filter(cds_digest_types__overlap=value)
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        qs_filter = Q(Q(name__icontains=value) | Q(description__icontains=value))
+        return queryset.filter(qs_filter)