nautobot 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

nautobot/extras/plugins/__init__.py

@@ -31,7 +31,6 @@ logger = getLogger(__name__)
 registry["plugin_banners"] = []
 registry["plugin_custom_validators"] = collections.defaultdict(list)
 registry["plugin_graphql_types"] = []
-registry["plugin_jobs"] = []
 registry["plugin_template_extensions"] = collections.defaultdict(list)
 registry["app_metrics"] = []
 
@@ -141,9 +140,9 @@ class NautobotAppConfig(NautobotConfig):
             register_graphql_types(graphql_types)
 
         # Import jobs (if present)
+        # Note that we do *not* auto-call `register_jobs()` - the App is responsible for doing so when imported.
         jobs = import_object(f"{self.__module__}.{self.jobs}")
         if jobs is not None:
-            register_jobs(jobs)
             self.features["jobs"] = jobs
 
         # Import metrics (if present)
@@ -423,24 +422,6 @@ def register_graphql_types(class_list):
         registry["plugin_graphql_types"].append(item)
 
 
-def register_jobs(class_list):
-    """
-    Register a list of Job classes
-    """
-    from nautobot.extras.jobs import Job
-
-    for job in class_list:
-        if not inspect.isclass(job):
-            raise TypeError(f"Job class {job} was passed as an instance!")
-        if not issubclass(job, Job):
-            raise TypeError(f"{job} is not a subclass of extras.jobs.Job!")
-
-        registry["plugin_jobs"].append(job)
-
-    # Note that we do not (and cannot) update the Job records in the Nautobot database at this time.
-    # That is done in response to the `nautobot_database_ready` signal, see nautobot.extras.signals.refresh_job_models
-
-
 def register_metrics(function_list):
     """
     Register a list of metric functions

nautobot/extras/signals.py

@@ -21,7 +21,7 @@ from django.utils import timezone
 from django_prometheus.models import model_deletes, model_inserts, model_updates
 import redis.exceptions
 
-from nautobot.core.celery import app, import_jobs_as_celery_tasks
+from nautobot.core.celery import app, import_jobs
 from nautobot.core.models import BaseModel
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.logging import sanitize
@@ -333,7 +333,7 @@ def git_repository_pre_delete(instance, **kwargs):
         app.control.broadcast("discard_git_repository", repository_slug=instance.slug)
         # But we don't have an equivalent way to broadcast to any other Django instances.
         # For now we just delete the one that we have locally and rely on other methods,
-        # such as the import_jobs_as_celery_tasks() signal that runs on server startup,
+        # such as the import_jobs() signal that runs on server startup,
         # to clean up other clones as they're encountered.
         if os.path.isdir(instance.filesystem_path):
             shutil.rmtree(instance.filesystem_path)
@@ -462,7 +462,7 @@ def refresh_job_models(sender, *, apps, **kwargs):
     """
     Callback for the nautobot_database_ready signal; updates Jobs in the database based on Job source file availability.
     """
-    from nautobot.extras.jobs import Job as JobClass  # avoid circular import
+    from nautobot.extras.jobs import get_jobs  # avoid circular import
 
     Job = apps.get_model("extras", "Job")
 
@@ -471,15 +471,12 @@ def refresh_job_models(sender, *, apps, **kwargs):
         logger.info("Skipping refresh_job_models() as it appears Job model has not yet been migrated to latest.")
         return
 
-    import_jobs_as_celery_tasks(app)
+    import_jobs()
 
     job_models = []
-    for task in app.tasks.values():
-        # Skip Celery tasks that aren't Jobs
-        if not isinstance(task, JobClass):
-            continue
 
-        job_model, _ = refresh_job_model_from_job_class(Job, task.__class__)
+    for job_class in get_jobs().values():
+        job_model, _ = refresh_job_model_from_job_class(Job, job_class)
         if job_model is not None:
             job_models.append(job_model)
 

nautobot/extras/test_jobs/__init__.py

@@ -0,0 +1,8 @@
+def load_tests(*args):
+    """Implement unittest discovery for this submodule as a no-op.
+
+    This prevents unittest from recursively loading all of the modules under this directory to inspect whether they
+    define test cases. This is necessary because otherwise the `jobs_module` submodule will get loaded when tests run,
+    which will in turn call `register_jobs()`, incorrectly/unexpectedly registering the test Job defined in that module
+    as if it were a system Job, which will cause tests to fail due to the unexpected presence of this Job.
+    """

nautobot/extras/test_jobs/dry_run.py

@@ -1,5 +1,5 @@
 from nautobot.core.celery import register_jobs
-from nautobot.extras.jobs import DryRunVar, get_task_logger, Job
+from nautobot.extras.jobs import DryRunVar, get_task_logger, IntegerVar, Job
 from nautobot.extras.models import Status
 
 logger = get_task_logger(__name__)
@@ -11,8 +11,9 @@ class TestDryRun(Job):
     """
 
     dryrun = DryRunVar()
