nautobot 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

nautobot/extras/datasources/git.py

@@ -7,7 +7,6 @@ import mimetypes
 import os
 from pathlib import Path
 import re
-import sys
 from urllib.parse import quote
 
 from django.conf import settings
@@ -17,9 +16,9 @@ from django.db import transaction
 from git import InvalidGitRepositoryError, Repo
 import yaml
 
-from nautobot.core.celery import app as celery_app
 from nautobot.core.utils.git import GitRepo
-from nautobot.dcim.models import Device, DeviceType, Location, Platform
+from nautobot.core.utils.module_loading import import_modules_privately
+from nautobot.dcim.models import Device, DeviceRedundancyGroup, DeviceType, Location, Platform
 from nautobot.extras.choices import (
     LogLevelChoices,
     SecretsGroupAccessTypeChoices,
@@ -36,7 +35,7 @@ from nautobot.extras.models import (
     Role,
     Tag,
 )
-from nautobot.extras.registry import DatasourceContent, register_datasource_contents
+from nautobot.extras.registry import DatasourceContent, register_datasource_contents, registry
 from nautobot.extras.utils import refresh_job_model_from_job_class
 from nautobot.tenancy.models import Tenant, TenantGroup
 from nautobot.virtualization.models import Cluster, ClusterGroup, VirtualMachine
@@ -186,7 +185,7 @@ def ensure_git_repository(repository_record, logger=None, head=None):  # pylint:
 def git_repository_dry_run(repository_record, logger):  # pylint: disable=redefined-outer-name
     """Log the difference between local branch and remote branch files.
     Args:
-        repository_record (GitRepository): The GitRepostiory instance to diff.
+        repository_record (GitRepository): The GitRepository instance to diff.
         logger (logging.Logger): Logger to log results to.
     """
     from_url, to_path, from_branch = get_repo_from_url_to_path_and_from_branch(repository_record)
@@ -272,6 +271,7 @@ def update_git_config_contexts(repository_record, job_result):
         "tenants",
         "tags",
         "dynamic_groups",
+        "device_redundancy_groups",
     ):
         if os.path.isdir(os.path.join(repository_record.filesystem_path, filter_type)):
             msg = (
@@ -402,6 +402,7 @@ def import_config_context(context_data, repository_record, job_result):
         ("tenants", Tenant),
         ("tags", Tag),
         ("dynamic_groups", DynamicGroup),
+        ("device_redundancy_groups", DeviceRedundancyGroup),
     ]:
         relations[key] = []
         for object_data in context_metadata.get(key, ()):
