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

nautobot/ipam/querysets.py

@@ -356,7 +356,7 @@ class PrefixQuerySet(LocationToLocationsQuerySetMixin, BaseNetworkQuerySet):
         """
         # Validate that it's a real CIDR
         cidr = self._validate_cidr(cidr)
-        broadcast = str(cidr.broadcast or cidr.ip)
+        broadcast = str(cidr.broadcast or cidr[-1])
         ip_version = cidr.version
 
         try:
@@ -366,7 +366,7 @@ class PrefixQuerySet(LocationToLocationsQuerySetMixin, BaseNetworkQuerySet):
 
         # Prepare the queryset filter
         lookup_kwargs = {
-            "network__lte": cidr.value,
+            "network__lte": cidr.network,
             "prefix_length__gte": shortest_prefix_length,
             "broadcast__gte": broadcast,
             "ip_version": ip_version,
@@ -376,7 +376,7 @@ class PrefixQuerySet(LocationToLocationsQuerySetMixin, BaseNetworkQuerySet):
         # we can choose the first one.
         possible_ancestors = self.filter(**lookup_kwargs).order_by("-prefix_length")
         if not include_self:
-            possible_ancestors = possible_ancestors.exclude(network=cidr.value, prefix_length=cidr.prefixlen)
+            possible_ancestors = possible_ancestors.exclude(network=cidr.network, prefix_length=cidr.prefixlen)
 
         # If we've got any matches, the first one is our closest parent.
         try:

nautobot/ipam/signals.py

@@ -80,11 +80,16 @@ def ip_address_to_interface_pre_delete(instance, raw=False, **kwargs):
         )
 
     # Only nullify the primary_ip field if no other interfaces/vm_interfaces have the ip_address
+    host_needs_save = False
     if not other_assignments_exist and instance.ip_address == host.primary_ip4:
         host.primary_ip4 = None
+        host_needs_save = True
     elif not other_assignments_exist and instance.ip_address == host.primary_ip6:
         host.primary_ip6 = None
-    host.save()
+        host_needs_save = True
+
+    if host_needs_save:
+        host.save()
 
 
 @receiver(pre_save, sender=IPAddressToInterface)

nautobot/ipam/templates/ipam/prefix.html

@@ -1,14 +1,6 @@
 {% extends 'generic/object_retrieve.html' %}
 {% load helpers %}
 
-{% block breadcrumbs %}
-    <li><a href="{% url 'ipam:namespace_list' %}">Namespaces</a></li>
-    <li>{{ object.namespace | hyperlinked_object }}</li>
-    <li><a href="{% url list_url %}?namespace={{ object.namespace.pk }}">{{ verbose_name_plural|bettertitle }}</a></li>
-    {% block extra_breadcrumbs %}{% endblock extra_breadcrumbs %}
-    <li>{{ object|hyperlinked_object }}</li>
-{% endblock breadcrumbs %}
-
 {% block extra_buttons %}
         {% if perms.ipam.add_prefix and active_tab == 'prefixes' and first_available_prefix %}
         <a href="{% url 'ipam:prefix_add' %}?prefix={{ first_available_prefix }}&namespace={{ object.namespace.pk }}&tenant_group={{ object.tenant.tenant_group.pk }}&tenant={{ object.tenant.pk }}{% for loc in object.locations.all %}&locations={{ loc.pk }}{% endfor %}" class="btn btn-success">

nautobot/ipam/tests/test_api.py

@@ -413,6 +413,11 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         }
         cls.choices_fields = ["type"]
 
+        # Generic `test_update_object()` will grab and update the first Prefix
+        first_pfx = Prefix.objects.first()
+        cls.update_data = cls.create_data[0].copy()
+        cls.update_data["namespace"] = first_pfx.namespace.pk  # can't change network and namespace in the same update
+
     def test_legacy_api_behavior(self):
         """
         Tests for the 2.0/2.1 REST API of Prefixes.

nautobot/ipam/tests/test_models.py

@@ -284,6 +284,393 @@ class IPAddressToInterfaceTest(TestCase):
         self.assertEqual(remaining_assignments.count(), 1)
         self.assertIn(assignment_nested_module, remaining_assignments)
 