+    value = IntegerVar(required=False)
 
-    def run(self, dryrun):
+    def run(self, dryrun, value=None):
         """
         Job function.
         """

nautobot/extras/test_jobs/fail.py

@@ -1,4 +1,7 @@
+from billiard.einfo import ExceptionInfo
+
 from nautobot.core.celery import register_jobs
+from nautobot.extras.choices import JobResultStatusChoices
 from nautobot.extras.jobs import get_task_logger, Job, RunJobTaskFailed
 
 logger = get_task_logger(__name__)
@@ -11,6 +14,15 @@ class TestFail(Job):
 
     description = "Validate job import"
 
+    def before_start(self, task_id, args, kwargs):
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        logger.info("before_start() was called as expected")
+
     def run(self):
         """
         Job function.
@@ -18,6 +30,37 @@ class TestFail(Job):
         logger.info("I'm a test job that fails!")
         raise RunJobTaskFailed("Test failure")
 
+    def on_success(self, retval, task_id, args, kwargs):
+        raise RuntimeError("on_success() was unexpectedly called!")
+
+    def on_failure(self, exc, task_id, args, kwargs, einfo):
+        if not isinstance(exc, RunJobTaskFailed):
+            raise RuntimeError(f"Expected exc to be a RunJobTaskFailed, but it was {exc!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if not isinstance(einfo, ExceptionInfo):
+            raise RuntimeError(f"Expected einfo to be an ExceptionInfo, but it was {einfo!r}")
+        logger.info("on_failure() was called as expected")
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        if status is not JobResultStatusChoices.STATUS_FAILURE:
+            raise RuntimeError(f"Expected status to be {JobResultStatusChoices.STATUS_FAILURE}, but it was {status!r}")
+        if not isinstance(retval, RunJobTaskFailed):
+            raise RuntimeError(f"Expected retval to be a RunJobTaskFailed, but it was {retval!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if not isinstance(einfo, ExceptionInfo):
+            raise RuntimeError(f"Expected einfo to be an ExceptionInfo, but it was {einfo!r}")
+        logger.info("after_return() was called as expected")
+
 
 class TestFailWithSanitization(Job):
     """

nautobot/extras/test_jobs/ipaddress_vars.py

@@ -1,5 +1,7 @@
 import json
 
+import netaddr
+
 from nautobot.core.celery import register_jobs
 from nautobot.extras.jobs import get_task_logger, IPAddressVar, IPAddressWithMaskVar, Job
 
@@ -30,7 +32,26 @@ class TestIPAddresses(Job):
         description="IPv6 network",
     )
 
