nautobot 2.4.15__py3-none-any.whl → 2.4.17__py3-none-any.whl

nautobot/ipam/models.py

@@ -1,5 +1,6 @@
 import logging
 import operator
+from typing import Optional
 
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import MultipleObjectsReturned, ValidationError
@@ -602,44 +603,40 @@ class Prefix(PrimaryModel):
         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)
         self._location = kwargs.pop("location", None)
         super().__init__(*args, **kwargs)
 
         # Initialize cached fields
-        self._parent = None
+        self._parent_id = None
         self._network = None
+        self._broadcast = None
         self._prefix_length = None
         self._namespace_id = None
+        self._ip_version = None
+        self._cleaned = False
 
         self._deconstruct_prefix(prefix)
 
-    @staticmethod
-    def _extract_field_value(field_name, field_names, values):
-        for current_field, field_value in zip(field_names, values):
-            if field_name == current_field:
-                return field_value
-        return None
-
     @classmethod
     def from_db(cls, db, field_names, values):
         instance = super().from_db(db, field_names, values)
         # These cached values are used to detect changes during save,
         # avoiding unnecessary re-parenting of subnets and IPs if these fields have not been updated.
-        instance._network = cls._extract_field_value("network", field_names, values)
-        instance._prefix_length = cls._extract_field_value("prefix_length", field_names, values)
-        instance._namespace_id = cls._extract_field_value("namespace_id", field_names, values)
+        for field_name, value in zip(field_names, values):
+            if field_name == "broadcast":
+                instance._broadcast = value
+            elif field_name == "ip_version":
+                instance._ip_version = value
+            elif field_name == "namespace_id":
+                instance._namespace_id = value
+            elif field_name == "network":
+                instance._network = value
+            elif field_name == "parent_id":
+                instance._parent_id = value
+            elif field_name == "prefix_length":
+                instance._prefix_length = value
         return instance
 
     def __str__(self):
@@ -671,116 +668,128 @@ class Prefix(PrimaryModel):
 
     def delete(self, *args, **kwargs):
         """
-        A Prefix with children will be impossible to delete and raise a `ProtectedError`.
-
-        If a Prefix has children, this catches the error and explicitly updates the
-        `protected_objects` from the exception setting their parent to the old parent of this
-        prefix, and then this prefix will be deleted.
+        As a part of deleting this Prefix, reparent any child Prefixes or IPAddresses to this Prefix's parent if any.
         """
 
-        try:
-            return super().delete(*args, **kwargs)
-        except models.ProtectedError as err:
-            for instance in err.protected_objects:
-                # This will be either IPAddress or Prefix.
-                protected_model = instance._meta.model
-
-                # IPAddress objects must have a valid parent.
-                # 3.0 TODO: uncomment this check to enforce it
-                # if protected_model == IPAddress and (
-                #     self.parent is None
-                #     or self.parent.type != choices.PrefixTypeChoices.TYPE_NETWORK
-                # ):
-                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 valid parent."
-                        ),
-                        protected_objects=err.protected_objects,
-                    ) from err
-
-                elif protected_model not in (IPAddress, Prefix):
-                    raise
-                # 3.0 TODO: uncomment this check to enforce it
-                # Prefix objects must have a valid parent
-                # elif (
-                #     protected_model == Prefix
-                #     and self.parent is not None
-                #     and constants.PREFIX_ALLOWED_PARENT_TYPES[instance.type] != self.parent.type
-                # ):
-                #     raise models.ProtectedError(
-                #         msg=(
-                #             f"Cannot delete Prefix {self} because it has child Prefix objects that "
-                #             "would no longer have a valid 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)
+        with transaction.atomic():
+            if self.parent is None and self.ip_addresses.exists():
+                raise models.ProtectedError(
+                    msg=(
+                        f"Cannot delete Prefix {self} because it has child IPAddress objects that "
+                        "would no longer have a valid parent."
+                    ),
+                    protected_objects=self.ip_addresses.all(),
+                )
+
+            self.children.update(parent=self.parent)
+            self.ip_addresses.update(parent=self.parent)
             return super().delete(*args, **kwargs)
 
     def get_parent(self):