+    def test_ip_address_to_interface_delete_signal_no_save_when_device_has_no_primary_ips(self):
+        """
+        Test that Device is not saved when removing an IP from an interface and the device
+        has no primary IPs assigned.
+        """
+        # Create an IP address
+        ip_addr = IPAddress.objects.create(address="192.0.2.1/24", status=self.status, namespace=self.namespace)
+
+        # Assign IP to interface
+        assignment_device_int1 = IPAddressToInterface.objects.create(interface=self.test_int1, ip_address=ip_addr)
+
+        # Mock the device save method to verify it's not called
+        with patch.object(self.test_device, "save") as mock_save:
+            # Remove the IP assignment from interface - this should NOT trigger a device save
+            assignment_device_int1.delete()
+
+            # Assert save was not called since no primary IPs were affected
+            mock_save.assert_not_called()
+
+    def test_ip_address_to_interface_delete_signal_no_save_when_removing_non_primary_ip_from_device(self):
+        """
+        Test that Device is not saved when removing an IP from an interface and the IP
+        is not the device's primary IP.
+        """
+        # Test removing non-primary IPv4 assignment
+        with self.subTest("IPv4 non-primary IP removal"):
+            # Create IPv4 addresses
+            primary_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.1/24", status=self.status, namespace=self.namespace
+            )
+            other_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.2/24", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IP to interface first (required before setting as primary)
+            IPAddressToInterface.objects.create(interface=self.test_int2, ip_address=primary_ipv4_addr)
+
+            # Set it as the device's primary IP
+            self.test_device.primary_ip4 = primary_ipv4_addr
+            self.test_device.save()
+
+            # Assign the other IP to a different interface
+            assignment_other_ipv4 = IPAddressToInterface.objects.create(
+                interface=self.test_int1, ip_address=other_ipv4_addr
+            )
+
+            with patch.object(self.test_device, "save") as mock_save:
+                assignment_other_ipv4.delete()
+                mock_save.assert_not_called()
+
+        # Test removing non-primary IPv6 assignment
+        with self.subTest("IPv6 non-primary IP removal"):
+            # Create IPv6 prefix first
+            Prefix.objects.create(prefix="2001:db8::/64", status=self.status, namespace=self.namespace)
+
+            # Create IPv6 addresses
+            primary_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::1/64", status=self.status, namespace=self.namespace
+            )
+            other_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::2/64", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IP to interface first (required before setting as primary)
+            IPAddressToInterface.objects.create(interface=self.test_int2, ip_address=primary_ipv6_addr)
+
+            # Set it as the device's primary IP
+            self.test_device.primary_ip6 = primary_ipv6_addr
+            self.test_device.save()
+
+            # Assign the other IP to a different interface
+            assignment_other_ipv6 = IPAddressToInterface.objects.create(
+                interface=self.test_int1, ip_address=other_ipv6_addr
+            )
+
+            with patch.object(self.test_device, "save") as mock_save:
+                assignment_other_ipv6.delete()
+                mock_save.assert_not_called()
+
+    def test_ip_address_to_interface_delete_signal_save_when_removing_primary_ip_from_device(self):
+        """
+        Test that Device is saved when removing an IP from an interface and the IP is the device's
+        primary IP and no other assignments exist.
+        """
+        # Test removing primary IPv4 assignment
+        with self.subTest("IPv4 primary IP removal"):
+            # Create primary IPv4 address
+            primary_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.1/24", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IPv4 to an interface first
+            assignment_primary_ipv4 = IPAddressToInterface.objects.create(
+                interface=self.test_int1, ip_address=primary_ipv4_addr
+            )
+
+            # Set it as the device's primary IP
+            self.test_device.primary_ip4 = primary_ipv4_addr
+            self.test_device.save()
+
+            # Mock the device save method to verify it's called
+            with patch.object(self.test_device, "save") as mock_save:
+                # Remove the primary IP assignment - this SHOULD trigger a device save
+                assignment_primary_ipv4.delete()
+
+                # Assert save was called to nullify primary_ip4
+                mock_save.assert_called_once()
+
+        # Test removing primary IPv6 assignment
+        with self.subTest("IPv6 primary IP removal"):
+            # Create IPv6 prefix first
+            Prefix.objects.create(prefix="2001:db8::/64", status=self.status, namespace=self.namespace)
+
+            # Create primary IPv6 address
+            primary_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::1/64", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IPv6 to an interface first
+            assignment_primary_ipv6 = IPAddressToInterface.objects.create(
+                interface=self.test_int1, ip_address=primary_ipv6_addr
+            )
+
+            # Set it as the device's primary IP
+            self.test_device.primary_ip6 = primary_ipv6_addr
+            self.test_device.save()
+
+            # Mock the device save method to verify it's called
+            with patch.object(self.test_device, "save") as mock_save:
+                # Remove the primary IP assignment - this SHOULD trigger a device save
+                assignment_primary_ipv6.delete()
+
+                # Assert save was called to nullify primary_ip6
+                mock_save.assert_called_once()
+
+    def test_ip_address_to_interface_delete_signal_no_save_when_device_primary_ip_has_multiple_assignments(self):
+        """
+        Test that Device is not saved when removing an IP from an interface and the IP is the device's
+        primary IP but is assigned to other interfaces on that device.
+        """
+        # Test IPv4 primary IP with multiple assignments
+        with self.subTest("IPv4 primary IP with multiple assignments"):
+            # Create primary IPv4 address
+            primary_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.1/24", status=self.status, namespace=self.namespace
+            )
+            # Assign primary IPv4 to multiple interfaces
+            assignment_ipv4_int1 = IPAddressToInterface.objects.create(
+                interface=self.test_int1, ip_address=primary_ipv4_addr
+            )
+            IPAddressToInterface.objects.create(interface=self.test_int2, ip_address=primary_ipv4_addr)
+
+            # Set it as the device's primary IP
+            self.test_device.primary_ip4 = primary_ipv4_addr
+            self.test_device.save()
+
+            # Mock the device save method to verify it's not called
+            with patch.object(self.test_device, "save") as mock_save:
+                # Remove primary IP from one interface - should NOT trigger save since other assignment exists
+                assignment_ipv4_int1.delete()
+
+                # Assert save was not called since IP is still assigned to test_int2
+                mock_save.assert_not_called()
+
+        # Test IPv6 primary IP with multiple assignments
+        with self.subTest("IPv6 primary IP with multiple assignments"):
+            # Create IPv6 prefix first
+            Prefix.objects.create(prefix="2001:db8::/64", status=self.status, namespace=self.namespace)
+
+            # Create primary IPv6 address
+            primary_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::1/64", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IPv6 to multiple interfaces
+            assignment_ipv6_int1 = IPAddressToInterface.objects.create(
+                interface=self.test_int1, ip_address=primary_ipv6_addr
+            )
+            IPAddressToInterface.objects.create(interface=self.test_int2, ip_address=primary_ipv6_addr)
+
+            # Set it as the device's primary IP
+            self.test_device.primary_ip6 = primary_ipv6_addr
+            self.test_device.save()
+
+            # Mock the device save method to verify it's not called
+            with patch.object(self.test_device, "save") as mock_save:
+                # Remove primary IP from one interface - should NOT trigger save since other assignment exists
+                assignment_ipv6_int1.delete()
+
+                # Assert save was not called since IP is still assigned to test_int2
+                mock_save.assert_not_called()
+
+    def test_ip_address_to_interface_delete_signal_no_save_when_vm_has_no_primary_ips(self):
+        """
+        Test that VM is not saved when removing an IP from a VM interface and the VM
+        has no primary IPs assigned.
+        """
+        # Create an IP address
+        ip_addr = IPAddress.objects.create(address="192.0.2.1/24", status=self.status, namespace=self.namespace)
+
+        # VM has no primary IPs by default (both are None)
+
+        # Assign IP to VM interface
+        assignment_vm_int1 = IPAddressToInterface.objects.create(vm_interface=self.test_vmint1, ip_address=ip_addr)
+
+        # Mock the VM save method to verify it's not called
+        with patch.object(self.test_vm, "save") as mock_save:
+            # Remove the IP assignment from VM interface - this should NOT trigger a VM save
+            assignment_vm_int1.delete()
+
+            # Assert save was not called since no primary IPs were affected
+            mock_save.assert_not_called()
+
+    def test_ip_address_to_interface_delete_signal_no_save_when_removing_non_primary_ip_from_vm(self):
+        """
+        Test that VM is not saved when removing an IP from a VM interface and the IP
+        is not the VM's primary IP.
+        """
+        # Test removing non-primary IPv4 assignment
+        with self.subTest("IPv4 non-primary IP removal"):
+            # Create IPv4 addresses
+            primary_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.1/24", status=self.status, namespace=self.namespace
+            )
+            other_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.2/24", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IP to VM interface first (required before setting as primary)
+            IPAddressToInterface.objects.create(vm_interface=self.test_vmint2, ip_address=primary_ipv4_addr)
+
+            # Set it as the VM's primary IP
+            self.test_vm.primary_ip4 = primary_ipv4_addr
+            self.test_vm.save()
+
+            # Assign the other IP to a different VM interface
+            assignment_vm_int1 = IPAddressToInterface.objects.create(
+                vm_interface=self.test_vmint1, ip_address=other_ipv4_addr
+            )
+
+            with patch.object(self.test_vm, "save") as mock_save:
+                assignment_vm_int1.delete()
+                mock_save.assert_not_called()
+
+        # Test removing non-primary IPv6 assignment
+        with self.subTest("IPv6 non-primary IP removal"):
+            # Create IPv6 prefix first
+            Prefix.objects.create(prefix="2001:db8::/64", status=self.status, namespace=self.namespace)
+
+            # Create IPv6 addresses
+            primary_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::1/64", status=self.status, namespace=self.namespace
+            )
+            other_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::2/64", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IP to VM interface first (required before setting as primary)
+            IPAddressToInterface.objects.create(vm_interface=self.test_vmint2, ip_address=primary_ipv6_addr)
+
+            # Set it as the VM's primary IP
+            self.test_vm.primary_ip6 = primary_ipv6_addr
+            self.test_vm.save()
+
+            # Assign the other IP to a different VM interface
+            assignment_vm_int1 = IPAddressToInterface.objects.create(
+                vm_interface=self.test_vmint1, ip_address=other_ipv6_addr
+            )
+
+            with patch.object(self.test_vm, "save") as mock_save:
+                assignment_vm_int1.delete()
+                mock_save.assert_not_called()
+
+    def test_ip_address_to_interface_delete_signal_save_when_removing_primary_ip_from_vm(self):
+        """
+        Test that VM is saved when removing an IP from a VM interface and the IP is the VM's
+        primary IP and no other assignments exist.
+        """
+        # Test removing primary IPv4 assignment
+        with self.subTest("IPv4 primary IP removal"):
+            # Create primary IPv4 address
+            primary_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.1/24", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IPv4 to VM interface first
+            assignment_primary_ipv4 = IPAddressToInterface.objects.create(
+                vm_interface=self.test_vmint1, ip_address=primary_ipv4_addr
+            )
+
+            # Set it as the VM's primary IP
+            self.test_vm.primary_ip4 = primary_ipv4_addr
+            self.test_vm.save()
+
+            # Mock the VM save method to verify it's called
+            with patch.object(self.test_vm, "save") as mock_save:
+                # Remove the primary IP assignment - this SHOULD trigger a VM save
+                assignment_primary_ipv4.delete()
+
+                # Assert save was called to nullify primary_ip4
+                mock_save.assert_called_once()
+
+        # Test removing primary IPv6 assignment
+        with self.subTest("IPv6 primary IP removal"):
+            # Create IPv6 prefix first
+            Prefix.objects.create(prefix="2001:db8::/64", status=self.status, namespace=self.namespace)
+
+            # Create primary IPv6 address
+            primary_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::1/64", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IPv6 to VM interface first
+            assignment_primary_ipv6 = IPAddressToInterface.objects.create(
+                vm_interface=self.test_vmint1, ip_address=primary_ipv6_addr
+            )
+
+            # Set it as the VM's primary IP
+            self.test_vm.primary_ip6 = primary_ipv6_addr
+            self.test_vm.save()
+
+            # Mock the VM save method to verify it's called
+            with patch.object(self.test_vm, "save") as mock_save:
+                # Remove the primary IP assignment - this SHOULD trigger a VM save
+                assignment_primary_ipv6.delete()
+
+                # Assert save was called to nullify primary_ip6
+                mock_save.assert_called_once()
+
+    def test_ip_address_to_interface_delete_signal_no_save_when_vm_primary_ip_has_multiple_assignments(self):
+        """
+        Test that VM is not saved when removing an IP from a VM interface and the IP is the VM's
+        primary IP but is assigned to other VM interfaces on that VM.
+        """
+        # Test IPv4 primary IP with multiple assignments
+        with self.subTest("IPv4 primary IP with multiple assignments"):
+            # Create primary IPv4 address
+            primary_ipv4_addr = IPAddress.objects.create(
+                address="192.0.2.1/24", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IPv4 to multiple VM interfaces
+            assignment_ipv4_vmint1 = IPAddressToInterface.objects.create(
+                vm_interface=self.test_vmint1, ip_address=primary_ipv4_addr
+            )
+            IPAddressToInterface.objects.create(vm_interface=self.test_vmint2, ip_address=primary_ipv4_addr)
+
+            # Set it as the VM's primary IP
+            self.test_vm.primary_ip4 = primary_ipv4_addr
+            self.test_vm.save()
+
+            # Mock the VM save method to verify it's not called
+            with patch.object(self.test_vm, "save") as mock_save:
+                # Remove primary IP from one VM interface - should NOT trigger save since other assignment exists
+                assignment_ipv4_vmint1.delete()
+
+                # Assert save was not called since IP is still assigned to test_vmint2
+                mock_save.assert_not_called()
+
+        # Test IPv6 primary IP with multiple assignments
+        with self.subTest("IPv6 primary IP with multiple assignments"):
+            # Create IPv6 prefix first
+            Prefix.objects.create(prefix="2001:db8::/64", status=self.status, namespace=self.namespace)
+
+            # Create primary IPv6 address
+            primary_ipv6_addr = IPAddress.objects.create(
+                address="2001:db8::1/64", status=self.status, namespace=self.namespace
+            )
+
+            # Assign primary IPv6 to multiple VM interfaces
+            assignment_ipv6_vmint1 = IPAddressToInterface.objects.create(
+                vm_interface=self.test_vmint1, ip_address=primary_ipv6_addr
+            )
+            IPAddressToInterface.objects.create(vm_interface=self.test_vmint2, ip_address=primary_ipv6_addr)
+
+            # Set it as the VM's primary IP
+            self.test_vm.primary_ip6 = primary_ipv6_addr
+            self.test_vm.save()
+
+            # Mock the VM save method to verify it's not called
+            with patch.object(self.test_vm, "save") as mock_save:
+                # Remove primary IP from one VM interface - should NOT trigger save since other assignment exists
+                assignment_ipv6_vmint1.delete()
+
+                # Assert save was not called since IP is still assigned to test_vmint2
+                mock_save.assert_not_called()
+
 
 class TestVarbinaryIPField(TestCase):
     """Tests for `nautobot.ipam.fields.VarbinaryIPField`."""

nautobot/ipam/tests/test_querysets.py

@@ -802,6 +802,23 @@ class PrefixQuerysetTestCase(TestCase):
                 status=self.status,
             )
 
