nautobot 2.3.12__py3-none-any.whl → 2.3.13__py3-none-any.whl

nautobot/extras/plugins/__init__.py

@@ -519,6 +519,7 @@ class TableExtension:
     """
 
     model = None
+    suffix = None
     table_columns = {}
     add_to_default_columns = ()
     remove_from_default_columns = ()
@@ -594,7 +595,7 @@ def _add_columns_into_model_table(table_extension, app_name):
         logger.error(error)
         return
 
-    table = get_table_for_model(table_extension.model)
+    table = get_table_for_model(table_extension.model, suffix=table_extension.suffix)
     for name, column in table_extension.table_columns.items():
         _validate_table_column_name_is_prefixed_with_app_name(name, app_name)
         _add_column_to_table_base_columns(table, name, column, app_name)
@@ -629,18 +630,28 @@ def _modify_default_table_columns(table_extension, app_name):
     """Add or remove columns from the table default columns."""
     from nautobot.core.utils.lookup import get_table_for_model
 
-    table = get_table_for_model(table_extension.model)
+    table = get_table_for_model(table_extension.model, suffix=table_extension.suffix)
     message = (
         f"{app_name}: Cannot {{action}} column `{{column_name}}` {{preposition}} the default columns for `{table}`."
     )
 
     for column_name in table_extension.add_to_default_columns:
+        if not getattr(table.Meta, "default_columns", None):
+            logger.warning(
+                f"{app_name}: Table `{table}` does not have a `default_columns` attribute. Cannot add column: {column_name}."
+            )
+            continue
         if column_name in table.base_columns:
             table.Meta.default_columns = (*table.Meta.default_columns, column_name)
         else:
             logger.debug(message.format(action="add", column_name=column_name, preposition="to"))
 
     for column_name in table_extension.remove_from_default_columns:
+        if not getattr(table.Meta, "default_columns", None):
+            logger.warning(
+                f"{app_name}: Table `{table}` does not have a `default_columns` attribute. Cannot remove column: {column_name}."
+            )
+            continue
         if column_name in table.Meta.default_columns:
             table.Meta.default_columns = tuple(name for name in table.Meta.default_columns if name != column_name)
         else:

nautobot/extras/tests/test_views.py

@@ -3607,6 +3607,8 @@ class RoleTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
 
         cls.bulk_edit_data = {
             "color": "000000",
+            "description": "I used to be a new role object.",
+            "weight": 255,
         }
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])

nautobot/ipam/lookups.py

@@ -3,7 +3,9 @@ from django.db.models import Lookup, lookups
 import netaddr
 
 
-def _mysql_varbin_to_broadcast():
+def _mysql_varbin_to_broadcast(alias=None):
+    if alias:
+        return f"HEX({alias}.broadcast)"
     return "HEX(broadcast)"
 
 
@@ -13,11 +15,15 @@ def _mysql_varbin_to_hex(lhs, alias=None):
     return f"HEX({lhs})"
 
 
-def _mysql_varbin_to_network():
+def _mysql_varbin_to_network(alias=None):
+    if alias:
+        return f"HEX({alias}.network)"
     return "HEX(network)"
 
 
-def _postgresql_varbin_to_broadcast(length):
+def _postgresql_varbin_to_broadcast(length, alias=None):
+    if alias:
+        return f"right({alias}.broadcast::text, -1)::varbit::bit({length})"
     return f"right(broadcast::text, -1)::varbit::bit({length})"
 
 
@@ -27,8 +33,10 @@ def _postgresql_varbin_to_integer(lhs, length, alias=None):
     return f"right({lhs}::text, -1)::varbit::bit({length})"
 
 
-def _postgresql_varbin_to_network(lhs, length):
+def _postgresql_varbin_to_network(lhs, length, alias=None):
     # convert to bitstring, 0 out everything larger than prefix_length
+    if alias:
+        return f"lpad(right({alias}.{lhs}::text, -1)::varbit::text, {alias}.prefix_length, '0')::bit({length})"
     return f"lpad(right({lhs}::text, -1)::varbit::text, prefix_length, '0')::bit({length})"
 
 
@@ -52,8 +60,8 @@ def get_ip_info(field_name, ip_str, alias=None):
         ip_details.rhs = py_to_hex(ip.ip, ip_details.length)
         ip_details.net_addr = f"'{py_to_hex(ip.network, ip_details.length)}'"
         ip_details.bcast_addr = f"'{py_to_hex(ip[-1], ip_details.length)}'"
-        ip_details.q_net = _mysql_varbin_to_network()
-        ip_details.q_bcast = _mysql_varbin_to_broadcast()
+        ip_details.q_net = _mysql_varbin_to_network(alias=alias)
+        ip_details.q_bcast = _mysql_varbin_to_broadcast(alias=alias)
         ip_details.q_ip = _mysql_varbin_to_hex(field_name, alias=alias)
 
     elif _connection.vendor == "postgresql":
@@ -61,8 +69,8 @@ def get_ip_info(field_name, ip_str, alias=None):
         ip_details.addr_str = f"B'{bin(int(ip_details.addr))[2:].zfill(ip_details.length)}'"
         ip_details.net_addr = f"B'{bin(int(ip.network))[2:].zfill(ip_details.length)}'"
         ip_details.bcast_addr = f"B'{bin(int(ip[-1]))[2:].zfill(ip_details.length)}'"
-        ip_details.q_net = _postgresql_varbin_to_network(field_name, ip_details.length)
-        ip_details.q_bcast = _postgresql_varbin_to_broadcast(ip_details.length)
+        ip_details.q_net = _postgresql_varbin_to_network(field_name, ip_details.length, alias=alias)
+        ip_details.q_bcast = _postgresql_varbin_to_broadcast(ip_details.length, alias=alias)
         ip_details.q_ip = _postgresql_varbin_to_integer(field_name, ip_details.length, alias=alias)
 
     return ip_details
@@ -71,25 +79,38 @@ def get_ip_info(field_name, ip_str, alias=None):
 class IPDetails:
     """Class for setting up all details about an IP they may be needed"""
 
-    net = None
-    addr = None
-    ip = None
-    prefix = None
-    length = None
-    addr_str = None
-    rhs = None
-    net_addr = None
-    bcast_addr = None
-    q_net = None
-    q_bcast = None
-    q_ip = None
+    addr = None  # 10.0.0.0
+    ip = None  # 10.0.0.0/8
+    prefix = None  # 8
+    length = None  # 32
+    addr_str = None  # B'00001010000000000000000000000000'
+    rhs = None  # 00001010000000000000000000000000
+    net_addr = None  # B'00001010000000000000000000000000'
+    bcast_addr = None  # B'00001010111111111111111111111111'
+    q_net = None  # mysql or postgres specific
+    q_bcast = None  # mysql or postgres specific
+    q_ip = None  # mysql or postgres specific
     to_len = {4: 32, 6: 128}
 
+    def __str__(self):
+        return f"""\
+addr: {self.addr}
+ip: {self.ip}
+prefix: {self.prefix}
+length: {self.length}
+addr_str: {self.addr_str}
+rhs: {self.rhs}
+net_addr: {self.net_addr}
+bcast_addr: {self.bcast_addr}
+q_net: {self.q_net}
+q_bcast: {self.q_bcast}
+q_ip: {self.q_ip}"""
+
 
 class StringMatchMixin:
-    def process_lhs(self, qn, connection, lhs=None):
+    def process_lhs(self, compiler, connection, lhs=None):
         lhs = lhs or self.lhs
-        lhs_string, lhs_params = qn.compile(lhs)
+        lhs_string, lhs_params = compiler.compile(lhs)
         if connection.vendor == "postgresql":
             raise NotSupportedError("Lookup not supported on postgresql.")
         return f"INET6_NTOA({lhs_string})", lhs_params
@@ -129,6 +150,7 @@ class IRegex(StringMatchMixin, lookups.IRegex):
 
 class NetworkFieldMixin:
     def get_prep_lookup(self):
+        self.alias = self.lhs.alias
         field_name = self.lhs.field.name
         if field_name not in ["host", "network"]:
             raise NotSupportedError(f"Lookup only provided on the host and network fields, not {field_name}.")
@@ -139,8 +161,8 @@ class NetworkFieldMixin:
         self.ip = get_ip_info(field_name, self.rhs, alias=self.lhs.alias)
         return str(self.ip.ip)
 
-    def process_rhs(self, qn, connection):
-        sql, params = super().process_rhs(qn, connection)
+    def process_rhs(self, compiler, connection):
+        sql, params = super().process_rhs(compiler, connection)
         params[0] = self.ip.rhs
         return sql, params
 
@@ -148,50 +170,67 @@ class NetworkFieldMixin:
 class NetEquals(NetworkFieldMixin, Lookup):
     lookup_name = "net_equals"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length = {self.ip.prefix} AND {rhs} = {self.ip.q_ip}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length = {self.ip.prefix} AND {rhs} = {self.ip.q_ip}"
+        else:
+            query = f"prefix_length = {self.ip.prefix} AND {rhs} = {self.ip.q_ip}"
         return query, lhs_params + rhs_params
 
 
 class NetContainsOrEquals(NetworkFieldMixin, Lookup):
     lookup_name = "net_contains_or_equals"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length <= {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length <= {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+        else:
+            query = f"prefix_length <= {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
         return query, lhs_params + rhs_params
 
 
 class NetContains(NetworkFieldMixin, Lookup):
     lookup_name = "net_contains"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length < {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = (
+                f"{self.alias}.prefix_length < {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
+            )
+        else:
+            query = f"prefix_length < {self.ip.prefix} AND {rhs} BETWEEN {self.ip.q_net} AND {self.ip.q_bcast}"
         return query, lhs_params + rhs_params
 
 
 class NetContainedOrEqual(NetworkFieldMixin, Lookup):
     lookup_name = "net_contained_or_equal"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length >= {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length >= {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+        else:
+            query = f"prefix_length >= {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
         return query, lhs_params + rhs_params
 
 
 class NetContained(NetworkFieldMixin, Lookup):
     lookup_name = "net_contained"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
-        query = f"prefix_length > {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        if self.alias:
+            query = f"{self.alias}.prefix_length > {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
+        else:
+            query = f"prefix_length > {self.ip.prefix} AND {self.ip.q_net} BETWEEN {rhs} AND {self.ip.bcast_addr}"
         return query, lhs_params + rhs_params
 
 
@@ -205,19 +244,19 @@ class NetHost(Lookup):
         self.ip = get_ip_info(field_name, self.rhs, alias=self.lhs.alias)
         return str(self.ip.ip)
 
-    def process_rhs(self, qn, connection):
-        sql, params = super().process_rhs(qn, connection)
+    def process_rhs(self, compiler, connection):
+        sql, params = super().process_rhs(compiler, connection)
         params[0] = self.ip.rhs
         return sql, params
 
-    def process_lhs(self, qn, connection, lhs=None):
+    def process_lhs(self, compiler, connection, lhs=None):
         lhs = lhs or self.lhs
-        _, lhs_params = qn.compile(lhs)
+        _, lhs_params = compiler.compile(lhs)
         return self.ip.q_ip, lhs_params
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         return f"{lhs} = {rhs}", lhs_params + rhs_params
 
 
@@ -242,9 +281,9 @@ class NetIn(Lookup):
             self.query_starter = "'1' != ANY(%s) AND "
         return self.rhs
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        _, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        _, rhs_params = self.process_rhs(compiler, connection)
         query = self.query_starter
         query += "OR ".join(f"{ip.q_ip} BETWEEN {ip.net_addr} AND {ip.bcast_addr} " for ip in self.ips)
         return query, lhs_params + rhs_params
@@ -253,9 +292,9 @@ class NetIn(Lookup):
 class NetHostContained(NetworkFieldMixin, Lookup):
     lookup_name = "net_host_contained"
 
-    def as_sql(self, qn, connection):
-        _, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        _, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         query = f"{self.ip.q_ip} BETWEEN {rhs} AND {self.ip.bcast_addr}"
         return query, lhs_params + rhs_params
 
@@ -270,12 +309,12 @@ class NetFamily(Lookup):
             self.rhs = 16
         return self.rhs
 
-    def process_lhs(self, qn, connection, lhs=None):
+    def process_lhs(self, compiler, connection, lhs=None):
         lhs = lhs or self.lhs
-        lhs_string, lhs_params = qn.compile(lhs)
+        lhs_string, lhs_params = compiler.compile(lhs)
         return f"LENGTH({lhs_string})", lhs_params
 
-    def as_sql(self, qn, connection):
-        lhs, lhs_params = self.process_lhs(qn, connection)
-        rhs, rhs_params = self.process_rhs(qn, connection)
+    def as_sql(self, compiler, connection):
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
         return f"{lhs} = {rhs}", lhs_params + rhs_params

nautobot/ipam/tables.py

@@ -442,13 +442,27 @@ class IPAddressTable(StatusTableMixin, RoleTableMixin, BaseTable):
     )
     tenant = TenantColumn()
     parent__namespace = tables.Column(linkify=True)
-    # Interface, Device, and VirtualMachine tables aren't currently filterable by IP address (?) so no LinkedCountColumn
-    interface_count = tables.Column(verbose_name="Interfaces")
-    interface_parent_count = tables.Column(verbose_name="Devices")
+    interface_count = LinkedCountColumn(
+        viewname="dcim:interface_list", url_params={"ip_addresses": "pk"}, verbose_name="Interfaces"
+    )
+    # TODO: what about interfaces assigned to modules?
+    interface_parent_count = LinkedCountColumn(
+        viewname="dcim:device_list",
+        url_params={"ip_addresses": "pk"},
+        reverse_lookup="interfaces__ip_addresses",
+        distinct=True,
+        verbose_name="Devices",
+    )
     vm_interface_count = LinkedCountColumn(
         viewname="virtualization:vminterface_list", url_params={"ip_addresses": "pk"}, verbose_name="VM Interfaces"
     )
-    vm_interface_parent_count = tables.Column(verbose_name="Virtual Machines")
+    vm_interface_parent_count = LinkedCountColumn(
+        viewname="virtualization:virtualmachine_list",
+        url_params={"ip_addresses": "pk"},
+        reverse_lookup="interfaces__ip_addresses",
+        distinct=True,
+        verbose_name="Virtual Machines",
+    )
 
     class Meta(BaseTable.Meta):
         model = IPAddress

nautobot/ipam/tests/test_querysets.py

@@ -1,13 +1,15 @@
 import re
 from unittest import skipIf
 
-from django.db import connection
+from django.contrib.contenttypes.models import ContentType
+from django.db import connection, transaction
 import netaddr
 
 from nautobot.core.testing import TestCase
 from nautobot.extras.models import Status
 from nautobot.ipam import choices
 from nautobot.ipam.models import IPAddress, Namespace, Prefix
+from nautobot.users.models import ObjectPermission
 
 
 class IPAddressQuerySet(TestCase):
@@ -266,6 +268,28 @@ class IPAddressQuerySet(TestCase):
             [instance for ip, instance in self.ips.items() if "10.0.0" in ip],
         )
 
+    def test_lookup_not_ambiguous(self):
+        """Check for issues like https://github.com/nautobot/nautobot/issues/5166."""
+        obj_perm = ObjectPermission.objects.create(name="Test Permission", constraints={}, actions=["view"])
+        obj_perm.object_types.add(ContentType.objects.get_for_model(IPAddress))
+        obj_perm.users.add(self.user)
+        queryset = IPAddress.objects.select_related("parent", "nat_inside", "status")
+
+        for permission_constraint in (
+            {"host__family": 4},
+            {"host__net_host": "10.0.0.1"},
+            {"host__net_host_contained": "10.0.0.0/24"},
+            {"host__net_in": ["10.0.0.0/24"]},
+        ):
+            with self.subTest(permission_type=next(iter(permission_constraint.keys()))):
+                try:
+                    with transaction.atomic():
+                        obj_perm.constraints = permission_constraint
+                        obj_perm.save()
+                        list(queryset.restrict(self.user, "view"))
+                finally:
+                    delattr(self.user, "_object_perm_cache")
+
     @skipIf(
         connection.vendor == "postgresql",
         "Not currently supported on postgresql",
@@ -648,6 +672,30 @@ class PrefixQuerysetTestCase(TestCase):
         prefix = Prefix.objects.filter(network__net_equals="192.168.0.0/16")[0]
         self.assertEqual(Prefix.objects.filter(prefix="192.168.0.0/16")[0], prefix)
 
+    def test_lookup_not_ambiguous(self):
+        """Check for issues like https://github.com/nautobot/nautobot/issues/5166."""
+        obj_perm = ObjectPermission.objects.create(name="Test Permission", constraints={}, actions=["view"])
+        obj_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
+        obj_perm.users.add(self.user)
+        queryset = Prefix.objects.select_related("parent", "rir", "role", "status", "namespace")
+
+        for permission_constraint in (
+            {"network__family": 4},
+            {"network__net_equals": "192.168.0.0/16"},
+            {"network__net_contained": "192.0.0.0/8"},
+            {"network__net_contained_or_equal": "192.0.0.0/8"},
+            {"network__net_contains": "192.168.3.192/32"},
+            {"network__net_contains_or_equals": "192.168.3.192/32"},
+        ):
+            with self.subTest(permission_type=next(iter(permission_constraint.keys()))):
+                try:
+                    with transaction.atomic():
+                        obj_perm.constraints = permission_constraint
+                        obj_perm.save()
+                        list(queryset.restrict(self.user, "view"))
+                finally:
+                    delattr(self.user, "_object_perm_cache")
+
     @skipIf(
         connection.vendor == "postgresql",
         "Not currently supported on postgresql",

nautobot/ipam/utils/__init__.py

@@ -4,6 +4,7 @@ import netaddr
 from nautobot.core.forms.utils import compress_range
 from nautobot.dcim.models import Interface
 from nautobot.extras.models import RelationshipAssociation
+from nautobot.ipam.choices import PrefixTypeChoices
 from nautobot.ipam.models import Prefix, VLAN
 from nautobot.ipam.querysets import IPAddressQuerySet
 from nautobot.virtualization.models import VMInterface
@@ -25,6 +26,13 @@ def add_available_prefixes(parent, prefix_list):
     return prefix_list
 
 
+def get_add_available_prefixes_callback(show_available, parent):
+    """Conditionally provide a callback for add_available_prefixes()."""
+    if show_available:
+        return lambda prefixes: add_available_prefixes(parent.prefix, prefixes)
+    return lambda prefixes: prefixes
+
+
 def add_available_ipaddresses(prefix, ipaddress_list, is_pool=False):
     """
     Annotate ranges of available IP addresses within a given prefix. If is_pool is True, the first and last IP will be
@@ -81,6 +89,15 @@ def add_available_ipaddresses(prefix, ipaddress_list, is_pool=False):
     return output
 
 
+def get_add_available_ipaddresses_callback(show_available, parent):
+    """Conditionally provide a callback for add_available_ipaddresses()."""
+    if show_available:
+        return lambda ip_addresses: add_available_ipaddresses(
+            parent.prefix, ip_addresses, is_pool=(parent.type == PrefixTypeChoices.TYPE_POOL)
+        )
+    return lambda ip_addresses: ip_addresses
+
+
 def add_available_vlans(vlan_group, vlans):
     """
     Create fake records for all gaps between used VLANs
@@ -99,6 +116,13 @@ def add_available_vlans(vlan_group, vlans):
     return vlans
 
 
+def get_add_available_vlans_callback(show_available, vlan_group):
+    """Conditionally provide a callback for add_available_vlans()."""
+    if show_available:
+        return lambda vlans: add_available_vlans(vlan_group=vlan_group, vlans=vlans)
+    return lambda vlans: vlans
+
+
 def handle_relationship_changes_when_merging_ips(merged_ip, merged_attributes, collapsed_ips):
     """
     Update/Delete RelationshipAssociation instances after we collapsed the IPs.