nautobot 2.3.1__py3-none-any.whl → 2.3.3__py3-none-any.whl

nautobot/extras/models/jobs.py

@@ -4,7 +4,6 @@ import contextlib
 from datetime import timedelta
 import logging
 
-from celery import schedules
 from celery.exceptions import NotRegistered
 from celery.utils.log import get_logger, LoggingProxy
 from django.conf import settings
@@ -16,7 +15,9 @@ from django.db.models import signals
 from django.utils import timezone
 from django.utils.functional import cached_property
 from django_celery_beat.clockedschedule import clocked
+from django_celery_beat.tzcrontab import TzAwareCrontab
 from prometheus_client import Histogram
+from timezone_field import TimeZoneField
 
 from nautobot.core.celery import (
     app,
@@ -935,6 +936,9 @@ class ScheduledJob(BaseModel):
         verbose_name="Start Datetime",
         help_text="Datetime when the schedule should begin triggering the task to run",
     )
+    # Django always stores DateTimeField as UTC internally, but we want scheduled jobs to respect DST and similar,
+    # so we need to store the time zone the job was scheduled under as well.
+    time_zone = TimeZoneField(default=timezone.get_default_timezone_name)
     # todoindex:
     enabled = models.BooleanField(
         default=True,
@@ -1005,12 +1009,15 @@ class ScheduledJob(BaseModel):
     def __str__(self):
         return f"{self.name}: {self.interval}"
 
+    class Meta:
+        ordering = ["name"]
+
     def save(self, *args, **kwargs):
         self.queue = self.queue or ""
         # make sure non-valid crontab doesn't get saved
         if self.interval == JobExecutionType.TYPE_CUSTOM:
             try:
-                self.get_crontab(self.crontab)
+                self.get_crontab(self.crontab, tz=self.time_zone)
             except Exception as e:
                 raise ValidationError({"crontab": e})
         if not self.enabled:
@@ -1055,7 +1062,7 @@ class ScheduledJob(BaseModel):
         return timezone.now() + timedelta(seconds=15)
 
     @classmethod
-    def get_crontab(cls, crontab):
+    def get_crontab(cls, crontab, tz=None):
         """
         Wrapper method translates crontab syntax to Celery crontab.
 
@@ -1068,13 +1075,17 @@ class ScheduledJob(BaseModel):
 
         No support for Last (L), Weekday (W), Number symbol (#), Question mark (?), and special @ strings.
         """
+        if not tz:
+            tz = timezone.get_default_timezone()
         minute, hour, day_of_month, month_of_year, day_of_week = crontab.split(" ")
-        return schedules.crontab(
+
+        return TzAwareCrontab(
             minute=minute,
             hour=hour,
             day_of_month=day_of_month,
             month_of_year=month_of_year,
             day_of_week=day_of_week,
+            tz=tz,
         )
 
     @classmethod
@@ -1116,13 +1127,13 @@ class ScheduledJob(BaseModel):
         """
 
         if interval == JobExecutionType.TYPE_IMMEDIATELY:
-            start_time = timezone.now()
+            start_time = timezone.localtime()
             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)
+                start_time = timezone.localtime() + timedelta(seconds=20)
 
         celery_kwargs = {
             "nautobot_job_profile": profile,
@@ -1145,6 +1156,7 @@ class ScheduledJob(BaseModel):
             task=job_model.class_path,
             job_model=job_model,
             start_time=start_time,
+            time_zone=start_time.tzinfo,
             description=f"Nautobot job {name} scheduled by {user} for {start_time}",
             kwargs=job_kwargs,
             celery_kwargs=celery_kwargs,
@@ -1159,15 +1171,16 @@ class ScheduledJob(BaseModel):
         return scheduled_job
 
     def to_cron(self):
-        t = self.start_time
+        tz = self.time_zone
+        t = self.start_time.astimezone(tz)
         if self.interval == JobExecutionType.TYPE_HOURLY:
-            return schedules.crontab(minute=t.minute)
+            return TzAwareCrontab(minute=t.minute, tz=tz)
         elif self.interval == JobExecutionType.TYPE_DAILY:
-            return schedules.crontab(minute=t.minute, hour=t.hour)
+            return TzAwareCrontab(minute=t.minute, hour=t.hour, tz=tz)
         elif self.interval == JobExecutionType.TYPE_WEEKLY:
-            return schedules.crontab(minute=t.minute, hour=t.hour, day_of_week=t.strftime("%w"))
+            return TzAwareCrontab(minute=t.minute, hour=t.hour, day_of_week=t.strftime("%w"), tz=tz)
         elif self.interval == JobExecutionType.TYPE_CUSTOM:
-            return self.get_crontab(self.crontab)
+            return self.get_crontab(self.crontab, tz=tz)
         raise ValueError(f"I do not know to convert {self.interval} to a Cronjob!")
 
 

nautobot/extras/tables.py

@@ -110,6 +110,10 @@ JOB_BUTTONS = """
 <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>
 """
 
+SCHEDULED_JOB_BUTTONS = """
+<a href="{% url 'extras:jobresult_list' %}?scheduled_job={{ 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 = """
 {% if record.changed_object and record.changed_object.get_absolute_url %}
     <a href="{{ record.changed_object.get_absolute_url }}">{{ record.object_repr }}</a>
@@ -835,6 +839,10 @@ class JobResultTable(BaseTable):
         orderable=False,
         attrs={"td": {"class": "text-nowrap report-stats"}},
     )
+    scheduled_job = tables.Column(
+        linkify=True,
+        verbose_name="Scheduled Job",
+    )
     actions = tables.TemplateColumn(
         template_code="""
             {% load helpers %}
@@ -884,6 +892,7 @@ class JobResultTable(BaseTable):
             "date_created",
             "name",
             "job_model",
+            "scheduled_job",
             "duration",
             "date_done",
             "user",
@@ -1038,16 +1047,37 @@ class NoteTable(BaseTable):
 
 class ScheduledJobTable(BaseTable):
     pk = ToggleColumn()
-    name = tables.LinkColumn()
+    name = tables.Column(linkify=True)
     job_model = tables.Column(verbose_name="Job", linkify=True)
     interval = tables.Column(verbose_name="Execution Type")
-    start_time = tables.Column(verbose_name="First Run")
-    last_run_at = tables.Column(verbose_name="Most Recent Run")
+    start_time = tables.DateTimeColumn(verbose_name="First Run", format=settings.SHORT_DATETIME_FORMAT)
+    last_run_at = tables.DateTimeColumn(verbose_name="Most Recent Run", format=settings.SHORT_DATETIME_FORMAT)
+    crontab = tables.Column()
     total_run_count = tables.Column(verbose_name="Total Run Count")
+    actions = ButtonsColumn(ScheduledJob, buttons=("delete"), prepend_template=SCHEDULED_JOB_BUTTONS)
 
     class Meta(BaseTable.Meta):
         model = ScheduledJob
-        fields = ("pk", "name", "job_model", "interval", "start_time", "last_run_at")
+        fields = (
+            "pk",
+            "name",
+            "total_run_count",
+            "job_model",
+            "interval",
+            "start_time",
+            "last_run_at",
+            "crontab",
+            "time_zone",
+            "actions",
+        )
+        default_columns = (
+            "pk",
+            "name",
+            "job_model",
+            "interval",
+            "last_run_at",
+            "actions",
+        )
 
 
 class ScheduledJobApprovalQueueTable(BaseTable):

nautobot/extras/templates/extras/scheduledjob.html

@@ -4,6 +4,7 @@
 {% load helpers %}
 {% load perms %}
 {% load plugins %}
+{% load tz %}
 
 {% block buttons %}
     {% plugin_buttons object %}
@@ -94,13 +95,23 @@
               <tr>
                   <td>Start Time</td>
                   <td>
-                      {{ object.start_time }}
+                      {{ object.start_time|timezone:object.time_zone|date:'Y-m-d H:i:s T' }}
+                      {% if default_time_zone != object.time_zone %}
+                          <br>{{ object.start_time|timezone:default_time_zone|date:'Y-m-d H:i:s T' }}
+                      {% endif %}
                   </td>
               </tr>
               <tr>
                   <td>Last Run At</td>
                   <td>
-                      {{ object.last_run_at|placeholder }}
+                      {% if object.last_run_at %}
+                          {{ object.last_run_at|timezone:object.time_zone|date:'Y-m-d H:i:s T' }}
+                          {% if default_time_zone != object.time_zone %}
+                              <br>{{ object.last_run_at|timezone:default_time_zone|date:'Y-m-d H:i:s T' }}
+                          {% endif %}
+                      {% else %}
+                          {{ object.last_run_at|placeholder }}
+                      {% endif %}
                   </td>
               </tr>
               <tr>

nautobot/extras/tests/test_api.py

@@ -12,6 +12,11 @@ from django.urls import reverse
 from django.utils.timezone import make_aware, now
 from rest_framework import status
 
+try:
+    from zoneinfo import ZoneInfo
+except ImportError:  # Python 3.8
+    from backports.zoneinfo import ZoneInfo
+
 from nautobot.core.choices import ColorChoices
 from nautobot.core.models.fields import slugify_dashes_to_underscores
 from nautobot.core.testing import APITestCase, APIViewTestCases
@@ -1583,7 +1588,7 @@ class JobTest(
             "schedule": {
                 "name": "test",
                 "interval": "future",
-                "start_time": str(datetime.now() + timedelta(minutes=1)),
+                "start_time": str(now() + timedelta(minutes=1)),
             },
         }
 
@@ -1780,7 +1785,7 @@ class JobTest(
             "var2": "Ground control to Major Tom",
             "var23": "Commencing countdown, engines on",
             "var1": test_file,
-            "_schedule_start_time": str(datetime.now() + timedelta(minutes=1)),
+            "_schedule_start_time": str(now() + timedelta(minutes=1)),
             "_schedule_interval": "future",
             "_schedule_name": "test",
         }
@@ -1799,7 +1804,7 @@ class JobTest(
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
             "schedule": {
-                "start_time": str(datetime.now() + timedelta(minutes=1)),
+                "start_time": str(now() + timedelta(minutes=1)),
                 "interval": "future",
                 "name": "test",
             },
@@ -1838,7 +1843,7 @@ class JobTest(
         data = {
             "data": {},
             "schedule": {
-                "start_time": str(datetime.now() + timedelta(minutes=1)),
+                "start_time": str(now() + timedelta(minutes=1)),
                 "interval": "future",
                 "name": "test",
             },
@@ -1914,7 +1919,7 @@ class JobTest(
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
             "schedule": {
-                "start_time": str(datetime.now() - timedelta(minutes=1)),
+                "start_time": str(now() - timedelta(minutes=1)),
                 "interval": "future",
                 "name": "test",
             },
@@ -1933,7 +1938,7 @@ class JobTest(
         data = {
             "data": {"var1": "x", "var2": 1, "var3": False, "var4": d.pk},
             "schedule": {
-                "start_time": str(datetime.now() + timedelta(minutes=1)),
+                "start_time": str(now() + timedelta(minutes=1)),
                 "interval": "hourly",
                 "name": "test",
             },
@@ -2438,30 +2443,24 @@ class ScheduledJobTest(
             name="test2",
             task="pass.TestPass",
             job_model=job_model,
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            interval=JobExecutionType.TYPE_DAILY,
             user=user,
             approval_required=True,
-            start_time=now(),
+            start_time=datetime(2020, 1, 23, 12, 34, 56, tzinfo=ZoneInfo("America/New_York")),
+            time_zone=ZoneInfo("America/New_York"),
         )
         ScheduledJob.objects.create(
             name="test3",
             task="pass.TestPass",
             job_model=job_model,
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            interval=JobExecutionType.TYPE_CUSTOM,
+            crontab="34 12 * * *",
+            enabled=False,
             user=user,
             approval_required=True,
             start_time=now(),
         )
 
-    # TODO: Unskip after resolving #2908, #2909
-    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
-    def test_list_objects_ascending_ordered(self):
-        pass
-
-    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
-    def test_list_objects_descending_ordered(self):
-        pass
-
 
 class JobApprovalTest(APITestCase):
     @classmethod

nautobot/extras/tests/test_context_managers.py

@@ -1,3 +1,5 @@
+from unittest import mock
+
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.test import TestCase
@@ -72,7 +74,9 @@ class WebRequestContextTestCase(TestCase):
         self.assertEqual(oc_list[0].changed_object, location)
         self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
 
-    def test_create_then_delete(self):
+    @mock.patch("nautobot.extras.jobs.enqueue_job_hooks")
+    @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
+    def test_create_then_delete(self, mock_enqueue_webhooks, mock_enqueue_job_hooks):
         """Test that a create followed by a delete is logged as two changes"""
         location_type = LocationType.objects.get(name="Campus")
         location_status = Status.objects.get_for_model(Location).first()
@@ -88,6 +92,8 @@ class WebRequestContextTestCase(TestCase):
         self.assertEqual(len(oc_list), 2)
         self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_DELETE)
         self.assertEqual(oc_list[1].action, ObjectChangeActionChoices.ACTION_CREATE)
+        mock_enqueue_job_hooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
+        mock_enqueue_webhooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
 
     def test_update_then_delete(self):
         """Test that an update followed by a delete is logged as a single delete"""
@@ -179,21 +185,30 @@ class WebRequestContextTestCase(TestCase):
         with self.subTest():
             self.assertEqual(oc_list[0].change_context_detail, "test_change_log_context")
 
-    def test_change_webhook_enqueued(self):
+    @mock.patch("nautobot.extras.webhooks.process_webhook.apply_async")
+    def test_change_webhook_enqueued(self, mock_apply_async):
         """Test that the webhook resides on the queue"""
-        # TODO(john): come back to this with a way to actually do it without a running worker
-        # The celery inspection API expects to be able to communicate with at least 1 running
-        # worker and there does not appear to be an easy way to look into the queues directly.
-        # with web_request_context(self.user):
-        #    site = Site(name="Test Site 2")
-        #    site.save()
+        with web_request_context(self.user):
+            location = Location(
+                name="Test Location 2",
+                location_type=LocationType.objects.get(name="Campus"),
+                status=Status.objects.get_for_model(Location).first(),
+            )
+            location.save()
 
         # Verify that a job was queued for the object creation webhook
-        # site = Site.objects.get(name="Test Site 2")
-
-        # self.assertEqual(job.args[0], Webhook.objects.get(type_create=True))
-        # self.assertEqual(job.args[1]["id"], str(site.pk))
-        # self.assertEqual(job.args[2], "site")
+        oc_list = get_changes_for_model(location)
+        mock_apply_async.assert_called_once()
+        call_args = mock_apply_async.call_args.kwargs["args"]
+        self.assertEqual(8, len(call_args), call_args)
+        self.assertEqual(call_args[0], Webhook.objects.get(type_create=True).pk)
+        self.assertEqual(call_args[1], oc_list[0].object_data_v2)
+        self.assertEqual(call_args[2], "location")
+        self.assertEqual(call_args[3], "create")
+        self.assertIsInstance(call_args[4], str)  # str(timezone.now())
+        self.assertEqual(call_args[5], self.user.username)
+        self.assertEqual(call_args[6], oc_list[0].request_id)
+        self.assertEqual(call_args[7], oc_list[0].get_snapshots())
 
 
 class WebRequestContextTransactionTestCase(TransactionTestCase):
@@ -282,7 +297,8 @@ class BulkEditDeleteChangeLogging(TestCase):
         self.assertIsNone(snapshots["differences"]["removed"])
         self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
 
-    def test_bulk_edit(self):
+    @mock.patch("nautobot.extras.jobs.import_jobs")
+    def test_bulk_edit(self, mock_import_jobs):
         """Test that edits to multiple objects are correctly logged"""
         location_type = LocationType.objects.get(name="Campus")
         location_status = Status.objects.get_for_model(Location).first()
@@ -309,6 +325,9 @@ class BulkEditDeleteChangeLogging(TestCase):
             self.assertIsNone(snapshots["differences"]["removed"])
             self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
 
+        # Check for regression of https://github.com/nautobot/nautobot/issues/6203
+        mock_import_jobs.assert_called_once()
+
     def test_bulk_edit_device_type_software_image_file(self):
         """Test that bulk edits to null does not cause integrity error"""
         manufacturer = Manufacturer.objects.create(name="Test")

nautobot/extras/tests/test_dynamicgroups.py

@@ -494,6 +494,17 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         self.assertIsInstance(fields["cluster"], MultiMatchModelMultipleChoiceField)
         self.assertIsInstance(fields["cluster"].widget, APISelectMultiple)
 
+    def test_map_filter_fields_with_custom_filter_method(self):
+        """
+        Test that extension_filters with custom methods can be concatenated into `generate_query_{filter_method}`
+        and _map_filter_fields method doesn't brake on string concatenation.
+        This is a regression test for issue #6184.
+        """
+        tenant_content_type = ContentType.objects.get_for_model(Tenant)
+        # using Tenant as example app has a custom filter with a custom method.
+        group = DynamicGroup(name="tenant", content_type=tenant_content_type)
+        self.assertIsInstance(group._map_filter_fields, dict)
+
     def test_map_filter_fields_skip_missing(self):
         """
         Test that missing fields are skipped in `DynamicGroup._map_filter_fields`

nautobot/extras/tests/test_filters.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 import uuid
 
 from django.contrib.auth import get_user_model
@@ -5,6 +6,12 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.db.models import Q
 from django.test import override_settings, RequestFactory
+from django.utils.timezone import now
+
+try:
+    from zoneinfo import ZoneInfo
+except ImportError:  # Python 3.8
+    from backports.zoneinfo import ZoneInfo
 
 from nautobot.core.choices import ColorChoices
 from nautobot.core.testing import FilterTestCases
@@ -22,6 +29,7 @@ from nautobot.dcim.models import (
 from nautobot.extras.choices import (
     CustomFieldTypeChoices,
     DynamicGroupTypeChoices,
+    JobExecutionType,
     JobResultStatusChoices,
     MetadataTypeDataTypeChoices,
     ObjectChangeActionChoices,
@@ -93,6 +101,7 @@ from nautobot.extras.models import (
     RelationshipAssociation,
     Role,
     SavedView,
+    ScheduledJob,
     Secret,
     SecretsGroup,
     SecretsGroupAssociation,
@@ -1124,13 +1133,49 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
     def setUpTestData(cls):
         jobs = Job.objects.all()[:3]
         cls.jobs = jobs
+        user = User.objects.create(username="user1", is_active=True)
+        job_model = Job.objects.get_for_class_path("pass.TestPass")
+        scheduled_jobs = [
+            ScheduledJob.objects.create(
+                name="test1",
+                task="pass.TestPass",
+                job_model=job_model,
+                interval=JobExecutionType.TYPE_IMMEDIATELY,
+                user=user,
+                approval_required=True,
+                start_time=now(),
+            ),
+            ScheduledJob.objects.create(
+                name="test2",
+                task="pass.TestPass",
+                job_model=job_model,
+                interval=JobExecutionType.TYPE_DAILY,
+                user=user,
+                approval_required=True,
+                start_time=datetime(2020, 1, 23, 12, 34, 56, tzinfo=ZoneInfo("America/New_York")),
+                time_zone=ZoneInfo("America/New_York"),
+            ),
+            ScheduledJob.objects.create(
+                name="test3",
+                task="pass.TestPass",
+                job_model=job_model,
+                interval=JobExecutionType.TYPE_CUSTOM,
+                crontab="34 12 * * *",
+                enabled=False,
+                user=user,
+                approval_required=True,
+                start_time=now(),
+            ),
+        ]
+        cls.scheduled_jobs = scheduled_jobs
         user = UserFactory.create()
-        for job in jobs:
+        for idx, job in enumerate(jobs):
             JobResult.objects.create(
                 job_model=job,
                 name=job.class_path,
                 user=user,
                 status=JobResultStatusChoices.STATUS_STARTED,
+                scheduled_job=scheduled_jobs[idx],
             )
 
     def test_job_model(self):
@@ -1144,6 +1189,17 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
                 self.filterset(params, self.queryset).qs, self.queryset.filter(job_model__in=jobs).distinct()
             )
 
+    def test_scheduled_job(self):
+        scheduled_jobs = list(self.scheduled_jobs[:2])
+        filter_params = [
+            {"scheduled_job": [scheduled_jobs[0].pk, scheduled_jobs[1].name]},
+        ]
+        for params in filter_params:
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                self.queryset.filter(scheduled_job__in=scheduled_jobs).distinct(),
+            )
+
 
 class JobHookFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
     queryset = JobHook.objects.all()