nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/ipam/models.py

@@ -1,27 +1,25 @@
 import logging
+import operator
 
 import netaddr
-from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError, MultipleObjectsReturned
 from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
-from django.db.models import F, Q
-from django.urls import reverse
-from django.utils.functional import classproperty
+from django.db.models import Q
+from django.utils.functional import cached_property, classproperty
 
 from nautobot.core.models import BaseManager, BaseModel
 from nautobot.core.models.fields import AutoSlugField, JSONArrayField
 from nautobot.core.models.generics import OrganizationalModel, PrimaryModel
 from nautobot.core.models.utils import array_to_string
 from nautobot.core.utils.data import UtilizationData
-from nautobot.dcim.models import Device, Interface
-from nautobot.extras.models import RoleModelMixin, Status, StatusModel
+from nautobot.dcim.models import Interface
+from nautobot.extras.models import RoleField, Status, StatusField
 from nautobot.extras.utils import extras_features
 from nautobot.ipam import choices
-from nautobot.virtualization.models import VirtualMachine, VMInterface
+from nautobot.virtualization.models import VMInterface
 from .constants import (
-    IPADDRESS_ROLES_NONUNIQUE,
     SERVICE_PORT_MAX,
     SERVICE_PORT_MIN,
     VRF_RD_MAX_LENGTH,
@@ -46,6 +44,49 @@ __all__ = (
 logger = logging.getLogger(__name__)
 
 
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "dynamic_groups",
+    "export_templates",
+    "graphql",
+    "locations",
+    "webhooks",
+)
+class Namespace(PrimaryModel):
+    """Container for unique IPAM objects."""
+
+    name = models.CharField(max_length=255, unique=True, db_index=True)
+    description = models.CharField(max_length=200, blank=True)
+    location = models.ForeignKey(
+        to="dcim.Location",
+        on_delete=models.PROTECT,
+        related_name="namespaces",
+        blank=True,
+        null=True,
+    )
+
+    @property
+    def ip_addresses(self):
+        """Return all IPAddresses associated to this Namespace through their parent Prefix."""
+        return IPAddress.objects.filter(parent__namespace=self).distinct()
+
+    class Meta:
+        ordering = ("name",)
+
+    def __str__(self):
+        return self.name
+
+
+def get_default_namespace():
+    """Return the Global namespace for use in default value for foreign keys."""
+    obj, _ = Namespace.objects.get_or_create(
+        name="Global", defaults={"description": "Default Global namespace. Created by Nautobot."}
+    )
+
+    return obj.pk
+
+
 @extras_features(
     "custom_links",
     "custom_validators",
@@ -63,12 +104,34 @@ class VRF(PrimaryModel):
     name = models.CharField(max_length=100, db_index=True)
     rd = models.CharField(
         max_length=VRF_RD_MAX_LENGTH,
-        unique=True,
         blank=True,
         null=True,
         verbose_name="Route distinguisher",
         help_text="Unique route distinguisher (as defined in RFC 4364)",
     )
+    namespace = models.ForeignKey(
+        "ipam.Namespace",
+        on_delete=models.PROTECT,
+        related_name="vrfs",
+        default=get_default_namespace,
+    )
+    devices = models.ManyToManyField(
+        to="dcim.Device",
+        related_name="vrfs",
+        through="ipam.VRFDeviceAssignment",
+        through_fields=("vrf", "device"),
+    )
+    virtual_machines = models.ManyToManyField(
+        to="virtualization.VirtualMachine",
+        related_name="vrfs",
+        through="ipam.VRFDeviceAssignment",
+        through_fields=("vrf", "virtual_machine"),
+    )
+    prefixes = models.ManyToManyField(
+        to="ipam.Prefix",
+        related_name="vrfs",
+        through="ipam.VRFPrefixAssignment",
+    )
     tenant = models.ForeignKey(
         to="tenancy.Tenant",
         on_delete=models.PROTECT,
@@ -76,48 +139,186 @@ class VRF(PrimaryModel):
         blank=True,
         null=True,
     )
-    enforce_unique = models.BooleanField(
-        default=True,
-        verbose_name="Enforce unique space",
-        help_text="Prevent duplicate prefixes/IP addresses within this VRF",
-    )
     description = models.CharField(max_length=200, blank=True)
     import_targets = models.ManyToManyField(to="ipam.RouteTarget", related_name="importing_vrfs", blank=True)
     export_targets = models.ManyToManyField(to="ipam.RouteTarget", related_name="exporting_vrfs", blank=True)
 
-    csv_headers = ["name", "rd", "tenant", "enforce_unique", "description"]
     clone_fields = [
         "tenant",
-        "enforce_unique",
         "description",
     ]
 
     class Meta:
-        ordering = ("name", "rd")  # (name, rd) may be non-unique
+        ordering = ("namespace", "name", "rd")  # (name, rd) may be non-unique
+        unique_together = [
+            ["namespace", "name"],
+            ["namespace", "rd"],
+        ]
         verbose_name = "VRF"
         verbose_name_plural = "VRFs"
 
     def __str__(self):
         return self.display or super().__str__()
 
-    def get_absolute_url(self):
-        return reverse("ipam:vrf", args=[self.pk])
-
-    def to_csv(self):
-        return (
-            self.name,
-            self.rd,
-            self.tenant.name if self.tenant else None,
-            str(self.enforce_unique),
-            self.description,
-        )
-
     @property
     def display(self):
-        if self.rd:
-            return f"{self.name} ({self.rd})"
+        if self.namespace:
+            return f"{self.namespace}: ({self.name})"
         return self.name
 
+    def add_device(self, device, rd="", name=""):
+        """
+        Add a `device` to this VRF, optionally overloading `rd` and `name`.
+
+        If `rd` or `name` are not provided, the values from this VRF will be inherited.
+
+        Args:
+            device (Device): Device instance
+            rd (str): (Optional) RD of the VRF when associated with this Device
+            name (str): (Optional) Name of the VRF when associated with this Device
+
+        Returns:
+            VRFDeviceAssignment instance
+        """
+        instance = self.devices.through(vrf=self, device=device, rd=rd, name=name)
+        instance.validated_save()
+        return instance
+
+    def remove_device(self, device):
+        """
+        Remove a `device` from this VRF.
+
+        Args:
+            device (Device): Device instance
+
+        Returns:
+            tuple (int, dict): Number of objects deleted and a dict with number of deletions.
+        """
+        instance = self.devices.through.objects.get(vrf=self, device=device)
+        return instance.delete()
+
+    def add_virtual_machine(self, virtual_machine, rd="", name=""):
+        """
+        Add a `virtual_machine` to this VRF, optionally overloading `rd` and `name`.
+
+        If `rd` or `name` are not provided, the values from this VRF will be inherited.
+
+        Args:
+            virtual_machine (VirtualMachine): VirtualMachine instance
+            rd (str): (Optional) RD of the VRF when associated with this VirtualMachine
+            name (str): (Optional) Name of the VRF when associated with this VirtualMachine
+
+        Returns:
+            VRFDeviceAssignment instance
+        """
+        instance = self.virtual_machines.through(vrf=self, virtual_machine=virtual_machine, rd=rd, name=name)
+        instance.validated_save()
+        return instance
+
+    def remove_virtual_machine(self, virtual_machine):
+        """
+        Remove a `virtual_machine` from this VRF.
+
+        Args:
+            virtual_machine (VirtualMachine): VirtualMachine instance
+
+        Returns:
+            tuple (int, dict): Number of objects deleted and a dict with number of deletions.
+        """
+        instance = self.virtual_machines.through.objects.get(vrf=self, virtual_machine=virtual_machine)
+        return instance.delete()
+
+    def add_prefix(self, prefix):
+        """
+        Add a `prefix` to this VRF. Each object must be in the same Namespace.
+
+        Args:
+            prefix (Prefix): Prefix instance
+
+        Returns:
+            VRFPrefixAssignment instance
+        """
+        instance = self.prefixes.through(vrf=self, prefix=prefix)
+        instance.validated_save()
+        return instance
+
+    def remove_prefix(self, prefix):
+        """
+        Remove a `prefix` from this VRF.
+
+        Args:
+            prefix (Prefix): Prefix instance
+
+        Returns:
+            tuple (int, dict): Number of objects deleted and a dict with number of deletions.
+        """
+        instance = self.prefixes.through.objects.get(vrf=self, prefix=prefix)
+        return instance.delete()
+
+
+class VRFDeviceAssignment(BaseModel):
+    vrf = models.ForeignKey("ipam.VRF", on_delete=models.CASCADE, related_name="device_assignments")
+    device = models.ForeignKey(
+        "dcim.Device", null=True, blank=True, on_delete=models.CASCADE, related_name="vrf_assignments"
+    )
+    virtual_machine = models.ForeignKey(
+        "virtualization.VirtualMachine", null=True, blank=True, on_delete=models.CASCADE, related_name="vrf_assignments"
+    )
+    rd = models.CharField(
+        max_length=VRF_RD_MAX_LENGTH,
+        blank=True,
+        null=True,
+        verbose_name="Route distinguisher",
+        help_text="Unique route distinguisher (as defined in RFC 4364)",
+    )
+    name = models.CharField(blank=True, max_length=100)
+
+    class Meta:
+        unique_together = [
+            ["vrf", "device"],
+            ["vrf", "virtual_machine"],
+            ["device", "rd", "name"],
+            ["virtual_machine", "rd", "name"],
+        ]
+
+    def __str__(self):
+        obj = self.device or self.virtual_machine
+        return f"{self.vrf} [{obj}] (rd: {self.rd}, name: {self.name})"
+
+    def clean(self):
+        super().clean()
+
+        # If RD is not set, inherit it from `vrf.rd`.
+        if not self.rd:
+            self.rd = self.vrf.rd
+
+        # If name is not set, inherit it from `vrf.name`.
+        if not self.name:
+            self.name = self.vrf.name
+
+        # A VRF must belong to a Device *or* to a VirtualMachine.
+        if all([self.device, self.virtual_machine]):
+            raise ValidationError("A VRF cannot be associated with both a device and a virtual machine.")
+        if not any([self.device, self.virtual_machine]):
+            raise ValidationError("A VRF must be associated with either a device or a virtual machine.")
+
+
+class VRFPrefixAssignment(BaseModel):
+    vrf = models.ForeignKey("ipam.VRF", on_delete=models.CASCADE, related_name="+")
+    prefix = models.ForeignKey("ipam.Prefix", on_delete=models.CASCADE, related_name="vrf_assignments")
+
+    class Meta:
+        unique_together = ["vrf", "prefix"]
+
+    def __str__(self):
+        return f"{self.vrf}: {self.prefix}"
+
+    def clean(self):
+        super().clean()
+
+        if self.prefix.namespace != self.vrf.namespace:
+            raise ValidationError({"prefix": "Prefix must be in same namespace as VRF"})
+
 
 @extras_features(
     "custom_links",
@@ -145,24 +346,12 @@ class RouteTarget(PrimaryModel):
         null=True,
     )
 
-    csv_headers = ["name", "description", "tenant"]
-
     class Meta:
         ordering = ["name"]
 
     def __str__(self):
         return self.name
 
-    def get_absolute_url(self):
-        return reverse("ipam:routetarget", args=[self.pk])
-
-    def to_csv(self):
-        return (
-            self.name,
-            self.description,
-            self.tenant.name if self.tenant else None,
-        )
-
 
 @extras_features(
     "custom_validators",
@@ -175,7 +364,6 @@ class RIR(OrganizationalModel):
     """
 
     name = models.CharField(max_length=100, unique=True)
-    slug = AutoSlugField(populate_from="name")
     is_private = models.BooleanField(
         default=False,
         verbose_name="Private",
@@ -183,8 +371,6 @@ class RIR(OrganizationalModel):
     )
     description = models.CharField(max_length=200, blank=True)
 
-    csv_headers = ["name", "slug", "is_private", "description"]
-
     objects = BaseManager.from_queryset(RIRQuerySet)()
 
     class Meta:
@@ -195,20 +381,6 @@ class RIR(OrganizationalModel):
     def __str__(self):
         return self.name
 
-    def natural_key(self):
-        return (self.name,)
-
-    def get_absolute_url(self):
-        return reverse("ipam:rir", args=[self.slug])
-
-    def to_csv(self):
-        return (
-            self.name,
-            self.slug,
-            str(self.is_private),
-            self.description,
-        )
-
 
 @extras_features(
     "custom_links",
@@ -220,12 +392,13 @@ class RIR(OrganizationalModel):
     "statuses",
     "webhooks",
 )
-class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
+class Prefix(PrimaryModel):
     """
     A Prefix represents an IPv4 or IPv6 network, including mask length.
     Prefixes can optionally be assigned to Locations and VRFs.
     A Prefix must be assigned a status and may optionally be assigned a user-defined Role.
     A Prefix can also be assigned to a VLAN where appropriate.
+    Prefixes are always ordered by `namespace` and `ip_version`, then by `network` and `prefix_length`.
     """
 
     network = VarbinaryIPField(
@@ -240,6 +413,23 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
         choices=choices.PrefixTypeChoices,
         default=choices.PrefixTypeChoices.TYPE_NETWORK,
     )
+    status = StatusField(blank=False, null=False)
+    role = RoleField(blank=True, null=True)
+    parent = models.ForeignKey(
+        "self",
+        blank=True,
+        null=True,
+        related_name="children",  # `IPAddress` to use `related_name="ip_addresses"`
+        on_delete=models.PROTECT,
+        help_text="The parent Prefix of this Prefix.",
+    )
+    # ip_version is set internally just like network, broadcast, and prefix_length.
+    ip_version = models.IntegerField(
+        choices=choices.IPAddressVersionChoices,
+        null=True,
+        editable=False,
+        db_index=True,
+    )
     location = models.ForeignKey(
         to="dcim.Location",
         on_delete=models.PROTECT,
@@ -247,13 +437,11 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
         blank=True,
         null=True,
     )
-    vrf = models.ForeignKey(
-        to="ipam.VRF",
+    namespace = models.ForeignKey(
+        to="ipam.Namespace",
         on_delete=models.PROTECT,
         related_name="prefixes",
-        blank=True,
-        null=True,
-        verbose_name="VRF",
+        default=get_default_namespace,
     )
     tenant = models.ForeignKey(
         to="tenancy.Tenant",
@@ -288,66 +476,60 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
 
     objects = BaseManager.from_queryset(PrefixQuerySet)()
 
-    # TODO: The current Prefix model has no appropriate natural key available yet.
-    #       However, by default all BaseModel subclasses now have a `natural_key` property;
-    #       but for this model, accessing the natural_key will raise an exception.
-    #       The below is a hacky way to "remove" the natural_key property from this model class for the time being.
-    class AttributeRemover:
-        def __get__(self, instance, owner):
-            raise AttributeError("Prefix doesn't yet have a natural key!")
-
-    natural_key = AttributeRemover()
-
-    csv_headers = [
-        "prefix",
-        "type",
-        "vrf",
-        "tenant",
-        "location",
-        "vlan_group",
-        "vlan",
-        "status",
-        "role",
-        "rir",
-        "date_allocated",
-        "description",
-    ]
     clone_fields = [
         "date_allocated",
         "description",
         "location",
+        "namespace",
         "rir",
         "role",
         "status",
         "tenant",
         "type",
         "vlan",
-        "vrf",
     ]
+    """
     dynamic_group_filter_fields = {
         "vrf": "vrf_id",  # Duplicate filter fields that will be collapsed in 2.0
     }
+    """
 
     class Meta:
         ordering = (
-            F("vrf__name").asc(nulls_first=True),
+            "namespace",
+            "ip_version",
             "network",
             "prefix_length",
-        )  # (vrf, prefix) may be non-unique
+        )
+        index_together = [
+            ["network", "broadcast", "prefix_length"],
+            ["namespace", "network", "broadcast", "prefix_length"],
+        ]
+        unique_together = ["namespace", "network", "prefix_length"]
         verbose_name_plural = "prefixes"
 
+    def validate_unique(self, exclude=None):
+        if self.namespace is None:
+            if Prefix.objects.filter(
+                network=self.network, prefix_length=self.prefix_length, namespace__isnull=True
+            ).exists():
+                raise ValidationError(
+                    {"__all__": "Prefix with this Namespace, Network and Prefix length already exists."}
+                )
+        super().validate_unique(exclude)
+
     def __init__(self, *args, **kwargs):
         prefix = kwargs.pop("prefix", None)
-        super(Prefix, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self._deconstruct_prefix(prefix)
 
     def __str__(self):
         return str(self.prefix)
 
-    def _deconstruct_prefix(self, pre):
-        if pre:
-            if isinstance(pre, str):
-                pre = netaddr.IPNetwork(pre)
+    def _deconstruct_prefix(self, prefix):
+        if prefix:
+            if isinstance(prefix, str):
+                prefix = netaddr.IPNetwork(prefix)
             # Note that our "broadcast" field is actually the last IP address in this prefix.
             # This is different from the more accurate technical meaning of a network's broadcast address in 2 cases:
             # 1. For a point-to-point prefix (IPv4 /31 or IPv6 /127), there are two addresses in the prefix,
@@ -356,62 +538,74 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
             #    We store this address as both the network and the "broadcast".
             # This variance is intentional in both cases as we use the "broadcast" primarily for filtering and grouping
             # of addresses and prefixes, not for packet forwarding. :-)
-            broadcast = pre.broadcast if pre.broadcast else pre[-1]
-            self.network = str(pre.network)
+            broadcast = prefix.broadcast if prefix.broadcast else prefix[-1]
+            self.network = str(prefix.network)
             self.broadcast = str(broadcast)
-            self.prefix_length = pre.prefixlen
+            self.prefix_length = prefix.prefixlen
+            self.ip_version = prefix.version
 
-    def get_absolute_url(self):
-        return reverse("ipam:prefix", args=[self.pk])
+    # TODO: this function is completely unused at present - remove?
+    def get_duplicates(self):
+        return Prefix.objects.net_equals(self.prefix).filter(namespace=self.namespace).exclude(pk=self.pk)
 
     def clean(self):
         super().clean()
 
-        if self.prefix:
-
-            # /0 masks are not acceptable
-            if self.prefix.prefixlen == 0:
-                raise ValidationError({"prefix": "Cannot create prefix with /0 mask."})
-
-            # Enforce unique IP space (if applicable)
-            if (self.vrf is None and settings.ENFORCE_GLOBAL_UNIQUE) or (self.vrf and self.vrf.enforce_unique):
-                duplicate_prefixes = self.get_duplicates()
-                if duplicate_prefixes:
-                    vrf = f"VRF {self.vrf}" if self.vrf else "global table"
-                    raise ValidationError({"prefix": f"Duplicate prefix found in {vrf}: {duplicate_prefixes.first()}"})
-
         # Validate location
         if self.location is not None:
-
             if ContentType.objects.get_for_model(self) not in self.location.location_type.content_types.all():
                 raise ValidationError(
                     {"location": f'Prefixes may not associate to locations of type "{self.location.location_type}".'}
                 )
 
-    def save(self, *args, **kwargs):
+    def delete(self, *args, **kwargs):
+        """
+        A Prefix with children will be impossible to delete and raise a `ProtectedError`.
 
-        if isinstance(self.prefix, netaddr.IPNetwork):
+        If a Prefix has children, this catch the error and explicitly update the
+        `protected_objects` from the exception setting their parent to the old parent of this
+        prefix, and then this prefix will be deleted.
+        """
 
+        try:
+            return super().delete(*args, **kwargs)
+        except models.ProtectedError as err:
+            # This will be either IPAddress or Prefix.
+            protected_model = tuple(err.protected_objects)[0]._meta.model
+
+            # IPAddress objects must have a parent.
+            if protected_model == IPAddress and self.parent is None:
+                raise models.ProtectedError(
+                    msg=(
+                        f"Cannot delete Prefix {self} because it has child IPAddress objects that "
+                        "would no longer have a parent."
+                    ),
+                    protected_objects=err.protected_objects,
+                ) from err
+
+            # Update protected objects to use the new parent and delete the old parent (self).
+            protected_pks = (po.pk for po in err.protected_objects)
+            protected_objects = protected_model.objects.filter(pk__in=protected_pks)
+            protected_objects.update(parent=self.parent)
+            return super().delete(*args, **kwargs)
+
+    def save(self, *args, **kwargs):
+        if isinstance(self.prefix, netaddr.IPNetwork):
             # Clear host bits from prefix
             self.prefix = self.prefix.cidr
 
+        # Determine if a parent exists and set it to the closest ancestor by `prefix_length`.
+        supernets = self.supernets()
+        if supernets:
+            parent = max(supernets, key=operator.attrgetter("prefix_length"))
+            self.parent = parent
+
         super().save(*args, **kwargs)
 
-    def to_csv(self):
-        return (
-            self.prefix,
-            self.get_type_display(),
-            self.vrf.name if self.vrf else None,
-            self.tenant.name if self.tenant else None,
-            self.location.name if self.location else None,
-            self.vlan.vlan_group.name if self.vlan and self.vlan.vlan_group else None,
-            self.vlan.vid if self.vlan else None,
-            self.get_status_display(),
-            self.role.name if self.role else None,
-            self.rir.name if self.rir else None,
-            str(self.date_allocated),
-            self.description,
-        )
+        # Determine the subnets and reparent them to this prefix.
+        self.reparent_subnets()
+        # Determine the child IPs and reparent them to this prefix.
+        self.reparent_ips()
 
     @property
     def cidr_str(self):
@@ -429,41 +623,168 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
     def prefix(self, prefix):
         self._deconstruct_prefix(prefix)
 
-    @property
-    def family(self):
-        if self.prefix:
-            return self.prefix.version
-        return None
+    def reparent_subnets(self):
+        """
+        Determine the list of child Prefixes and set the parent to self.
 
-    def get_duplicates(self):
-        return Prefix.objects.net_equals(self.prefix).filter(vrf=self.vrf).exclude(pk=self.pk)
+        This query is similiar performing update from the query returned by `subnets(direct=True)`,
+        but explicitly filters for subnets of the parent of this Prefix so they can be reparented.
+        """
+        query = Prefix.objects.select_for_update().filter(
+            ~models.Q(id=self.id),  # Don't include yourself...
+            parent_id=self.parent_id,
+            prefix_length__gt=self.prefix_length,
+            ip_version=self.ip_version,
+            network__gte=self.network,
+            broadcast__lte=self.broadcast,
+            namespace=self.namespace,
+        )
+
+        return query.update(parent=self)
+
+    def reparent_ips(self):
+        """Determine the list of child IPAddresses and set the parent to self."""
+        query = IPAddress.objects.select_for_update().filter(
+            ip_version=self.ip_version,
+            parent_id=self.parent_id,
+            host__gte=self.network,
+            host__lte=self.broadcast,
+        )
+
+        return query.update(parent=self)
 
-    def get_child_prefixes(self):
+    def supernets(self, direct=False, include_self=False, for_update=False):
         """
-        Return all Prefixes within this Prefix and VRF. If this Prefix is a container in the global table, return child
-        Prefixes belonging to any VRF.
+        Return supernets of this Prefix.
+
+        Args:
+            direct (bool): Whether to only return the direct ancestor.
+            include_self (bool): Whether to include this Prefix in the list of supernets.
+            for_update (bool): Lock rows until the end of any subsequent transactions.
+
+        Returns:
+            QuerySet
         """
-        if self.vrf is None and self.type == choices.PrefixTypeChoices.TYPE_CONTAINER:
-            return Prefix.objects.net_contained(self.prefix)
-        else:
-            return Prefix.objects.net_contained(self.prefix).filter(vrf=self.vrf)
+        query = Prefix.objects.all()
+
+        if for_update:
+            query = query.select_for_update()
+
+        if direct:
+            return query.filter(id=self.parent_id)
+
+        if not include_self:
+            query = query.exclude(id=self.id)
+
+        return query.filter(
+            ip_version=self.ip_version,
+            prefix_length__lte=self.prefix_length,
+            network__lte=self.network,
+            broadcast__gte=self.broadcast,
+            namespace=self.namespace,
+        )
 
-    def get_child_ips(self):
+    def subnets(self, direct=False, include_self=False, for_update=False):
         """
-        Return all IPAddresses within this Prefix and VRF. If this Prefix is a container in the global table, return
-        child IPAddresses belonging to any VRF.
+        Return subnets of this Prefix.
+
+        Args:
+            direct (bool): Whether to only return direct descendants.
+            include_self (bool): Whether to include this Prefix in the list of subnets.
+            for_update (bool): Lock rows until the end of any subsequent transactions.
+
+        Returns:
+            QuerySet
         """
-        if self.vrf is None and self.type == choices.PrefixTypeChoices.TYPE_CONTAINER:
-            return IPAddress.objects.net_host_contained(self.prefix)
-        else:
-            return IPAddress.objects.net_host_contained(self.prefix).filter(vrf=self.vrf)
+        query = Prefix.objects.all()
+
+        if for_update:
+            query = query.select_for_update()
+
+        if direct:
+            return query.filter(parent_id=self.id)
+
+        if not include_self:
+            query = query.exclude(id=self.id)
+
+        return query.filter(
+            ip_version=self.ip_version,
+            prefix_length__gte=self.prefix_length,
+            network__gte=self.network,
+            broadcast__lte=self.broadcast,
+            namespace=self.namespace,
+        )
+
+    def is_child_node(self):
+        """
+        Returns whether I am a child node.
+        """
+        return self.parent is not None
+
+    def is_leaf_node(self):
+        """
+        Returns whether I am leaf node (no children).
+        """
+        return not self.children.exists()
+
+    def is_root_node(self):
+        """
+        Returns whether I am a root node (no parent).
+        """
+        return self.parent is None
+
+    def ancestors(self, ascending=False, include_self=False):
+        """
+        Return my ancestors descending from larger to smaller prefix lengths.
+
+        Args:
+            ascending (bool): If set, reverses the return order.
+            include_self (bool): Whether to include this Prefix in the list of subnets.
+        """
+        query = self.supernets(include_self=include_self)
+        if ascending:
+            query = query.reverse()
+        return query
+
+    def descendants(self, include_self=False):
+        """
+        Return all of my children!
+
+        Args:
+            include_self (bool): Whether to include this Prefix in the list of subnets.
+        """
+        return self.subnets(include_self=include_self)
+
+    @cached_property
+    def descendants_count(self):
+        """Display count of descendants."""
+        return self.descendants().count()
+
+    def root(self):
+        """
+        Returns the root node (the parent of all of my ancestors).
+        """
+        return self.ancestors().first()
+
+    def siblings(self, include_self=False):
+        """
+        Return my siblings. Root nodes are siblings to other root nodes.
+
+        Args:
+            include_self (bool): Whether to include this Prefix in the list of subnets.
+        """
+        query = Prefix.objects.filter(parent=self.parent)
+        if not include_self:
+            query = query.exclude(id=self.id)
+
+        return query
 
     def get_available_prefixes(self):
         """
         Return all available Prefixes within this prefix as an IPSet.
         """
         prefix = netaddr.IPSet(self.prefix)
-        child_prefixes = netaddr.IPSet([child.prefix for child in self.get_child_prefixes()])
+        child_prefixes = netaddr.IPSet([child.prefix for child in self.descendants()])
         available_prefixes = prefix - child_prefixes
 
         return available_prefixes
@@ -473,15 +794,15 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
         Return all available IPs within this prefix as an IPSet.
         """
         prefix = netaddr.IPSet(self.prefix)
-        child_ips = netaddr.IPSet([ip.address.ip for ip in self.get_child_ips()])
+        child_ips = netaddr.IPSet([ip.address.ip for ip in self.ip_addresses.all()])
         available_ips = prefix - child_ips
 
         # IPv6, pool, or IPv4 /31-32 sets are fully usable
         if any(
             [
-                self.family == 6,
+                self.ip_version == 6,
                 self.type == choices.PrefixTypeChoices.TYPE_POOL,
-                self.family == 4 and self.prefix.prefixlen >= 31,
+                self.ip_version == 4 and self.prefix_length >= 31,
             ]
         ):
             return available_ips
@@ -512,7 +833,7 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
         available_ips = self.get_available_ips()
         if not available_ips:
             return None
-        return f"{next(available_ips.__iter__())}/{self.prefix.prefixlen}"
+        return f"{next(available_ips.__iter__())}/{self.prefix_length}"
 
     def get_utilization(self):
         """Get the child prefix size and parent size.
@@ -523,16 +844,15 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
             UtilizationData (namedtuple): (numerator, denominator)
         """
         if self.type == choices.PrefixTypeChoices.TYPE_CONTAINER:
-            queryset = Prefix.objects.net_contained(self.prefix).filter(vrf=self.vrf)
-            child_prefixes = netaddr.IPSet([p.prefix for p in queryset])
+            child_prefixes = netaddr.IPSet(p.prefix for p in self.descendants())
             return UtilizationData(numerator=child_prefixes.size, denominator=self.prefix.size)
 
         else:
             prefix_size = self.prefix.size
             if all(
                 [
-                    self.prefix.version == 4,
-                    self.prefix.prefixlen < 31,
+                    self.ip_version == 4,
+                    self.prefix_length < 31,
                     self.type != choices.PrefixTypeChoices.TYPE_POOL,
                 ]
             ):
@@ -550,7 +870,7 @@ class Prefix(PrimaryModel, StatusModel, RoleModelMixin):
     "statuses",
     "webhooks",
 )
-class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
+class IPAddress(PrimaryModel):
     """
     An IPAddress represents an individual IPv4 or IPv6 address and its mask. The mask length should match what is
     configured in the real world. (Typically, only loopback interfaces are configured with /32 or /128 masks.) Like
@@ -567,15 +887,23 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
         db_index=True,
         help_text="IPv4 or IPv6 host address",
     )
-    broadcast = VarbinaryIPField(null=False, db_index=True, help_text="IPv4 or IPv6 broadcast address")
-    prefix_length = models.IntegerField(null=False, db_index=True, help_text="Length of the Network prefix, in bits.")
-    vrf = models.ForeignKey(
-        to="ipam.VRF",
-        on_delete=models.PROTECT,
-        related_name="ip_addresses",
+    mask_length = models.IntegerField(null=False, db_index=True, help_text="Length of the network mask, in bits.")
+    status = StatusField(blank=False, null=False)
+    role = RoleField(blank=True, null=True)
+    parent = models.ForeignKey(
+        "ipam.Prefix",
         blank=True,
         null=True,
-        verbose_name="VRF",
+        related_name="ip_addresses",  # `IPAddress` to use `related_name="ip_addresses"`
+        on_delete=models.PROTECT,
+        help_text="The parent Prefix of this IPAddress.",
+    )
+    # ip_version is set internally just like network, and mask_length.
+    ip_version = models.IntegerField(
+        choices=choices.IPAddressVersionChoices,
+        null=True,
+        editable=False,
+        db_index=True,
     )
     tenant = models.ForeignKey(
         to="tenancy.Tenant",
@@ -603,18 +931,7 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
     )
     description = models.CharField(max_length=200, blank=True)
 
-    csv_headers = [
-        "address",
-        "vrf",
-        "tenant",
-        "status",
-        "role",
-        "is_primary",
-        "dns_name",
-        "description",
-    ]
     clone_fields = [
-        "vrf",
         "tenant",
         "status",
         "role",
@@ -625,13 +942,22 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
     objects = BaseManager.from_queryset(IPAddressQuerySet)()
 
     class Meta:
-        ordering = ("host", "prefix_length")  # address may be non-unique
+        ordering = ("ip_version", "host", "mask_length")  # address may be non-unique
         verbose_name = "IP address"
         verbose_name_plural = "IP addresses"
+        unique_together = ["parent", "host"]
 
     def __init__(self, *args, **kwargs):
         address = kwargs.pop("address", None)
-        super(IPAddress, self).__init__(*args, **kwargs)
+        namespace = kwargs.pop("namespace", None)
+        # We don't want users providing their own parent since it will be derived automatically.
+        parent = kwargs.pop("parent", None)
+        # If namespace wasn't provided, but parent was, we'll use the parent's namespace.
+        if namespace is None and parent is not None:
+            namespace = parent.namespace
+        self._namespace = namespace
+
+        super().__init__(*args, **kwargs)
         self._deconstruct_address(address)
 
     def __str__(self):
@@ -641,34 +967,15 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
         if address:
             if isinstance(address, str):
                 address = netaddr.IPNetwork(address)
-            # Note that our "broadcast" field is actually the last IP address in this network.
-            # This is different from the more accurate technical meaning of a network's broadcast address in 2 cases:
-            # 1. For a point-to-point address (IPv4 /31 or IPv6 /127), there are two addresses in the network,
-            #    and neither one is considered a broadcast address. We store the second address as our "broadcast".
-            # 2. For a host prefix (IPv6 /32 or IPv6 /128) there's only one address in the network.
-            #    We store this address as both the host and the "broadcast".
-            # This variance is intentional in both cases as we use the "broadcast" primarily for filtering and grouping
-            # of addresses and prefixes, not for packet forwarding. :-)
-            broadcast = address.broadcast if address.broadcast else address[-1]
             self.host = str(address.ip)
-            self.broadcast = str(broadcast)
-            self.prefix_length = address.prefixlen
-
-    def get_absolute_url(self):
-        return reverse("ipam:ipaddress", args=[self.pk])
+            self.mask_length = address.prefixlen
+            self.ip_version = address.version
 
     def get_duplicates(self):
         return IPAddress.objects.filter(vrf=self.vrf, host=self.host).exclude(pk=self.pk)
 
     # TODO: The current IPAddress model has no appropriate natural key available yet.
-    #       However, by default all BaseModel subclasses now have a `natural_key` property;
-    #       but for this model, accessing the natural_key will raise an exception.
-    #       The below is a hacky way to "remove" the natural_key property from this model class for the time being.
-    class AttributeRemover:
-        def __get__(self, instance, owner):
-            raise AttributeError("IPAddress doesn't yet have a natural key!")
-
-    natural_key = AttributeRemover()
+    natural_key_field_names = ["id"]
 
     @classproperty  # https://github.com/PyCQA/pylint-django/issues/240
     def STATUS_SLAAC(cls):  # pylint: disable=no-self-argument
@@ -676,7 +983,7 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
         cls.__status_slaac = getattr(cls, "__status_slaac", None)
         if cls.__status_slaac is None:
             try:
-                cls.__status_slaac = Status.objects.get_for_model(IPAddress).get(slug="slaac")
+                cls.__status_slaac = Status.objects.get_for_model(IPAddress).get(name="SLAAC")
             except Status.DoesNotExist:
                 logger.error("SLAAC Status not found")
         return cls.__status_slaac
@@ -684,73 +991,36 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
     def clean(self):
         super().clean()
 
-        if self.address:
-
-            # /0 masks are not acceptable
-            if self.address.prefixlen == 0:
-                raise ValidationError({"address": "Cannot create IP address with /0 mask."})
-
-            # Enforce unique IP space (if applicable)
-            if self.role not in IPADDRESS_ROLES_NONUNIQUE and (
-                (self.vrf is None and settings.ENFORCE_GLOBAL_UNIQUE) or (self.vrf and self.vrf.enforce_unique)
-            ):
-                duplicate_ips = self.get_duplicates()
-                if duplicate_ips:
-                    vrf = f"VRF {self.vrf}" if self.vrf else "global table"
-                    raise ValidationError({"address": f"Duplicate IP address found in {vrf}: {duplicate_ips.first()}"})
-
-        # TODO: update to work with interface M2M
-        # This attribute will have been set by `IPAddressForm.clean()` to indicate that the
-        # `primary_ip{version}` field on `self.assigned_object.parent` has been nullified but not yet saved.
-        primary_ip_unset_by_form = getattr(self, "_primary_ip_unset_by_form", False)
-
-        # Check for primary IP assignment that doesn't match the assigned device/VM if and only if
-        # "_primary_ip_unset" has not been set by the caller.
-        if self.present_in_database and not primary_ip_unset_by_form:
-            device = Device.objects.filter(Q(primary_ip4=self) | Q(primary_ip6=self)).first()
-            if device:
-                if getattr(self.assigned_object, "device", None) != device:
-                    raise ValidationError(
-                        {"interface": f"IP address is primary for device {device} but not assigned to it!"}
-                    )
-            vm = VirtualMachine.objects.filter(Q(primary_ip4=self) | Q(primary_ip6=self)).first()
-            if vm:
-                if getattr(self.assigned_object, "virtual_machine", None) != vm:
-                    raise ValidationError(
-                        {"vminterface": f"IP address is primary for virtual machine {vm} but not assigned to it!"}
-                    )
+        # Validate that host is not being modified
+        if self.present_in_database:
+            ip_address = IPAddress.objects.get(id=self.id)
+            if ip_address.host != self.host:
+                raise ValidationError({"address": "Host address cannot be changed once created"})
 
         # Validate IP status selection
-        if self.status == IPAddress.STATUS_SLAAC and self.family != 6:
+        if self.status == IPAddress.STATUS_SLAAC and self.ip_version != 6:
             raise ValidationError({"status": "Only IPv6 addresses can be assigned SLAAC status"})
 
         # Force dns_name to lowercase
         self.dns_name = self.dns_name.lower()
 
-    def to_csv(self):
-
-        # Determine if this IP is primary for a Device
-        is_primary = False
-        if self.address.version == 4 and getattr(self, "primary_ip4_for", False):
-            is_primary = True
-        elif self.address.version == 6 and getattr(self, "primary_ip6_for", False):
-            is_primary = True
-
-        return (
-            self.address,
-            self.vrf.name if self.vrf else None,
-            self.tenant.name if self.tenant else None,
-            self.get_status_display(),
-            self.role.name if self.role else None,
-            str(is_primary),
-            self.dns_name,
-            self.description,
-        )
+    def save(self, *args, **kwargs):
+        if not self.present_in_database:
+            if self._namespace is None:
+                raise ValidationError({"parent": "Namespace could not be determined."})
+            namespace = self._namespace
+        else:
+            namespace = self.parent.namespace
+
+        # Determine the closest parent automatically based on the Namespace.
+        self.parent = Prefix.objects.get_closest_parent(self.host, namespace=namespace)
+
+        super().save(*args, **kwargs)
 
     @property
     def address(self):
-        if self.host is not None and self.prefix_length is not None:
-            cidr = f"{self.host}/{self.prefix_length}"
+        if self.host is not None and self.mask_length is not None:
+            cidr = f"{self.host}/{self.mask_length}"
             return netaddr.IPNetwork(cidr)
         return None
 
@@ -758,11 +1028,38 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
     def address(self, address):
         self._deconstruct_address(address)
 
-    @property
-    def family(self):
-        if self.address:
-            return self.address.version
-        return None
+    def ancestors(self, ascending=False):
+        """
+        Return my ancestors descending from larger to smaller prefix lengths.
+
+        Args:
+            ascending (bool): If set, reverses the return order.
+        """
+        return self.parent.ancestors(include_self=True, ascending=ascending)
+
+    @cached_property
+    def ancestors_count(self):
+        """Display count of ancestors."""
+        return self.ancestors().count()
+
+    def root(self):
+        """
+        Returns the root node (the parent of all of my ancestors).
+        """
+        return self.ancestors().first()
+
+    def siblings(self, include_self=False):
+        """
+        Return my siblings that share the same parent Prefix.
+
+        Args:
+            include_self (bool): Whether to include this IPAddress in the list of siblings.
+        """
+        query = IPAddress.objects.filter(parent=self.parent)
+        if not include_self:
+            query = query.exclude(id=self.id)
+
+        return query
 
     # 2.0 TODO: Remove exception, getter, setter below when we can safely deprecate previous properties
     class NATOutsideMultipleObjectsReturned(MultipleObjectsReturned):
@@ -776,28 +1073,6 @@ class IPAddress(PrimaryModel, StatusModel, RoleModelMixin):
         def __str__(self):
             return f"Multiple IPAddress objects specify this object (pk: {self.obj.pk}) as nat_inside. Please refer to nat_outside_list."
 
-    @property
-    def nat_outside(self):
-        if self.nat_outside_list.count() > 1:
-            raise self.NATOutsideMultipleObjectsReturned(self)
-        return self.nat_outside_list.first()
-
-    @nat_outside.setter
-    def nat_outside(self, value):
-        if self.nat_outside_list.count() > 1:
-            raise self.NATOutsideMultipleObjectsReturned(self)
-        return self.nat_outside_list.set([value])
-
-    def _set_mask_length(self, value):
-        """
-        Expose the IPNetwork object's prefixlen attribute on the parent model so that it can be manipulated directly,
-        e.g. for bulk editing.
-        """
-        if self.address is not None:
-            self.prefix_length = value
-
-    mask_length = property(fset=_set_mask_length)
-
 
 class IPAddressToInterface(BaseModel):
     ip_address = models.ForeignKey("ipam.IPAddress", on_delete=models.CASCADE, related_name="+")
@@ -819,19 +1094,11 @@ class IPAddressToInterface(BaseModel):
     is_secondary = models.BooleanField(default=False, help_text="Is secondary address on interface")
     is_standby = models.BooleanField(default=False, help_text="Is standby address on interface")
 
-    def validate_unique(self, exclude=None):
-        """
-        Check uniqueness on combination of `ip_address`, `interface` and `vm_interface` fields
-        and raise ValidationError if check failed.
-        """
-        if IPAddressToInterface.objects.filter(
-            ip_address=self.ip_address,
-            interface=self.interface,
-            vm_interface=self.vm_interface,
-        ).exists():
-            raise ValidationError(
-                "IPAddressToInterface with this ip_address, interface and vm_interface already exists."
-            )
+    class Meta:
+        unique_together = [
+            ["ip_address", "interface"],
+            ["ip_address", "vm_interface"],
+        ]
 
     def clean(self):
         super().clean()
@@ -873,8 +1140,6 @@ class VLANGroup(OrganizationalModel):
     )
     description = models.CharField(max_length=200, blank=True)
 
-    csv_headers = ["name", "slug", "location", "description"]
-
     class Meta:
         ordering = (
             "location",
@@ -897,7 +1162,6 @@ class VLANGroup(OrganizationalModel):
 
         # Validate location
         if self.location is not None:
-
             if ContentType.objects.get_for_model(self) not in self.location.location_type.content_types.all():
                 raise ValidationError(
                     {"location": f'VLAN groups may not associate to locations of type "{self.location.location_type}".'}
@@ -906,17 +1170,6 @@ class VLANGroup(OrganizationalModel):
     def __str__(self):
         return self.name
 
-    def get_absolute_url(self):
-        return reverse("ipam:vlangroup", args=[self.pk])
-
-    def to_csv(self):
-        return (
-            self.name,
-            self.slug,
-            self.location.name if self.location else None,
-            self.description,
-        )
-
     def get_next_available_vid(self):
         """
         Return the first available VLAN ID (1-4094) in the group.
@@ -937,7 +1190,7 @@ class VLANGroup(OrganizationalModel):
     "statuses",
     "webhooks",
 )
-class VLAN(PrimaryModel, StatusModel, RoleModelMixin):
+class VLAN(PrimaryModel):
     """
     A VLAN is a distinct layer two forwarding domain identified by a 12-bit integer (1-4094).
     Each VLAN must be assigned to a Location, however VLAN IDs need not be unique within a Location.
@@ -965,6 +1218,8 @@ class VLAN(PrimaryModel, StatusModel, RoleModelMixin):
         verbose_name="ID", validators=[MinValueValidator(1), MaxValueValidator(4094)]
     )
     name = models.CharField(max_length=255, db_index=True)
+    status = StatusField(blank=False, null=False)
+    role = RoleField(blank=True, null=True)
     tenant = models.ForeignKey(
         to="tenancy.Tenant",
         on_delete=models.PROTECT,
@@ -974,16 +1229,6 @@ class VLAN(PrimaryModel, StatusModel, RoleModelMixin):
     )
     description = models.CharField(max_length=200, blank=True)
 
-    csv_headers = [
-        "location",
-        "vlan_group",
-        "vid",
-        "name",
-        "tenant",
-        "status",
-        "role",
-        "description",
-    ]
     clone_fields = [
         "location",
         "vlan_group",
@@ -993,6 +1238,8 @@ class VLAN(PrimaryModel, StatusModel, RoleModelMixin):
         "description",
     ]
 
+    natural_key_field_names = ["vid", "vlan_group"]
+
     class Meta:
         ordering = (
             "location",
@@ -1011,15 +1258,11 @@ class VLAN(PrimaryModel, StatusModel, RoleModelMixin):
     def __str__(self):
         return self.display or super().__str__()
 
-    def get_absolute_url(self):
-        return reverse("ipam:vlan", args=[self.pk])
-
     def clean(self):
         super().clean()
 
         # Validate location
         if self.location is not None:
-
             if ContentType.objects.get_for_model(self) not in self.location.location_type.content_types.all():
                 raise ValidationError(
                     {"location": f'VLANs may not associate to locations of type "{self.location.location_type}".'}
@@ -1038,18 +1281,6 @@ class VLAN(PrimaryModel, StatusModel, RoleModelMixin):
                 }
             )
 
-    def to_csv(self):
-        return (
-            self.location.name if self.location else None,
-            self.vlan_group.name if self.vlan_group else None,
-            self.vid,
-            self.name,
-            self.tenant.name if self.tenant else None,
-            self.get_status_display(),
-            self.role.name if self.role else None,
-            self.description,
-        )
-
     @property
     def display(self):
         return f"{self.name} ({self.vid})"
@@ -1110,15 +1341,6 @@ class Service(PrimaryModel):
     )
     description = models.CharField(max_length=200, blank=True)
 
-    csv_headers = [
-        "device",
-        "virtual_machine",
-        "name",
-        "protocol",
-        "ports",
-        "description",
-    ]
-
     class Meta:
         ordering = (
             "protocol",
@@ -1128,13 +1350,12 @@ class Service(PrimaryModel):
     def __str__(self):
         return f"{self.name} ({self.get_protocol_display()}/{self.port_list})"
 
-    def get_absolute_url(self):
-        return reverse("ipam:service", args=[self.pk])
-
     @property
     def parent(self):
         return self.device or self.virtual_machine
 
+    natural_key_field_names = ["name", "device", "virtual_machine"]
+
     def clean(self):
         super().clean()
 
@@ -1144,16 +1365,6 @@ class Service(PrimaryModel):
         if not self.device and not self.virtual_machine:
             raise ValidationError("A service must be associated with either a device or a virtual machine.")
 
-    def to_csv(self):
-        return (
-            self.device.name if self.device else None,
-            self.virtual_machine.name if self.virtual_machine else None,
-            self.name,
-            self.get_protocol_display(),
-            self.ports,
-            self.description,
-        )
-
     @property
     def port_list(self):
         return array_to_string(self.ports)