@@ -714,56 +715,41 @@ def delete_git_config_context_schemas(repository_record, job_result, preserve=()
 #
 
 
-def refresh_code_from_repository(repository_slug, consumer=None, skip_reimport=False):
+def refresh_job_code_from_repository(repository_slug, skip_reimport=False, ignore_import_errors=True):
     """
-    After cloning/updating a GitRepository on disk, call this function to reload and reregister the repo's Python code.
+    After cloning/updating/deleting a GitRepository on disk, call this function to reload and reregister its Python.
 
     Args:
-        repository_slug (str): Repository directory in GIT_ROOT that was refreshed.
-        consumer (celery.worker.Consumer): Celery Consumer to update as well
+        repository_slug (str): Repository directory in GIT_ROOT that was updated or deleted.
         skip_reimport (bool): If True, unload existing code from this repository but do not re-import it.
+        ignore_import_errors (bool): If True, any exceptions raised in the import will be caught and logged.
+            If False, exceptions will be re-raised after logging.
     """
-    if settings.GIT_ROOT not in sys.path:
-        sys.path.append(settings.GIT_ROOT)
-
-    app = consumer.app if consumer is not None else celery_app
-    # TODO: This is ugly, but when app.use_fast_trace_task is set (true by default), Celery calls
-    # celery.app.trace.fast_trace_task(...) which assumes that all tasks are cached and have a valid `__trace__()`
-    # function defined. In theory consumer.update_strategies() (below) should ensure this, but it doesn't
-    # go far enough (possibly a discrepancy between the main worker process and the prefork executors?)
-    # as we can and do still encounter errors where `task.__trace__` is unexpectedly None.
-    # For now, simply disabling use_fast_trace_task forces the task trace function to be rebuilt each time,
-    # which avoids the issue at the cost of very slight overhead.
-    app.use_fast_trace_task = False
-
     # Unload any previous version of this module and its submodules if present
-    for module_name in list(sys.modules):
-        if module_name == repository_slug or module_name.startswith(f"{repository_slug}."):
-            logger.debug("Unloading module %s", module_name)
-            if module_name in app.loader.task_modules:
-                app.loader.task_modules.remove(module_name)
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-
-    # Unregister any previous Celery tasks from this module
-    for task_name in list(app.tasks):
-        if task_name.startswith(f"{repository_slug}."):
-            logger.debug("Unregistering Celery task %s", task_name)
-            app.tasks.unregister(task_name)
-            if consumer is not None and task_name in consumer.strategies:
-                del consumer.strategies[task_name]
-
-    if not skip_reimport:
-        try:
-            repository = GitRepository.objects.get(slug=repository_slug)
-            if "extras.job" in repository.provided_contents:
-                # Re-import Celery tasks from this module
-                logger.debug("Importing Jobs from %s.jobs in GIT_ROOT", repository_slug)
-                app.loader.import_task_module(f"{repository_slug}.jobs")
-                if consumer is not None:
-                    consumer.update_strategies()
-        except GitRepository.DoesNotExist as exc:
-            logger.error("Unable to reload Jobs from %s.jobs: %s", repository_slug, exc)
+    for job_class_path in list(registry["jobs"]):
+        if job_class_path.startswith(f"{repository_slug}."):
+            del registry["jobs"][job_class_path]
+
+    if skip_reimport:
+        return
+
+    try:
+        repository = GitRepository.objects.get(slug=repository_slug)
+        if "extras.job" in repository.provided_contents:
+            if not (
+                os.path.isdir(os.path.join(repository.filesystem_path, "jobs"))
+                or os.path.isfile(os.path.join(repository.filesystem_path, "jobs.py"))
+            ):
+                logger.error("No `jobs` submodule found in Git repository %s", repository)
+                if not ignore_import_errors:
+                    raise FileNotFoundError(f"No `jobs` submodule found in Git repository {repository}")
+            else:
+                import_modules_privately(
+                    settings.GIT_ROOT, module_path=[repository_slug, "jobs"], ignore_import_errors=ignore_import_errors
+                )
+    except GitRepository.DoesNotExist as exc:
+        logger.error("Unable to reload Jobs from %s.jobs: %s", repository_slug, exc)
+        if not ignore_import_errors:
             raise
 
 
@@ -773,13 +759,13 @@ def refresh_git_jobs(repository_record, job_result, delete=False):
     if "extras.job" in repository_record.provided_contents and not delete:
         found_jobs = False
         try:
-            refresh_code_from_repository(repository_record.slug)
+            refresh_job_code_from_repository(repository_record.slug, ignore_import_errors=False)
 
-            for task_name, task in celery_app.tasks.items():
-                if not task_name.startswith(f"{repository_record.slug}."):
+            for job_class_path, job_class in registry["jobs"].items():
+                if not job_class_path.startswith(f"{repository_record.slug}.jobs."):
                     continue
                 found_jobs = True
-                job_model, created = refresh_job_model_from_job_class(Job, task.__class__)
+                job_model, created = refresh_job_model_from_job_class(Job, job_class)
 
                 if job_model is None:
                     msg = "Failed to create Job record; check Nautobot logs for details"
@@ -788,15 +774,18 @@ def refresh_git_jobs(repository_record, job_result, delete=False):
                     continue
 
                 if created:
-                    message = "Created Job record"
+                    message = f"Created Job record for {job_class_path}"
                 else:
-                    message = "Refreshed Job record"
+                    message = f"Refreshed Job record for {job_class_path}"
                 logger.info(message)
                 job_result.log(message=message, obj=job_model, grouping="jobs", level_choice=LogLevelChoices.LOG_INFO)
                 installed_jobs.append(job_model)
 
             if not found_jobs:
-                msg = "No jobs were registered on loading the `jobs` submodule. Did you miss a `register_jobs()` call?"
+                msg = (
+                    f"No jobs were registered on loading the `{repository_record.slug}.jobs` submodule. "
+                    "Did you miss a `register_jobs()` call? Or was there a syntax error or similar in your code?"
+                )
                 logger.warning(msg)
                 job_result.log(msg, grouping="jobs", level_choice=LogLevelChoices.LOG_WARNING)
         except Exception as exc:
@@ -804,8 +793,8 @@ def refresh_git_jobs(repository_record, job_result, delete=False):
             logger.error(msg)
             job_result.log(msg, grouping="jobs", level_choice=LogLevelChoices.LOG_ERROR)
     else:
-        # Unload code from this repository, do not reimport it
-        refresh_code_from_repository(repository_record.slug, skip_reimport=True)
+        # Flush this repository's job classes
+        refresh_job_code_from_repository(repository_record.slug, skip_reimport=True)
 
     for job_model in Job.objects.filter(module_name__startswith=f"{repository_record.slug}."):
         if job_model.installed and job_model not in installed_jobs:

nautobot/extras/forms/forms.py

@@ -844,8 +844,10 @@ class JobEditForm(NautobotModelForm):
         """
         For all overridable fields, if they aren't marked as overridden, revert them to the underlying value if known.
         """
+        from nautobot.extras.jobs import get_job  # avoid circular import
+
         cleaned_data = super().clean() or self.cleaned_data
-        job_class = self.instance.job_class
+        job_class = get_job(self.instance.class_path, reload=True)
         if job_class is not None:
             for field_name in JOB_OVERRIDABLE_FIELDS:
                 if not cleaned_data.get(f"{field_name}_override", False):

nautobot/extras/jobs.py

@@ -6,18 +6,14 @@ import inspect
 import json
 import logging
 import os
+import sys
 import tempfile
 from textwrap import dedent
 from typing import final
 import warnings
 
-from billiard.einfo import ExceptionInfo, ExceptionWithTraceback
-from celery import states
-from celery.exceptions import NotRegistered, Retry
-from celery.result import EagerResult
-from celery.utils.functional import maybe_list
+from billiard.einfo import ExceptionInfo
 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
@@ -30,12 +26,10 @@ from django.db.models import Model
 from django.db.models.query import QuerySet
 from django.forms import ValidationError
 from django.utils.functional import classproperty
-from kombu.utils.uuid import uuid
 import netaddr
 import yaml
 
-from nautobot.core.celery import app as celery_app
-from nautobot.core.celery.task import Task
+from nautobot.core.celery import import_jobs, nautobot_task
 from nautobot.core.forms import (
     DynamicModelChoiceField,
     DynamicModelMultipleChoiceField,
@@ -53,6 +47,7 @@ from nautobot.extras.models import (
     JobResult,
     ObjectChange,
 )
+from nautobot.extras.registry import registry
 from nautobot.extras.utils import change_logged_models_queryset, task_queues_as_choices
 from nautobot.ipam.formfields import IPAddressFormField, IPNetworkFormField
 from nautobot.ipam.validators import (
@@ -88,7 +83,7 @@ class RunJobTaskFailed(Exception):
     """Celery task failed for some reason."""
 
 
-class BaseJob(Task):
+class BaseJob:
     """Base model for jobs.
 
     Users can subclass this directly if they want to provide their own base class for implementing multiple jobs
@@ -158,38 +153,6 @@ class BaseJob(Task):
 
     # 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.
 
@@ -201,8 +164,6 @@ class BaseJob(Task):
         Returns:
             (None): The return value of this handler is ignored.
         """
-        self.clear_cache()
-
         try:
             self.job_result
         except ObjectDoesNotExist as err:
@@ -234,7 +195,7 @@ class BaseJob(Task):
                 extra={"grouping": "initialization"},
             )
 
-        self.logger.info("Running job", extra={"grouping": "initialization"})
+        self.logger.info("Running job", extra={"grouping": "initialization", "object": self.job_model})
 
     def run(self, *args, **kwargs):
         """
@@ -314,84 +275,10 @@ class BaseJob(Task):
         if status == JobResultStatusChoices.STATUS_SUCCESS:
             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
-        }
-        if "stamped_headers" in options:
-            request["stamped_headers"] = maybe_list(options["stamped_headers"])
-            request["stamps"] = {header: maybe_list(options.get(header, [])) for header in request["stamped_headers"]}
-
-        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, ExceptionWithTraceback):
-                retval = retval.exc
-        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)
-
     @final
     @classproperty
     def file_path(cls) -> str:  # pylint: disable=no-self-argument
+        """Deprecated as of Nautobot 2.2.3."""
         return inspect.getfile(cls)
 
     @final
@@ -430,7 +317,7 @@ class BaseJob(Task):
     @classproperty
     def grouping(cls) -> str:  # pylint: disable=no-self-argument
         module = inspect.getmodule(cls)
-        return getattr(module, "name", module.__name__)
+        return getattr(module, "name", cls.__module__)
 
     @final
     @classmethod
@@ -530,6 +417,7 @@ class BaseJob(Task):
     @final
     @classproperty
     def registered_name(cls) -> str:  # pylint: disable=no-self-argument
+        """Deprecated - use class_path classproperty instead."""
         return f"{cls.__module__}.{cls.__name__}"
 
     @classmethod
@@ -545,7 +433,10 @@ class BaseJob(Task):
         base_classes = reversed(inspect.getmro(cls))
         attr_names = [name for base in base_classes for name in base.__dict__.keys()]
         for name in attr_names:
-            attr_class = getattr(cls, name, None).__class__
+            try:
+                attr_class = getattr(cls, name, None).__class__
+            except TypeError:
+                pass
             if name not in cls_vars and issubclass(attr_class, ScriptVariable):
                 cls_vars[name] = getattr(cls, name)
 
@@ -612,27 +503,9 @@ class BaseJob(Task):
 
         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__)
+        return JobModel.objects.get(module_name=self.__module__, job_class_name=self.__class__.__name__)
 
     @functools.cached_property
     def job_result(self):
@@ -1199,16 +1072,76 @@ def is_variable(obj):
     return isinstance(obj, ScriptVariable)
 
 
-def get_job(class_path):
+def get_jobs(*, reload=False):
+    """
+    Compile a dictionary of all Job classes available at this time.
+
+    Args:
+        reload (bool): If True, reimport Jobs from `JOBS_ROOT` and all applicable GitRepositories.
+
+    Returns:
+        (dict): `{"class_path.Job1": <job_class>, "class_path.Job2": <job_class>, ...}`
+    """
+    if reload:
+        import_jobs()
+
+    return registry["jobs"]
+
+
+def get_job(class_path, reload=False):
     """
     Retrieve a specific job class by its class_path (`<module_name>.<JobClassName>`).
 
-    May return None if the job isn't properly registered with Celery at this time.
+    May return None if the job can't be imported.
+
+    Args:
+        reload (bool): If True, **and** the given class_path describes a JOBS_ROOT or GitRepository Job,
+            then refresh **all** such Jobs before retrieving the job class.
+    """
+    if reload:
+        if class_path.startswith("nautobot."):
+            # System job - not reloadable
+            reload = False
+        if any(class_path.startswith(f"{app_name}.") for app_name in settings.PLUGINS):
+            # App provided job - not reloadable
+            reload = False
+    jobs = get_jobs(reload=reload)
+    return jobs.get(class_path, None)
+
+
+@nautobot_task(bind=True)
+def run_job(self, job_class_path, *args, **kwargs):
+    """
+    "Runner" function for execution of any Job class by a worker.
+
+    This calls the following Job APIs in the following order:
+
+    - `__init__()`
+    - `before_start()`
+    - `__call__()` (which calls `run()`)
+    - If no exceptions have been raised, `on_success()`, else `on_failure()`
+    - `after_return()`
+
+    Finally, it either returns the data returned from `run()` or re-raises any exception encountered.
     """
+    logger.debug("Running job %s", job_class_path)
+
+    job_class = get_job(job_class_path, reload=True)
+    if job_class is None:
+        raise KeyError(f"Job class not found for class path {job_class_path}")
+    job = job_class()
+    job.request = self.request
     try:
-        return celery_app.tasks[class_path].__class__
-    except NotRegistered:
-        return None
+        job.before_start(self.request.id, args, kwargs)
+        result = job(*args, **kwargs)
+        job.on_success(result, self.request.id, args, kwargs)
+        job.after_return(JobResultStatusChoices.STATUS_SUCCESS, result, self.request.id, args, kwargs, None)
+        return result
+    except Exception as exc:
+        einfo = ExceptionInfo(sys.exc_info())
+        job.on_failure(exc, self.request.id, args, kwargs, einfo)
+        job.after_return(JobResultStatusChoices.STATUS_FAILURE, exc, self.request.id, args, kwargs, einfo)
+        raise
 
 
 def enqueue_job_hooks(object_change):

nautobot/extras/models/datasources.py

@@ -97,8 +97,6 @@ class GitRepository(PrimaryModel):
         if not self.present_in_database:
             check_if_key_is_graphql_safe(self.__class__.__name__, self.slug, "slug")
             # Check on create whether the proposed slug conflicts with a module name already in the Python environment.
-            # Because we add GIT_ROOT to the end of sys.path, trying to import this repository will instead
-            # import the earlier-found Python module in its place, which would be undesirable.
             if find_spec(self.slug) is not None:
                 raise ValidationError(
                     f'Please choose a different slug, as "{self.slug}" is an installed Python package or module.'

nautobot/extras/models/jobs.py

@@ -5,6 +5,7 @@ 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
 from django.contrib.contenttypes.models import ContentType
@@ -22,7 +23,6 @@ from nautobot.core.celery import (
     NautobotKombuJSONEncoder,
     setup_nautobot_job_logging,
 )
-from nautobot.core.celery.control import refresh_git_repository
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models import BaseManager, BaseModel
 from nautobot.core.models.fields import JSONArrayField
@@ -233,13 +233,20 @@ class Job(PrimaryModel):
     def __str__(self):
         return self.name
 
-    @cached_property
+    @property
     def job_class(self):
-        """Get the Job class (source code) associated with this Job model."""
+        """
+        Get the Job class (source code) associated with this Job model.
+
+        CAUTION: if the Job is provided by a Git Repository or is installed in JOBS_ROOT, you may need or wish to
+        call `get_job(self.class_path, reload=True)` to ensure that you have the latest Job code...
+        """
+        from nautobot.extras.jobs import get_job
+
         if not self.installed:
             return None
         try:
-            return self.job_task.__class__
+            return get_job(self.class_path)
         except Exception as exc:
             logger.error(str(exc))
             return None
@@ -278,20 +285,23 @@ class Job(PrimaryModel):
 
     @property
     def job_task(self):
-        """Get the registered Celery task, refreshing it if necessary."""
-        if self.git_repository is not None:
-            # If this Job comes from a Git repository, make sure we have the correct version of said code.
-            refresh_git_repository(
-                state=None, repository_pk=self.git_repository.pk, head=self.git_repository.current_head
-            )
-        return app.tasks[f"{self.module_name}.{self.job_class_name}"]
+        """Get an instance of the associated Job class, refreshing it if necessary."""
+        from nautobot.extras.jobs import get_job
+
+        try:
+            return get_job(self.class_path, reload=True)()
+        except TypeError as err:  # keep 2.0-2.2.2 exception behavior
+            raise NotRegistered from err
 
     def clean(self):
         """For any non-overridden fields, make sure they get reset to the actual underlying class value if known."""
-        if self.job_class is not None:
+        from nautobot.extras.jobs import get_job
+
+        job_class = get_job(self.class_path, reload=True)
+        if job_class is not None:
             for field_name in JOB_OVERRIDABLE_FIELDS:
                 if not getattr(self, f"{field_name}_override", False):
-                    setattr(self, field_name, getattr(self.job_class, field_name))
+                    setattr(self, field_name, getattr(job_class, field_name))
 
         # Protect against invalid input when auto-creating Job records
         if len(self.module_name) > JOB_MAX_NAME_LENGTH:
@@ -617,12 +627,14 @@ class JobResult(BaseModel, CustomFieldModel):
             schedule (ScheduledJob, optional): ScheduledJob instance to link to the JobResult. Cannot be used with synchronous=True.
             task_queue (str, optional): The celery queue to send the job to. If not set, use the default celery queue.
             synchronous (bool, optional): If True, run the job in the current process, blocking until the job completes.
-            *job_args: positional args passed to the job task
+            *job_args: positional args passed to the job task (UNUSED)
             **job_kwargs: keyword args passed to the job task
 
         Returns:
             JobResult instance
         """
+        from nautobot.extras.jobs import run_job  # TODO circular import
+
         if schedule is not None and synchronous:
             raise ValueError("Scheduled jobs cannot be run synchronously")
 
@@ -666,8 +678,11 @@ class JobResult(BaseModel, CustomFieldModel):
             redirect_logger = get_logger("celery.redirected")
             proxy = LoggingProxy(redirect_logger, app.conf.worker_redirect_stdouts_level)
             with contextlib.redirect_stdout(proxy), contextlib.redirect_stderr(proxy):
-                eager_result = job_model.job_task.apply(
-                    args=job_args, kwargs=job_kwargs, task_id=str(job_result.id), **job_celery_kwargs
+                eager_result = run_job.apply(
+                    args=[job_model.class_path, *job_args],
+                    kwargs=job_kwargs,
+                    task_id=str(job_result.id),
+                    **job_celery_kwargs,
                 )
 
             # copy fields from eager result to job result
@@ -687,8 +702,11 @@ class JobResult(BaseModel, CustomFieldModel):
         else:
             # Jobs queued inside of a transaction need to run after the transaction completes and the JobResult is saved to the database
             transaction.on_commit(
-                lambda: job_model.job_task.apply_async(
-                    args=job_args, kwargs=job_kwargs, task_id=str(job_result.id), **job_celery_kwargs
+                lambda: run_job.apply_async(
+                    args=[job_model.class_path, *job_args],
+                    kwargs=job_kwargs,
+                    task_id=str(job_result.id),
+                    **job_celery_kwargs,
                 )
             )