+        # same but for IPv6
+        container_v6 = netaddr.IPNetwork("2001:db8::/120")
+        Prefix.objects.create(
+            prefix=container_v6,
+            type=choices.PrefixTypeChoices.TYPE_CONTAINER,
+            namespace=namespace,
+            status=self.status,
+        )
+        for prefix_length in range(121, 129):
+            network = list(container_v6.subnet(prefix_length))[1]
+            Prefix.objects.create(
+                prefix=network,
+                type=choices.PrefixTypeChoices.TYPE_NETWORK,
+                namespace=namespace,
+                status=self.status,
+            )
+
         for last_octet in range(1, 255):
             ip = netaddr.IPAddress(f"10.0.0.{last_octet}")
             expected_prefix_length = 33 - len(bin(last_octet)[2:])  # [1] = 32, [2,3] = 31, [4,5,6,7] = 30, etc.
@@ -819,3 +836,32 @@ class PrefixQuerysetTestCase(TestCase):
                     .order_by("-prefix_length")
                     .first(),
                 )
+
+            ip = netaddr.IPAddress(f"2001:db8::{last_octet:x}")
+            expected_prefix_length = 129 - len(bin(last_octet)[2:])  # [1] = 128, [2,3] = 127, [4,5,6,7] = 126, etc.
+            with self.subTest(ip=ip, expected_prefix_length=expected_prefix_length):
+                closest_parent = Prefix.objects.filter(namespace=namespace).get_closest_parent(ip, include_self=True)
+                expected_parent = list(container_v6.subnet(expected_prefix_length))[1]
+                self.assertEqual(closest_parent.prefix, expected_parent)
+                self.assertEqual(
+                    closest_parent,
+                    Prefix.objects.filter(
+                        network__lte=ip.value,
+                        broadcast__gte=ip.value,
+                        namespace=namespace,
+                    )
+                    .order_by("-prefix_length")
+                    .first(),
+                )
+
+        slash32 = Prefix.objects.create(prefix="10.1.1.154/32", namespace=namespace, status=self.status)
+        slash31 = Prefix.objects.create(prefix="10.1.1.154/31", namespace=namespace, status=self.status)
+        slash30 = Prefix.objects.create(prefix="10.1.1.154/30", namespace=namespace, status=self.status)
+        self.assertEqual(slash31, Prefix.objects.get_closest_parent(slash32.prefix))
+        self.assertEqual(slash30, Prefix.objects.get_closest_parent(slash31.prefix))
+
+        slash126 = Prefix.objects.create(prefix="::1/126", namespace=namespace, status=self.status)
+        slash127 = Prefix.objects.create(prefix="::1/127", namespace=namespace, status=self.status)
+        slash128 = Prefix.objects.create(prefix="::1/128", namespace=namespace, status=self.status)
+        self.assertEqual(slash126, Prefix.objects.get_closest_parent(slash127.prefix))
+        self.assertEqual(slash127, Prefix.objects.get_closest_parent(slash128.prefix))

