nautobot 3.0.4__py3-none-any.whl → 3.0.5__py3-none-any.whl

nautobot/ipam/filters.py

@@ -1,4 +1,5 @@
 import contextlib
+import ipaddress
 import uuid
 
 from django.core.exceptions import ValidationError
@@ -221,6 +222,10 @@ class PrefixFilterSet(
         method="filter_prefix",
         label="Prefix",
     )
+    prefix_exact = MultiValueCharFilter(
+        method="filter_prefix_exact",
+        label="Prefix (exact, strict)",
+    )
     within = MultiValueCharFilter(
         method="search_within",
         label="Within prefix",
@@ -327,6 +332,20 @@ class PrefixFilterSet(
             return queryset.net_equals(*prefixes)
         return queryset.none()
 
+    def filter_prefix_exact(self, queryset, name, value):
+        """
+        Strict version of `prefix` filter.
+        Rejects prefixes with host bits set (e.g. 10.32.0.34/28 vs 10.32.0.32/28).
+        """
+        prefixes = self._strip_values(value)
+
+        for prefix in prefixes:
+            try:
+                ipaddress.ip_network(prefix, strict=True)
+            except ValueError:
+                raise ValidationError(f"Invalid prefix_exact value as it is not a subnet boundary: {prefix}.")
+        return self.filter_prefix(queryset, name, value)
+
     def search_within(self, queryset, name, value):
         prefixes = self._strip_values(value)
         with contextlib.suppress(netaddr.AddrFormatError, ValueError):
@@ -417,6 +436,10 @@ class IPAddressFilterSet(
         method="search_by_prefix",
         label="Contained in prefix",
     )
+    prefix_exact = MultiValueCharFilter(
+        method="search_by_prefix_exact",
+        label="Prefix (exact, strict)",
+    )
     address = MultiValueCharFilter(
         method="filter_address",
         label="Address",
@@ -512,17 +535,49 @@ class IPAddressFilterSet(
         params = self.generate_query__has_interface_assignments(value)
         return queryset.filter(params)
 
-    def search_by_prefix(self, queryset, name, value):
+    def _strip_prefix_values(self, values):
+        """Normalize inputs: strip whitespace + resolve UUIDs to Prefix.prefix."""
         prefixes = []
-        for prefix in value:
+        for prefix in values:
             prefix = prefix.strip()
+            if not prefix:
+                continue
             if is_uuid(prefix):
                 prefixes.append(Prefix.objects.get(pk=prefix).prefix)
-            elif prefix:
+            else:
                 prefixes.append(prefix)
+        return prefixes
 
+    def search_by_prefix(self, queryset, name, value):
+        prefixes = self._strip_prefix_values(value)
         return queryset.net_host_contained(*prefixes)
 
+    def search_by_prefix_exact(self, queryset, name, value):
+        """
+        Strict version of `prefix` filter.
+        Rejects prefixes with host bits set (e.g. 10.32.0.34/28 vs 10.32.0.32/28).
+        """
+        prefixes = self._strip_prefix_values(value)
+
+        # Validate network is on CIDR boundary
+        for prefix in prefixes:
+            if "/" not in str(prefix):
+                # If someone passes a host-only string here, treat it as invalid for "prefix_exact".
+                raise ValidationError(f"Invalid prefix_exact value (missing mask): {prefix}")
+
+            with contextlib.suppress(netaddr.AddrFormatError, ValueError):
+                ip_network = netaddr.IPNetwork(str(prefix)).cidr
+                # cidr will always a proper network subnet; compare against original input
+                if str(ip_network) != str(prefix):
+                    raise ValidationError(
+                        f"Invalid prefix_exact value as it is not a subnet boundary: {prefix}, did you mean {ip_network}?"
+                    )
+                continue
+
+            # Defensive programming in case there is logic missed above
+            raise ValidationError(f"Invalid prefix_exact value as it is not a subnet boundary: {prefix}.")
+        return self.search_by_prefix(queryset, name, prefixes)
+
     def filter_address(self, queryset, name, value):
         try:
             return queryset.net_in(value)

nautobot/ipam/tables.py

@@ -40,7 +40,11 @@ AVAILABLE_LABEL = mark_safe('<span class="badge bg-success">Available</span>')
 
 UTILIZATION_GRAPH = """
 {% load helpers %}
-{% if record.present_in_database %}{% utilization_graph record.get_utilization %}{% else %}&mdash;{% endif %}
+{% if record.present_in_database %}
+    {% utilization_graph record.get_utilization %}
+{% else %}
+    <span class="text-secondary">&mdash;</span>
+{% endif %}
 """
 
 
@@ -73,7 +77,7 @@ PREFIX_ROLE_LINK = """
 {% if record.role %}
     <a href="{% url 'ipam:prefix_list' %}?role={{ record.role.name }}">{{ record.role }}</a>
 {% else %}
-    &mdash;
+    <span class="text-secondary">&mdash;</span>
 {% endif %}
 """
 
@@ -157,7 +161,7 @@ VRF_TARGETS = """
 {% for rt in value.all %}
     <a href="{{ rt.get_absolute_url }}">{{ rt }}</a>{% if not forloop.last %}<br />{% endif %}
 {% empty %}
-    &mdash;
+    <span class="text-secondary">&mdash;</span>
 {% endfor %}
 """
 
@@ -179,7 +183,7 @@ VLAN_PREFIXES = """
 {% for prefix in record.prefixes.all %}
     <a href="{% url 'ipam:prefix' pk=prefix.pk %}">{{ prefix }}</a>{% if not forloop.last %}<br />{% endif %}
 {% empty %}
-    &mdash;
+    <span class="text-secondary">&mdash;</span>
 {% endfor %}
 """
 

nautobot/ipam/tests/test_filters.py

@@ -1,4 +1,5 @@
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
 from django.db.models import Q
 
 from nautobot.core.testing import FilterTestCases, TestCase
@@ -242,6 +243,32 @@ class PrefixTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilt
         ancestors = [ancestor.id for ancestor in prefixes[2].ancestors()]
         self.assertQuerysetEqualAndNotEmpty(filterset.qs, self.queryset.filter(id__in=ancestors))
 
+    def test_prefix(self):
+        Prefix.objects.create(
+            prefix="192.0.2.0/29",
+            type=PrefixTypeChoices.TYPE_POOL,
+            namespace=Namespace.objects.first(),
+            status=Status.objects.get_for_model(Prefix).first(),
+        )
+        params = {"prefix": "192.0.2.0/29"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"prefix": "192.0.2.1/29"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_prefix_exact(self):
+        Prefix.objects.create(
+            prefix="192.0.2.0/29",
+            type=PrefixTypeChoices.TYPE_POOL,
+            namespace=Namespace.objects.first(),
+            status=Status.objects.get_for_model(Prefix).first(),
+        )
+        params = {"prefix_exact": "192.0.2.0/29"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"prefix_exact": "192.0.2.1/29"}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value" in str(exc.exception))
+
 
 class PrefixLocationAssignmentTestCase(FilterTestCases.FilterTestCase):
     queryset = PrefixLocationAssignment.objects.all()
@@ -807,6 +834,34 @@ class IPAddressTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyF
             self.filterset(params, self.queryset).qs, self.queryset.net_host_contained(ipv4_parent, ipv6_parent)
         )
 
+    def test_prefix_exact(self):
+        ipv4_parent = self.queryset.filter(ip_version=4).first().address.supernet()[-1]
+        ipv6_parent = self.queryset.filter(ip_version=6).first().address.supernet()[-1]
+
+        params = {"prefix_exact": [str(ipv4_parent), str(ipv6_parent)]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.net_host_contained(ipv4_parent, ipv6_parent)
+        )
+
+        # Get the first usable IP address in the subnet (not the network address)
+        ipv4_parent = self.queryset.filter(ip_version=4).first().address
+        ipv6_parent = self.queryset.filter(ip_version=6).first().address
+
+        params = {"prefix_exact": [str(ipv4_parent)]}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value" in str(exc.exception))
+
+        params = {"prefix_exact": [str(ipv6_parent)]}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value" in str(exc.exception))
+
+        params = {"prefix_exact": ["10.1.1.1"]}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value (missing mask)" in str(exc.exception))
+
     def test_filter_address(self):
         """Check IPv4 and IPv6, with and without a mask"""
         ipv4_addresses = self.queryset.filter(ip_version=4)[:2]