-        # Determine if a parent exists and set it to the closest ancestor by `prefix_length`.
-        if self._parent is not None:
-            return self._parent
+        """
+        Identify the prefix in this namespace that should serve as the parent of this Prefix.
 
+        Note that for historical reasons this does not directly set `self.parent`, but just returns the candidate.
+        """
+        # Closest ancestor by `prefix_length`.
         if supernets := self.supernets():
-            parent = max(supernets, key=operator.attrgetter("prefix_length"))
-            self._parent = parent
-            return parent
+            return max(supernets, key=operator.attrgetter("prefix_length"))
         return None
 
-    get_parent.alters_data = True
+    @property
+    def _networking_values_changed(self) -> bool:
+        """
+        Check if the networking fields of this Prefix have changed compared to their database values.
+
+        Returns:
+            bool: True if any of (network, broadcast, prefix_length, ip_version) have changed.
+        """
+        if not self.present_in_database:
+            return False
+        return (
+            self._network != self.network
+            or self._broadcast != self.broadcast
+            or self._prefix_length != self.prefix_length
+            or self._ip_version != self.ip_version
+        )
 
     def clean(self):
-        if self.prefix is not None:  # missing network/prefix_length will be caught by super().clean()
-            # Clear host bits from prefix
-            # This also has the subtle side effect of calling self._deconstruct_prefix(),
-            # which will (re)set the broadcast and ip_version values of this instance to their correct values.
-            self.prefix = self.prefix.cidr
+        """
+        Perform various data sanitization and validation.
+
+        - Prevent simultaneously changing network fields and namespace (too complex to handle)
+        - Ensure that `network`/`broadcast`/`prefix_length`/`ip_version` are set and self-consistent.
+          This includes clearing any host bits from the `prefix` or `network` based on the `prefix_length`.
+        - (Re)calculate `self.parent` if any networking fields have changed or if this is a new record.
+        - Raise a `ValidationError` if changes would orphan any existing child IPAddresses.
+        """
+        if self.prefix is not None:  # skip if missing a network/prefix_length; that will be caught by super().clean()
+            self._deconstruct_prefix(self.prefix)
 
-            self.parent = self.get_parent()
+            # Determine correct `parent` from `namespace`/`prefix` if needed
+            if (
+                self._networking_values_changed
+                or self._namespace_id != self.namespace_id
+                or not self.present_in_database
+            ):
+                self.parent = self.get_parent()
 
         super().clean()
 
+        if self._networking_values_changed and self._namespace_id != self.namespace_id:
+            raise ValidationError(
+                {
+                    "__all__": "Cannot change network and namespace in the same update. "
+                    "Consider creating a new Prefix instead."
+                }
+            )
+
+        if self._networking_values_changed and self._parent_id is None:
+            orphaned_ips = self.ip_addresses.exclude(
+                ip_version=self.ip_version,
+                host__gte=self.network,
+                host__lte=self.broadcast,
+            )
+            if orphaned_ips_count := orphaned_ips.count():
+                raise ValidationError(
+                    {
+                        "__all__": f"{orphaned_ips_count} existing IP addresses (including "
+                        f"{orphaned_ips.first().host}) would no longer have a valid parent Prefix after this change."
+                    }
+                )
+
+        if self.present_in_database and self._namespace_id != self.namespace_id:
+            if self.vrfs.exists():
+                raise ValidationError(
+                    {
+                        "namespace": "Cannot move to a different Namespace while associated to VRFs in the current "
+                        "Namespace. Remove all VRFs from this Prefix and descendants before making this change."
+                    }
+                )
+            if VRFPrefixAssignment.objects.filter(
+                prefix__ip_version=self.ip_version,
+                prefix__network__gte=self.network,
+                prefix__broadcast__lte=self.broadcast,
+                prefix__prefix_length__gt=self.prefix_length,
+                prefix__namespace_id=self._namespace_id,
+            ).exists():
+                raise ValidationError(
+                    {
+                        "namespace": "Cannot move to a different Namespace with descendant Prefixes associated to VRFs "
+                        "in the current Namespace. Remove all VRFs from all descendants before making this change."
+                    }
+                )
+
+        self._cleaned = True
+
     clean.alters_data = True
 
     def save(self, *args, **kwargs):
