netbox-plugin-dns 1.0.7__py3-none-any.whl → 1.1.0__py3-none-any.whl

netbox_dns/management/commands/rebuild_dnssync.py

@@ -0,0 +1,18 @@
+from django.core.management.base import BaseCommand
+
+from ipam.models import IPAddress
+
+from netbox_dns.utilities import update_dns_records
+
+
+class Command(BaseCommand):
+    help = "Rebuild DNSsync relationships between IP addresses and records"
+
+    def handle(self, *model_names, **options):
+        ip_addresses = IPAddress.objects.all()
+        for ip_address in ip_addresses:
+            if options.get("verbosity") >= 2:
+                self.stdout.write(
+                    f"Updating DNS records for IP Address {ip_address}, VRF {ip_address.vrf}"
+                )
+            update_dns_records(ip_address)

netbox_dns/management/commands/setup_dnssync.py

@@ -0,0 +1,140 @@
+from django.core.management.base import BaseCommand
+
+from core.models import ObjectType
+from extras.models import CustomField
+from extras.choices import CustomFieldTypeChoices
+from ipam.models import IPAddress
+
+
+class Command(BaseCommand):
+    help = "Setup IPAddress custom fields for IPAM DNSsync"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--remove", action="store_true", default=False, help="Remove custom fields"
+        )
+
+    def handle(self, *model_names, **options):
+        ipaddress_object_type = ObjectType.objects.get_for_model(IPAddress)
+
+        if options.get("remove"):
+            if options.get("verbosity"):
+                self.stdout.write("Trying to remove IPAM DNSsync custom fields")
+            for cf in (
+                "ipaddress_dns_disabled",
+                "ipaddress_dns_record_ttl",
+                "ipaddress_dns_record_disable_ptr",
+            ):
+                try:
+                    CustomField.objects.get(
+                        name=cf, object_types=ipaddress_object_type
+                    ).delete()
+                    if options.get("verbosity"):
+                        self.stdout.write(f"Removed custom field '{cf}'")
+                except CustomField.DoesNotExist:
+                    pass
+            return
+
+        # +
+        # Remove pre-existing IPAM Coupling custom fields
+        # -
+        if options.get("verbosity") >= 2:
+            self.stdout.write("Trying to remove obsolete IPAM Coupling custom fields")
+        for cf in (
+            "ipaddress_dns_record_name",
+            "ipaddress_dns_zone_id",
+        ):
+            try:
+                CustomField.objects.get(
+                    name=cf, object_types=ipaddress_object_type
+                ).delete()
+                if options.get("verbosity"):
+                    self.stdout.write(f"Removed custom field '{cf}'")
+            except CustomField.DoesNotExist:
+                pass
+
+        if options.get("verbosity") >= 2:
+            self.stdout.write("Creating IPAM DNSsync custom fields")
+
+        if not CustomField.objects.filter(
+            name="ipaddress_dns_disabled",
+            type=CustomFieldTypeChoices.TYPE_BOOLEAN,
+            object_types=ipaddress_object_type,
+        ).exists():
+            cf_dnssync_disabled = CustomField.objects.create(
+                name="ipaddress_dns_disabled",
+                label="Disable DNSsync",
+                description="Disable DNS address and pointer record generation for this address",
+                type=CustomFieldTypeChoices.TYPE_BOOLEAN,
+                required=False,
+                default=False,
+                group_name="DNSsync",
+                is_cloneable=True,
+                weight=100,
+            )
+            cf_dnssync_disabled.object_types.set([ipaddress_object_type])
+            if options.get("verbosity"):
+                self.stdout.write("Created custom field 'ipaddress_dns_disabled'")
+
+        try:
+            cf_ttl = CustomField.objects.get(
+                name="ipaddress_dns_record_ttl",
+                type=CustomFieldTypeChoices.TYPE_INTEGER,
+                object_types=ipaddress_object_type,
+            )
+            if cf_ttl.group_name != "DNSsync":
+                cf_ttl.group_name = "DNSsync"
+                cf_ttl.description = ("TTL for DNS records created for this address",)
+                cf_ttl.save()
+                if options.get("verbosity"):
+                    self.stdout.write("Updated custom field 'ipaddress_dns_record_ttl'")
+        except CustomField.DoesNotExist:
+            cf_ttl = CustomField.objects.create(
+                name="ipaddress_dns_record_ttl",
+                description="TTL for DNS records created for this address",
+                label="TTL",
+                type=CustomFieldTypeChoices.TYPE_INTEGER,
+                validation_minimum=0,
+                validation_maximum=2147483647,
+                required=False,
+                group_name="DNSsync",
+                is_cloneable=True,
+                weight=200,
+            )
+            cf_ttl.object_types.set([ipaddress_object_type])
+            if options.get("verbosity"):
+                self.stdout.write("Created custom field 'ipaddress_dns_record_ttl'")
+
+        try:
+            cf_disable_ptr = CustomField.objects.get(
+                name="ipaddress_dns_record_disable_ptr",
+                type=CustomFieldTypeChoices.TYPE_BOOLEAN,
+                object_types=ipaddress_object_type,
+            )
+            if cf_disable_ptr.group_name != "DNSsync":
+                cf_disable_ptr.group_name = "DNSsync"
+                cf_disable_ptr.description = (
+                    "Disable DNS PTR record generation for this address",
+                )
+                cf_disable_ptr.save()
+                if options.get("verbosity"):
+                    self.stdout.write(
+                        "Updated custom field 'ipaddress_dns_record_disable_ptr'"
+                    )
+        except CustomField.DoesNotExist:
+            cf_disable_ptr = CustomField.objects.create(
+                name="ipaddress_dns_record_disable_ptr",
+                description="Disable DNS PTR record generation for this address",
+                label="Disable PTR",
+                type=CustomFieldTypeChoices.TYPE_BOOLEAN,
+                required=False,
+                default=False,
+                group_name="DNSsync",
+                is_cloneable=True,
+                weight=300,
+            )
+            cf_disable_ptr.object_types.set([ipaddress_object_type])
+            if options.get("verbosity"):
+                self.stdout.write(
+                    "Created custom field 'ipaddress_dns_record_disable_ptr'"
+                )