-    def run(self, ipv4_address, ipv4_with_mask, ipv4_network, ipv6_address, ipv6_with_mask, ipv6_network):
+    def before_start(self, task_id, args, kwargs):
+        for expected_kwarg in self._get_vars().keys():
+            if expected_kwarg not in kwargs:
+                raise RuntimeError(f"kwargs should contain {expected_kwarg} but it doesn't!")
+            if kwargs[expected_kwarg] is None:
+                raise RuntimeError(f"kwargs[{expected_kwarg}] is unexpectedly None!")
+
+    def run(self, *, ipv4_address, ipv4_with_mask, ipv4_network, ipv6_address, ipv6_with_mask, ipv6_network):
+        if not isinstance(ipv4_address, netaddr.IPAddress):
+            raise RuntimeError(f"Expected ipv4_address to be a netaddr.IPAddress, but it was {ipv4_address!r}")
+        if not isinstance(ipv4_with_mask, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv4_with_mask to be a netaddr.IPNetwork, but it was {ipv4_with_mask!r}")
+        if not isinstance(ipv4_network, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv4_network to be a netaddr.IPNetwork, but it was {ipv4_network!r}")
+        if not isinstance(ipv6_address, netaddr.IPAddress):
+            raise RuntimeError(f"Expected ipv6_address to be a netaddr.IPAddress, but it was {ipv6_address!r}")
+        if not isinstance(ipv6_with_mask, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv6_with_mask to be a netaddr.IPNetwork, but it was {ipv6_with_mask!r}")
+        if not isinstance(ipv6_network, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv6_network to be a netaddr.IPNetwork, but it was {ipv6_network!r}")
         # Log the data as JSON so we can pull it back out for testing.
         logger.info(
             "IP Address Test",
@@ -59,5 +80,23 @@ class TestIPAddresses(Job):
 
         return "Nice IPs, bro."
 
+    def on_success(self, retval, task_id, args, kwargs):
+        if retval != "Nice IPs, bro.":
+            raise RuntimeError(f"retval is unexpected: {retval!r}")
+        for expected_kwarg in self._get_vars().keys():
+            if expected_kwarg not in kwargs:
+                raise RuntimeError(f"kwargs should contain {expected_kwarg} but it doesn't!")
+            if kwargs[expected_kwarg] is None:
+                raise RuntimeError(f"kwargs[{expected_kwarg}] is unexpectedly None!")
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        if retval != "Nice IPs, bro.":
+            raise RuntimeError(f"retval is unexpected: {retval!r}")
+        for expected_kwarg in self._get_vars().keys():
+            if expected_kwarg not in kwargs:
+                raise RuntimeError(f"kwargs should contain {expected_kwarg} but it doesn't!")
+            if kwargs[expected_kwarg] is None:
+                raise RuntimeError(f"kwargs[{expected_kwarg}] is unexpectedly None!")
+
 
 register_jobs(TestIPAddresses)

nautobot/extras/test_jobs/jobs_module/__init__.py

@@ -0,0 +1,5 @@
+from nautobot.apps.jobs import register_jobs
+
+from .jobs_submodule import ChildJob
+
+register_jobs(ChildJob)

nautobot/extras/test_jobs/jobs_module/jobs_submodule/__init__.py

@@ -0,0 +1 @@
+from .jobs import ChildJob  # noqa: F401

nautobot/extras/test_jobs/jobs_module/jobs_submodule/jobs.py

@@ -0,0 +1,6 @@
+from nautobot.apps.jobs import Job
+
+
+class ChildJob(Job):
+    def run(self):
+        pass

nautobot/extras/test_jobs/pass.py

@@ -1,4 +1,5 @@
 from nautobot.core.celery import register_jobs
+from nautobot.extras.choices import JobResultStatusChoices
 from nautobot.extras.jobs import get_task_logger, Job
 
 logger = get_task_logger(__name__)
@@ -14,11 +15,50 @@ class TestPass(Job):
     class Meta:
         has_sensitive_variables = False
 
+    def before_start(self, task_id, args, kwargs):
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        logger.info("before_start() was called as expected")
+
     def run(self):
         """
         Job function.
         """
         logger.info("Success")
+        return True
+
+    def on_success(self, retval, task_id, args, kwargs):
+        if retval is not True:
+            raise RuntimeError(f"Expected retval to be True, but it was {retval!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        logger.info("on_success() was called as expected")
+
+    def on_failure(self, exc, task_id, args, kwargs, einfo):
+        raise RuntimeError("on_failure() was unexpectedly called!")
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        if status is not JobResultStatusChoices.STATUS_SUCCESS:
+            raise RuntimeError(f"Expected status to be {JobResultStatusChoices.STATUS_SUCCESS}, but it was {status!r}")
+        if retval is not True:
+            raise RuntimeError(f"Expected retval to be True, but it was {retval!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if einfo is not None:
+            raise RuntimeError(f"Expected einfo to be None, but it was {einfo!r}")
+        logger.info("after_return() was called as expected")
 
 
 register_jobs(TestPass)

nautobot/extras/test_jobs/relative_import.py

@@ -0,0 +1,11 @@
+from fail import TestFail  # pylint: disable=import-error
+
+from nautobot.apps.jobs import register_jobs
+
+
+class TestReallyPass(TestFail):
+    def run(self):
+        pass
+
+
+register_jobs(TestReallyPass)

nautobot/extras/tests/test_api.py

@@ -2303,6 +2303,7 @@ class JobApprovalTest(APITestCase):
             name="test dryrun",
             task="dry_run.TestDryRun",
             job_model=cls.dryrun_job_model,
+            kwargs={"value": 1},
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=cls.additional_user,
             approval_required=True,
@@ -2442,6 +2443,8 @@ class JobApprovalTest(APITestCase):
         url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.dryrun_scheduled_job.pk})
         response = self.client.post(url, **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
+        # The below fails because JobResult.task_kwargs doesn't get set until *after* the task begins executing.
+        # self.assertEqual(response.data["task_kwargs"], {"dryrun": True, "value": 1}, response.data)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_dry_run_not_supported(self):

nautobot/extras/tests/test_context_managers.py

@@ -12,6 +12,7 @@ from nautobot.extras.context_managers import (
     web_request_context,
 )
 from nautobot.extras.models import Status, Webhook
+from nautobot.extras.utils import bulk_delete_with_bulk_change_logging
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -231,6 +232,23 @@ class BulkEditDeleteChangeLogging(TestCase):
                     location.save()
                     location.delete()
 
+    def test_bulk_delete_has_user_in_change_log(self):
+        """Test that the bulk delete operation adds the user to the change log"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+            location.save()
+            location_pk = location.pk
+            location_qs = Location.objects.filter(pk=location_pk)
+            bulk_delete_with_bulk_change_logging(location_qs)
+
+        oc_list = get_changes_for_model(location)
+        self.assertEqual(len(oc_list), 2)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_DELETE)
+        self.assertEqual(oc_list[0].user, self.user)
+        self.assertEqual(oc_list[0].user_name, self.user.username)
+
     def test_create_then_update(self):
         """Test that a create followed by an update is logged as a single create"""
         location_type = LocationType.objects.get(name="Campus")