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

netbox_dns/management/commands/cleanup_database.py

@@ -1,186 +1,205 @@
-import dns
-from dns import rdtypes, rdata, rdatatype, rdataclass
-
-from netaddr import IPAddress, IPNetwork, AddrFormatError
+from netaddr import IPAddress
 
 from django.core.management.base import BaseCommand
 
-from netbox_dns.models import (
-    Zone,
-    ZoneStatusChoices,
-    Record,
-    RecordTypeChoices,
-    RecordClassChoices,
-)
-
-
-def zone_rename_passive_status_to_parked(verbose=False):
-    passive_zones = Zone.objects.filter(status="passive")
-    if passive_zones:
-        if verbose:
-            print("Renaming 'passive' zone status to 'parked'")
-
-        for zone in passive_zones:
-            zone.status = ZoneStatusChoices.STATUS_PARKED
-            zone.save()
-
+from netbox_dns.models import Zone, Record
+from netbox_dns.choices import RecordTypeChoices
 
-def zone_cleanup_ns_records(verbose=False):
-    ns_name = "@"
 
-    for zone in Zone.objects.all():
-        nameservers = zone.nameservers.all()
-        nameserver_names = [f'{ns.name.rstrip(".")}.' for ns in nameservers]
-
-        delete_ns = zone.record_set.filter(
-            name=ns_name, type=RecordTypeChoices.NS
-        ).exclude(value__in=nameserver_names)
-        for record in delete_ns:
-            if verbose:
-                print(f"Deleting obsolete NS record {record}")
-            record.delete()
-
-        for ns in nameserver_names:
-            ns_records = zone.record_set.filter(
-                name=ns_name,
-                type=RecordTypeChoices.NS,
-                value=ns,
-            )
+class Command(BaseCommand):
+    help = "Clean up NetBox DNS database"
 