netbox_dns/migrations/0008_view_prefixes.py

@@ -0,0 +1,18 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipam", "0067_ipaddress_index_host"),
+        ("netbox_dns", "0007_alter_ordering_options"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="view",
+            name="prefixes",
+            field=models.ManyToManyField(
+                blank=True, related_name="netbox_dns_views", to="ipam.prefix"
+            ),
+        ),
+    ]

netbox_dns/migrations/0009_rename_contact_registrationcontact.py

@@ -0,0 +1,27 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("netbox_dns", "0008_view_prefixes"),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name="Contact",
+            new_name="RegistrationContact",
+        ),
+        migrations.RunSQL(
+            "ALTER TABLE netbox_dns_contact_id_seq RENAME TO netbox_dns_registrationcontact_id_seq"
+        ),
+        migrations.RunSQL(
+            "ALTER INDEX netbox_dns_contact_pkey RENAME TO netbox_dns_registrationcontact_pkey"
+        ),
+        migrations.RunSQL(
+            "ALTER INDEX netbox_dns_contact_contact_id_50e9d89d_like RENAME TO netbox_dns_registrationcontact_contact_id_6ff98464_like"
+        ),
+        migrations.RunSQL(
+            "ALTER INDEX netbox_dns_contact_contact_id_key RENAME TO netbox_dns_contact_registrationcontact_id_key"
+        ),
+    ]

netbox_dns/models/__init__.py

@@ -2,7 +2,7 @@ from .zone import *
 from .nameserver import *
 from .record import *
 from .view import *
-from .contact import *
+from .registration_contact import *
 from .registrar import *
 from .zone_template import *
 from .record_template import *
@@ -11,5 +11,3 @@ from .record_template import *
 # Backwards compatibility fix, will be removed in version 1.1
 # -
 from netbox_dns.choices import *
-
-from netbox_dns.signals import ipam_coupling

netbox_dns/models/record.py

@@ -7,6 +7,7 @@ from django.core.exceptions import ValidationError
 from django.db import transaction, models
 from django.db.models import Q, ExpressionWrapper, BooleanField, Min
 from django.urls import reverse
+from django.conf import settings
 
 from netbox.models import NetBoxModel
 from netbox.models.features import ContactsMixin
@@ -36,6 +37,43 @@ def min_ttl(*ttl_list):
     return min((ttl for ttl in ttl_list if ttl is not None), default=None)
 
 