-        self.clean()
-
-        # Validate that creation of this prefix does not create an invalid parent/child relationship
-        # 3.0 TODO: uncomment this to enforce this constraint
-        # if self.parent and self.parent.type != constants.PREFIX_ALLOWED_PARENT_TYPES[self.type]:
-        #     err_msg = f"{self.type.title()} prefixes cannot be children of {self.parent.type.title()} prefixes"
-        #     raise ValidationError({"type": err_msg})
-
-        # This is filtering on prefixes that share my parent and will be reparented to me
-        # but are not the correct type for this parent/child relationship
-        # 3.0 TODO: uncomment the below to enforce this constraint
-        # invalid_children = Prefix.objects.filter(
-        #     ~models.Q(id=self.id),
-        #     ~models.Q(type__in=constants.PREFIX_ALLOWED_CHILD_TYPES[self.type]),
-        #     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,
-        # )
-        #
-        # if invalid_children.exists():
-        #     invalid_child_prefixes = [
-        #         f"{child.cidr_str} ({child.type})" for child in invalid_children.only("network", "prefix_length")
-        #     ]
-        #     err_msg = (
-        #         f'Creating prefix "{self.prefix}" in namespace "{self.namespace}" with type "{self.type}" '
-        #         f"would create an invalid parent/child relationship with prefixes {invalid_child_prefixes}"
-        #     )
-        #     raise ValidationError({"__all__": err_msg})
+        """
+        If not already cleaned, clean automatically before saving, and after saving, update related IPs and Prefixes.
+        """
+        if not self._cleaned:
+            self.clean()
 
         # cache the value of present_in_database; because after `super().save()`
         # `self.present_in_database` would always return True`
@@ -788,29 +797,66 @@ class Prefix(PrimaryModel):
 
         with transaction.atomic():
             super().save(*args, **kwargs)
+
+            # Backward-compatibility: if this was initialized with a `location`, update the `locations` M2M now.
             if self._location is not None:
                 self.location = self._location
 
-        # Only reparent subnets and ips if any of these fields has been updated.
-        if (
-            not present_in_database
-            or self._network != self.network
-            or self._namespace_id != self.namespace_id
-            or self._prefix_length != self.prefix_length
-        ):
-            # 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()
+            if self._namespace_id != self.namespace_id and present_in_database:
+                # Namespace changed, move *all* descendants to the new namespace as well.
+                subnets = Prefix.objects.filter(
+                    ip_version=self.ip_version,
+                    network__gte=self.network,
+                    broadcast__lte=self.broadcast,
+                    prefix_length__gt=self.prefix_length,
+                    namespace_id=self._namespace_id,  # important!
+                )
+                # Is this a "merge" case where there are existing prefixes in the target namespace?
+                if (
+                    Prefix.objects.filter(
+                        ip_version=self.ip_version,
+                        network__gte=self.network,
+                        broadcast__lte=self.broadcast,
+                        prefix_length__gt=self.prefix_length,
+                        namespace_id=self.namespace_id,  # important!
+                    ).exists()
+                    or IPAddress.objects.filter(
+                        ip_version=self.ip_version,
+                        host__gte=self.network,
+                        host__lte=self.broadcast,
+                        parent__namespace_id=self.namespace_id,
+                    ).exists()
+                ):
+                    for subnet in subnets.iterator():
+                        # We don't use `subnets.update()` here because we need to have each subnet call its own
+                        # reparent_ips() and reparent_subnets()
+                        subnet.namespace_id = self.namespace_id
+                        subnet.save()
+                else:
+                    # Nothing to merge, much more efficient:
+                    subnets.update(namespace_id=self.namespace_id)
+
+            if self._networking_values_changed or self._namespace_id != self.namespace_id or not present_in_database:
+                # Claim and/or un-claim child prefixes and IPs
+                self.reparent_subnets()
+                self.reparent_ips()
+
+        self._network = self.network
+        self._broadcast = self.broadcast
+        self._prefix_length = self.prefix_length
+        self._ip_version = self.ip_version
+        self._namespace_id = self.namespace_id
+        self._parent_id = self.parent_id
+        self._cleaned = False
 
     @property