-            delete_ns = ns_records[1:]
+    def handle(self, *model_names, **options):
+        self._zone_cleanup_ns_records(**options)
+        self._zone_cleanup_soa_records(**options)
+        self._zone_update_arpa_network(**options)
+        self._record_cleanup_disable_ptr(**options)
+        self._record_update_ptr_records(**options)
+        self._record_update_ip_address(**options)
+        self._record_remove_orphaned_ptr_records(**options)
+        self._record_remove_orphaned_address_records(**options)
+
+        if options.get("verbosity"):
+            self.stdout.write("Database cleanup completed.")
+
+    def _zone_cleanup_ns_records(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Cleaning up the NS records for all zones")
+
+        ns_name = "@"
+
+        for zone in Zone.objects.all():
+            nameservers = zone.nameservers.all()
+            nameserver_names = [f'{ns.name.rstrip(".")}.' for ns in nameservers]
+
+            delete_ns = zone.records.filter(
+                name=ns_name, type=RecordTypeChoices.NS
+            ).exclude(value__in=nameserver_names)
             for record in delete_ns:
-                if verbose:
-                    print(f"Deleting duplicate NS record {record}")
+                if options.get("verbosity") > 1:
+                    self.stdout.write(
+                        f"Removing obsolete NS record '{record}' with value '{record.value}'"
+                    )
                 record.delete()
 
-            try:
-                ns_record = zone.record_set.get(
+            for ns in nameserver_names:
+                ns_records = zone.records.filter(
                     name=ns_name,
                     type=RecordTypeChoices.NS,
                     value=ns,
                 )
 
-                if ns_record.ttl is not None or not ns_record.managed:
-                    if verbose:
-                        print(f"Updating NS record '{ns_record}'")
-                    ns_record.ttl = None
-                    ns_record.managed = True
-                    ns_record.save()
-
-            except Record.DoesNotExist:
-                if verbose:
-                    print(f"Creating NS record for '{ns.rstrip('.')}' in zone '{zone}'")
-                Record.objects.create(
-                    name=ns_name,
-                    zone=zone,
-                    type=RecordTypeChoices.NS,
-                    value=ns,
-                    ttl=None,
-                    managed=True,
-                )
+                delete_ns = ns_records[1:]
+                for record in delete_ns:
+                    if options.get("verbosity") > 1:
+                        self.stdout.write(
+                            f"Removing duplicate NS record '{record}' with value '{record.value}'"
+                        )
+                    record.delete()
+
+                try:
+                    ns_record = zone.records.get(
+                        name=ns_name,
+                        type=RecordTypeChoices.NS,
+                        value=ns,
+                    )
+
+                    if ns_record.ttl is not None or not ns_record.managed:
+                        if options.get("verbosity") > 1:
+                            self.stdout.write(
+                                f"Updating NS record '{ns_record}' with value '{record.value}'"
+                            )
+                        ns_record.ttl = None
+                        ns_record.managed = True
+                        ns_record.save()
+
+                except Record.DoesNotExist:
+                    if options.get("verbosity") > 1:
+                        self.stdout.write(
+                            f"Creating NS record for '{ns.rstrip('.')}' in zone '{zone}'"
+                        )
+                    Record.objects.create(
+                        name=ns_name,
+                        zone=zone,
+                        type=RecordTypeChoices.NS,
+                        value=ns,
+                        ttl=None,
+                        managed=True,
+                    )
 
+    def _zone_cleanup_soa_records(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Cleaning up the SOA record for all zones")
 
-def zone_update_soa_records(verbose=False):
-    soa_name = "@"
+        soa_name = "@"
 
-    for zone in Zone.objects.all():
-        delete_soa = zone.record_set.filter(name=soa_name, type=RecordTypeChoices.SOA)[
-            1:
-        ]
-        for record in delete_soa:
-            if verbose:
-                print(f"Deleting duplicate SOA record {record}")
-            record.delete()
+        for zone in Zone.objects.all():
+            delete_soa = zone.records.filter(name=soa_name, type=RecordTypeChoices.SOA)[
+                1:
+            ]
+            for record in delete_soa:
+                if options.get("verbosity") > 1:
+                    self.stdout.write(
+                        f"Deleting duplicate SOA record '{record}' for zone '{zone}'"
+                    )
+                record.delete()
 
-        zone.update_soa_record()
+            zone.update_soa_record()
 
+    def _zone_update_arpa_network(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Updating the ARPA network for reverse zones")
 
-def zone_update_arpa_network(verbose=False):
-    for zone in Zone.objects.filter(name__endswith=".arpa"):
-        name = zone.name
+        for zone in Zone.objects.filter(name__endswith=".arpa"):
+            if zone.arpa_network != (arpa_network := zone.network_from_name):
+                if options.get("verbosity") > 1:
+                    self.stdout.write(
+                        f"Setting the ARPA network for zone '{zone}' to '{arpa_network}'"
+                    )
 
-        # TODO: Rewrite with utility function
-        if name.endswith(".in-addr.arpa"):
-            address = ".".join(reversed(name.replace(".in-addr.arpa", "").split(".")))
-            mask = len(address.split(".")) * 8
+                zone.arpa_network = arpa_network
+                zone.save()
 
-            try:
-                prefix = IPNetwork(f"{address}/{mask}")
-            except AddrFormatError:
-                prefix = None
+    def _record_cleanup_disable_ptr(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Updating 'Disable PTR' for non-address records")
 
-        elif name.endswith("ip6.arpa"):
-            address = "".join(reversed(name.replace(".ip6.arpa", "").split(".")))
-            mask = len(address)
-            address = address + "0" * (32 - mask)
+        records = Record.objects.filter(
+            disable_ptr=True,
+        ).exclude(type__in=(RecordTypeChoices.A, RecordTypeChoices.AAAA))
 
-            try:
-                prefix = IPNetwork(
-                    f"{':'.join([(address[i:i+4]) for i in range(0, 32, 4)])}/{mask*4}"
+        for record in records:
+            if options.get("verbosity") > 1:
+                self.stdout.write(
+                    f"Setting 'Disable PTR' to False for record '{record}'"
                 )
-            except AddrFormatError:
-                prefix = None
-        # TODO: End
-
-        if zone.arpa_network != prefix:
-            if verbose:
-                print(f"Updating ARPA prefix for zone '{zone}' to '{prefix}'")
-            zone.arpa_network = prefix
-            zone.save()
-
-
-def record_cleanup_disable_ptr(verbose=False):
-    Record.objects.filter(
-        disable_ptr=False,
-    ).exclude(
-        type__in=(RecordTypeChoices.A, RecordTypeChoices.AAAA)
-    ).update(disable_ptr=True)
-
-
-def record_update_ptr_records(verbose=False):
-    for record in Record.objects.filter(
-        type__in=(RecordTypeChoices.A, RecordTypeChoices.AAAA)
-    ):
-        record.update_ptr_record()
-
-
-def record_update_ip_address(verbose=False):
-    for record in Record.objects.filter(
-        type__in=(RecordTypeChoices.A, RecordTypeChoices.AAAA, RecordTypeChoices.PTR)
-    ):
-        if record.is_ptr_record:
-            if record.ip_address != record.address_from_name:
-                if verbose:
-                    print(
-                        f"Updating IP address of pointer record {record} to {record.address_from_name}"
-                    )
-                record.ip_address = record.address_from_name
-                record.save()
-        else:
-            if record.ip_address != IPAddress(record.value):
-                if verbose:
-                    print(
-                        f"Updating IP address of address record {record} to {IPAddress(record.value)}"
-                    )
-                record.ip_address = record.value
-                record.save()
 
+            record.disable_ptr = False
+            record.save(update_fields=["disable_ptr"])
 
-class Command(BaseCommand):
-    help = "Clean up NetBox DNS database"
+    def _record_update_ptr_records(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Updating the PTR record for all address records")
+
+        for record in Record.objects.filter(
+            type__in=(RecordTypeChoices.A, RecordTypeChoices.AAAA)
+        ):
+            record.save(update_fields=["ptr_record"])
 
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--verbose", action="store_true", help="Increase output verbosity"
+    def _record_update_ip_address(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Updating the IP address for all address and PTR records")
+
+        for record in Record.objects.filter(
+            type__in=(
+                RecordTypeChoices.A,
+                RecordTypeChoices.AAAA,
+                RecordTypeChoices.PTR,
+            )
+        ):
+            if record.is_ptr_record:
+                if record.ip_address != record.address_from_name:
+                    if options.get("verbosity") > 1:
+                        self.stdout.write(
+                            f"Setting the IP Address for pointer record '{record}' to '{record.address_from_name}'"
+                        )
+                    record.ip_address = record.address_from_name
+                    record.save()
+            else:
+                if record.ip_address != IPAddress(record.value):
+                    if options.get("verbosity") > 1:
+                        self.stdout.write(
+                            f"Updating the IP address for address record '{record}' to '{IPAddress(record.value)}'"
+                        )
+                    record.ip_address = record.value
+                    record.save()
+
+    def _record_remove_orphaned_ptr_records(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Removing orphaned managed PTR records")
+
+        orphaned_ptr_records = Record.objects.filter(
+            type=RecordTypeChoices.PTR,
+            managed=True,
+            address_records__isnull=True,
         )
 
-    def handle(self, *model_names, **options):
-        zone_rename_passive_status_to_parked(options["verbose"])
-        zone_cleanup_ns_records(options["verbose"])
-        zone_update_soa_records(options["verbose"])
-        zone_update_arpa_network(options["verbose"])
-        record_cleanup_disable_ptr(options["verbose"])
-        record_update_ptr_records(options["verbose"])
-        record_update_ip_address(options["verbose"])
-
-        self.stdout.write("Database cleanup completed.")
+        for record in orphaned_ptr_records:
+            if options.get("verbosity") > 1:
+                self.stdout.write(f"Removing orphaned PTR record '{record}'")
+            record.delete()
+
+    def _record_remove_orphaned_address_records(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Removing orphaned managed address records")
+
+        orphaned_address_records = Record.objects.filter(
+            type__in=(RecordTypeChoices.A, RecordTypeChoices.AAAA),
+            managed=True,
+            ipam_ip_address__isnull=True,
+        )
+
+        for record in orphaned_address_records:
+            if options.get("verbosity") > 1:
+                self.stdout.write(f"Removing orphaned address record '{record}'")
+            record.delete()

netbox_dns/management/commands/cleanup_rrset_ttl.py

@@ -0,0 +1,64 @@
+from django.core.management.base import BaseCommand
+from django.db.models import Max, Min
+
+from netbox_dns.models import Record
+from netbox_dns.choices import RecordTypeChoices
+
+
+class Command(BaseCommand):
+    help = "Clean up the TTLs for RRSets"
+
+    def add_arguments(self, parser):
+        min_max = parser.add_mutually_exclusive_group()
+        min_max.add_argument(
+            "--min",
+            action="store_true",
+            help="Use the minimum TTL of an RRSet for all Records",
+        )
+        min_max.add_argument(
+            "--max",
+            action="store_true",
+            help="Use the maximum TTL of an RRSet for all Records",
+        )
+
+    def handle(self, *model_names, **options):
+        self._cleanup_rrset_ttl(**options)
+
+    def _cleanup_rrset_ttl(self, **options):
+        if options.get("verbosity"):
+            self.stdout.write("Cleaning up diverging RRset TTL values")
+
+        ttl_records = (
+            Record.objects.filter(ttl__isnull=False)
+            .exclude(type=RecordTypeChoices.SOA)
+            .exclude(type=RecordTypeChoices.PTR, managed=True)
+        )
+        for record in ttl_records:
+            records = Record.objects.filter(
+                name=record.name,
+                zone=record.zone,
+                type=record.type,
+            ).exclude(type=RecordTypeChoices.PTR, managed=True)
+
+            if records.count() == 1:
+                if options.get("verbosity") > 2:
+                    self.stdout.write(
+                        f"Ignoring single record '{record.pk}' ('{record}')"
+                    )
+                continue
+
+            if options.get("max"):
+                ttl = records.aggregate(Max("ttl")).get("ttl__max")
+            else:
+                ttl = records.aggregate(Min("ttl")).get("ttl__min")
+
+            for record in records.exclude(ttl=ttl):
+                if options.get("verbosity") > 1:
+                    self.stdout.write(
+                        f"Setting TTL for record '{record.pk}' ('{record}') to {ttl}"
+                    )
+                record.ttl = ttl
+                record.save(update_fields=["ttl"], update_rrset_ttl=False)
+
+        if options.get("verbosity"):
+            self.stdout.write("RRSet TTL cleanup completed.")

netbox_dns/management/commands/rebuild_dnssync.py

@@ -0,0 +1,23 @@
+from django.core.management.base import BaseCommand
+
+from ipam.models import IPAddress
+
+from netbox_dns.utilities import update_dns_records, get_zones
+
+
+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}"
+                )
+            if options.get("verbosity") >= 3:
+                self.stdout.write(f"  Zones: {get_zones(ip_address)}")
+            if update_dns_records(ip_address) and options.get("verbosity") >= 1:
+                self.stdout.write(
+                    f"Updated DNS records for IP Address {ip_address}, VRF {ip_address.vrf}"
+                )

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/0001_squashed_netbox_dns_0_15.py

@@ -9,35 +9,8 @@ import netbox_dns.fields.network
 
 
 class Migration(migrations.Migration):
-    replaces = [
-        ("netbox_dns", "0001_initial"),
-        ("netbox_dns", "0015_add_record_status"),
-        ("netbox_dns", "0013_add_nameserver_zone_record_description"),
-        ("netbox_dns", "0011_add_view_model"),
-        ("netbox_dns", "0002_zone_default_ttl"),
-        ("netbox_dns", "0003_soa_managed_records"),
-        ("netbox_dns", "0004_create_ptr_for_a_aaaa_records"),
-        ("netbox_dns", "0006_zone_soa_serial_auto"),
-        ("netbox_dns", "0007_alter_zone_soa_serial_auto"),
-        ("netbox_dns", "0005_update_ns_records"),
-        ("netbox_dns", "0008_zone_status_names"),
-        ("netbox_dns", "0009_netbox32"),
-        ("netbox_dns", "0010_update_soa_records"),
-        ("netbox_dns", "0012_adjust_zone_and_record"),
-        ("netbox_dns", "0014_add_view_description"),
-        ("netbox_dns", "0016_cleanup_ptr_records"),
-        ("netbox_dns", "0017_alter_record_ttl"),
-        ("netbox_dns", "0018_zone_arpa_network"),
-        ("netbox_dns", "0019_update_ns_ttl"),
-    ]
-
-    initial = True
-
     dependencies = [
-        ("extras", "0072_created_datetimefield"),
-        ("extras", "0062_clear_secrets_changelog"),
         ("extras", "0073_journalentry_tags_custom_fields"),
-        ("extras", "0059_exporttemplate_as_attachment"),
     ]
 
     operations = [