nautobot/ipam/utils/migrations.py

@@ -587,7 +587,7 @@ def get_closest_parent(obj, qs):
     """
     # Validate that it's a real CIDR
     cidr = validate_cidr(obj)
-    broadcast = str(cidr.broadcast or cidr.ip)
+    broadcast = str(cidr.broadcast or cidr[-1])
 
     # Prepare the queryset filter
     lookup_kwargs = {

nautobot/ipam/views.py

@@ -24,6 +24,7 @@ from nautobot.core.constants import MAX_PAGE_SIZE_DEFAULT
 from nautobot.core.models.querysets import count_related
 from nautobot.core.templatetags import helpers
 from nautobot.core.ui import object_detail
+from nautobot.core.ui.breadcrumbs import Breadcrumbs, InstanceBreadcrumbItem, ModelBreadcrumbItem
 from nautobot.core.ui.choices import SectionChoices
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.permissions import get_permission_for_model
@@ -335,6 +336,19 @@ class PrefixView(generic.ObjectView):
         "vlan__vlan_group",
         "namespace",
     ).prefetch_related("locations")
+    breadcrumbs = Breadcrumbs(
+        items={
+            "detail": [
+                ModelBreadcrumbItem(model=Namespace),
+                InstanceBreadcrumbItem(instance=lambda context: context["object"].namespace),
+                ModelBreadcrumbItem(
+                    model=Prefix,
+                    reverse_query_params=lambda context: {"namespace": context["object"].namespace.pk},
+                    label_key="verbose_name_plural",
+                ),
+            ]
+        }
+    )
 
     def get_extra_context(self, request, instance):
         # Parent prefixes table
@@ -1102,16 +1116,10 @@ class VLANUIViewSet(NautobotUIViewSet):  # 3.0 TODO: remove, unused BulkImportVi
     queryset = VLAN.objects.all()
 
     class VLANObjectFieldsPanel(object_detail.ObjectFieldsPanel):
-        def get_data(self, context):
-            instance = get_obj_from_context(context, self.context_object_key)
-            data = super().get_data(context)
-            data["locations"] = instance.locations.all()
-            return data
-
         def render_value(self, key, value, context):
-            instance = get_obj_from_context(context)
             if key == "locations":
-                return helpers.render_m2m(value, f"/dcim/locations/?vlans={instance.pk}", key)
+                instance = get_obj_from_context(context)
+                return helpers.render_m2m(value.all(), f"/dcim/locations/?vlans={instance.pk}", key)
             return super().render_value(key, value, context)
 
     class PrefixObjectsTablePanel(object_detail.ObjectsTablePanel):
@@ -1138,6 +1146,7 @@ class VLANUIViewSet(NautobotUIViewSet):  # 3.0 TODO: remove, unused BulkImportVi
                 weight=100,
                 section=SectionChoices.LEFT_HALF,
                 fields="__all__",
+                additional_fields=["locations"],
             ),
             PrefixObjectsTablePanel(
                 weight=100,