-    def cidr_str(self):
+    def cidr_str(self) -> Optional[str]:
         if self.network is not None and self.prefix_length is not None:
             return f"{self.network}/{self.prefix_length}"
         return None
 
     @property
-    def prefix(self):
+    def prefix(self) -> Optional[netaddr.IPNetwork]:
         if self.cidr_str:
             return netaddr.IPNetwork(self.cidr_str)
         return None
@@ -818,6 +864,7 @@ class Prefix(PrimaryModel):
     @prefix.setter
     def prefix(self, prefix):
         self._deconstruct_prefix(prefix)
+        self._cleaned = False
 
     @property
     def location(self):
@@ -837,35 +884,87 @@ class Prefix(PrimaryModel):
 
     def reparent_subnets(self):
         """
-        Determine the list of child Prefixes and set the parent to self.
+        Handle changes to the parentage of other Prefixes as a consequence of this Prefix's creation or update.
 
-        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,
-        )
+        - Former child Prefixes of ours that are no longer our descendants can be reparented to our former parent.
+        - Subnets that we are now the closest parent of can be reparented to us.
+        - Former children that we are no longer the closest parent of can be reparented to one of our new descendants.
 
-        return query.update(parent=self)
+        Called automatically by save(); generally not intended for use outside of that context.
+        """
+        if self._networking_values_changed:
+            # Former child Prefixes of ours that are no longer our descendants can be reparented to our former parent.
+            self.children.exclude(
+                ip_version=self.ip_version,
+                network__gte=self.network,
+                broadcast__lte=self.broadcast,
+                prefix_length__gt=self.prefix_length,
+                namespace_id=self.namespace_id,
+            ).update(parent_id=self._parent_id)
+
+        # Subnets that we are now the closest parent of can be reparented to us.
+        self.subnets().filter(
+            models.Q(parent__isnull=True)  # No parent
+            | models.Q(parent__prefix_length__lt=self.prefix_length)  # We're closer than the current parent
+        ).update(parent=self)
+
+        if self._networking_values_changed:
+            # Former children that we are no longer the closest parent can be reparented to one of our new descendants.
+            children_to_reparent = []
+            for child in self.children.filter(prefix_length__gt=self.prefix_length + 1):
+                try:
+                    closest_parent = self.children.get_closest_parent(child.prefix)  # pylint: disable=no-member
+                except Prefix.DoesNotExist:
+                    closest_parent = self
+                if closest_parent != self:
+                    child.parent = closest_parent
+                    children_to_reparent.append(child)
+
+            Prefix.objects.bulk_update(children_to_reparent, ["parent"], batch_size=1000)
 
     reparent_subnets.alters_data = True
 
     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,
-        )
+        """
+        Handle changes to the parentage of IPAddresses as a consequence of this Prefix's creation or update.
 
-        return query.update(parent=self)
+        - Former child IPs of ours that are no longer our descendants can be reparented to our former parent.
+        - Former child IPs that we are no longer the closest parent of can be reparented to one of our new descendants.
+        - IPs that we are now the closest parent of can be reparented to us.
+
+        Called automatically by save(); generally not intended for use outside of that context.
+        """
+        if self._networking_values_changed:
+            # Former child IPs of ours that are no longer our descendants can be reparented to our former parent.
+            reparentable_ips = self.ip_addresses.exclude(
+                ip_version=self.ip_version,
+                host__gte=self.network,
+                host__lte=self.broadcast,
+            )
+            if self._parent_id is None and reparentable_ips.exists():
+                raise ValidationError(
+                    {
+                        "__all__": f"{reparentable_ips.count()} existing IP addresses would no longer have "
+                        "a valid parent Prefix after this change."
+                    }
+                )
+            reparentable_ips.update(parent_id=self._parent_id)
+
+            # Former child IPs that we are no longer closest parent of can be reparented to one of our new descendants.
+            ips_to_reparent = []
+            for ip in self.ip_addresses.all():
+                try:
+                    closest_parent = self.children.get_closest_parent(ip.host, include_self=True)  # pylint: disable=no-member
+                except Prefix.DoesNotExist:
+                    closest_parent = self
+                if closest_parent != self:
+                    ip.parent = closest_parent
+                    ips_to_reparent.append(ip)
+
+            IPAddress.objects.bulk_update(ips_to_reparent, ["parent"], batch_size=1000)
+
+        # IPs that we are now the closest parent of can be reparented to us.
+        self.get_all_ips().select_for_update().filter(parent__prefix_length__lt=self.prefix_length).update(parent=self)
 
     reparent_ips.alters_data = True
 
