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

nautobot/apps/jobs.py

@@ -12,6 +12,7 @@ from nautobot.extras.jobs import (
     enqueue_job_hooks,
     FileVar,
     get_job,
+    get_jobs,
     IntegerVar,
     IPAddressVar,
     IPAddressWithMaskVar,
@@ -40,6 +41,7 @@ __all__ = (
     "enqueue_job_hooks",
     "FileVar",
     "get_job",
+    "get_jobs",
     "GitRepositoryDryRun",
     "GitRepositorySync",
     "IntegerVar",

nautobot/core/api/utils.py

@@ -167,28 +167,31 @@ def is_api_request(request):
     return request.path_info.startswith(api_path)
 
 
-def get_view_name(view, suffix=None):
+def get_view_name(view):
     """
     Derive the view name from its associated model, if it has one. Fall back to DRF's built-in `get_view_name`.
     """
-    if hasattr(view, "queryset"):
+    if hasattr(view, "name") and view.name:
+        return view.name
+    elif hasattr(view, "queryset"):
         # Determine the model name from the queryset.
-        name = view.queryset.model._meta.verbose_name
+        if hasattr(view, "detail") and view.detail:
+            name = view.queryset.model._meta.verbose_name
+        else:
+            name = view.queryset.model._meta.verbose_name_plural
         name = " ".join([w[0].upper() + w[1:] for w in name.split()])  # Capitalize each word
 
     else:
         # Replicate DRF's built-in behavior.
-        name = getattr(view, "name", None)
-        if name is not None:
-            return view.name
-
         name = view.__class__.__name__
         name = formatting.remove_trailing_string(name, "View")
         name = formatting.remove_trailing_string(name, "ViewSet")
         name = formatting.camelcase_to_spaces(name)
 
-    if suffix:
-        name += " " + suffix
+        # Suffix may be set by some Views, such as a ViewSet.
+        suffix = getattr(view, "suffix", None)
+        if suffix:
+            name += " " + suffix
 
     return name
 

nautobot/core/apps/__init__.py

@@ -918,9 +918,9 @@ class CoreConfig(NautobotConfig):
         super().ready()
 
         # Register jobs last after everything else has been done.
-        from nautobot.core.celery import app, import_jobs_as_celery_tasks
+        from nautobot.core.celery import import_jobs
 
-        import_jobs_as_celery_tasks(app, database_ready=False)
+        import_jobs()
 
 
 class NautobotConstanceConfig(ConstanceConfig):

nautobot/core/celery/__init__.py

@@ -1,16 +1,14 @@
-from importlib.util import find_spec
 import json
 import logging
 import os
 from pathlib import Path
-import pkgutil
 import shutil
-import sys
 
 from celery import Celery, shared_task, signals
 from celery.app.log import TaskFormatter
 from celery.utils.log import get_logger
 from django.conf import settings
+from django.db.utils import ProgrammingError
 from django.utils.functional import SimpleLazyObject
 from django.utils.module_loading import import_string
 from kombu.serialization import register
@@ -19,6 +17,8 @@ from prometheus_client import CollectorRegistry, multiprocess, start_http_server
 from nautobot.core.celery.control import discard_git_repository, refresh_git_repository  # noqa: F401  # unused-import
 from nautobot.core.celery.encoders import NautobotKombuJSONEncoder
 from nautobot.core.celery.log import NautobotDatabaseHandler
+from nautobot.core.utils.module_loading import import_modules_privately
+from nautobot.extras.registry import registry
 
 logger = logging.getLogger(__name__)
 
@@ -29,16 +29,6 @@ os.environ.setdefault("DJANGO_SETTINGS_MODULE", "nautobot_config")
 class NautobotCelery(Celery):
     task_cls = "nautobot.core.celery.task:NautobotTask"
 
-    def register_task(self, task, **options):
-        """Override the default task name for job classes to allow app provided jobs to use the full module path."""
-        from nautobot.extras.jobs import Job
-
-        if issubclass(task, Job):
-            task = task()
-            task.name = task.registered_name
-
-        return super().register_task(task, **options)
-
 
 app = NautobotCelery("nautobot")
 
@@ -53,60 +43,77 @@ app.autodiscover_tasks()
 
 
 @signals.import_modules.connect
-def import_jobs_as_celery_tasks(sender, database_ready=True, **kwargs):
+def import_jobs(sender=None, **kwargs):
     """
-    Import system Jobs into Celery as well as Jobs from JOBS_ROOT and GIT_ROOT.
+    Import system Jobs into Nautobot as well as Jobs from JOBS_ROOT and GIT_ROOT.
+
+    Note that app-provided jobs are automatically imported at startup time via NautobotAppConfig.ready()
+    """
+    import nautobot.core.jobs  # noqa: F401
+
+    _import_jobs_from_jobs_root()
 
-    Note that app-provided Jobs are automatically imported at startup time via NautobotAppConfig.ready()
+    try:
+        _import_jobs_from_git_repositories()
+    except ProgrammingError:  # Database not ready yet, as may be the case on initial startup and migration
+        pass
+
+
+def _import_jobs_from_jobs_root():
+    """
+    (Re)import all modules in settings.JOBS_ROOT.
     """
-    logger.debug("Importing system Jobs")
-    sender.loader.import_task_module("nautobot.core.jobs")
-
-    jobs_root = settings.JOBS_ROOT
-    if jobs_root and os.path.exists(jobs_root):
-        if jobs_root not in sys.path:
-            sys.path.append(jobs_root)
-        for _, module_name, _ in pkgutil.iter_modules([jobs_root]):
-            try:
-                logger.debug("Importing Jobs from %s in JOBS_ROOT", module_name)
-                existing_module = find_spec(module_name)
-                if existing_module is not None:
-                    existing_module_path = os.path.realpath(existing_module.origin)
-                    jobs_root_path = os.path.realpath(jobs_root)
-                    if not existing_module_path.startswith(jobs_root_path):
-                        raise ImportError(
-                            f"JOBS_ROOT Jobs module {module_name} conflicts with existing module {existing_module_path}"
-                        )
-                sender.loader.import_task_module(module_name)
-            except Exception as exc:
-                logger.exception(exc)
-
-    git_root = settings.GIT_ROOT
-    if git_root and os.path.exists(git_root):
-        if git_root not in sys.path:
-            sys.path.append(git_root)
-
-        # We can't detect which Git directories we're *supposed* to auto-load Jobs from if we can't read GitRepository
-        # records from the DB, unfortunately.
-        # We work around this in JobModel.job_task to try later loading Git jobs on-the-fly if needed.
-        if database_ready:
+    if not (settings.JOBS_ROOT and os.path.isdir(settings.JOBS_ROOT)):
+        return
+
+    # Flush any previously loaded non-system, non-App Jobs
+    for job_class_path in list(registry["jobs"]):
+        if job_class_path.startswith("nautobot."):
+            # System job
+            continue
+        if any(job_class_path.startswith(f"{app_name}.") for app_name in settings.PLUGINS):
+            # App provided job
+            continue
+        try:
             from nautobot.extras.models import GitRepository
 
-            # Make sure there are no git clones in GIT_ROOT that *aren't* tracked by a GitRepository;
-            # for example, maybe a GitRepository was deleted while this worker process wasn't running?
-            for filename in os.listdir(git_root):
-                filepath = os.path.join(git_root, filename)
-                if (
-                    os.path.isdir(filepath)
-                    and os.path.isdir(os.path.join(filepath, ".git"))
-                    and not GitRepository.objects.filter(slug=filename).exists()
-                ):
-                    logger.warning("Deleting unmanaged (leftover?) Git repository clone at %s", filepath)
-                    shutil.rmtree(filepath)
+            if any(
+                job_class_path.startswith(f"{repo.slug}.")
+                for repo in GitRepository.objects.filter(provided_contents__contains="extras.job")
+            ):
+                # Git provided job
+                continue
+        except ProgrammingError:  # Database not ready yet, as may be the case on initial startup and migration
+            pass
+        # Else, it's presumably a JOBS_ROOT job
+        del registry["jobs"][job_class_path]
+
+    # Load all modules in JOBS_ROOT
+    import_modules_privately(path=os.path.realpath(settings.JOBS_ROOT))
+
+
+def _import_jobs_from_git_repositories():
+    git_root = os.path.realpath(settings.GIT_ROOT)
+    if not (git_root and os.path.exists(git_root)):
+        return
+
+    from nautobot.extras.models import GitRepository
+
+    # Make sure there are no git clones in GIT_ROOT that *aren't* tracked by a GitRepository;
+    # for example, maybe a GitRepository was deleted while this worker process wasn't running?
+    for filename in os.listdir(git_root):
+        filepath = os.path.join(git_root, filename)
+        if (
+            os.path.isdir(filepath)
+            and os.path.isdir(os.path.join(filepath, ".git"))
+            and not GitRepository.objects.filter(slug=filename).exists()
+        ):
+            logger.warning("Deleting unmanaged (leftover?) Git repository clone at %s", filepath)
+            shutil.rmtree(filepath)
 
-            # Make sure all GitRepository records that include Jobs have up-to-date git clones, and load their jobs
-            for repo in GitRepository.objects.all():
-                refresh_git_repository(state=None, repository_pk=repo.pk, head=repo.current_head)
+    # Make sure all GitRepository records that include Jobs have up-to-date git clones, and load their jobs
+    for repo in GitRepository.objects.filter(provided_contents__contains="extras.job"):
+        refresh_git_repository(state=None, repository_pk=repo.pk, head=repo.current_head)
 
 
 def add_nautobot_log_handler(logger_instance, log_format=None):
@@ -151,11 +158,11 @@ def setup_prometheus(**kwargs):
     multiprocess_coordination_directory.mkdir(parents=True, exist_ok=True)
 
     # Set up the collector registry
-    registry = CollectorRegistry()
-    multiprocess.MultiProcessCollector(registry, path=multiprocess_coordination_directory)
+    collector_registry = CollectorRegistry()
+    multiprocess.MultiProcessCollector(collector_registry, path=multiprocess_coordination_directory)
     for port in settings.CELERY_WORKER_PROMETHEUS_PORTS:
         try:
-            start_http_server(port, registry=registry)
+            start_http_server(port, registry=collector_registry)
             break
         except OSError:
             continue
@@ -206,9 +213,13 @@ register("nautobot_json", _dumps, _loads, content_type="application/x-nautobot-j
 nautobot_task = shared_task
 
 
+registry["jobs"] = {}
+
+
 def register_jobs(*jobs):
-    """Helper method to register jobs with Celery"""
+    """
+    Method to register jobs - with Celery in Nautobot 2.0 through 2.2.2, with Nautobot itself in 2.2.3 and later.
+    """
     for job in jobs:
-        # TODO: should we only register a job if it corresponds to a Job database record?
-        logger.debug("Registering job %s.%s", job.__module__, job.__name__)
-        app.register_task(job)
+        if job.class_path not in registry["jobs"]:
+            registry["jobs"][job.class_path] = job

nautobot/core/celery/backends.py

@@ -37,6 +37,7 @@ class NautobotDatabaseBackend(DatabaseBackend):
             "worker": None,
         }
         if request and self.app.conf.find_value_for_key("extended", "result"):
+            task_name = getattr(request, "task", None)
             # do not encode args/kwargs as we store these in a JSONField instead of TextField
             task_args = getattr(request, "args", None)
             task_kwargs = getattr(request, "kwargs", None)
@@ -54,6 +55,13 @@ class NautobotDatabaseBackend(DatabaseBackend):
             if traceback is not None:
                 traceback = sanitize(traceback)
 
+            # Preserve the JobResult data behavior from Nautobot 2.0 through 2.2 (wherein the Job itself was the task)
+            # by manipulating `task_name` and `task_args` to hide the fact that we are now calling
+            # `run_job.apply(args=[JobClass.class_path, ...])` instead of `JobClass.apply(args=[...])`.
+            if task_name == "nautobot.extras.jobs.run_job" and task_args:
+                task_name = task_args[0]
+                task_args = task_args[1:]
+
             extended_props.update(
                 {
                     "task_args": task_args,
@@ -61,7 +69,7 @@ class NautobotDatabaseBackend(DatabaseBackend):
                     "celery_kwargs": celery_kwargs,
                     "job_model_id": properties.get("nautobot_job_job_model_id", None),
                     "scheduled_job_id": properties.get("nautobot_job_scheduled_job_id", None),
-                    "task_name": getattr(request, "task", None),
+                    "task_name": task_name,
                     "traceback": traceback,
                     "user_id": properties.get("nautobot_job_user_id", None),
                     "worker": getattr(request, "hostname", None),

nautobot/core/celery/control.py

@@ -13,14 +13,14 @@ def refresh_git_repository(state, repository_pk, head):
     """
     Celery worker control event to ensure that all active workers have the correct head for a given Git repository.
     """
-    from nautobot.extras.datasources.git import ensure_git_repository, refresh_code_from_repository
+    from nautobot.extras.datasources.git import ensure_git_repository, refresh_job_code_from_repository
     from nautobot.extras.models import GitRepository
 
     try:
         repository = GitRepository.objects.get(pk=repository_pk)
         # Refresh the repository on disk
         ensure_git_repository(repository, head=head, logger=logger)
-        refresh_code_from_repository(repository.slug, consumer=state.consumer if state is not None else None)
+        refresh_job_code_from_repository(repository.slug, ignore_import_errors=False)
 
         return {"ok": {"head": repository.current_head}}
     except Exception as exc:
@@ -33,12 +33,9 @@ def discard_git_repository(state, repository_slug):
     """
     Celery worker control even to ensure that all active workers unload a given Git repository and delete it from disk.
     """
-    from nautobot.extras.datasources.git import refresh_code_from_repository
+    from nautobot.extras.datasources.git import refresh_job_code_from_repository
 
     filesystem_path = os.path.join(settings.GIT_ROOT, repository_slug)
     if os.path.isdir(filesystem_path):
         shutil.rmtree(filesystem_path)
-    # Unload any code from this repository
-    refresh_code_from_repository(
-        repository_slug, consumer=state.consumer if state is not None else None, skip_reimport=True
-    )
+    refresh_job_code_from_repository(repository_slug, skip_reimport=True)

nautobot/core/celery/schedulers.py

@@ -22,11 +22,13 @@ class NautobotScheduleEntry(ModelEntry):
         """Initialize the model entry."""
         self.app = app or current_app._get_current_object()
         self.name = f"{model.name}_{model.pk}"
-        self.task = model.task
+        self.task = "nautobot.extras.jobs.run_job"
         try:
             # Nautobot scheduled jobs pass args/kwargs as constructed objects,
             # but Celery built-in jobs such as celery.backend_cleanup pass them as JSON to be parsed
-            self.args = model.args if isinstance(model.args, (tuple, list)) else loads(model.args or "[]")
+            self.args = [model.task] + (
+                model.args if isinstance(model.args, (tuple, list)) else loads(model.args or "[]")
+            )
             self.kwargs = model.kwargs if isinstance(model.kwargs, dict) else loads(model.kwargs or "{}")
         except (TypeError, ValueError) as exc:
             logger.exception("Removing schedule %s for argument deserialization error: %s", self.name, exc)

nautobot/core/celery/task.py

@@ -1,12 +1,85 @@
-from celery import Task
-
-from nautobot.extras.jobs import get_task_logger
-
-logger = get_task_logger(__name__)
+from billiard.einfo import ExceptionInfo, ExceptionWithTraceback
+from celery import states, Task
+from celery.exceptions import Retry
+from celery.result import EagerResult
+from celery.utils.functional import maybe_list
+from celery.utils.nodenames import gethostname
+from kombu.utils.uuid import uuid
 
 
 class NautobotTask(Task):
     """Nautobot extensions to tasks for integrating with Job machinery."""
 
+    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 Task.apply() method to propagate options to the task result just like apply_async does."""
+        # 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,  # <------- this is the one line fix to the 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)
+
 
 Task = NautobotTask  # So that the class path resolves.

nautobot/core/graphql/schema.py

@@ -45,7 +45,7 @@ from nautobot.extras.graphql.types import DynamicGroupType, TagType
 from nautobot.extras.models import ComputedField, CustomField, Relationship
 from nautobot.extras.registry import registry
 from nautobot.extras.utils import check_if_key_is_graphql_safe
-from nautobot.ipam.graphql.types import IPAddressType, PrefixType
+from nautobot.ipam.graphql.types import IPAddressType, PrefixType, VLANType
 from nautobot.virtualization.graphql.types import VirtualMachineType, VMInterfaceType
 
 logger = logging.getLogger(__name__)
@@ -71,6 +71,7 @@ registry["graphql_types"]["extras.tag"] = TagType
 registry["graphql_types"]["extras.dynamicgroup"] = DynamicGroupType
 registry["graphql_types"]["ipam.ipaddress"] = IPAddressType
 registry["graphql_types"]["ipam.prefix"] = PrefixType
+registry["graphql_types"]["ipam.vlan"] = VLANType
 registry["graphql_types"]["virtualization.virtualmachine"] = VirtualMachineType
 registry["graphql_types"]["virtualization.vminterface"] = VMInterfaceType
 

nautobot/core/jobs/__init__.py

@@ -50,7 +50,8 @@ class GitRepositorySync(Job):
             # Given that the above succeeded, tell all workers (including ourself) to call ensure_git_repository()
             app.control.broadcast("refresh_git_repository", repository_pk=repository.pk, head=repository.current_head)
         finally:
-            self.logger.info(f"Repository synchronization completed in {job_result.duration}")
+            if job_result.duration:
+                self.logger.info("Repository synchronization completed in %s", job_result.duration)
 
 
 class GitRepositoryDryRun(Job):

nautobot/core/templates/generic/object_list.html

@@ -74,7 +74,7 @@
                     class="remove-filter-param"
                     title="Remove all items"
                     data-field-type="parent"
-                    data-field-value={{ field.name }}
+                    data-field-value="{{ field.name }}"
             >×</span>
             <ul class="filter-selection-rendered">
                 {% for value in field.values %}
@@ -85,8 +85,8 @@
                     <span
                             class="filter-selection-choice-remove remove-filter-param"
                             data-field-type="child"
-                            data-field-parent={{ field.name }}
-                            data-field-value={{ value.name }}
+                            data-field-parent="{{ field.name }}"
+                            data-field-value="{{ value.name }}"
                     >×</span>{{ value.display }}
                 </li>
                 {% endfor %}

nautobot/core/templatetags/helpers.py

@@ -8,7 +8,7 @@ from django.conf import settings
 from django.contrib.staticfiles.finders import find
 from django.templatetags.static import static, StaticNode
 from django.urls import NoReverseMatch, reverse
-from django.utils.html import format_html
+from django.utils.html import format_html, format_html_join
 from django.utils.safestring import mark_safe
 from django.utils.text import slugify as django_slugify
 from django_jinja import library
@@ -71,14 +71,7 @@ def hyperlinked_object(value, field="display"):
         >>> hyperlinked_object(location, "name")
         '<a href="/dcim/locations/leaf/">Leaf</a>'
     """
-    if value is None:
-        return placeholder(value)
-    display = getattr(value, field) if hasattr(value, field) else str(value)
-    if hasattr(value, "get_absolute_url"):
-        if hasattr(value, "description") and value.description:
-            return format_html('<a href="{}" title="{}">{}</a>', value.get_absolute_url(), value.description, display)
-        return format_html('<a href="{}">{}</a>', value.get_absolute_url(), display)
-    return format_html("{}", display)
+    return _build_hyperlink(value, field)
 
 
 @library.filter()
@@ -822,3 +815,67 @@ def queryset_to_pks(obj):
     result = list(obj.values_list("pk", flat=True)) if obj else []
     result = [str(entry) for entry in result]
     return ",".join(result)
+
+
+@library.filter()
+@register.filter()
+def hyperlinked_object_target_new_tab(value, field="display"):
+    """Render and link to a Django model instance, if any, or render a placeholder if not.
+
+    Similar to the hyperlinked_object filter, but passes attributes needed to open the link in new tab.
+
+    Uses the specified object field if available, otherwise uses the string representation of the object.
+    If the object defines `get_absolute_url()` this will be used to hyperlink the displayed object;
+    additionally if there is an `object.description` this will be used as the title of the hyperlink.
+
+    Args:
+        value (Union[django.db.models.Model, None]): Instance of a Django model or None.
+        field (Optional[str]): Name of the field to use for the display value. Defaults to "display".
+
+    Returns:
+        (str): String representation of the value (hyperlinked if it defines get_absolute_url()) or a placeholder.
+
+    Examples:
+        >>> hyperlinked_object_target_new_tab(device)
+        '<a href="/dcim/devices/3faafe8c-bdd6-4317-88dc-f791e6988caa/" target="_blank" rel="noreferrer">Device 1</a>'
+        >>> hyperlinked_object_target_new_tab(device_role)
+        '<a href="/dcim/device-roles/router/" title="Devices that are routers, not switches" target="_blank" rel="noreferrer">Router</a>'
+        >>> hyperlinked_object_target_new_tab(None)
+        '<span class="text-muted">&mdash;</span>'
+        >>> hyperlinked_object_target_new_tab("Hello")
+        'Hello'
+        >>> hyperlinked_object_target_new_tab(location)
+        '<a href="/dcim/locations/leaf/" target="_blank" rel="noreferrer">Root → Intermediate → Leaf</a>'
+        >>> hyperlinked_object_target_new_tab(location, "name")
+        '<a href="/dcim/locations/leaf/" target="_blank" rel="noreferrer">Leaf</a>'
+    """
+    return _build_hyperlink(value, field, target="_blank", rel="noreferrer")
+
+
+def _build_hyperlink(value, field="", target="", rel=""):
+    """Internal function used by filters to build hyperlinks.
+
+    Args:
+        value (Union[django.db.models.Model, None]): Instance of a Django model or None.
+        field (Optional[str]): Name of the field to use for the display value. Defaults to "display".
+        target (Optional[str]): Location to open the linked document.  Defaults to "" which is _self.
+        rel (Optional[str]): Relationship between current document and linked document. Defaults to "".
+
+    Returns:
+        (str): String representation of the value (hyperlinked if it defines get_absolute_url()) or a placeholder.
+    """
+    if value is None:
+        return placeholder(value)
+
+    attributes = {}
+    display = getattr(value, field) if hasattr(value, field) else str(value)
+    if hasattr(value, "get_absolute_url"):
+        attributes["href"] = value.get_absolute_url()
+        if hasattr(value, "description") and value.description:
+            attributes["title"] = value.description
+        if target:
+            attributes["target"] = target
+        if rel:
+            attributes["rel"] = rel
+        return format_html("<a {}>{}</a>", format_html_join(" ", '{}="{}"', attributes.items()), display)
+    return format_html("{}", display)

nautobot/core/testing/__init__.py

@@ -102,7 +102,12 @@ def get_job_class_and_model(module, name, source="local"):
         (JobClassInfo): Named 2-tuple of (job_class, job_model)
     """
     job_class = get_job(f"{module}.{name}")
-    job_model = Job.objects.get(module_name=module, job_class_name=name)
+    try:
+        job_model = Job.objects.get(module_name=module, job_class_name=name)
+    except Job.DoesNotExist:
+        raise RuntimeError(
+            f"Job database record for {module}.{name} not found. Known jobs are: {list(Job.objects.all())}"
+        )
     job_model.enabled = True
     job_model.validated_save()
     return JobClassInfo(job_class, job_model)