nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/jobs.py

@@ -1,15 +1,21 @@
 """Jobs functionality - consolidates and replaces legacy "custom scripts" and "reports" features."""
 from collections import OrderedDict
-import copy
+import functools
 import inspect
 import json
 import logging
 import os
-import shutil
+import tempfile
 from textwrap import dedent
-import traceback
 import warnings
 
+from billiard.einfo import ExceptionInfo
+from celery import states
+from celery.exceptions import NotRegistered, Retry
+from celery.result import EagerResult
+from celery.utils.functional import maybe_list
+from celery.utils.log import get_task_logger
+from celery.utils.nodenames import gethostname
 from db_file_storage.form_widgets import DBClearableFileInput
 from django import forms
 from django.conf import settings
@@ -17,24 +23,33 @@ from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import InMemoryUploadedFile
 from django.core.validators import RegexValidator
-from django.db import transaction, IntegrityError
 from django.db.models import Model
 from django.db.models.query import QuerySet
+from django.core.exceptions import ObjectDoesNotExist
 from django.forms import ValidationError
-from django.test.client import RequestFactory
-from django.utils import timezone
 from django.utils.functional import classproperty
+from kombu.utils.uuid import uuid
 import netaddr
 import yaml
 
-from nautobot.core.celery import nautobot_task
-from nautobot.core.exceptions import AbortTransaction
+from nautobot.core.celery import app as celery_app
+from nautobot.core.celery.task import Task
 from nautobot.core.forms import (
     DynamicModelChoiceField,
     DynamicModelMultipleChoiceField,
 )
 from nautobot.core.utils.lookup import get_model_from_name
