nautobot 2.2.7__py3-none-any.whl → 2.2.9__py3-none-any.whl

nautobot/core/filters.py

@@ -7,9 +7,11 @@ from django import forms as django_forms
 from django.conf import settings
 from django.db import models
 from django.forms.utils import ErrorDict, ErrorList
+from django.utils.encoding import force_str
+from django.utils.text import capfirst
 import django_filters
 from django_filters.constants import EMPTY_VALUES
-from django_filters.utils import get_model_field, resolve_field
+from django_filters.utils import get_model_field, label_for_filter, resolve_field, verbose_lookup_expr
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field
 
@@ -681,6 +683,18 @@ class BaseFilterSet(django_filters.FilterSet):
                 # Of course setting the negation of the existing filter's exclude attribute handles both cases
                 new_filter.exclude = not filter_field.exclude
 
+            # If the base filter_field has a custom label, django_filters won't adjust it for the new_filter lookup,
+            # so we have to do it.
+            if filter_field.label and filter_field.label != label_for_filter(
+                cls.Meta.model, filter_field.field_name, filter_field.lookup_expr, filter_field.exclude
+            ):
+                # Lightly adjusted from label_for_filter() implementation:
+                verbose_expression = ["exclude", filter_field.label] if new_filter.exclude else [filter_field.label]
+                if isinstance(lookup_expr, str):
+                    verbose_expression.append(verbose_lookup_expr(lookup_expr))
+                verbose_expression = [force_str(part) for part in verbose_expression if part]
+                new_filter.label = capfirst(" ".join(verbose_expression))
+
             magic_filters[new_filter_name] = new_filter
 
         return magic_filters

nautobot/core/graphql/generators.py

@@ -55,17 +55,17 @@ def generate_null_choices_resolver(name, resolver_name):
 
 def generate_filter_resolver(schema_type, resolver_name, field_name):
     """
-    Generate function to resolve OneToMany filtering.
+    Generate function to resolve filtering of ManyToOne and ManyToMany related objects.
 
     Args:
         schema_type (DjangoObjectType): DjangoObjectType for a given model
         resolver_name (str): name of the resolver
-        field_name (str): name of OneToMany field to filter
+        field_name (str): name of ManyToOneField, ManyToManyRel, or ManyToOneRel field to filter
     """
     filterset_class = schema_type._meta.filterset_class
 
-    def resolve_filter(self, *args, **kwargs):
-        if not filterset_class:
+    def resolve_filter(self, info, **kwargs):
+        if not filterset_class or not kwargs:
             return getattr(self, field_name).all()
 
         # Inverse of substitution logic from get_filtering_args_from_filterset() - transform "_type" back to "type"

nautobot/core/graphql/schema.py

@@ -6,7 +6,8 @@ import logging
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.validators import ValidationError
-from django.db.models.fields.reverse_related import ManyToOneRel, OneToOneRel
+from django.db.models import ManyToManyField
+from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel, OneToOneRel
 import graphene
 from graphene.types import generic
 
