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

nautobot/dcim/tests/test_models.py

@@ -16,6 +16,7 @@ from nautobot.dcim.choices import (
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerOutletFeedLegChoices,
+    SubdeviceRoleChoices,
 )
 from nautobot.dcim.models import (
     Cable,
@@ -886,6 +887,13 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         self.device_type = DeviceType.objects.create(
             manufacturer=manufacturer,
             model="Test Device Type 1",
+            subdevice_role=SubdeviceRoleChoices.ROLE_PARENT,
+        )
+        self.child_devicetype = DeviceType.objects.create(
+            model="Child Device Type 1",
+            manufacturer=manufacturer,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+            u_height=0,
         )
         self.device_role = Role.objects.get_for_model(Device).first()
         self.device_status = Status.objects.get_for_model(Device).first()
@@ -1188,6 +1196,104 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         self.device_type.software_image_files.add(software_image_file)
         self.device.validated_save()
 
+    def test_child_devices_are_not_saved_when_unnecessary(self):
+        parent_device = Device.objects.create(
+            name="Parent Device 1",
+            location=self.location_3,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        parent_device.validated_save()
+
+        child_device = Device.objects.create(
+            name="Child Device 1",
+            location=parent_device.location,
+            device_type=self.child_devicetype,
+            role=parent_device.role,
+            status=self.device_status,
+        )
+        child_device.validated_save()
+        child_mtime_before_parent_saved = str(child_device.last_updated)
+
+        devicebay = DeviceBay.objects.get(device=parent_device, name="Device Bay 1")
+        devicebay.installed_device = child_device
+        devicebay.validated_save()
+
+        #
+        # Tests
+        #
+
+        #
+        # On a NOOP save, the child device shouldn't be updated
+        parent_device.save()
+
+        child_mtime_after_parent_noop_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertEqual(child_mtime_before_parent_saved, child_mtime_after_parent_noop_save)
+
+        #
+        # On a serial number update, the child device shouldn't be updated
+        parent_device.serial = "12345"
+        parent_device.save()
+
+        child_mtime_after_parent_serial_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertEqual(child_mtime_before_parent_saved, child_mtime_after_parent_serial_update_save)
+
+        #
+        # If the parent rack updates, the child mtime should update.
+        rack = Rack.objects.create(name="Rack 1", location=parent_device.location, status=self.device_status)
+        parent_device.rack = rack
+        parent_device.save()
+
+        child_mtime_after_parent_rack_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertNotEqual(child_mtime_after_parent_noop_save, child_mtime_after_parent_rack_update_save)
+
+        #
+        # If the parent site updates, the child mtime should update
+        location = Location.objects.create(
+            name="New Site 1", status=self.device_status, location_type=self.location_type_3
+        )
+        parent_device.location = location
+        parent_device.save()
+
+        child_mtime_after_parent_site_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertNotEqual(child_mtime_after_parent_rack_update_save, child_mtime_after_parent_site_update_save)
+
+
+class DeviceBayTestCase(ModelTestCases.BaseModelTestCase):
+    model = DeviceBay
+
+    def setUp(self):
+        self.devices = Device.objects.filter(device_type__subdevice_role=SubdeviceRoleChoices.ROLE_PARENT)
+        devicetype = DeviceType.objects.create(
+            manufacturer=self.devices[0].device_type.manufacturer,
+            model="TestDeviceType1",
+            u_height=0,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+        )
+        child_device = Device.objects.create(
+            device_type=devicetype,
+            role=self.devices[0].role,
+            name="TestDevice1",
+            status=self.devices[0].status,
+            location=self.devices[0].location,
+        )
+        DeviceBay.objects.create(device=self.devices[0], name="Device Bay 1", installed_device=child_device)
+
+    def test_assigning_installed_device(self):
+        server = Device.objects.exclude(device_type__subdevice_role=SubdeviceRoleChoices.ROLE_CHILD).last()
+        bay = DeviceBay(device=self.devices[1], name="Device Bay Err", installed_device=server)
+        with self.assertRaises(ValidationError) as err:
+            bay.validated_save()
+        self.assertIn(
+            f'Cannot install device "{server}"; device-type "{server.device_type}" subdevice_role is not "child".',
+            str(err.exception),
+        )
+
 
 class DeviceTypeToSoftwareImageFileTestCase(ModelTestCases.BaseModelTestCase):
     model = DeviceTypeToSoftwareImageFile

nautobot/dcim/tests/test_views.py

@@ -1789,6 +1789,19 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
                 sorted(interface_ips),
             )
 
+        with self.subTest("Assert Assigning IPAddress Without Selecting Any IPAddress Raises Exception"):
+            assign_ip_form_data["pk"] = []
+            assign_ip_request = {
+                "path": reverse("ipam:ipaddress_assign")
+                + f"?interface={self.interfaces[1].id}&return_url={device_list_url}",
+                "data": post_data(assign_ip_form_data),
+            }
+            response = self.client.post(**assign_ip_request, follow=True)
+            self.assertHttpStatus(response, 200)
+            self.assertIn(
+                "Please select at least one IP Address from the table.", response.content.decode(response.charset)
+            )
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_device_rearports(self):
         device = Device.objects.first()

nautobot/dcim/views.py

@@ -3029,8 +3029,11 @@ class DeviceRedundancyGroupUIViewSet(NautobotUIViewSet):
     form_class = forms.DeviceRedundancyGroupForm
     queryset = (
         DeviceRedundancyGroup.objects.select_related("status")
-        .prefetch_related("devices")
-        .annotate(device_count=count_related(Device, "device_redundancy_group"))
+        .prefetch_related("controllers", "devices")
+        .annotate(
+            device_count=count_related(Device, "device_redundancy_group"),
+            controller_count=count_related(Controller, "controller_device_redundancy_group"),
+        )
     )
     serializer_class = serializers.DeviceRedundancyGroupSerializer
     table_class = tables.DeviceRedundancyGroupTable
@@ -3043,6 +3046,9 @@ class DeviceRedundancyGroupUIViewSet(NautobotUIViewSet):
             devices_table = tables.DeviceTable(devices)
             devices_table.columns.show("device_redundancy_group_priority")
             context["devices_table"] = devices_table
+            controllers = instance.controllers_sorted.restrict(request.user)
+            controllers_table = tables.ControllerTable(controllers)
+            context["controllers_table"] = controllers_table
         return context
 
 

nautobot/extras/api/views.py

@@ -1,5 +1,3 @@
-from datetime import timedelta
-
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.forms import ValidationError as FormsValidationError
@@ -449,59 +447,6 @@ class ImageAttachmentViewSet(ModelViewSet):
 #
 
 
-def _create_schedule(serializer, data, job_model, user, approval_required, task_queue=None):
-    """
-    This is an internal function to create a scheduled job from API data.
-    It has to handle both once-offs (i.e. of type TYPE_FUTURE) and interval
-    jobs.
-    """
-    type_ = serializer["interval"]
-    if type_ == JobExecutionType.TYPE_IMMEDIATELY:
-        time = timezone.now()
-        name = serializer.get("name") or f"{job_model.name} - {time}"
-    elif type_ == JobExecutionType.TYPE_CUSTOM:
-        time = serializer.get("start_time")  # doing .get("key", "default") returns None instead of "default"
-        if time is None:
-            # "start_time" is checked against models.ScheduledJob.earliest_possible_time()
-            # which returns timezone.now() + timedelta(seconds=15)
-            time = timezone.now() + timedelta(seconds=20)
-        name = serializer["name"]
-    else:
-        time = serializer["start_time"]
-        name = serializer["name"]
-    crontab = serializer.get("crontab", "")
-
-    celery_kwargs = {
-        "nautobot_job_profile": False,
-        "queue": task_queue,
-    }
-
-    # 2.0 TODO: To revisit this as part of a larger Jobs cleanup in 2.0.
-    #
-    # We pass in task and job_model here partly for forward/backward compatibility logic, and
-    # part fallback safety. It's mildly useful to store both the task module/class name and the JobModel
-    # FK on the ScheduledJob, as in the case where the JobModel gets deleted (and the FK becomes
-    # null) you still have a bit of context on the ScheduledJob as to what it was originally
-    # scheduled for.
-    scheduled_job = ScheduledJob(
-        name=name,
-        task=job_model.class_path,
-        job_model=job_model,
-        start_time=time,
-        description=f"Nautobot job {name} scheduled by {user} for {time}",
-        kwargs=data,
-        celery_kwargs=celery_kwargs,
-        interval=type_,
-        one_off=(type_ == JobExecutionType.TYPE_FUTURE),
-        user=user,
-        approval_required=approval_required,
-        crontab=crontab,
-        queue=task_queue,
-    )
-    scheduled_job.validated_save()
-    return scheduled_job
-
-
 class JobViewSetBase(
     NautobotAPIVersionMixin,
     # note no CreateModelMixin
@@ -701,13 +646,16 @@ class JobViewSetBase(
 
         # Try to create a ScheduledJob, or...
         if schedule_data:
-            schedule = _create_schedule(
-                schedule_data,
-                job_class.serialize_data(cleaned_data),
+            schedule = ScheduledJob.create_schedule(
                 job_model,
                 request.user,
-                approval_required,
+                name=schedule_data.get("name"),
+                start_time=schedule_data.get("start_time"),
+                interval=schedule_data.get("interval"),
+                crontab=schedule_data.get("crontab", ""),
+                approval_required=approval_required,
                 task_queue=input_serializer.validated_data.get("task_queue", None),
+                **job_class.serialize_data(cleaned_data),
             )
         else:
             schedule = None

nautobot/extras/homepage.py

@@ -7,14 +7,24 @@ def get_job_results(request):
     """Callback function to collect job history for panel."""
     return (
         JobResult.objects.filter(status__in=JobResultStatusChoices.READY_STATES)
-        .defer("result")
+        .restrict(request.user, "view")
+        .only("id", "name", "status", "date_done", "user")
         .order_by("-date_done")[:10]
     )
 
 
 def get_changelog(request):
     """Callback function to collect changelog for panel."""
-    return ObjectChange.objects.restrict(request.user, "view")[:15]
+    return ObjectChange.objects.restrict(request.user, "view").only(
+        "id",
+        "action",
+        "changed_object",
+        "changed_object_id",
+        "changed_object_type",
+        "object_repr",
+        "user_name",
+        "time",
+    )[:15]
 
 
 layout = (

nautobot/extras/jobs.py

@@ -20,7 +20,7 @@ from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
-from django.core.files.uploadedfile import InMemoryUploadedFile
+from django.core.files.uploadedfile import UploadedFile
 from django.core.validators import RegexValidator
 from django.db.models import Model
 from django.db.models.query import QuerySet
@@ -539,7 +539,7 @@ class BaseJob:
             elif isinstance(value, Model):
                 return_data[field_name] = value.pk
             # FileVar (Save each FileVar as a FileProxy)
-            elif isinstance(value, InMemoryUploadedFile):
+            elif isinstance(value, UploadedFile):
                 return_data[field_name] = BaseJob._save_file_to_proxy(value)
             # IPAddressVar, IPAddressWithMaskVar, IPNetworkVar
             elif isinstance(value, netaddr.ip.BaseIP):

nautobot/extras/models/jobs.py

@@ -1074,6 +1074,87 @@ class ScheduledJob(BaseModel):
             day_of_week=day_of_week,
         )
 
+    @classmethod
+    def create_schedule(
+        cls,
+        job_model,
+        user,
+        name=None,
+        start_time=None,
+        interval=JobExecutionType.TYPE_IMMEDIATELY,
+        crontab="",
+        profile=False,
+        approval_required=False,
+        task_queue=None,
+        **job_kwargs,
+    ):
+        """
+        Schedule a job with the specified parameters.
+
+        This method creates a schedule for a job to be executed at a specific time
+        or interval. It handles immediate execution, custom start times, and
+        crontab-based scheduling.
+
+        Parameters:
+            job_model (JobModel): The job model instance.
+            user (User): The user who is scheduling the job.
+            name (str, optional): The name of the scheduled job. Defaults to None.
+            start_time (datetime, optional): The start time for the job. Defaults to None.
+            interval (JobExecutionType, optional): The interval type for the job execution.
+                Defaults to JobExecutionType.TYPE_IMMEDIATELY.
+            crontab (str, optional): The crontab string for the schedule. Defaults to "".
+            profile (bool, optional): Flag indicating whether to profile the job. Defaults to False.
+            approval_required (bool, optional): Flag indicating if approval is required. Defaults to False.
+            task_queue (str, optional): The task queue for the job. Defaults to None, which will use the configured default celery queue.
+            **job_kwargs: Additional keyword arguments to pass to the job.
+
+        Returns:
+            ScheduledJob instance
+        """
+
+        if interval == JobExecutionType.TYPE_IMMEDIATELY:
+            start_time = timezone.now()
+            name = name or f"{job_model.name} - {start_time}"
+        elif interval == JobExecutionType.TYPE_CUSTOM:
+            if start_time is None:
+                # "start_time" is checked against models.ScheduledJob.earliest_possible_time()
+                # which returns timezone.now() + timedelta(seconds=15)
+                start_time = timezone.now() + timedelta(seconds=20)
+
+        celery_kwargs = {
+            "nautobot_job_profile": profile,
+            "queue": task_queue,
+        }
+        if job_model.soft_time_limit > 0:
+            celery_kwargs["soft_time_limit"] = job_model.soft_time_limit
+        if job_model.time_limit > 0:
+            celery_kwargs["time_limit"] = job_model.time_limit
+
+        # 2.0 TODO: To revisit this as part of a larger Jobs cleanup in 2.0.
+        #
+        # We pass in task and job_model here partly for forward/backward compatibility logic, and
+        # part fallback safety. It's mildly useful to store both the task module/class name and the JobModel
+        # FK on the ScheduledJob, as in the case where the JobModel gets deleted (and the FK becomes
+        # null) you still have a bit of context on the ScheduledJob as to what it was originally
+        # scheduled for.
+        scheduled_job = cls(
+            name=name,
+            task=job_model.class_path,
+            job_model=job_model,
+            start_time=start_time,
+            description=f"Nautobot job {name} scheduled by {user} for {start_time}",
+            kwargs=job_kwargs,
+            celery_kwargs=celery_kwargs,
+            interval=interval,
+            one_off=(interval == JobExecutionType.TYPE_FUTURE),
+            user=user,
+            approval_required=approval_required,
+            crontab=crontab,
+            queue=task_queue,
+        )
+        scheduled_job.validated_save()
+        return scheduled_job
+
     def to_cron(self):
         t = self.start_time
         if self.interval == JobExecutionType.TYPE_HOURLY:

nautobot/extras/models/relationships.py

@@ -244,6 +244,18 @@ class RelationshipModel(models.Model):
             if relation.skip_required(cls, opposite_side):
                 continue
 
+            if getattr(relation, f"{relation.required_on}_filter") and instance:
+                filterset = get_filterset_for_model(cls)
+                if filterset:
+                    filter_params = getattr(relation, f"{relation.required_on}_filter")
+                    # If the relationship is required on the model, but the object is not in the filter,
+                    # we should allow the object to be saved, as the object is not part of the relationship.
+                    # Example: We want a Device with a Role of Switch to be required to have a relationship
+                    # with a Device that has a Role of Router. A Device with a Role of Printer should
+                    # be exempt from the requirement.
+                    if not filterset(filter_params, cls.objects.filter(id=instance.id)).qs.exists():
+                        continue
+
             if relation.has_many(opposite_side):
                 num_required_verbose = "at least one"
             else:

nautobot/extras/signals.py

@@ -15,7 +15,7 @@ from django.core.cache import cache
 from django.core.exceptions import ValidationError
 from django.core.files.storage import get_storage_class
 from django.db import transaction
-from django.db.models.signals import m2m_changed, post_delete, post_save, pre_delete, pre_save
+from django.db.models.signals import m2m_changed, post_delete, post_migrate, post_save, pre_delete, pre_save
 from django.dispatch import receiver
 from django.utils import timezone
 from django_prometheus.models import model_deletes, model_inserts, model_updates
@@ -268,6 +268,19 @@ def _handle_deleted_object(sender, instance, **kwargs):
     model_deletes.labels(instance._meta.model_name).inc()
 
 
+#
+# Content types
+#
+
+
+@receiver(post_migrate)
+def post_migrate_clear_content_type_caches(sender, app_config, signal, **kwargs):
+    """Clear various content-type caches after a migration."""
+    with contextlib.suppress(redis.exceptions.ConnectionError):
+        cache.delete("nautobot.extras.utils.change_logged_models_queryset")
+        cache.delete_pattern("nautobot.extras.utils.FeatureQuery.*")
+
+
 #
 # Custom fields
 #

nautobot/extras/tables.py

@@ -99,6 +99,7 @@ GITREPOSITORY_BUTTONS = """
 
 JOB_BUTTONS = """
 <a href="{% url 'extras:job' pk=record.pk %}" class="btn btn-default btn-xs" title="Details"><i class="mdi mdi-information-outline" aria-hidden="true"></i></a>
+<a href="{% url 'extras:jobresult_list' %}?job_model={{ record.name | urlencode }}" class="btn btn-default btn-xs" title="Job Results"><i class="mdi mdi-format-list-bulleted" aria-hidden="true"></i></a>
 """
 
 OBJECTCHANGE_OBJECT = """
@@ -639,7 +640,10 @@ class JobTable(BaseTable):
         return render_markdown(value)
 
     def render_name(self, value):
-        return format_html('<span class="btn btn-primary btn-xs"><i class="mdi mdi-play"></i></span>{}', value)
+        return format_html(
+            '<span class="btn btn-primary btn-xs"><i class="mdi mdi-play"></i></span>{}',
+            value,
+        )
 
     class Meta(BaseTable.Meta):
         model = JobModel
@@ -811,7 +815,16 @@ class JobResultTable(BaseTable):
             "summary",
             "actions",
         )
-        default_columns = ("pk", "date_created", "name", "job_model", "user", "status", "summary", "actions")
+        default_columns = (
+            "pk",
+            "date_created",
+            "name",
+            "job_model",
+            "user",
+            "status",
+            "summary",
+            "actions",
+        )
 
 
 class JobButtonTable(BaseTable):
@@ -953,7 +966,15 @@ class RelationshipAssociationTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = RelationshipAssociation
-        fields = ("pk", "relationship", "source_type", "source", "destination_type", "destination", "actions")
+        fields = (
+            "pk",
+            "relationship",
+            "source_type",
+            "source",
+            "destination_type",
+            "destination",
+            "actions",
+        )
         default_columns = ("pk", "relationship", "source", "destination", "actions")
 
 
@@ -1069,7 +1090,15 @@ class TagTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = Tag
-        fields = ("pk", "name", "items", "color", "content_types", "description", "actions")
+        fields = (
+            "pk",
+            "name",
+            "items",
+            "color",
+            "content_types",
+            "description",
+            "actions",
+        )
 
 
 class TaggedItemTable(BaseTable):
@@ -1149,7 +1178,9 @@ class WebhookTable(BaseTable):
 class AssociatedContactsTable(StatusTableMixin, RoleTableMixin, BaseTable):
     pk = ToggleColumn()
     contact_type = tables.TemplateColumn(
-        CONTACT_OR_TEAM_ICON, verbose_name="Type", attrs={"td": {"style": "width:20px;"}}
+        CONTACT_OR_TEAM_ICON,
+        verbose_name="Type",
+        attrs={"td": {"style": "width:20px;"}},
     )
     name = tables.TemplateColumn(CONTACT_OR_TEAM, verbose_name="Name")
     contact_or_team_phone = tables.TemplateColumn(PHONE, accessor="contact_or_team.phone", verbose_name="Phone")

nautobot/extras/templates/extras/job_detail.html

@@ -115,6 +115,17 @@
                 <td>{{ object.enabled | render_boolean }}</td>
                 <td></td>
             </tr>
+            <tr>
+                <td>Job Results</td>
+                <td>
+                    {% if object.job_results.exists %}
+                        <a href="{% url 'extras:jobresult_list' %}?job_model={{ object.name | urlencode }}">{{ object.job_results.count }}</a>
+                    {% else %}
+                        {{ None|placeholder }}
+                    {% endif %}
+                </td>
+                <td></td>
+            </tr>
         </table>
     </div>
 {% endblock content_left_page %}

nautobot/extras/tests/integration/test_dynamicgroups.py

@@ -74,7 +74,7 @@ class DynamicGroupTestCase(SeleniumTestCase):
 
         # And just a cursory check to make sure that the filter worked.
         group = DynamicGroup.objects.get(name=name)
-        self.assertEqual(group.count, len(devices))
+        self.assertEqual(group.count, Device.objects.filter(status__name="Active").count())
         self.assertEqual(group.filter, {"status": ["Active"]})
 
         # Verify dynamic group shows up on device detail tab