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

nautobot/ipam/navigation.py

@@ -1,208 +1,85 @@
-from nautobot.core.apps import NavMenuAddButton, NavMenuGroup, NavMenuItem, NavMenuImportButton, NavMenuTab
+from nautobot.core.apps import NavMenuGroup, NavMenuItem, NavMenuTab
 
 
 menu_items = (
     NavMenuTab(
-        name="IPAM",
-        weight=300,
+        name="Networks",
         groups=(
             NavMenuGroup(
-                name="IP Addresses",
+                name="IP Management",
                 weight=100,
                 items=(
                     NavMenuItem(
-                        link="ipam:ipaddress_list",
                         name="IP Addresses",
                         weight=100,
-                        permissions=[
-                            "ipam.view_ipaddress",
-                        ],
-                        buttons=(
-                            NavMenuAddButton(
-                                link="ipam:ipaddress_add",
-                                permissions=[
-                                    "ipam.add_ipaddress",
-                                ],
-                            ),
-                            NavMenuImportButton(
-                                link="ipam:ipaddress_import",
-                                permissions=[
-                                    "ipam.add_ipaddress",
-                                ],
-                            ),
-                        ),
+                        link="ipam:ipaddress_list",
+                        permissions=["ipam.view_ipaddress"],
                     ),
-                ),
-            ),
-            NavMenuGroup(
-                name="Prefixes",
-                weight=200,
-                items=(
                     NavMenuItem(
-                        link="ipam:prefix_list",
                         name="Prefixes",
-                        weight=100,
-                        permissions=[
-                            "ipam.view_prefix",
-                        ],
-                        buttons=(
-                            NavMenuAddButton(
-                                link="ipam:prefix_add",
-                                permissions=[
-                                    "ipam.add_prefix",
-                                ],
-                            ),
-                            NavMenuImportButton(
-                                link="ipam:prefix_import",
-                                permissions=[
-                                    "ipam.add_prefix",
-                                ],
-                            ),
-                        ),
+                        weight=200,
+                        link="ipam:prefix_list",
+                        permissions=["ipam.view_prefix"],
                     ),
                     NavMenuItem(
-                        link="ipam:rir_list",
                         name="RIRs",
-                        weight=200,
-                        permissions=[
-                            "ipam.view_rir",
-                        ],
-                        buttons=(
-                            NavMenuAddButton(
-                                link="ipam:rir_add",
-                                permissions=[
-                                    "ipam.add_rir",
-                                ],
-                            ),
-                            NavMenuImportButton(
-                                link="ipam:rir_import",
-                                permissions=[
-                                    "ipam.add_rir",
-                                ],
-                            ),
-                        ),
+                        weight=300,
+                        link="ipam:rir_list",
+                        permissions=["ipam.view_rir"],
                     ),
                 ),
             ),
             NavMenuGroup(
-                name="VRFs",
-                weight=400,
+                name="Layer 2 / Switching",
+                weight=200,
                 items=(
                     NavMenuItem(
-                        link="ipam:vrf_list",
-                        name="VRFs",
+                        name="VLANs",
                         weight=100,
-                        permissions=[
-                            "ipam.view_vrf",
-                        ],
-                        buttons=(
-                            NavMenuAddButton(
-                                link="ipam:vrf_add",
-                                permissions=[
-                                    "ipam.add_vrf",
-                                ],
-                            ),
-                            NavMenuImportButton(
-                                link="ipam:vrf_import",
-                                permissions=[
-                                    "ipam.add_vrf",
-                                ],
-                            ),
-                        ),
+                        link="ipam:vlan_list",
+                        permissions=["ipam.view_vlan"],
                     ),
                     NavMenuItem(
-                        link="ipam:routetarget_list",
-                        name="Route Targets",
+                        name="VLAN Groups",
                         weight=200,
-                        permissions=[
-                            "ipam.view_routetarget",
-                        ],
-                        buttons=(
-                            NavMenuAddButton(
-                                link="ipam:routetarget_add",
-                                permissions=[
-                                    "ipam.add_routetarget",
-                                ],
-                            ),
-                            NavMenuImportButton(
-                                link="ipam:routetarget_import",
-                                permissions=[
-                                    "ipam.add_routetarget",
-                                ],
-                            ),
-                        ),
+                        link="ipam:vlangroup_list",
+                        permissions=["ipam.view_vlangroup"],
                     ),
                 ),
             ),
             NavMenuGroup(
-                name="VLANs",
-                weight=500,
+                name="Layer 3 / Routing",
+                weight=300,
                 items=(
                     NavMenuItem(
-                        link="ipam:vlan_list",
-                        name="VLANs",
+                        name="Namespaces",
                         weight=100,
-                        permissions=[
-                            "ipam.view_vlan",
-                        ],
-                        buttons=(
-                            NavMenuAddButton(
-                                link="ipam:vlan_add",
-                                permissions=[
-                                    "ipam.add_vlan",
-                                ],
-                            ),
-                            NavMenuImportButton(
-                                link="ipam:vlan_import",
-                                permissions=[
-                                    "ipam.add_vlan",
-                                ],
-                            ),
-                        ),
+                        link="ipam:namespace_list",
+                        permissions=["ipam.namespace_vrf"],
                     ),
                     NavMenuItem(
-                        link="ipam:vlangroup_list",
-                        name="VLAN Groups",
+                        name="VRFs",
                         weight=200,
-                        permissions=[
-                            "ipam.view_vlangroup",
-                        ],
-                        buttons=(
-                            NavMenuAddButton(
-                                link="ipam:vlangroup_add",
-                                permissions=[
-                                    "ipam.add_vlangroup",
-                                ],
-                            ),
-                            NavMenuImportButton(
-                                link="ipam:vlangroup_import",
-                                permissions=[
-                                    "ipam.add_vlangroup",
-                                ],
-                            ),
-                        ),
+                        link="ipam:vrf_list",
+                        permissions=["ipam.view_vrf"],
+                    ),
+                    NavMenuItem(
+                        name="Route Targets",
+                        weight=300,
+                        link="ipam:routetarget_list",
+                        permissions=["ipam.view_routetarget"],
                     ),
                 ),
             ),
             NavMenuGroup(
                 name="Services",
-                weight=600,
+                weight=400,
                 items=(
                     NavMenuItem(
-                        link="ipam:service_list",
                         name="Services",
                         weight=100,
-                        permissions=[
-                            "ipam.view_service",
-                        ],
-                        buttons=(
-                            NavMenuImportButton(
-                                link="ipam:service_import",
-                                permissions=[
-                                    "ipam.add_service",
-                                ],
-                            ),
-                        ),
+                        link="ipam:service_list",
+                        permissions=["ipam.view_service"],
                     ),
                 ),
             ),

nautobot/ipam/querysets.py

@@ -1,19 +1,9 @@
 import re
-import uuid
 
 import netaddr
-from django.db.models import (
-    Count,
-    ExpressionWrapper,
-    IntegerField,
-    F,
-    OuterRef,
-    Subquery,
-    Q,
-    UUIDField,
-    Value,
-)
-from django.db.models.functions import Coalesce, Length
+from django.core.exceptions import ValidationError
+from django.db.models import F, ProtectedError, Q
+from django.db.models.functions import Length
 
 from nautobot.core.models.querysets import RestrictedQuerySet
 from nautobot.ipam.constants import IPV4_BYTE_LENGTH, IPV6_BYTE_LENGTH
@@ -207,71 +197,6 @@ class BaseNetworkQuerySet(RestrictedQuerySet):
 class PrefixQuerySet(BaseNetworkQuerySet):
     """Queryset for `Prefix` objects."""
 
-    def annotate_tree(self):
-        """
-        Annotate the number of parent and child prefixes for each Prefix.
-
-        The UUID being used is fake for purposes of satisfying the COALESCE condition.
-        """
-        # The COALESCE needs a valid, non-zero, non-null UUID value to do the comparison.
-        # The value itself has no meaning, so we just generate a random UUID for the query.
-        FAKE_UUID = uuid.uuid4()
-
-        from nautobot.ipam.models import Prefix
-
-        return self.annotate(
-            parents=Subquery(
-                Prefix.objects.annotate(
-                    maybe_vrf=ExpressionWrapper(
-                        Coalesce(F("vrf_id"), FAKE_UUID),
-                        output_field=UUIDField(),
-                    )
-                )
-                .filter(
-                    Q(prefix_length__lt=OuterRef("prefix_length"))
-                    & Q(network__lte=OuterRef("network"))
-                    & Q(broadcast__gte=OuterRef("broadcast"))
-                    & Q(
-                        maybe_vrf=ExpressionWrapper(
-                            Coalesce(OuterRef("vrf_id"), FAKE_UUID),
-                            output_field=UUIDField(),
-                        )
-                    )
-                )
-                .order_by()
-                .annotate(fake_group_by=Value(1))  # This is an ORM hack to remove the unwanted GROUP BY clause
-                .values("fake_group_by")
-                .annotate(count=Count("*"))
-                .values("count")[:1],
-                output_field=IntegerField(),
-            ),
-            children=Subquery(
-                Prefix.objects.annotate(
-                    maybe_vrf=ExpressionWrapper(
-                        Coalesce(F("vrf_id"), FAKE_UUID),
-                        output_field=UUIDField(),
-                    )
-                )
-                .filter(
-                    Q(prefix_length__gt=OuterRef("prefix_length"))
-                    & Q(network__gte=OuterRef("network"))
-                    & Q(broadcast__lte=OuterRef("broadcast"))
-                    & Q(
-                        maybe_vrf=ExpressionWrapper(
-                            Coalesce(OuterRef("vrf_id"), FAKE_UUID),
-                            output_field=UUIDField(),
-                        )
-                    )
-                )
-                .order_by()
-                .annotate(fake_group_by=Value(1))  # This is an ORM hack to remove the unwanted GROUP BY clause
-                .values("fake_group_by")
-                .annotate(count=Count("*"))
-                .values("count")[:1],
-                output_field=IntegerField(),
-            ),
-        )
-
     def ip_family(self, family):
         try:
             byte_len = self.ip_family_map[family]
@@ -327,7 +252,7 @@ class PrefixQuerySet(BaseNetworkQuerySet):
         """
         if prefix:
             _prefix = netaddr.IPNetwork(prefix)
-            if str(_prefix) != prefix:
+            if str(_prefix) != str(prefix):
                 raise self.model.DoesNotExist()
             last_ip = self._get_last_ip(_prefix)
             kwargs["prefix_length"] = _prefix.prefixlen
@@ -347,6 +272,114 @@ class PrefixQuerySet(BaseNetworkQuerySet):
             kwargs["broadcast"] = last_ip
         return super().filter(*args, **kwargs)
 
+    # TODO(jathan): This was copied from `Prefix.delete()` but this won't work in the same way.
+    # Currently the issue is with `queryset.delete()` on bulk delete view from list view, how do we
+    # reference the "parent" that was deleted here? It's not in context on the `ProtectedError`.
+    # raised. This comment can be deleted after this has been successfully unit-tested.
+    def delete(self, *args, **kwargs):
+        """
+        A Prefix with children will be impossible to delete and raise a `ProtectedError`.
+
+        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 ProtectedError as err:
+            # This will be either IPAddress or Prefix.
+            protected_instance = tuple(err.protected_objects)[0]
+            protected_model = protected_instance._meta.model
+            protected_parent = protected_instance.parent
+            new_parent = protected_parent.parent_id
+
+            # Prepare a queryset for the protected objects.
+            protected_pks = (po.pk for po in err.protected_objects)
+            protected_objects = protected_model.objects.filter(pk__in=protected_pks)
+
+            # IPAddress objects must have a parent.
+            if protected_model._meta.model_name == "ipaddress" and new_parent is None:
+                # If any of the child IPs would have a null parent after this change, raise an
+                # error.
+                raise ProtectedError(
+                    msg=(
+                        f"Cannot delete Prefix {protected_parent} 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 grand-parent of the parent Prefix and delete the old
+            # parent. This should be equivalent at the row level of saying `parent=self.parent`.
+            protected_objects.update(parent=new_parent)
+            return super().delete(*args, **kwargs)
+
+    def _validate_cidr(self, value):
+        """
+        Validate whether `value` is a validr IPv4/IPv6 CIDR.
+
+        Args:
+            value (str): IP address
+        """
+        try:
+            return netaddr.IPNetwork(str(value))
+        except netaddr.AddrFormatError as err:
+            raise ValidationError({"cidr": f"{value} does not appear to be an IPv4 or IPv6 network."}) from err
+
+    def get_closest_parent(self, cidr, namespace, max_prefix_length=0):
+        """
+        Return the closest matching parent Prefix for a `cidr` even if it doesn't exist in the database.
+
+        Args:
+            cidr (str): IPv4/IPv6 CIDR string
+            namespace (Namespace): Namespace instance
+            max_prefix_length (int): Maximum prefix length depth for closest parent lookup
+        """
+        # Validate that it's a real CIDR
+        cidr = self._validate_cidr(cidr)
+        broadcast = str(cidr.broadcast or cidr.ip)
+        ip_version = cidr.version
+
+        try:
+            max_prefix_length = int(max_prefix_length)
+        except ValueError:
+            raise ValidationError({"max_prefix_length": f"Invalid prefix_length: {max_prefix_length}."})
+
+        # Walk the supernets backwrds from smallest to largest prefix.
+        try:
+            supernets = cidr.supernet(prefixlen=max_prefix_length)
+        except ValueError as err:
+            raise ValidationError({"max_prefix_length": str(err)})
+        else:
+            supernets.reverse()
+
+        # Enumerate all unique networks and prefixes
+        networks = {str(s.network) for s in supernets}
+        del supernets  # Free the memory because it could be quite large.
+
+        # Prepare the queryset filter
+        lookup_kwargs = {
+            "network__in": networks,
+            # TODO(jathan): This might be flawed if an IPAddress has a prefix_length that excludes it from a
+            # parent that should otherwise contain it. If we encounter issues in the future for
+            # identifying closest parent prefixes, this might be a starting point.
+            "prefix_length__lte": cidr.prefixlen,
+            "broadcast__gte": broadcast,
+            "ip_version": ip_version,
+            "namespace": namespace,
+        }
+
+        # Search for possible ancestors by network/prefix, returning them in reverse order, so that
+        # we can choose the first one.
+        possible_ancestors = self.filter(**lookup_kwargs).order_by("-prefix_length")
+
+        # If we've got any matches, the first one is our closest parent.
+        try:
+            return possible_ancestors[0]
+        except IndexError:
+            raise self.model.DoesNotExist(f"Could not determine parent Prefix for {cidr}")
+
 
 class IPAddressQuerySet(BaseNetworkQuerySet):
     """Queryset for `IPAddress` objects."""
@@ -411,7 +444,7 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
         masked_hosts = [bytes(netaddr.IPNetwork(val).ip) for val in networks if "/" in val]
         masked_prefixes = [netaddr.IPNetwork(val).prefixlen for val in networks if "/" in val]
         unmasked_hosts = [bytes(netaddr.IPNetwork(val).ip) for val in networks if "/" not in val]
-        return self.filter(Q(host__in=masked_hosts, prefix_length__in=masked_prefixes) | Q(host__in=unmasked_hosts))
+        return self.filter(Q(host__in=masked_hosts, mask_length__in=masked_prefixes) | Q(host__in=unmasked_hosts))
 
     def get(self, *args, address=None, **kwargs):
         """
@@ -419,10 +452,8 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
         """
         if address:
             address = netaddr.IPNetwork(address)
-            last_ip = self._get_last_ip(address)
-            kwargs["prefix_length"] = address.prefixlen
+            kwargs["mask_length"] = address.prefixlen
             kwargs["host"] = address.ip
-            kwargs["broadcast"] = last_ip
         return super().get(*args, **kwargs)
 
     def filter(self, *args, address=None, **kwargs):
@@ -431,10 +462,8 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
         """
         if address:
             address = netaddr.IPNetwork(address)
-            last_ip = self._get_last_ip(address)
-            kwargs["prefix_length"] = address.prefixlen
+            kwargs["mask_length"] = address.prefixlen
             kwargs["host"] = address.ip
-            kwargs["broadcast"] = last_ip
         return super().filter(*args, **kwargs)
 
     def filter_address_or_pk_in(self, addresses, pk_values=None):
@@ -446,11 +475,9 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
         q = Q()
         for _address in addresses:
             _address = netaddr.IPNetwork(_address)
-            last_ip = self._get_last_ip(_address)
-            prefix_length = _address.prefixlen
+            mask_length = _address.prefixlen
             host = _address.ip
-            broadcast = last_ip
-            q |= Q(prefix_length=prefix_length, host=host, broadcast=broadcast)
+            q |= Q(mask_length=mask_length, host=host)
 
         if pk_values is not None:
             q |= Q(pk__in=pk_values)

nautobot/ipam/signals.py

@@ -0,0 +1,89 @@
+from django.core.exceptions import ValidationError
+from django.db.models.signals import m2m_changed, pre_delete, pre_save
+from django.dispatch import receiver
+
+from nautobot.ipam.models import IPAddressToInterface, VRF, VRFDeviceAssignment, VRFPrefixAssignment
+
+
+@receiver(pre_save, sender=VRFDeviceAssignment)
+@receiver(pre_save, sender=VRFPrefixAssignment)
+def ipam_object_saved(sender, instance, raw=False, **kwargs):
+    """
+    Forcibly call `full_clean()` when a new IPAM intermediate model is manually saved to prevent
+    creation of invalid objects.
+    """
+    if raw:
+        return
+    instance.full_clean()
+
+
+@receiver(m2m_changed, sender=VRFPrefixAssignment)
+def vrf_prefix_associated(sender, instance, action, reverse, model, pk_set, **kwargs):
+    """
+    Disallow adding Prefixes if the namespace doesn't match.
+    """
+
+    if action == "pre_add":
+        prefixes = model.objects.filter(pk__in=pk_set).exclude(namespace=instance.namespace)
+        if prefixes.exists():
+            raise ValidationError({"prefixes": "Prefix must match namespace of VRF"})
+
+
+@receiver(m2m_changed, sender=VRFDeviceAssignment)
+def vrf_device_associated(sender, instance, action, reverse, model, pk_set, **kwargs):
+    """
+    Assert validation on m2m when devices are associated with a VRF.
+    """
+
+    # TODO(jathan): Temporary workaround until a formset to add/remove/update VRFs <-> Devices and
+    # optionally setting RD/name on assignment. k
+    if action == "post_add":
+        if isinstance(instance, VRF):
+            for assignment in instance.device_assignments.iterator():
+                assignment.validated_save()
+        else:
+            for assignment in instance.vrf_assignments.iterator():
+                assignment.validated_save()
+
+
+@receiver(pre_delete, sender=IPAddressToInterface)
+def ip_address_to_interface_pre_delete(instance, raw=False, **kwargs):
+    if raw:
+        return
+
+    # Check if the removed IPAddressToInterface instance contains an IPAddress
+    # that is the primary_v{version} of the host machine.
+
+    if getattr(instance, "interface"):
+        host = instance.interface.device
+        other_assignments_exist = (
+            IPAddressToInterface.objects.filter(interface__device=host, ip_address=instance.ip_address)
+            .exclude(id=instance.id)
+            .exists()
+        )
+    else:
+        host = instance.vm_interface.virtual_machine
+        other_assignments_exist = (
+            IPAddressToInterface.objects.filter(vm_interface__virtual_machine=host, ip_address=instance.ip_address)
+            .exclude(id=instance.id)
+            .exists()
+        )
+
+    # Only nullify the primary_ip field if no other interfaces/vm_interfaces have the ip_address
+    if not other_assignments_exist and instance.ip_address == host.primary_ip4:
+        host.primary_ip4 = None
+    elif not other_assignments_exist and instance.ip_address == host.primary_ip6:
+        host.primary_ip6 = None
+    host.save()
+
+
+@receiver(pre_save, sender=IPAddressToInterface)
+def ip_address_to_interface_assignment_created(sender, instance, raw=False, **kwargs):
+    """
+    Forcibly call `full_clean()` when a new `IPAddressToInterface` object
+    is manually created to prevent inadvertantly creating invalid IPAddressToInterface.
+    """
+    if raw:
+        return
+
+    instance.full_clean()