@@ -198,9 +199,11 @@ def extend_schema_type_filter(schema_type, model):
         (DjangoObjectType): The extended schema_type object
     """
     for field in model._meta.get_fields():
-        # Check attribute is a ManyToOne field
-        # OneToOneRel is a subclass of ManyToOneRel, but we don't want to treat is as a list
-        if not isinstance(field, ManyToOneRel) or isinstance(field, OneToOneRel):
+        # Check whether attribute is a ManyToOne or ManyToMany field
+        if not isinstance(field, (ManyToManyField, ManyToManyRel, ManyToOneRel)):
+            continue
+        # OneToOneRel is a subclass of ManyToOneRel, but we don't want to treat it as a list
+        if isinstance(field, OneToOneRel):
             continue
         child_schema_type = registry["graphql_types"].get(field.related_model._meta.label_lower)
         if child_schema_type:
@@ -367,10 +370,9 @@ def extend_schema_type_relationships(schema_type, model):
     """Extend the schema type with attributes and resolvers corresponding
     to the relationships associated with this model."""
 
-    ct = ContentType.objects.get_for_model(model)
     relationships_by_side = {
-        "source": Relationship.objects.filter(source_type=ct),
-        "destination": Relationship.objects.filter(destination_type=ct),
+        "source": Relationship.objects.get_for_model_source(model),
+        "destination": Relationship.objects.get_for_model_destination(model),
     }
 
     prefix = ""

nautobot/core/jobs/__init__.py

@@ -1,3 +1,4 @@
+import codecs
 import contextlib
 from io import BytesIO
 
@@ -282,7 +283,9 @@ class ImportObjects(Job):
         if not csv_data and not csv_file:
             raise RunJobTaskFailed("Either csv_data or csv_file must be provided")
         if csv_file:
-            csv_bytes = csv_file
+            # data_encoding is utf-8 and file_encoding is utf-8-sig
+            # Bytes read from the original file are decoded according to file_encoding, and the result is encoded using data_encoding.
+            csv_bytes = codecs.EncodedFile(csv_file, "utf-8", "utf-8-sig")
         else:
             csv_bytes = BytesIO(csv_data.encode("utf-8"))
 

nautobot/core/settings.py

@@ -907,13 +907,24 @@ CELERY_TASK_TRACK_STARTED = True
 # If enabled, a `task-sent` event will be sent for every task so tasks can be tracked before they're consumed by a worker.
 CELERY_TASK_SEND_SENT_EVENT = True
 
+# How many tasks a worker is allowed to reserve for its own consumption and execution.
+# If set to zero (not recommended) a single worker can reserve all tasks even if other workers are free.
+# For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
+# Conversely, for long running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to 1
+# so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
+# until the long-running task completes.
+# https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits
+CELERY_WORKER_PREFETCH_MULTIPLIER = int(os.getenv("NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER", "4"))
+
 # If enabled stdout and stderr of running jobs will be redirected to the task logger.
 CELERY_WORKER_REDIRECT_STDOUTS = is_truthy(os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS", "True"))
 
-# The log level of log messages generated by redirected job stdout and stderr. Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
+# The log level of log messages generated by redirected job stdout and stderr.
+# Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
 CELERY_WORKER_REDIRECT_STDOUTS_LEVEL = os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS_LEVEL", "WARNING")
 
-# Send task-related events so that tasks can be monitored using tools like flower. Sets the default value for the workers -E argument.
+# Send task-related events so that tasks can be monitored using tools like flower.
+# Sets the default value for the workers -E argument.
 CELERY_WORKER_SEND_TASK_EVENTS = True
 
 # Default celery queue name that will be used by workers and tasks if no queue is specified

nautobot/core/settings.yaml

@@ -426,6 +426,20 @@ properties:
     see_also:
       "`CELERY_TASK_SOFT_TIME_LIMIT`": "#celery_task_soft_time_limit"
     type: "integer"
+  CELERY_WORKER_PREFETCH_MULTIPLIER:
+    default: 4
+    description: "How many tasks a worker is allowed to reserve for its own consumption and execution."
+    details: >-
+      If set to `0` (not recommended) a single worker can reserve all tasks even if other workers are free.
+      For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
+      Conversely, for long-running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to `1`
+      so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
+      until the long-running task completes.
+    environment_variable: "NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER"
+    see_also:
+      "Celery documentation": "https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits"
+    type: "integer"
+    version_added: "2.2.9"
   CELERY_WORKER_PROMETHEUS_PORTS:
     default: []
     description: "Ports for Prometheus metric HTTP server running on the celery worker(s)."

nautobot/core/templates/nautobot_config.py.j2

@@ -282,6 +282,15 @@ SECRET_KEY = os.getenv("NAUTOBOT_SECRET_KEY", "{{ secret_key }}")
 # CELERY_TASK_SOFT_TIME_LIMIT = int(os.getenv("NAUTOBOT_CELERY_TASK_SOFT_TIME_LIMIT", str(5 * 60)))
 # CELERY_TASK_TIME_LIMIT = int(os.getenv("NAUTOBOT_CELERY_TASK_TIME_LIMIT", str(10 * 60)))
 
+# How many tasks a worker is allowed to reserve for its own consumption and execution.
+# If set to zero (not recommended) a single worker can reserve all tasks even if other workers are free.
+# For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
+# Conversely, for long running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to 1
+# so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
+# until the long-running task completes.
+# https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits
+# CELERY_WORKER_PREFETCH_MULTIPLIER = int(os.getenv("NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER", "4"))
+
 # Ports for prometheus metric HTTP server running on the celery worker.
 # Normally this should be set to a single port, unless you have multiple workers running on a single machine, i.e.
 # sharing the same available ports. In that case you need to specify a range of ports greater than or equal to the
@@ -294,6 +303,12 @@ SECRET_KEY = os.getenv("NAUTOBOT_SECRET_KEY", "{{ secret_key }}")
 #         int(value) for value in os.getenv("NAUTOBOT_CELERY_WORKER_PROMETHEUS_PORTS").split(",")
 #     ]
 
+# If enabled stdout and stderr of running jobs will be redirected to the task logger.
+# CELERY_WORKER_REDIRECT_STDOUTS = is_truthy(os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS", "True"))
+
+# The log level of log messages generated by redirected job stdout and stderr.
+# Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
+# CELERY_WORKER_REDIRECT_STDOUTS_LEVEL = os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS_LEVEL", "WARNING")
 
 # Number of days to retain changelog entries. Set to 0 to retain changes indefinitely. Defaults to 90 if not set here.
 #

nautobot/core/tests/integration/test_general_functionality.py

@@ -0,0 +1,36 @@
+from django.urls import reverse
+
+from nautobot.core.testing.integration import SeleniumTestCase
+
+
+class StaticMediaFailureTestCase(SeleniumTestCase):
+    """Integration test to make sure no static media failures are encountered."""
+
+    def setUp(self):
+        super().setUp()
+        self.user.is_superuser = True
+        self.user.is_staff = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+    def tearDown(self):
+        self.logout()
+        super().tearDown()
+
+    def test_for_static_media_failure(self):
+        test_urls = [
+            reverse("home"),
+            reverse("api-root"),
+            reverse("graphql"),
+            reverse("api_docs"),
+            "/admin/",
+            "/static/docs/index.html",
+        ]
+        for url in test_urls:
+            with self.subTest(test_url=url):
+                self.browser.visit(self.live_server_url + url)
+                # Wait for body element to appear
+                self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=10), "Page failed to load")
+                # Ensure we weren't redirected to another page
+                self.assertEqual(self.browser.url, self.live_server_url + url)
+                self.assertTrue(self.browser.is_text_not_present("Static Media Failure"))

nautobot/core/tests/test_graphql.py

@@ -729,8 +729,8 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.location_type = LocationType.objects.get(name="Campus")
         cls.location1 = Location.objects.filter(location_type=cls.location_type).first()
         cls.location2 = Location.objects.filter(location_type=cls.location_type).last()
-        cls.location1.name = "Location-1"
-        cls.location2.name = "Location-2"
+        cls.location1.name = "Campus Location-1"
+        cls.location2.name = "Campus Location-2"
         cls.location1.status = cls.location_statuses[0]
         cls.location2.status = cls.location_statuses[1]
         cls.location1.validated_save()
@@ -930,6 +930,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.prefix1 = Prefix.objects.create(
             prefix="10.0.1.0/24", namespace=cls.namespace, status=cls.prefix_statuses[0]
         )
+        cls.prefix1.locations.add(cls.location1, cls.location2)
         cls.ipaddr1 = IPAddress.objects.create(
             address="10.0.1.1/24", namespace=cls.namespace, status=cls.ip_statuses[0]
         )
@@ -968,6 +969,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.prefix2 = Prefix.objects.create(
             prefix="10.0.2.0/24", namespace=cls.namespace, status=cls.prefix_statuses[1]
         )
+        cls.prefix2.locations.add(cls.location1, cls.location2)
         cls.ipaddr2 = IPAddress.objects.create(
             address="10.0.2.1/30", namespace=cls.namespace, status=cls.ip_statuses[1]
         )
@@ -1507,9 +1509,9 @@ query {
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_locations_filter(self):
         filters = (
-            ('name: "Location-1"', 1),
-            ('name: ["Location-1"]', 1),
-            ('name: ["Location-1", "Location-2"]', 2),
+            ('name: "Campus Location-1"', 1),
+            ('name: ["Campus Location-1"]', 1),
+            ('name: ["Campus Location-1", "Campus Location-2"]', 2),
             ('name__ic: "Location"', Location.objects.filter(name__icontains="Location").count()),
             ('name__ic: ["Location"]', Location.objects.filter(name__icontains="Location").count()),
             ('name__nic: "Location"', Location.objects.exclude(name__icontains="Location").count()),
@@ -1541,6 +1543,50 @@ query {
                 self.assertIsNone(result.errors)
                 self.assertEqual(len(result.data["locations"]), nbr_expected_results)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_query_prefixes_nested_m2m_filter(self):
+        """
+        Test functionality added to address https://github.com/nautobot/nautobot/issues/5906.
+
+        Prefix.locations is a ManyToManyField, which was not filterable in our GraphQL schema before this fix.
+        """
+        query = 'query { prefixes (prefix_length__gte:16) { prefix locations (location_type:["Campus"]) { name } } }'
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        found_valid_location = False
+        found_invalid_location = False
+        for prefix_data in result.data["prefixes"]:
+            for location_data in prefix_data["locations"]:
+                if location_data["name"].startswith("Campus"):
+                    found_valid_location = True
+                else:
+                    print(f"Found unexpected unfiltered location {location_data['name']} under {prefix_data['prefix']}")
+                    found_invalid_location = True
+        self.assertTrue(found_valid_location)
+        self.assertFalse(found_invalid_location)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_query_locations_nested_reverse_m2m_filter(self):
+        """
+        Test functionality added to address https://github.com/nautobot/nautobot/issues/5906.
+
+        Location.prefixes is a (reverse) ManyToManyRel, which was not filterable in our GraphQL schema before this fix.
+        """
+        query = "query { locations { name prefixes (prefix_length:24) { prefix } } }"
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        found_valid_prefix = False
+        found_invalid_prefix = False
+        for location_data in result.data["locations"]:
+            for prefix_data in location_data["prefixes"]:
+                if prefix_data["prefix"].endswith("/24"):
+                    found_valid_prefix = True
+                else:
+                    print(f"Found unexpected unfiltered prefix {prefix_data['prefix']} under {location_data['name']}")
+                    found_invalid_prefix = True
+        self.assertTrue(found_valid_prefix)
+        self.assertFalse(found_invalid_prefix)
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_devices_filter(self):
         filterset_class = DeviceFilterSet

nautobot/core/tests/test_jobs.py

@@ -1,12 +1,22 @@
 from pathlib import Path
 
 from django.contrib.contenttypes.models import ContentType
+from django.core.files.base import ContentFile
 import yaml
 
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
-from nautobot.dcim.models import DeviceType, Location, LocationType, Manufacturer
+from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
-from nautobot.extras.models import Contact, ContactAssociation, ExportTemplate, JobLogEntry, Role, Status
+from nautobot.extras.models import (
+    Contact,
+    ContactAssociation,
+    ExportTemplate,
+    FileProxy,
+    JobLogEntry,
+    Role,
+    Status,
+)
+from nautobot.ipam.models import Prefix
 from nautobot.users.models import ObjectPermission
 
 
@@ -204,6 +214,76 @@ class ImportObjectsTestCase(TransactionTestCase):
         )
         self.assertEqual(4, Status.objects.filter(name__startswith="test_status").count())
 
+    def test_csv_import_with_utf_8_with_bom_encoding(self):
+        """
+        A superuser running the job with a .csv file with utf_8 with bom encoding should successfully create all specified objects.
+        Test for bug fix https://github.com/nautobot/nautobot/issues/5812 and https://github.com/nautobot/nautobot/issues/5985
+        """
+
+        status = Status.objects.get(name="Active").pk
+        content = f"prefix,status\n192.168.1.1/32,{status}"
+        content = content.encode("utf-8-sig")
+        filename = "test.csv"
+        csv_file = FileProxy.objects.create(name=filename, file=ContentFile(content, name=filename))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ImportObjects",
+            content_type=ContentType.objects.get_for_model(Prefix).pk,
+            csv_file=csv_file.id,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+        self.assertEqual(
+            1, Prefix.objects.filter(status=Status.objects.get(name="Active"), prefix="192.168.1.1/32").count()
+        )
+        mfr = Manufacturer.objects.create(name="Test Cisco Manufacturer")
+        device_type = DeviceType.objects.create(
+            manufacturer=mfr,
+            model="Cisco CSR1000v",
+            u_height=0,
+        )
+        location_type = LocationType.objects.create(name="Test Location Type")
+        location_type.content_types.set([ContentType.objects.get_for_model(Device)])
+        location = Location.objects.create(
+            name="Device Location",
+            location_type=location_type,
+            status=Status.objects.get_for_model(Location).first(),
+        )
+        role = Role.objects.create(name="Device Status")
+        role.content_types.set([ContentType.objects.get_for_model(Device)])
+        content = "\n".join(
+            [
+                "serial,asset_tag,device_type,location,status,name,role",
+                f"1021C4,CA211,{device_type.pk},{location.pk},{status},Test-AC-01,{role}",
+                f"1021C5,CA212,{device_type.pk},{location.pk},{status},Test-AC-02,{role}",
+            ]
+        )
+        content = content.encode("utf-8-sig")
+        filename = "test.csv"
+        csv_file = FileProxy.objects.create(name=filename, file=ContentFile(content, name=filename))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ImportObjects",
+            content_type=ContentType.objects.get_for_model(Device).pk,
+            csv_file=csv_file.id,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+        device_1 = Device.objects.get(name="Test-AC-01")
+        device_2 = Device.objects.get(name="Test-AC-02")
+        self.assertEqual(device_1.serial, "1021C4")
+        self.assertEqual(device_2.serial, "1021C5")
+
     def test_csv_import_bad_row(self):
         """A row of incorrect data should fail validation for that object but import all others successfully if `roll_back_if_error` is False."""
         csv_data = self.csv_data.split("\n")

nautobot/core/tests/test_templatetags_netutils.py

@@ -20,15 +20,15 @@ class NautobotTemplateTagsNetutilsTest(TestCase):
                 i = 1
                 for param_name, param in signature.parameters.items():
                     template_string += f" {param_name}="
-                    if param.annotation == str:
+                    if param.annotation is str:
                         template_string += f'"{i}"'
-                    elif param.annotation == bool:
+                    elif param.annotation is bool:
                         template_string += "True"
                     elif param.annotation in (int, float):
                         template_string += str(i)
                     elif param.annotation in (list, tuple):
                         template_string += "[]"
-                    elif param.annotation == dict:
+                    elif param.annotation is dict:
                         template_string += "{}"
                     else:
                         template_string += "None"

nautobot/dcim/models/device_components.py

@@ -24,6 +24,7 @@ from nautobot.dcim.choices import (
     PowerOutletFeedLegChoices,
     PowerOutletTypeChoices,
     PowerPortTypeChoices,
+    SubdeviceRoleChoices,
 )
 from nautobot.dcim.constants import (
     NONCONNECTABLE_IFACE_TYPES,
@@ -1019,6 +1020,12 @@ class DeviceBay(ComponentModel):
                         "installed_device": f"Cannot install the specified device; device is already installed in {current_bay}"
                     }
                 )
+            if self.installed_device.device_type.subdevice_role != SubdeviceRoleChoices.ROLE_CHILD:
+                raise ValidationError(
+                    {
+                        "installed_device": f'Cannot install device "{self.installed_device}"; device-type "{self.installed_device.device_type}" subdevice_role is not "child".'
+                    }
+                )
 
     @property
     def parent(self):

nautobot/dcim/models/devices.py

@@ -832,9 +832,16 @@ class Device(PrimaryModel, ConfigContextModel):
         # Update Location and Rack assignment for any child Devices
         devices = Device.objects.filter(parent_bay__device=self)
         for device in devices:
-            device.location = self.location
-            device.rack = self.rack
-            device.save()
+            save_child_device = False
+            if device.location != self.location:
+                device.location = self.location
+                save_child_device = True
+            if device.rack != self.rack:
+                device.rack = self.rack
+                save_child_device = True
+
+            if save_child_device:
+                device.save()
 
     def create_components(self):
         """Create device components from the device type definition."""
@@ -1058,6 +1065,10 @@ class DeviceRedundancyGroup(PrimaryModel):
     def devices_sorted(self):
         return self.devices.order_by("device_redundancy_group_priority")
 
+    @property
+    def controllers_sorted(self):
+        return self.controllers.order_by("name")
+
     def __str__(self):
         return self.name
 

nautobot/dcim/tables/devices.py

@@ -938,17 +938,32 @@ class VirtualChassisTable(BaseTable):
 class DeviceRedundancyGroupTable(BaseTable):
     pk = ToggleColumn()
     name = tables.Column(linkify=True)
-    device_count = tables.TemplateColumn(
-        template_code=LINKED_RECORD_COUNT,
+    device_count = LinkedCountColumn(
+        viewname="dcim:device_list",
+        url_params={"device_redundancy_group": "pk"},
         verbose_name="Devices",
     )
+    controller_count = LinkedCountColumn(
+        viewname="dcim:controller_list",
+        url_params={"controller_device_redundancy_group": "pk"},
+        verbose_name="Controllers",
+    )
     secrets_group = tables.Column(linkify=True)
     tags = TagColumn(url_name="dcim:deviceredundancygroup_list")
 
     class Meta(BaseTable.Meta):
         model = DeviceRedundancyGroup
-        fields = ("pk", "name", "status", "failover_strategy", "device_count", "secrets_group", "tags")
-        default_columns = ("pk", "name", "status", "failover_strategy", "device_count")
+        fields = (
+            "pk",
+            "name",
+            "status",
+            "failover_strategy",
+            "controller_count",
+            "device_count",
+            "secrets_group",
+            "tags",
+        )
+        default_columns = ("pk", "name", "status", "failover_strategy", "controller_count", "device_count")
 
 
 #

nautobot/dcim/templates/dcim/deviceredundancygroup_retrieve.html

@@ -45,6 +45,12 @@
 {% endblock content_right_page %}
 
 {% block content_full_width_page %}
+        <div class="panel panel-default">
+            <div class="panel-heading">
+                <strong>Controllers</strong>
+            </div>
+            {% include 'responsive_table.html' with table=controllers_table %}
+        </div>
         <div class="panel panel-default">
             <div class="panel-heading">
                 <strong>Devices</strong>