+def record_data_from_ip_address(ip_address, zone):
+    cf_data = ip_address.custom_field_data
+
+    if cf_data.get("ipaddress_dns_disabled"):
+        return None
+
+    data = {
+        "name": (
+            dns_name.from_text(ip_address.dns_name)
+            .relativize(dns_name.from_text(zone.name))
+            .to_text()
+        ),
+        "type": (
+            RecordTypeChoices.A
+            if ip_address.address.version == 4
+            else RecordTypeChoices.AAAA
+        ),
+        "value": str(ip_address.address.ip),
+        "status": (
+            RecordStatusChoices.STATUS_ACTIVE
+            if ip_address.status
+            in settings.PLUGINS_CONFIG["netbox_dns"].get(
+                "dnssync_ipaddress_active_status", []
+            )
+            else RecordStatusChoices.STATUS_INACTIVE
+        ),
+    }
+
+    if "ipaddress_dns_record_ttl" in cf_data:
+        data["ttl"] = cf_data.get("ipaddress_dns_record_ttl")
+
+    if (disable_ptr := cf_data.get("ipaddress_dns_record_disable_ptr")) is not None:
+        data["disable_ptr"] = disable_ptr
+
+    return data
+
+
 class RecordManager(models.Manager.from_queryset(RestrictedQuerySet)):
     """
     Custom manager for records providing the activity status annotation
@@ -434,29 +472,70 @@ class Record(ObjectModificationMixin, ContactsMixin, NetBoxModel):
                 self.rfc2317_cname_record.delete(save_zone_serial=save_zone_serial)
                 self.rfc2317_cname_record = None
 
-    def validate_name(self):
-        try:
-            _zone = dns_name.from_text(self.zone.name, origin=dns_name.root)
-            name = dns_name.from_text(self.name, origin=None)
-            fqdn = dns_name.from_text(self.name, origin=_zone)
+    def update_from_ip_address(self, ip_address, zone=None):
+        if zone is None:
+            zone = self.zone
 
-            _zone.to_unicode()
-            name.to_unicode()
+        data = record_data_from_ip_address(ip_address, zone)
 
-            self.name = name.relativize(_zone).to_text()
-            self.fqdn = fqdn.to_text()
+        if data is None:
+            self.delete()
+            return
 
-        except dns.exception.DNSException as exc:
+        if all((getattr(self, attr) == data[attr] for attr in data.keys())):
+            return
+
+        for attr, value in data.items():
+            setattr(self, attr, value)
+
+        return self
+
+    @classmethod
+    def create_from_ip_address(cls, ip_address, zone):
+        data = record_data_from_ip_address(ip_address, zone)
+
+        if data is None:
+            return
+
+        return Record(
+            zone=zone,
+            managed=True,
+            ipam_ip_address=ip_address,
+            **data,
+        )
+
+    def update_fqdn(self, zone=None):
+        if zone is None:
+            zone = self.zone
+
+        _zone = dns_name.from_text(zone.name, origin=dns_name.root)
+        name = dns_name.from_text(self.name, origin=None)
+        fqdn = dns_name.from_text(self.name, origin=_zone)
+
+        if not fqdn.is_subdomain(_zone):
             raise ValidationError(
                 {
-                    "name": str(exc),
+                    "name": f"{self.name} is not a name in {zone.name}",
                 }
             )
 
-        if not fqdn.is_subdomain(_zone):
+        _zone.to_unicode()
+        name.to_unicode()
+
+        self.name = name.relativize(_zone).to_text()
+        self.fqdn = fqdn.to_text()
+
+    def validate_name(self, new_zone=None):
+        if new_zone is None:
+            new_zone = self.zone
+
+        try:
+            self.update_fqdn(zone=new_zone)
+
+        except dns.exception.DNSException as exc:
             raise ValidationError(
                 {
-                    "name": f"{self.name} is not a name in {self.zone.name}",
+                    "name": str(exc),
                 }
             )
 
@@ -488,15 +567,18 @@ class Record(ObjectModificationMixin, ContactsMixin, NetBoxModel):
         except ValidationError as exc:
             raise ValidationError({"value": exc}) from None
 
-    def check_unique_record(self):
+    def check_unique_record(self, new_zone=None):
         if not get_plugin_config("netbox_dns", "enforce_unique_records", False):
             return
 
         if not self.is_active:
             return
 
+        if new_zone is None:
+            new_zone = self.zone
+
         records = Record.objects.filter(
-            zone=self.zone,
+            zone=new_zone,
             name=self.name,
             type=self.type,
             value=self.value,
@@ -506,13 +588,41 @@ class Record(ObjectModificationMixin, ContactsMixin, NetBoxModel):
         if self.pk is not None:
             records = records.exclude(pk=self.pk)
 
-        if len(records):
+        if records.exists():
+            if self.ipam_ip_address is not None:
+                if not records.filter(
+                    ipam_ip_address__isnull=True
+                ).exists() or get_plugin_config(
+                    "netbox_dns", "dnssync_conflict_deactivate", False
+                ):
+                    return
+
             raise ValidationError(
                 {
                     "value": f"There is already an active {self.type} record for name {self.name} in zone {self.zone} with value {self.value}."
                 }
             ) from None
 
+    def handle_conflicting_address_records(self):
+        if self.ipam_ip_address is None or not self.is_active:
+            return
+
+        if not get_plugin_config("netbox_dns", "dnssync_conflict_deactivate", False):
+            return
+
+        records = Record.objects.filter(
+            zone=self.zone,
+            name=self.name,
+            type=self.type,
+            value=self.value,
+            status__in=Record.ACTIVE_STATUS_LIST,
+            ipam_ip_address__isnull=True,
+        )
+
+        for record in records:
+            record.status = RecordStatusChoices.STATUS_INACTIVE
+            record.save(update_fields=["status"])
+
     def check_unique_rrset_ttl(self):
         if self.pk is not None:
             return
@@ -520,6 +630,11 @@ class Record(ObjectModificationMixin, ContactsMixin, NetBoxModel):
         if not get_plugin_config("netbox_dns", "enforce_unique_rrset_ttl", False):
             return
 
+        if self.ipam_ip_address is not None and get_plugin_config(
+            "netbox_dns", "dnssync_conflict_deactivate", False
+        ):
+            return
+
         if self.type == RecordTypeChoices.PTR and self.managed:
             return
 
@@ -534,10 +649,13 @@ class Record(ObjectModificationMixin, ContactsMixin, NetBoxModel):
             .exclude(status=RecordStatusChoices.STATUS_INACTIVE)
         )
 
+        if self.ipam_ip_address is not None:
+            records = records.exclude(ipam_ip_address__isnull=False)
+
         if not records.exists():
             return
 
-        conflicting_ttls = ", ".join(set(str(record.ttl) for record in records))
+        conflicting_ttls = ", ".join({str(record.ttl) for record in records})
         raise ValidationError(
             {
                 "ttl": f"There is at least one active {self.type} record for name {self.name} in zone {self.zone} and TTL is different ({conflicting_ttls})."
@@ -577,10 +695,10 @@ class Record(ObjectModificationMixin, ContactsMixin, NetBoxModel):
         self.type = self.type.upper()
         super().clean_fields(*args, **kwargs)
 
-    def clean(self, *args, **kwargs):
-        self.validate_name()
+    def clean(self, *args, new_zone=None, **kwargs):
+        self.validate_name(new_zone=new_zone)
         self.validate_value()
-        self.check_unique_record()
+        self.check_unique_record(new_zone=new_zone)
         if self.pk is None:
             self.check_unique_rrset_ttl()
 
@@ -686,6 +804,7 @@ class Record(ObjectModificationMixin, ContactsMixin, NetBoxModel):
             self.ip_address = None
 
         if self.is_address_record:
+            self.handle_conflicting_address_records()
             self.update_ptr_record(
                 update_rfc2317_cname=update_rfc2317_cname,
                 save_zone_serial=save_zone_serial,

netbox_dns/models/{contact.py → registration_contact.py}

@@ -8,12 +8,12 @@ from taggit.managers import TaggableManager
 
 
 __all__ = (
-    "Contact",
-    "ContactIndex",
+    "RegistrationContact",
+    "RegistrationContactIndex",
 )
 
 
-class Contact(NetBoxModel):
+class RegistrationContact(NetBoxModel):
     # +
     # Data fields according to https://www.icann.org/resources/pages/rdds-labeling-policy-2017-02-01-en
     # -
@@ -105,7 +105,7 @@ class Contact(NetBoxModel):
     )
 
     def get_absolute_url(self):
-        return reverse("plugins:netbox_dns:contact", kwargs={"pk": self.pk})
+        return reverse("plugins:netbox_dns:registrationcontact", kwargs={"pk": self.pk})
 
     def __str__(self):
         if self.name is not None:
@@ -114,8 +114,8 @@ class Contact(NetBoxModel):
         return self.contact_id
 
     class Meta:
-        verbose_name = "Contact"
-        verbose_name_plural = "Contacts"
+        verbose_name = "Registration Contact"
+        verbose_name_plural = "Registration Contacts"
 
         ordering = (
             "name",
@@ -133,8 +133,8 @@ class Contact(NetBoxModel):
 
 
 @register_search
-class ContactIndex(SearchIndex):
-    model = Contact
+class RegistrationContactIndex(SearchIndex):
+    model = RegistrationContact
     fields = (
         ("name", 100),
         ("contact_id", 100),

netbox_dns/models/view.py

@@ -29,6 +29,11 @@ class View(ObjectModificationMixin, ContactsMixin, NetBoxModel):
     default_view = models.BooleanField(
         default=False,
     )
+    prefixes = models.ManyToManyField(
+        to="ipam.Prefix",
+        related_name="netbox_dns_views",
+        blank=True,
+    )
     tenant = models.ForeignKey(
         to="tenancy.Tenant",
         on_delete=models.PROTECT,