-from nautobot.core.utils.requests import copy_safe_request
+from nautobot.extras.choices import ObjectChangeActionChoices, ObjectChangeEventContextChoices
+from nautobot.extras.context_managers import change_logging, JobChangeContext, JobHookChangeContext
+from nautobot.extras.forms import JobForm
+from nautobot.extras.models import (
+    FileProxy,
+    Job as JobModel,
+    JobHook,
+    JobResult,
+    ObjectChange,
+)
+from nautobot.extras.utils import ChangeLoggedModelsQuery, task_queues_as_choices
 from nautobot.ipam.formfields import IPAddressFormField, IPNetworkFormField
 from nautobot.ipam.validators import (
     MaxPrefixLengthValidator,
@@ -42,14 +57,6 @@ from nautobot.ipam.validators import (
     prefix_validator,
 )
 
-from .choices import LogLevelChoices, ObjectChangeActionChoices, ObjectChangeEventContextChoices
-from .context_managers import change_logging, JobChangeContext, JobHookChangeContext
-from .datasources.git import ensure_git_repository
-from .forms import JobForm
-from .models import FileProxy, GitRepository, Job as JobModel, JobHook, ObjectChange, ScheduledJob
-from .registry import registry
-from .utils import ChangeLoggedModelsQuery, get_job_content_type, jobs_in_directory, task_queues_as_choices
-
 
 User = get_user_model()
 
@@ -73,17 +80,17 @@ __all__ = [
 logger = logging.getLogger(__name__)
 
 
-class BaseJob:
-    """Base model for jobs (reports, scripts).
+class RunJobTaskFailed(Exception):
+    """Celery task failed for some reason."""
+
+
+class BaseJob(Task):
+    """Base model for jobs.
 
     Users can subclass this directly if they want to provide their own base class for implementing multiple jobs
     with shared functionality; if no such sharing is required, use Job class instead.
 
-    For backward compatibility with NetBox, this class has several APIs that can be implemented by the user:
-
-    1. run(self, data, commit) - First method called when invoking a Job, can handle setup and parameter storage.
-    2. test_*(self) - Any method matching this pattern will be called next
-    3. post_run(self) - Last method called, will be called even in case of an exception during the above methods
+    Jobs must define at minimum a run method.
     """
 
     class Meta:
@@ -92,10 +99,8 @@ class BaseJob:
 
         - name (str)
         - description (str)
-        - commit_default (bool)
         - hidden (bool)
         - field_order (list)
-        - read_only (bool)
         - approval_required (bool)
         - soft_time_limit (int)
         - time_limit (int)
@@ -104,25 +109,274 @@ class BaseJob:
         """
 
     def __init__(self):
-        self.logger = logging.getLogger(f"{__name__}.{self.__class__.__name__}")
+        self.logger = get_task_logger(self.__module__)
 
-        self.request = None
-        self.active_test = "main"
-        self.failed = False
-        self._job_result = None
+    def __call__(self, *args, **kwargs):
+        # Attempt to resolve serialized data back into original form by creating querysets or model instances
+        # If we fail to find any objects, we consider this a job execution error, and fail.
+        # This might happen when a job sits on the queue for a while (i.e. scheduled) and data has changed
+        # or it might be bad input from an API request, or manual execution.
+        try:
+            deserialized_kwargs = self.deserialize_data(kwargs)
+        except Exception as err:
+            raise RunJobTaskFailed("Error initializing job") from err
+        context_class = JobHookChangeContext if isinstance(self, JobHookReceiver) else JobChangeContext
+        change_context = context_class(user=self.user, context_detail=self.class_path)
 
-        # Compile test methods and initialize results skeleton
-        self.test_methods = []
+        with change_logging(change_context):
+            if self.celery_kwargs.get("nautobot_job_profile", False) is True:
+                import cProfile
+
+                # TODO: This should probably be available as a file download rather than dumped to the hard drive.
+                # Pending this: https://github.com/nautobot/nautobot/issues/3352
+                profiling_path = f"{tempfile.gettempdir()}/nautobot-jobresult-{self.job_result.id}.pstats"
+                self.logger.info(
+                    "Writing profiling information to %s.", profiling_path, extra={"grouping": "initialization"}
+                )
 
-        for method_name in dir(self):
-            if method_name.startswith("test_") and callable(getattr(self, method_name)):
-                self.test_methods.append(method_name)
+                with cProfile.Profile() as pr:
+                    try:
+                        output = self.run(*args, **deserialized_kwargs)
+                    except Exception as err:
+                        pr.dump_stats(profiling_path)
+                        raise err
+                    else:
+                        pr.dump_stats(profiling_path)
+                        return output
+            else:
+                return self.run(*args, **deserialized_kwargs)
 
     def __str__(self):
         return str(self.name)
 
     # See https://github.com/PyCQA/pylint-django/issues/240 for why we have a pylint disable on each classproperty below
 
+    # TODO(jathan): Could be interesting for custom stuff when the Job is
+    # enabled in the database and then therefore registered in Celery
+    @classmethod
+    def on_bound(cls, app):
+        """Called when the task is bound to an app.
+
+        Note:
+            This class method can be defined to do additional actions when
+            the task class is bound to an app.
+        """
+
+    # TODO(jathan): Could be interesting for showing the Job's class path as the
+    # shadow name vs. the Celery task_name?
+    def shadow_name(self, args, kwargs, options):
+        """Override for custom task name in worker logs/monitoring.
+
+        Example:
+                from celery.utils.imports import qualname
+
+                def shadow_name(task, args, kwargs, options):
+                    return qualname(args[0])
+
+                @app.task(shadow_name=shadow_name, serializer='pickle')
+                def apply_function_async(fun, *args, **kwargs):
+                    return fun(*args, **kwargs)
+
+        Arguments:
+            args (Tuple): Task positional arguments.
+            kwargs (Dict): Task keyword arguments.
+            options (Dict): Task execution options.
+        """
+
+    def before_start(self, task_id, args, kwargs):
+        """Handler called before the task starts.
+
+        Arguments:
+            task_id (str): Unique id of the task to execute.
+            args (Tuple): Original arguments for the task to execute.
+            kwargs (Dict): Original keyword arguments for the task to execute.
+
+        Returns:
+            None: The return value of this handler is ignored.
+        """
+        self.clear_cache()
+
+        try:
+            self.job_result
+        except ObjectDoesNotExist as err:
+            raise RunJobTaskFailed(f"Unable to find associated job result for job {task_id}") from err
+
+        try:
+            self.job_model
+        except ObjectDoesNotExist as err:
+            raise RunJobTaskFailed(f"Unable to find associated job model for job {task_id}") from err
+
+        if not self.job_model.enabled:
+            self.logger.error(
+                "Job %s is not enabled to be run!",
+                self.job_model,
+                extra={"object": self.job_model, "grouping": "initialization"},
+            )
+            raise RunJobTaskFailed(f"Job {self.job_model} is not enabled to be run!")
+
+        soft_time_limit = self.job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
+        time_limit = self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
+        if time_limit <= soft_time_limit:
+            self.logger.warning(
+                "The hard time limit of %s seconds is less than "
+                "or equal to the soft time limit of %s seconds. "
+                "This job will fail silently after %s seconds.",
+                time_limit,
+                soft_time_limit,
+                time_limit,
+                extra={"grouping": "initialization"},
+            )
+
+        self.logger.info("Running job", extra={"grouping": "initialization"})
+
+    def run(self, *args, **kwargs):
+        """
+        Method invoked when this Job is run.
+        """
+        raise NotImplementedError("Jobs must define the run method.")
+
+    def on_success(self, retval, task_id, args, kwargs):
+        """Success handler.
+
+        Run by the worker if the task executes successfully.
+
+        Arguments:
+            retval (Any): The return value of the task.
+            task_id (str): Unique id of the executed task.
+            args (Tuple): Original arguments for the executed task.
+            kwargs (Dict): Original keyword arguments for the executed task.
+
+        Returns:
+            None: The return value of this handler is ignored.
+        """
+
+    def on_retry(self, exc, task_id, args, kwargs, einfo):
+        """Retry handler.
+
+        This is run by the worker when the task is to be retried.
+
+        Arguments:
+            exc (Exception): The exception sent to :meth:`retry`.
+            task_id (str): Unique id of the retried task.
+            args (Tuple): Original arguments for the retried task.
+            kwargs (Dict): Original keyword arguments for the retried task.
+            einfo (~billiard.einfo.ExceptionInfo): Exception information.
+
+        Returns:
+            None: The return value of this handler is ignored.
+        """
+
+    def on_failure(self, exc, task_id, args, kwargs, einfo):
+        """Error handler.
+
+        This is run by the worker when the task fails.
+
+        Arguments:
+            exc (Exception): The exception raised by the task.
+            task_id (str): Unique id of the failed task.
+            args (Tuple): Original arguments for the task that failed.
+            kwargs (Dict): Original keyword arguments for the task that failed.
+            einfo (~billiard.einfo.ExceptionInfo): Exception information.
+
+        Returns:
+            None: The return value of this handler is ignored.
+        """
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        """
+        Handler called after the task returns.
+
+        Parameters
+            status - Current task state.
+            retval - Task return value/exception.
+            task_id - Unique id of the task.
+            args - Original arguments for the task that returned.
+            kwargs - Original keyword arguments for the task that returned.
+
+        Keyword Arguments
+            einfo - ExceptionInfo instance, containing the traceback (if any).
+
+        Returns:
+            None: The return value of this handler is ignored.
+        """
+
+        # Cleanup FileProxy objects
+        file_fields = list(self._get_file_vars())
+        file_ids = [kwargs[f] for f in file_fields]
+        if file_ids:
+            self.delete_files(*file_ids)
+
+        self.logger.info("Job completed", extra={"grouping": "post_run"})
+
+        # TODO(gary): document this in job author docs
+        # Super.after_return must be called for chords to function properly
+        super().after_return(status, retval, task_id, args, kwargs, einfo=einfo)
+
+    def apply(
+        self,
+        args=None,
+        kwargs=None,
+        link=None,
+        link_error=None,
+        task_id=None,
+        retries=None,
+        throw=None,
+        logfile=None,
+        loglevel=None,
+        headers=None,
+        **options,
+    ):
+        """Fix celery's apply method to propagate options to the task result"""
+        # trace imports Task, so need to import inline.
+        from celery.app.trace import build_tracer
+
+        app = self._get_app()
+        args = args or ()
+        kwargs = kwargs or {}
+        task_id = task_id or uuid()
+        retries = retries or 0
+        if throw is None:
+            throw = app.conf.task_eager_propagates
+
+        # Make sure we get the task instance, not class.
+        task = app._tasks[self.name]
+
+        request = {
+            "id": task_id,
+            "retries": retries,
+            "is_eager": True,
+            "logfile": logfile,
+            "loglevel": loglevel or 0,
+            "hostname": gethostname(),
+            "callbacks": maybe_list(link),
+            "errbacks": maybe_list(link_error),
+            "headers": headers,
+            "ignore_result": options.get("ignore_result", False),
+            "delivery_info": {
+                "is_eager": True,
+                "exchange": options.get("exchange"),
+                "routing_key": options.get("routing_key"),
+                "priority": options.get("priority"),
+            },
+            "properties": options,  # one line fix to overloaded method
+        }
+        tb = None
+        tracer = build_tracer(
+            task.name,
+            task,
+            eager=True,
+            propagate=throw,
+            app=self._get_app(),
+        )
+        ret = tracer(task_id, args, kwargs, request)
+        retval = ret.retval
+        if isinstance(retval, ExceptionInfo):
+            retval, tb = retval.exception, retval.traceback
+        if isinstance(retval, Retry) and retval.sig is not None:
+            return retval.sig.apply(retries=retries + 1)
+        state = states.SUCCESS if ret.info is None else ret.info.state
+        return EagerResult(task_id, retval, state, traceback=tb)
+
     @classproperty
     def file_path(cls):  # pylint: disable=no-self-argument
         return inspect.getfile(cls)
@@ -130,47 +384,31 @@ class BaseJob:
     @classproperty
     def class_path(cls):  # pylint: disable=no-self-argument
         """
-        Unique identifier of a specific Job class, in the form <source_grouping>/<module_name>/<ClassName>.
+        Unique identifier of a specific Job class, in the form <module_name>.<ClassName>.
 
         Examples:
-        local/my_script/MyScript
-        plugins/my_plugin.jobs/MyPluginJob
-        git.my-repository/myjob/MyJob
+        my_script.MyScript - Local Job
+        nautobot.core.jobs.MySystemJob - System Job
+        my_plugin.jobs.MyPluginJob - App-provided Job
+        git_repository.jobs.myjob.MyJob - GitRepository Job
         """
-        # TODO(Glenn): it'd be nice if this were derived more automatically instead of needing this logic
-        if cls in registry["plugin_jobs"]:
-            source_grouping = "plugins"
-        elif cls.file_path.startswith(settings.JOBS_ROOT):
-            source_grouping = "local"
-        elif cls.file_path.startswith(settings.GIT_ROOT):
-            # $GIT_ROOT/<repo_slug>/jobs/job.py -> <repo_slug>
-            source_grouping = ".".join(
-                [
-                    "git",
-                    os.path.basename(os.path.dirname(os.path.dirname(cls.file_path))),
-                ]
-            )
-        else:
-            raise RuntimeError(
-                f"Unknown/unexpected job file_path {cls.file_path}, should be one of "
-                + ", ".join([settings.JOBS_ROOT, settings.GIT_ROOT])
-            )
-
-        return "/".join([source_grouping, cls.__module__, cls.__name__])
+        return f"{cls.__module__}.{cls.__name__}"
 
     @classproperty
     def class_path_dotted(cls):  # pylint: disable=no-self-argument
         """
         Dotted class_path, suitable for use in things like Python logger names.
+
+        Deprecated as of Nautobot 2.0: just use .class_path instead.
         """
-        return cls.class_path.replace("/", ".")
+        return cls.class_path
 
     @classproperty
     def class_path_js_escaped(cls):  # pylint: disable=no-self-argument
         """
         Escape various characters so that the class_path can be used as a jQuery selector.
         """
-        return cls.class_path.replace("/", r"\/").replace(".", r"\.")
+        return cls.class_path.replace(".", r"\.")
 
     @classproperty
     def grouping(cls):  # pylint: disable=no-self-argument
@@ -192,8 +430,8 @@ class BaseJob:
         return ""
 
     @classproperty
-    def commit_default(cls):  # pylint: disable=no-self-argument
-        return getattr(cls.Meta, "commit_default", True)
+    def dryrun_default(cls):  # pylint: disable=no-self-argument
+        return getattr(cls.Meta, "dryrun_default", False)
 
     @classproperty
     def hidden(cls):  # pylint: disable=no-self-argument
@@ -223,6 +461,10 @@ class BaseJob:
     def has_sensitive_variables(cls):  # pylint: disable=no-self-argument
         return getattr(cls.Meta, "has_sensitive_variables", True)
 
+    @classproperty
+    def supports_dryrun(cls):  # pylint: disable=no-self-argument
+        return isinstance(getattr(cls, "dryrun", None), DryRunVar)
+
     @classproperty
     def task_queues(cls):  # pylint: disable=no-self-argument
         return getattr(cls.Meta, "task_queues", [])
@@ -239,15 +481,17 @@ class BaseJob:
             "grouping": cls.grouping,
             "description": cls.description,
             "approval_required": cls.approval_required,
-            "commit_default": cls.commit_default,
             "hidden": cls.hidden,
-            "read_only": cls.read_only,
             "soft_time_limit": cls.soft_time_limit,
             "time_limit": cls.time_limit,
             "has_sensitive_variables": cls.has_sensitive_variables,
             "task_queues": cls.task_queues,
         }
 
+    @classproperty
+    def registered_name(cls):  # pylint: disable=no-self-argument
+        return f"{cls.__module__}.{cls.__name__}"
+
     @classmethod
     def _get_vars(cls):
         """
@@ -276,33 +520,6 @@ class BaseJob:
 
         return file_vars
 
-    @property
-    def job_result(self):
-        return self._job_result
-
-    @job_result.setter
-    def job_result(self, value):
-        # Initialize job_result data format for our usage
-        value.data = OrderedDict()
-
-        self._job_result = value
-
-    @property
-    def results(self):
-        """
-        The results generated by this job.
-        ** If you need the logs, you will need to filter on JobLogEntry **
-            Ex.
-            from nautobot.extras.models import JogLogEntry
-
-            JobLogEntry.objects.filter(job_result=self.job_result, <other criteria>)
-
-        {
-            "output": "...",
-        }
-        """
-        return self.job_result.data if self.job_result else None
-
     def as_form_class(self):
         """
         Dynamically generate a Django form class corresponding to the variables in this Job.
@@ -324,27 +541,22 @@ class BaseJob:
 
         try:
             job_model = JobModel.objects.get_for_class_path(self.class_path)
-            read_only = job_model.read_only if job_model.read_only_override else self.read_only
-            commit_default = job_model.commit_default if job_model.commit_default_override else self.commit_default
+            dryrun_default = job_model.dryrun_default if job_model.dryrun_default_override else self.dryrun_default
             task_queues = job_model.task_queues if job_model.task_queues_override else self.task_queues
         except JobModel.DoesNotExist:
-            # 2.0 TODO: remove this fallback, Job records should always exist.
             logger.error("No Job instance found in the database corresponding to %s", self.class_path)
-            read_only = self.read_only
-            commit_default = self.commit_default
+            dryrun_default = self.dryrun_default
             task_queues = self.task_queues
 
-        if read_only:
-            # Hide the commit field for read only jobs
-            form.fields["_commit"].widget = forms.HiddenInput()
-            form.fields["_commit"].initial = False
-        elif not initial or "_commit" not in initial:
-            # Set initial "commit" checkbox state based on the Meta parameter
-            form.fields["_commit"].initial = commit_default
-
         # Update task queue choices
         form.fields["_task_queue"].choices = task_queues_as_choices(task_queues)
 
+        if self.supports_dryrun and (not initial or "dryrun" not in initial):
+            # Set initial "dryrun" checkbox state based on the Meta parameter
+            form.fields["dryrun"].initial = dryrun_default
+        if not settings.DEBUG:
+            form.fields["_profile"].widget = forms.HiddenInput()
+
         # https://github.com/PyCQA/pylint/issues/3484
         if self.field_order:  # pylint: disable=using-constant-test
             form.order_fields(self.field_order)
@@ -354,11 +566,42 @@ class BaseJob:
             for _, field in form.fields.items():
                 field.disabled = True
 
-            # Alter the commit help text to avoid confusion concerning approval dry-runs
-            form.fields["_commit"].help_text = "Commit changes to the database"
-
         return form
 
+    def clear_cache(self):
+        """
+        Clear all cached properties on this instance without accessing them. This is required because
+        celery reuses task instances for multiple runs.
+        """
+        try:
+            del self.celery_kwargs
+        except AttributeError:
+            pass
+        try:
+            del self.job_result
+        except AttributeError:
+            pass
+        try:
+            del self.job_model
+        except AttributeError:
+            pass
+
+    @functools.cached_property
+    def job_model(self):
+        return JobModel.objects.get(module_name=self.__module__, job_class_name=self.__name__)
+
+    @functools.cached_property
+    def job_result(self):
+        return JobResult.objects.get(id=self.request.id)
+
+    @functools.cached_property
+    def celery_kwargs(self):
+        return self.job_result.celery_kwargs or {}
+
+    @property
+    def user(self):
+        return getattr(self.job_result, "user", None)
+
     @staticmethod
     def serialize_data(data):
         """
@@ -390,6 +633,7 @@ class BaseJob:
 
         return return_data
 
+    # TODO: can the deserialize_data logic be moved to NautobotKombuJSONEncoder?
     @classmethod
     def deserialize_data(cls, data):
         """
@@ -409,7 +653,7 @@ class BaseJob:
             raise TypeError("Data should be a dictionary.")
 
         for field_name, value in data.items():
-            # If a field isn't a var, skip it (e.g. `_commit`).
+            # If a field isn't a var, skip it (e.g. `_task_queue`).
             try:
                 var = cls_vars[field_name]
             except KeyError:
@@ -467,6 +711,12 @@ class BaseJob:
 
         return f.cleaned_data
 
+    @classmethod
+    def prepare_job_kwargs(cls, job_kwargs):
+        """Process dict and return kwargs that exist as ScriptVariables on this job."""
+        job_vars = cls._get_vars()
+        return {k: v for k, v in job_kwargs.items() if k in job_vars}
+
     @staticmethod
     def load_file(pk):
         """Load a file proxy stored in the database by primary key.
@@ -495,8 +745,7 @@ class BaseJob:
         fp = FileProxy.objects.create(name=uploaded_file.name, file=uploaded_file)
         return fp.pk
 
-    @staticmethod
-    def delete_files(*files_to_delete):
+    def delete_files(self, *files_to_delete):
         """Given an unpacked list of primary keys for `FileProxy` objects, delete them.
 
         Args:
@@ -510,86 +759,9 @@ class BaseJob:
         for fp in files:
             fp.delete()  # Call delete() on each, so `FileAttachment` is reaped
             num += 1
-        logger.debug(f"Deleted {num} file proxies")
+        self.logger.debug("Deleted %d file proxies", num, extra={"grouping": "post_run"})
         return num
 
-    def run(self, data, commit):
-        """
-        Method invoked when this Job is run, before any "test_*" methods.
-        """
-
-    def post_run(self):
-        """
-        Method invoked after "run()" and all "test_*" methods.
-        """
-
-    # Logging
-
-    def _log(self, obj, message, level_choice=LogLevelChoices.LOG_DEFAULT):
-        """
-        Log a message. Do not call this method directly; use one of the log_* wrappers below.
-        """
-        self.job_result.log(
-            message,
-            obj=obj,
-            level_choice=level_choice,
-            grouping=self.active_test,
-            logger=self.logger,
-        )
-
-    def log(self, message):
-        """
-        Log a generic message which is not associated with a particular object.
-        """
-        self._log(None, message, level_choice=LogLevelChoices.LOG_DEFAULT)
-
-    def log_debug(self, message):
-        """
-        Log a debug message which is not associated with a particular object.
-        """
-        self._log(None, message, level_choice=LogLevelChoices.LOG_DEFAULT)
-
-    def log_success(self, obj=None, message=None):
-        """
-        Record a successful test against an object. Logging a message is optional.
-        If the object provided is a string, treat it as a message. This is a carryover of Netbox Report API
-        """
-        if isinstance(obj, str) and message is None:
-            self._log(obj=None, message=obj, level_choice=LogLevelChoices.LOG_SUCCESS)
-        else:
-            self._log(obj, message, level_choice=LogLevelChoices.LOG_SUCCESS)
-
-    def log_info(self, obj=None, message=None):
-        """
-        Log an informational message.
-        If the object provided is a string, treat it as a message. This is a carryover of Netbox Report API
-        """
-        if isinstance(obj, str) and message is None:
-            self._log(obj=None, message=obj, level_choice=LogLevelChoices.LOG_INFO)
-        else:
-            self._log(obj, message, level_choice=LogLevelChoices.LOG_INFO)
-
-    def log_warning(self, obj=None, message=None):
-        """
-        Log a warning.
-        If the object provided is a string, treat it as a message. This is a carryover of Netbox Report API
-        """
-        if isinstance(obj, str) and message is None:
-            self._log(obj=None, message=obj, level_choice=LogLevelChoices.LOG_WARNING)
-        else:
-            self._log(obj, message, level_choice=LogLevelChoices.LOG_WARNING)
-
-    def log_failure(self, obj=None, message=None):
-        """
-        Log a failure. Calling this method will automatically mark the overall job as failed.
-        If the object provided is a string, treat it as a message. This is a carryover of Netbox Report API
-        """
-        if isinstance(obj, str) and message is None:
-            self._log(obj=None, message=obj, level_choice=LogLevelChoices.LOG_FAILURE)
-        else:
-            self._log(obj, message, level_choice=LogLevelChoices.LOG_FAILURE)
-        raise RunJobTaskFailed(message)
-
     # Convenience functions
 
     def load_yaml(self, filename):
@@ -728,6 +900,23 @@ class BooleanVar(ScriptVariable):
         self.field_attrs["required"] = False
 
 
+class DryRunVar(BooleanVar):
+    """
+    Special boolean variable that bypasses approval requirements if this is set to True on job execution.
+    """
+
+    description = "Check to run job in dryrun mode."
+
+    def __init__(self, *args, **kwargs):
+        # Default must be false unless overridden through `dryrun_default` meta attribute
+        kwargs["default"] = False
+
+        # Default description if one was not provided
+        kwargs.setdefault("description", self.description)
+
+        super().__init__(*args, **kwargs)
+
+
 class ChoiceVar(ScriptVariable):
     """
     Select one of several predefined static choices, passed as a list of two-tuples. Example:
@@ -866,9 +1055,8 @@ class JobHookReceiver(Job):
 
     object_change = ObjectVar(model=ObjectChange)
 
-    def run(self, data, commit):
+    def run(self, object_change):
         """JobHookReceiver subclasses generally shouldn't need to override this method."""
-        object_change = data["object_change"]
         self.receive_job_hook(
             change=object_change,
             action=object_change.action,
@@ -895,11 +1083,8 @@ class JobButtonReceiver(Job):
     object_pk = StringVar()
     object_model_name = StringVar()
 
-    def run(self, data, commit):
+    def run(self, object_pk, object_model_name):
         """JobButtonReceiver subclasses generally shouldn't need to override this method."""
-        object_pk = data["object_pk"]
-        object_model_name = data["object_model_name"]
-
         model = get_model_from_name(object_model_name)
         obj = model.objects.get(pk=object_pk)
 
@@ -918,11 +1103,8 @@ def is_job(obj):
     """
     Returns True if the given object is a Job subclass.
     """
-    from .scripts import Script, BaseScript
-    from .reports import Report
-
     try:
-        return issubclass(obj, Job) and obj not in [Job, Script, BaseScript, Report, JobHookReceiver, JobButtonReceiver]
+        return issubclass(obj, Job) and obj not in [Job, JobHookReceiver, JobButtonReceiver]
     except TypeError:
         return False
 
@@ -934,372 +1116,23 @@ def is_variable(obj):
     return isinstance(obj, ScriptVariable)
 
 
-def get_jobs():
-    """
-    Compile a dictionary of all jobs available across all modules in the jobs path(s).
-
-    Returns an OrderedDict:
-
-    {
-        "local": {
-            <module_name>: {
-                "name": <human-readable module name>,
-                "jobs": {
-                   <class_name>: <job_class>,
-                   <class_name>: <job_class>,
-                   ...
-                },
-            },
-            <module_name>: { ... },
-            ...
-        },
-        "git.<repository-slug>": {
-            <module_name>: { ... },
-        },
-        ...
-        "plugins": {
-            <module_name>: { ... },
-        }
-    }
-    """
-    jobs = OrderedDict()
-
-    paths = _get_job_source_paths()
-
-    # Iterate over all filesystem sources (local, git.<slug1>, git.<slug2>, etc.)
-    for source, path in paths.items():
-        for job_info in jobs_in_directory(path):
-            jobs.setdefault(source, {})
-            if job_info.module_name not in jobs[source]:
-                jobs[source][job_info.module_name] = {"name": job_info.job_class.grouping, "jobs": OrderedDict()}
-            jobs[source][job_info.module_name]["jobs"][job_info.job_class_name] = job_info.job_class
-
-    # Add jobs from plugins (which were already imported at startup)
-    for cls in registry["plugin_jobs"]:
-        module = inspect.getmodule(cls)
-        jobs.setdefault("plugins", {}).setdefault(module.__name__, {"name": cls.grouping, "jobs": OrderedDict()})
-        jobs["plugins"][module.__name__]["jobs"][cls.__name__] = cls
-
-    return jobs
-
-
-def _get_job_source_paths():
-    """
-    Helper function to get_jobs().
-
-    Constructs a dict of {"grouping": filesystem_path, ...}.
-    Current groupings are "local", "git.<repository_slug>".
-    Plugin jobs aren't loaded dynamically from a source_path and so are not included in this function
-    """
-    paths = {}
-    # Locally installed jobs
-    if settings.JOBS_ROOT and os.path.exists(settings.JOBS_ROOT):
-        paths["local"] = settings.JOBS_ROOT
-
-    # Jobs derived from Git repositories
-    if settings.GIT_ROOT and os.path.isdir(settings.GIT_ROOT):
-        for repository_record in GitRepository.objects.all():
-            if "extras.job" not in repository_record.provided_contents:
-                # This repository isn't marked as containing jobs that we should use.
-                continue
-
-            try:
-                # In the case where we have multiple Nautobot instances, or multiple worker instances,
-                # they are not required to share a common filesystem; therefore, we may need to refresh our local clone
-                # of the Git repository to ensure that it is in sync with the latest repository clone from any instance.
-                ensure_git_repository(
-                    repository_record,
-                    head=repository_record.current_head,
-                    logger=logger,
-                )
-            except Exception as exc:
-                logger.error(f"Error during local clone of Git repository {repository_record}: {exc}")
-                continue
-
-            jobs_path = os.path.join(repository_record.filesystem_path, "jobs")
-            if os.path.isdir(jobs_path):
-                paths[f"git.{repository_record.slug}"] = jobs_path
-            else:
-                logger.warning(f"Git repository {repository_record} is configured to provide jobs, but none are found!")
-
-        # TODO(Glenn): when a Git repo is deleted or its slug is changed, we update the local filesystem
-        # (see extras/signals.py, extras/models/datasources.py), but as noted above, there may be multiple filesystems
-        # involved, so not all local clones of deleted Git repositories may have been deleted yet.
-        # For now, if we encounter a "leftover" Git repo here, we delete it now.
-        for git_slug in os.listdir(settings.GIT_ROOT):
-            git_path = os.path.join(settings.GIT_ROOT, git_slug)
-            if not os.path.isdir(git_path):
-                logger.warning(
-                    f"Found non-directory {git_slug} in {settings.GIT_ROOT}. Only Git repositories should exist here."
-                )
-            elif not os.path.isdir(os.path.join(git_path, ".git")):
-                logger.warning(f"Directory {git_slug} in {settings.GIT_ROOT} does not appear to be a Git repository.")
-            elif not GitRepository.objects.filter(slug=git_slug):
-                logger.warning(f"Deleting unmanaged (leftover?) repository at {git_path}")
-                shutil.rmtree(git_path)
-
-    return paths
-
-
-def get_job_classpaths():
-    """
-    Get a list of all known Job class_path strings.
-
-    This is used as a cacheable, light-weight alternative to calling get_jobs() or get_job()
-    when all that's needed is to verify whether a given job exists.
-    """
-    jobs_dict = get_jobs()
-    result = set()
-    for grouping_name, modules_dict in jobs_dict.items():
-        for module_name in modules_dict:
-            for class_name in modules_dict[module_name]["jobs"]:
-                result.add(f"{grouping_name}/{module_name}/{class_name}")
-    return result
-
-
 def get_job(class_path):
     """
-    Retrieve a specific job class by its class_path.
+    Retrieve a specific job class by its class_path (<module_name>.<JobClassName>).
 
-    Note that this is built atop get_jobs() and so is not a particularly light-weight API;
-    if all you need to do is to verify whether a given class_path exists, use get_job_classpaths() instead.
-
-    Returns None if not found.
+    May return None if the job isn't properly registered with Celery at this time.
     """
     try:
-        grouping_name, module_name, class_name = class_path.split("/", 2)
-    except ValueError:
-        logger.error(f'Invalid class_path value "{class_path}"')
+        return celery_app.tasks[class_path].__class__
+    except NotRegistered:
         return None
 
-    jobs = get_jobs()
-    return jobs.get(grouping_name, {}).get(module_name, {}).get("jobs", {}).get(class_name, None)
-
-
-class RunJobTaskFailed(Exception):
-    """Celery task failed for some reason."""
-
-
-@nautobot_task
-def run_job(data, request, job_result_pk, commit=True, *args, **kwargs):
-    """
-    Helper function to call the "run()", "test_*()", and "post_run" methods on a Job.
-
-    This function is responsible for setting up the job execution, handing the DB tranaction
-    and rollback conditions, plus post execution cleanup and saving the JobResult record.
-    """
-    from nautobot.extras.models import JobResult  # avoid circular import
-
-    # Getting the correct job result can fail if the stored data cannot be serialized.
-    # Catching `TypeError: the JSON object must be str, bytes or bytearray, not int`
-    job_result = JobResult.objects.get(pk=job_result_pk)
-
-    job_model = job_result.job_model
-    initialization_failure = None
-    job_model = JobModel.objects.get_for_class_path(job_result.name)
-
-    if not job_model.enabled:
-        initialization_failure = f"Job {job_model} is not enabled to be run!"
-    else:
-        job_class = job_model.job_class
-
-        if not job_model.installed or not job_class:
-            initialization_failure = f'Unable to locate job "{job_result.name}" to run it!'
-
-    if initialization_failure:
-        job_result.log(
-            message=initialization_failure,
-            obj=job_model,
-            level_choice=LogLevelChoices.LOG_FAILURE,
-            grouping="initialization",
-            logger=logger,
-        )
-        raise RunJobTaskFailed(initialization_failure)
-
-    job = job_class()
-    job.active_test = "initialization"
-    job.job_result = job_result
-
-    soft_time_limit = job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
-    time_limit = job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
-    if time_limit <= soft_time_limit:
-        job_result.log(
-            f"The hard time limit of {time_limit} seconds is less than "
-            f"or equal to the soft time limit of {soft_time_limit} seconds. "
-            f"This job will fail silently after {time_limit} seconds.",
-            level_choice=LogLevelChoices.LOG_WARNING,
-            grouping="initialization",
-            logger=logger,
-        )
-
-    file_ids = None
-    try:
-        # Capture the file IDs for any FileProxy objects created so we can cleanup later.
-        file_fields = list(job._get_file_vars())
-        file_ids = [data[f] for f in file_fields]
-
-        # Attempt to resolve serialized data back into original form by creating querysets or model instances
-        # If we fail to find any objects, we consider this a job execution error, and fail.
-        # This might happen when a job sits on the queue for a while (i.e. scheduled) and data has changed
-        # or it might be bad input from an API request, or manual execution.
-
-        data = job_class.deserialize_data(data)
-    # TODO(jathan): Another place where because `log()` is called which mutates `.data`, we must
-    # explicitly call `save()` again. We need to see if we can move more of this to `NauotbotTask`
-    # and/or the DB backend as well.
-    except Exception:
-        stacktrace = traceback.format_exc()
-        job_result.log(
-            f"Error initializing job:\n```\n{stacktrace}\n```",
-            level_choice=LogLevelChoices.LOG_FAILURE,
-            grouping="initialization",
-            logger=logger,
-        )
-        job_result.save()
-        if file_ids:
-            # Cleanup FileProxy objects
-            job.delete_files(*file_ids)  # pylint: disable=not-an-iterable
-        raise
-
-    if job_model.read_only:
-        # Force commit to false for read only jobs.
-        commit = False
-
-    # TODO(Glenn): validate that all args required by this job are set in the data or else log helpful errors?
-
-    job.logger.info(f"Running job (commit={commit})")
-
-    # Add the current request as a property of the job
-    job.request = request
-
-    def _run_job():
-        """
-        Core job execution task.
-
-        We capture this within a subfunction to allow for conditionally wrapping it with the change_logging
-        context manager (which is only relevant if commit == True).
-
-        If the job is marked as read_only == True, then commit is forced to False and no log messages will be
-        emitted related to reverting database changes.
-        """
-        started = timezone.now()
-        job.results["output"] = ""
-        try:
-            with transaction.atomic():
-                # Script-like behavior
-                job.active_test = "run"
-                output = job.run(data=data, commit=commit)
-                if output:
-                    job.results["output"] += "\n" + str(output)
-
-                # Report-like behavior
-                for method_name in job.test_methods:
-                    job.active_test = method_name
-                    output = getattr(job, method_name)()
-                    if output:
-                        job.results["output"] += "\n" + str(output)
-
-                job.logger.info("job completed successfully")
-
-                if not commit:
-                    raise AbortTransaction("Database changes have been reverted automatically.")
-
-        except AbortTransaction:
-            if not job_model.read_only:
-                job.log_info(message="Database changes have been reverted automatically.")
-
-        except Exception:
-            if not job_model.read_only:
-                job.log_info(message="Database changes have been reverted due to error.")
-            raise
-
-        # TODO(jathan): For now we still need to call `save()` so that any output data from the job
-        # that was stored gets saved to the `JobResult`. We need to consider where this should be
-        # moved as we get closer to eliminating `run_job()` entirely. Hint: Probably inside of
-        # `NautobotTask` class.
-        finally:
-            _data = copy.deepcopy(job_result.data)
-            job_result.refresh_from_db()
-            job_result.data = _data
-            try:
-                job_result.save()
-            except IntegrityError:
-                # handle job_model deleted while job was running
-                job_result.job_model = None
-                job_result.save()
-            if file_ids:
-                job.delete_files(*file_ids)  # Cleanup FileProxy objects
-
-        # TODO(jathan): Pretty sure this can also be handled by the backend, but
-        # leaving it for now.
-        # record data about this jobrun in the scheduled_job
-        if job_result.scheduled_job:
-            job_result.scheduled_job.total_run_count += 1
-            job_result.scheduled_job.last_run_at = started
-            job_result.scheduled_job.save()
-
-        # Perform any post-run tasks
-        # 2.0 TODO Remove post_run() method entirely
-        job.active_test = "post_run"
-        output = job.post_run()
-        # TODO(jathan): We need to call `save()` here too so that any appended output from
-        # `post_run` gets stored on the `JobResult`. We need to move this out of here as well.
-        if output:
-            job.results["output"] += "\n" + str(output)
-            job_result.save()
-
-        job_result.refresh_from_db()
-        job.logger.info(f"Job completed in {job_result.duration}")
-
-        # TODO(jathan): For now this is only output from `post_run()` which is not straightforward.
-        # We need to think about what we want to be returned from job runs and stored as
-        # `JobResult.result`, otherwise it will always be `None`.
-        return output
-
-    # Execute the job. If commit == True, wrap it with the change_logging context manager to ensure we
-    # process change logs, webhooks, etc.
-    if commit:
-        context_class = JobHookChangeContext if job_model.is_job_hook_receiver else JobChangeContext
-        change_context = context_class(user=request.user, context_detail=job_model.slug)
-        with change_logging(change_context):
-            output = _run_job()
-    else:
-        output = _run_job()
-
-    # This is just passing through the return value from `post_run()` which for now will always be
-    # `None` (see above).
-    return output
-
-
-@nautobot_task
-def scheduled_job_handler(*args, **kwargs):
-    """
-    A thin wrapper around JobResult.enqueue_job() that allows for it to be called as an async task
-    for the purposes of enqueuing scheduled jobs at their recurring intervals. Thus, JobResult.enqueue_job()
-    is responsible for enqueuing the actual job for execution and this method is the task executed
-    by the scheduler to kick off the job execution on a recurring interval.
-    """
-    from nautobot.extras.models import JobResult  # avoid circular import
-
-    user_pk = kwargs.pop("user")
-    user = User.objects.get(pk=user_pk)
-    name = kwargs.pop("name")
-    scheduled_job_pk = kwargs.pop("scheduled_job_pk")
-    celery_kwargs = kwargs.pop("celery_kwargs", {})
-    schedule = ScheduledJob.objects.get(pk=scheduled_job_pk)
-
-    job_content_type = get_job_content_type()
-    JobResult.enqueue_job(
-        run_job, name, job_content_type, user, celery_kwargs=celery_kwargs, schedule=schedule, **kwargs
-    )
-
 
 def enqueue_job_hooks(object_change):
     """
     Find job hook(s) assigned to this changed object type + action and enqueue them
     to be processed
     """
-    from nautobot.extras.models import JobResult  # avoid circular import
 
     # Job hooks cannot trigger other job hooks
     if object_change.change_context == ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK:
@@ -1321,16 +1154,5 @@ def enqueue_job_hooks(object_change):
 
     # Enqueue the jobs related to the job_hooks
     for job_hook in job_hooks:
-        job_content_type = get_job_content_type()
         job_model = job_hook.job
-        request = RequestFactory().request(SERVER_NAME="job_hook")
-        request.user = object_change.user
-        JobResult.enqueue_job(
-            run_job,
-            job_model.class_path,
-            job_content_type,
-            object_change.user,
-            data=job_model.job_class.serialize_data({"object_change": object_change}),
-            request=copy_safe_request(request),
-            commit=True,
-        )
+        JobResult.enqueue_job(job_model, object_change.user, object_change=object_change.pk)