@@ -1018,9 +1117,9 @@ class Prefix(PrimaryModel):
         # IPv6, pool, or IPv4 /31-32 sets are fully usable
         if any(
             [
-                self.ip_version == 6,
+                self.ip_version == choices.IPAddressVersionChoices.VERSION_6,
                 self.type == choices.PrefixTypeChoices.TYPE_POOL,
-                self.ip_version == 4 and self.prefix_length >= 31,
+                self.ip_version == choices.IPAddressVersionChoices.VERSION_4 and self.prefix_length >= 31,
             ]
         ):
             return available_ips
@@ -1097,10 +1196,9 @@ class Prefix(PrimaryModel):
     def get_utilization(self):
         """Return the utilization of this prefix as a UtilizationData object.
 
-        For prefixes containing other prefixes, all direct child prefixes are considered fully utilized.
+        For CONTAINER and NETWORK prefixes, all child prefixes are considered fully utilized.
 
-        For prefixes containing IP addresses and/or pools, pools are considered fully utilized while
-        only IP addresses that are not contained within pools are added to the utilization.
+        For NETWORK and POOL prefixes, individual IP addresses not already covered by a child prefix are also counted.
 
         It is recommended that when using this method you add the following prefetch to the queryset when dealing with
         multiple prefixes to ensure good performance:
@@ -1120,9 +1218,7 @@ class Prefix(PrimaryModel):
         child_ips = netaddr.IPSet()
         child_prefixes = netaddr.IPSet()
 
-        # 3.0 TODO: In the long term, TYPE_POOL prefixes will be disallowed from directly containing IPAddresses,
-        # and the addresses will instead be parented to the containing TYPE_NETWORK prefix. It should be possible to
-        # change this when that is the case, see #3873 for historical context.
+        # NETWORK and POOL prefixes, but not CONTAINER prefixes, count contained IPAddresses towards utilization.
         if self.type != choices.PrefixTypeChoices.TYPE_CONTAINER:
             pool_ips = IPAddress.objects.filter(
                 parent__namespace_id=self.namespace_id,
@@ -1132,6 +1228,7 @@ class Prefix(PrimaryModel):
             ).values_list("host", flat=True)
             child_ips = netaddr.IPSet(pool_ips)
 
+        # CONTAINER and NETWORK prefixes, but not POOL prefixes, count contained Prefixes towards utilization.
         if self.type != choices.PrefixTypeChoices.TYPE_POOL:
             # Using self.children.all over self.children.iterator (with chunk_size given or not) consistently shaves
             # off around 200 extra SQL queries and shows better performance.
@@ -1141,13 +1238,13 @@ class Prefix(PrimaryModel):
 
         numerator_set = child_ips | child_prefixes
 
-        # Exclude network and broadcast address from the denominator unless they've been assigned to an IPAddress or child pool.
+        # Exclude network and broadcast IPs from the denominator unless they're assigned to an IPAddress or child pool.
         # Only applies to IPv4 network prefixes with a prefix length of /30 or shorter
         if all(
             [
                 denominator > 2,
                 self.type == choices.PrefixTypeChoices.TYPE_NETWORK,
-                self.ip_version == 4,
+                self.ip_version == choices.IPAddressVersionChoices.VERSION_4,
             ]
         ):
             if not any([self.network in numerator_set, self.broadcast in numerator_set]):
@@ -1266,12 +1363,26 @@ class IPAddress(PrimaryModel):
     def __init__(self, *args, address=None, namespace=None, **kwargs):
         super().__init__(*args, **kwargs)
 
+        self._parent = None
+        self._host = None
+
         if namespace is not None and not self.present_in_database:
             self._provided_namespace = namespace
 
         if address is not None and not self.present_in_database:
             self._deconstruct_address(address)
 
+    @classmethod
+    def from_db(cls, db, field_names, values):
+        instance = super().from_db(db, field_names, values)
+        # These cached values are used to detect changes during save
+        for field_name, value in zip(field_names, values):
+            if field_name == "host":
+                instance._host = value
+            elif field_name == "parent":
+                instance._parent = value
+        return instance
+
     def __str__(self):
         return str(self.address)
 
@@ -1297,33 +1408,36 @@ class IPAddress(PrimaryModel):
         if self.host in empty_values or self.mask_length in empty_values:
             return None
         try:
-            closest_parent = (
-                Prefix.objects.filter(namespace=self._namespace)
-                # 3.0 TODO: disallow IPAddress from parenting to a TYPE_POOL prefix, instead pick closest TYPE_NETWORK
-                # .exclude(type=choices.PrefixTypeChoices.TYPE_POOL)
-                .get_closest_parent(self.host, include_self=True)
+            closest_parent = Prefix.objects.filter(namespace=self._namespace).get_closest_parent(
+                self.host, include_self=True
             )
             return closest_parent
         except Prefix.DoesNotExist as e:
-            raise ValidationError({"namespace": "No suitable parent Prefix exists in this Namespace"}) from e
+            raise ValidationError(
+                {"namespace": f"No suitable parent Prefix for {self.host} exists in Namespace {self._namespace}"}
+            ) from e
 
     def clean(self):
-        self.address = self.address  # not a no-op - forces re-calling of self._deconstruct_address()
+        self._deconstruct_address(self.address)
 
-        # 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"})
+        if self.present_in_database and self._host != self.host:
+            raise ValidationError({"__all__": "Host address cannot be changed once created"})
 
         # Validate IP status selection
-        if self.type == choices.IPAddressTypeChoices.TYPE_SLAAC and self.ip_version != 6:
+        if (
+            self.type == choices.IPAddressTypeChoices.TYPE_SLAAC
+            and self.ip_version != choices.IPAddressVersionChoices.VERSION_6
+        ):
             raise ValidationError({"type": "Only IPv6 addresses can be assigned SLAAC type"})
 
         closest_parent = self._get_closest_parent()
-        # Validate `parent` can be used as the parent for this ipaddress
         if closest_parent is not None:
-            if self.parent is not None and self.parent != closest_parent:
+            # If `parent` was explicitly set or changed, validate it and reject if invalid.
+            if (
+                self.parent is not None
+                and (self.parent != self._parent or not self.present_in_database)
+                and self.parent != closest_parent
+            ):
                 raise ValidationError(
                     {
                         "parent": (
@@ -1332,14 +1446,10 @@ class IPAddress(PrimaryModel):
                         )
                     }
                 )
+            # Otherwise, it was *implicitly* changed (e.g. by changing `namespace`), so just update it as appropriate.
             self.parent = closest_parent
             self._namespace = None
 
-        # 3.0 TODO: uncomment the below to enforce this constraint
-        # if self.parent.type != choices.PrefixTypeChoices.TYPE_NETWORK:
-        #     err_msg = f"IP addresses cannot be created in {self.parent.type} prefixes. You must create a network prefix first."
-        #     raise ValidationError({"address": err_msg})
-
         # Force dns_name to lowercase
         if not self.dns_name.islower:
             self.dns_name = self.dns_name.lower()
@@ -1353,6 +1463,9 @@ class IPAddress(PrimaryModel):
 
         super().save(*args, **kwargs)
 
+        self._parent = self.parent
+        self._host = self.host
+
     @property
     def address(self):
         if self.host is not None and self.mask_length is not None:
@@ -1371,6 +1484,8 @@ class IPAddress(PrimaryModel):
         Args:
             ascending (bool): If set, reverses the return order.
         """
+        if self.parent is None:  # invalid, but possible currently
+            return Prefix.objects.none()
         return self.parent.ancestors(include_self=True, ascending=ascending)
 
     @cached_property
@@ -1674,6 +1789,14 @@ class VLAN(PrimaryModel):
         # Return all VM interfaces assigned to this VLAN
         return VMInterface.objects.filter(Q(untagged_vlan_id=self.pk) | Q(tagged_vlans=self.pk)).distinct()
 
+    @property
+    def interfaces(self):
+        return self.get_interfaces()
+
+    @property
+    def vminterfaces(self):
+        return self.get_vminterfaces()
+
     def clean(self):
         super().clean()