nautobot 2.4.3__py3-none-any.whl → 2.4.5__py3-none-any.whl

nautobot/extras/jobs.py

@@ -13,13 +13,13 @@ from typing import final
 import warnings
 
 from billiard.einfo import ExceptionInfo
+from celery.exceptions import Ignore, Reject
 from celery.utils.log import get_task_logger
 from db_file_storage.form_widgets import DBClearableFileInput
 from django import forms
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.cache import cache
-from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import UploadedFile
 from django.core.validators import RegexValidator
@@ -121,6 +121,7 @@ class BaseJob:
 
     def __init__(self):
         self.logger = get_task_logger(self.__module__)
+        self._failed = False
 
     def __call__(self, *args, **kwargs):
         # Attempt to resolve serialized data back into original form by creating querysets or model instances
@@ -130,8 +131,9 @@ class BaseJob:
         try:
             deserialized_kwargs = self.deserialize_data(kwargs)
         except Exception as err:
-            self.logger.error("%s", err)
+            self.logger.exception("Error deserializing kwargs")
             raise RunJobTaskFailed("Error initializing job") from err
+
         if isinstance(self, JobHookReceiver):
             change_context = ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK
         else:
@@ -163,7 +165,11 @@ class BaseJob:
     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
+    def fail(self, msg, *args, **kwargs):
+        """Mark this job as failed without immediately raising an exception and aborting."""
+        # Instead of failing in "fail" grouping, fail in the parent function's grouping by default
+        self.logger.failure(msg, *args, stacklevel=2, **kwargs)
+        self._failed = True
 
     def before_start(self, task_id, args, kwargs):
         """Handler called before the task starts.
@@ -174,65 +180,10 @@ class BaseJob:
             kwargs (Dict): Original keyword arguments for the task to execute.
 
         Returns:
-            (None): The return value of this handler is ignored.
+            (Any): The return value of this handler is ignored normally, **except** if `self.fail()` is called herein,
+                in which case the return value will be used as the overall JobResult return value
+                since `self.run()` will **not** be called in such a case.
         """
-        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!")
-
-        ignore_singleton_lock = self.celery_kwargs.get("nautobot_job_ignore_singleton_lock", False)
-        if self.job_model.is_singleton:
-            is_running = cache.get(self.singleton_cache_key)
-            if is_running:
-                if ignore_singleton_lock:
-                    self.logger.info(
-                        "Job %s is a singleton and already running, but singleton will be ignored because"
-                        " `ignore_singleton_lock` is set.",
-                        self.job_model,
-                        extra={"object": self.job_model, "grouping": "initialization"},
-                    )
-                else:
-                    self.logger.error(
-                        "Job %s is a singleton and already running.",
-                        self.job_model,
-                        extra={"object": self.job_model, "grouping": "initialization"},
-                    )
-                    raise RunJobTaskFailed(f"Job '{self.job_model}' is a singleton and already running.")
-            cache_parameters = {
-                "key": self.singleton_cache_key,
-                "value": 1,
-                "timeout": self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT,
-            }
-            cache.set(**cache_parameters)
-
-        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", "object": self.job_model})
 
     def run(self, *args, **kwargs):
         """
@@ -277,11 +228,12 @@ class BaseJob:
         This is run by the worker when the task fails.
 
         Arguments:
-            exc (Exception): The exception raised by the task.
+            exc (Any): Exception raised by the task (if any) **or** return value from the task, if it failed cleanly,
+                such as if the Job called `self.fail()` rather than raising an exception.
             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.
+            einfo (~billiard.einfo.ExceptionInfo): Exception information, or None.
 
         Returns:
             (None): The return value of this handler is ignored.
@@ -303,16 +255,7 @@ class BaseJob:
             (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 f in kwargs]
-        if file_ids:
-            self._delete_file_proxies(*file_ids)
-
-        if status == JobResultStatusChoices.STATUS_SUCCESS:
-            self.logger.success("Job completed", extra={"grouping": "post_run"})
-
-        cache.delete(self.singleton_cache_key)
+    # See https://github.com/PyCQA/pylint-django/issues/240 for why we have a pylint disable on each classproperty below
 
     @final
     @classproperty
@@ -1205,6 +1148,114 @@ def get_job(class_path, reload=False):
     return jobs.get(class_path, None)
 
 
+def _prepare_job(job_class_path, request, kwargs) -> tuple[Job, dict]:
+    """Helper method to run_job task, handling initial data setup and initialization before running a Job."""
+    logger.debug("Preparing to run job %s for task %s", job_class_path, request.id)
+
+    # Get the job code
+    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 = request
+
+    # Get the JobResult record to record results to
+    try:
+        job_result = JobResult.objects.get(id=request.id)
+    except JobResult.DoesNotExist:
+        job.logger.exception("Unable to find JobResult %s", request.id, extra={"grouping": "initialization"})
+        raise
+
+    # Get the JobModel record associated with this job
+    try:
+        job.job_model
+    except JobModel.DoesNotExist:
+        job.logger.exception(
+            "Unable to find Job database record %s", job_class_path, extra={"grouping": "initialization"}
+        )
+        raise
+
+    # Make sure it's valid to run this job - 1) is it enabled?
+    if not job.job_model.enabled:
+        job.logger.error(
+            "Job %s is not enabled to be run!",
+            job.job_model,
+            extra={"object": job.job_model, "grouping": "initialization"},
+        )
+        raise RunJobTaskFailed(f"Job {job.job_model} is not enabled to be run!")
+    # 2) if it's a singleton, is there any existing lock to be aware of?
+    if job.job_model.is_singleton:
+        is_running = cache.get(job.singleton_cache_key)
+        if is_running:
+            ignore_singleton_lock = job.celery_kwargs.get("nautobot_job_ignore_singleton_lock", False)
+            if ignore_singleton_lock:
+                job.logger.warning(
+                    "Job %s is a singleton and already running, but singleton will be ignored because"
+                    " `ignore_singleton_lock` is set.",
+                    job.job_model,
+                    extra={"object": job.job_model, "grouping": "initialization"},
+                )
+            else:
+                # TODO 3.0: maybe change to logger.failure() and return cleanly, as this is an "acceptable" failure?
+                job.logger.error(
+                    "Job %s is a singleton and already running.",
+                    job.job_model,
+                    extra={"object": job.job_model, "grouping": "initialization"},
+                )
+                raise RunJobTaskFailed(f"Job '{job.job_model}' is a singleton and already running.")
+        cache_parameters = {
+            "key": job.singleton_cache_key,
+            "value": 1,
+            "timeout": job.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT,
+        }
+        cache.set(**cache_parameters)
+
+    # Check for validity of the soft/hard time limits for the job.
+    # TODO: this is a bit out of place?
+    soft_time_limit = job.job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
+    time_limit = job.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
+    if time_limit <= soft_time_limit:
+        job.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", "object": job.job_model},
+        )
+
+    # Send notice that the job is running
+    event_payload = {
+        "job_result_id": request.id,
+        "job_name": job.name,  # TODO: should this be job.job_model.name instead? Possible breaking change
+        "user_name": job_result.user.username,
+    }
+    if not job.job_model.has_sensitive_variables:
+        event_payload["job_kwargs"] = kwargs
+    publish_event(topic="nautobot.jobs.job.started", payload=event_payload)
+    job.logger.info("Running job", extra={"grouping": "initialization", "object": job.job_model})
+
+    # Return the job, ready to run
+    return job, event_payload
+
+
+def _cleanup_job(job, event_payload, status, kwargs):
+    """Helper method to run_job task, handling cleanup after running a Job."""
+    # Cleanup FileProxy objects
+    file_fields = list(job._get_file_vars())
+    file_ids = [kwargs[f] for f in file_fields if f in kwargs]
+    if file_ids:
+        job._delete_file_proxies(*file_ids)
+
+    if status == JobResultStatusChoices.STATUS_SUCCESS:
+        job.logger.success("Job completed", extra={"grouping": "post_run"})
+
+    publish_event(topic="nautobot.jobs.job.completed", payload=event_payload)
+
+    cache.delete(job.singleton_cache_key)
+
+
 @nautobot_task(bind=True)
 def run_job(self, job_class_path, *args, **kwargs):
     """
@@ -1212,49 +1263,76 @@ def run_job(self, job_class_path, *args, **kwargs):
 
     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()`
+    - `Job.__init__()`
+    - `Job.before_start(self.request.id, args, kwargs)`
+    - `Job.__call__(*args, **kwargs)` (which calls `run(*args, **kwargs)`)
+    - If no exceptions have been raised (and `Job.fail()` was not called):
+        - `Job.on_success(result, self.request.id, args, kwargs)`
+    - Else:
+        - `Job.on_failure(result_or_exception, self.request.id, args, kwargs, einfo)`
+    - `Job.after_return(status, result_or_exception, self.request.id, args, kwargs, einfo)`
 
-    Finally, it either returns the data returned from `run()` or re-raises any exception encountered.
+    Finally, it either returns any data returned from `Job.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
-    job_result = JobResult.objects.get(id=self.request.id)
-    payload = {
-        "job_result_id": self.request.id,
-        "job_name": job.name,
-        "user_name": job_result.user.username,
-    }
-    if not job.job_model.has_sensitive_variables:
-        payload["job_kwargs"] = kwargs
+    job, event_payload = _prepare_job(job_class_path, self.request, kwargs)
+
+    result = None
+    status = None
     try:
-        publish_event(topic="nautobot.jobs.job.started", payload=payload)
-        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)
-        payload["job_output"] = result
-        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
-        return result
+        before_start_result = job.before_start(self.request.id, args, kwargs)
+        if not job._failed:
+            # Call job(), which automatically calls job.run():
+            result = job(*args, **kwargs)
+        else:
+            # don't run the job if before_start() reported a failure, and report the before_start() return value
+            result = before_start_result
+
+        event_payload["job_output"] = result
+        status = JobResultStatusChoices.STATUS_SUCCESS if not job._failed else JobResultStatusChoices.STATUS_FAILURE
+
+        if status == JobResultStatusChoices.STATUS_SUCCESS:
+            job.on_success(result, self.request.id, args, kwargs)
+        else:
+            job.on_failure(result, self.request.id, args, kwargs, None)
+
+        job.after_return(status, result, self.request.id, args, kwargs, None)
+
+        if status == JobResultStatusChoices.STATUS_SUCCESS:
+            return result
+
+        # Report a failure, but with a result rather than an exception and einfo:
+        self.update_state(
+            state=status,
+            meta=result,
+        )
+        # If we return a result, Celery automatically applies STATUS_SUCCESS.
+        # If we raise an exception *other than* `Ignore` or `Reject`, Celery automatically applies STATUS_FAILURE.
+        # We don't want to overwrite the manual state update that we did above, so:
+        raise Ignore()
+
+    except Reject:
+        status = status or JobResultStatusChoices.STATUS_REJECTED
+        raise
+
+    except Ignore:
+        status = status or JobResultStatusChoices.STATUS_IGNORED
+        raise
+
     except Exception as exc:
+        status = JobResultStatusChoices.STATUS_FAILURE
         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)
-        payload["einfo"] = {
+        event_payload["einfo"] = {
             "exc_type": type(exc).__name__,
             "exc_message": sanitize(str(exc)),
         }
-        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
         raise
 
+    finally:
+        _cleanup_job(job, event_payload, status, kwargs)
+
 
 def enqueue_job_hooks(object_change, may_reload_jobs=True, jobhook_queryset=None):
     """

nautobot/extras/management/utils.py

@@ -47,12 +47,21 @@ def report_job_status(command, job_result):
         logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group)
         debug_count = logs.filter(log_level=LogLevelChoices.LOG_DEBUG).count()
         info_count = logs.filter(log_level=LogLevelChoices.LOG_INFO).count()
+        success_count = logs.filter(log_level=LogLevelChoices.LOG_SUCCESS).count()
         warning_count = logs.filter(log_level=LogLevelChoices.LOG_WARNING).count()
+        failure_count = logs.filter(log_level=LogLevelChoices.LOG_FAILURE).count()
         error_count = logs.filter(log_level=LogLevelChoices.LOG_ERROR).count()
         critical_count = logs.filter(log_level=LogLevelChoices.LOG_CRITICAL).count()
 
         command.stdout.write(
-            f"\t{group}: {debug_count} debug, {info_count} info, {warning_count} warning, {error_count} error, {critical_count} critical"
+            f"\t{group}: "
+            f"{debug_count} debug, "
+            f"{info_count} info, "
+            f"{success_count} success, "
+            f"{warning_count} warning, "
+            f"{failure_count} failure, "
+            f"{error_count} error, "
+            f"{critical_count} critical"
         )
 
         for log_entry in logs:
@@ -63,7 +72,7 @@ def report_job_status(command, job_result):
                 status = status
             elif status == "warning":
                 status = command.style.WARNING(status)
-            elif status == "failure":
+            elif status in ["failure", "error", "critical"]:
                 status = command.style.NOTICE(status)
 
             if log_entry.log_object:
@@ -73,6 +82,8 @@ def report_job_status(command, job_result):
 
     if job_result.result:
         command.stdout.write(str(job_result.result))
+    if job_result.traceback:
+        command.stdout.write(command.style.ERROR(job_result.traceback))
 
     if job_result.status == JobResultStatusChoices.STATUS_FAILURE:
         status = command.style.ERROR("FAILURE")

nautobot/extras/models/datasources.py

@@ -131,16 +131,20 @@ class GitRepository(PrimaryModel):
 
     def get_latest_sync(self):
         """
-        Return a `JobResult` for the latest sync operation.
+        Return a `JobResult` for the latest sync operation if one has occurred.
 
         Returns:
-            JobResult
+            Returns a `JobResult` if the repo has been synced before, otherwise returns None.
         """
         from nautobot.extras.models import JobResult
 
         # This will match all "GitRepository" jobs (pull/refresh, dry-run, etc.)
         prefix = "nautobot.core.jobs.GitRepository"
-        return JobResult.objects.filter(task_name__startswith=prefix, task_kwargs__repository=self.pk).latest()
+
+        if JobResult.objects.filter(task_name__startswith=prefix, task_kwargs__repository=self.pk).exists():
+            return JobResult.objects.filter(task_name__startswith=prefix, task_kwargs__repository=self.pk).latest()
+        else:
+            return None
 
     def to_csv(self):
         return (
@@ -216,6 +220,8 @@ class GitRepository(PrimaryModel):
         Returns:
             Returns the absolute path of the cloned repo if clone was successful, otherwise returns None.
         """
+        from nautobot.extras.datasources import get_repo_access_url
+
         if branch and head:
             raise ValueError("Cannot specify both branch and head")
 
@@ -229,7 +235,8 @@ class GitRepository(PrimaryModel):
             branch = self.branch
 
         try:
-            repo_helper = GitRepo(path_name, self.remote_url, depth=depth, branch=branch)
+            remote_url = get_repo_access_url(self)
+            repo_helper = GitRepo(path_name, remote_url, depth=depth, branch=branch)
             if head:
                 repo_helper.checkout(branch, head)
         except Exception as e:

nautobot/extras/models/jobs.py

@@ -897,25 +897,28 @@ class JobResult(BaseModel, CustomFieldModel):
                     # Cancel the scheduled SIGALRM if it hasn't fired already
                     signal.alarm(0)
 
-            # copy fields from eager result to job result
             job_result.refresh_from_db()
-            # Emulate prepare_exception() behavior
-            if isinstance(eager_result.result, Exception):
-                job_result.result = {
-                    "exc_type": type(eager_result.result).__name__,
-                    "exc_message": sanitize(str(eager_result.result)),
-                }
-            else:
-                if eager_result.result is not None:
+            # copy from eager result to job result if and only if the job result isn't already in a proper state.
+            if JobResultStatusChoices.precedence(job_result.status) > JobResultStatusChoices.precedence(
+                eager_result.status
+            ):
+                if eager_result.status in JobResultStatusChoices.EXCEPTION_STATES and isinstance(
+                    eager_result.result, Exception
+                ):
+                    job_result.result = {
+                        "exc_type": type(eager_result.result).__name__,
+                        "exc_message": sanitize(str(eager_result.result)),
+                    }
+                elif eager_result.result is not None:
                     job_result.result = sanitize(eager_result.result)
-                else:
-                    job_result.result = None
-            job_result.status = eager_result.status
-            if eager_result.traceback is not None:
-                job_result.traceback = sanitize(eager_result.traceback)
-            else:
-                job_result.traceback = None
-            job_result.date_done = timezone.now()
+                job_result.status = eager_result.status
+                if (
+                    eager_result.status in JobResultStatusChoices.EXCEPTION_STATES
+                    and eager_result.traceback is not None
+                ):
+                    job_result.traceback = sanitize(eager_result.traceback)
+            if not job_result.date_done:
+                job_result.date_done = timezone.now()
             job_result.save()
         else:
             # Jobs queued inside of a transaction need to run after the transaction completes and the JobResult is saved to the database

nautobot/extras/plugins/__init__.py

@@ -728,6 +728,31 @@ def register_plugin_menu_items(section_name, menu_items):
 #
 
 
+class CustomValidatorContext(dict):
+    def __init__(self, obj):
+        """
+        If there is an active change context, meaning we are in a web request context,
+        we have access to the current user object. Otherwise, we are likely running inside
+        a management command or other non-web or non-Job context, and we should use an AnonymousUser.
+        This ensures people's custom validators don't outright break when running in non-web
+        contexts, and should generally provide a sane default, given validation based on the
+        user is commonly going to be least-privelege based, and thus the AnonymousUser will
+        cause such validation logic to fail closed.
+        """
+        from django.contrib.auth.models import AnonymousUser
+
+        from nautobot.extras.signals import change_context_state
+
+        change_context = change_context_state.get()
+        user = None
+        if change_context:
+            user = change_context.get_user()
+        if user is None:
+            user = AnonymousUser()
+
+        super().__init__(object=obj, user=user)
+
+
 class CustomValidator:
     """
     This class is used to register plugin custom model validators which act on specified models. It contains the clean
@@ -742,7 +767,7 @@ class CustomValidator:
     model = None
 
     def __init__(self, obj):
-        self.context = {"object": obj}
+        self.context = CustomValidatorContext(obj)
 
     def validation_error(self, message):
         """

nautobot/extras/tables.py

@@ -112,6 +112,27 @@ JOB_BUTTONS = """
 <a href="{% url 'extras:jobresult_list' %}?job_model={{ record.name | urlencode }}" class="btn btn-default btn-xs" title="Job Results"><i class="mdi mdi-format-list-bulleted" aria-hidden="true"></i></a>
 """
 
+JOB_RESULT_BUTTONS = """
+{% load helpers %}
+{% if perms.extras.run_job %}
+    {% if record.job_model and record.task_kwargs %}
+        <a href="{% url 'extras:job_run' pk=record.job_model.pk %}?kwargs_from_job_result={{ record.pk }}"
+           class="btn btn-xs btn-success" title="Re-run job with same arguments.">
+            <i class="mdi mdi-repeat"></i>
+        </a>
+    {% elif record.job_model is not None %}
+        <a href="{% url 'extras:job_run' pk=record.job_model.pk %}" class="btn btn-primary btn-xs"
+           title="Run job">
+            <i class="mdi mdi-play"></i>
+        </a>
+    {% else %}
+        <a href="#" class="btn btn-xs btn-default disabled" title="Job is not available, cannot be re-run">
+            <i class="mdi mdi-repeat-off"></i>
+        </a>
+    {% endif %}
+{% endif %}
+"""
+
 SCHEDULED_JOB_BUTTONS = """
 <a href="{% url 'extras:jobresult_list' %}?scheduled_job={{ record.name | urlencode }}" class="btn btn-default btn-xs" title="Job Results"><i class="mdi mdi-format-list-bulleted" aria-hidden="true"></i></a>
 """
@@ -675,7 +696,7 @@ def log_object_link(value, record):
 
 
 def log_entry_color_css(record):
-    if record.log_level.lower() in ("error", "critical"):
+    if record.log_level.lower() in ("failure", "error", "critical"):
         return "danger"
     return record.log_level.lower()
 
@@ -811,7 +832,7 @@ class JobLogEntryTable(BaseTable):
     def render_log_level(self, value):
         log_level = value.lower()
         # The css is label-danger for failure items.
-        if log_level in ["error", "critical"]:
+        if log_level in ["failure", "error", "critical"]:
             log_level = "danger"
         elif log_level == "debug":
             log_level = "default"
@@ -877,32 +898,7 @@ class JobResultTable(BaseTable):
         linkify=True,
         verbose_name="Scheduled Job",
     )
-    actions = tables.TemplateColumn(
-        template_code="""
-            {% load helpers %}
-            {% if perms.extras.run_job %}
-                {% if record.job_model and record.task_kwargs %}
-                    <a href="{% url 'extras:job_run' pk=record.job_model.pk %}?kwargs_from_job_result={{ record.pk }}"
-                       class="btn btn-xs btn-success" title="Re-run job with same arguments.">
-                        <i class="mdi mdi-repeat"></i>
-                    </a>
-                {% elif record.job_model is not None %}
-                    <a href="{% url 'extras:job_run' pk=record.job_model.pk %}" class="btn btn-primary btn-xs"
-                       title="Run job">
-                        <i class="mdi mdi-play"></i>
-                    </a>
-                {% else %}
-                    <a href="#" class="btn btn-xs btn-default disabled" title="Job is not available, cannot be re-run">
-                        <i class="mdi mdi-repeat-off"></i>
-                    </a>
-                {% endif %}
-            {% endif %}
-            <a href="{% url 'extras:jobresult_delete' pk=record.pk %}" class="btn btn-xs btn-danger"
-               title="Delete this job result.">
-                <i class="mdi mdi-trash-can-outline"></i>
-            </a>
-        """
-    )
+    actions = ButtonsColumn(JobResult, buttons=("delete",), prepend_template=JOB_RESULT_BUTTONS)
 
     def render_summary(self, record):
         """
@@ -1094,7 +1090,7 @@ class ScheduledJobTable(BaseTable):
     last_run_at = tables.DateTimeColumn(verbose_name="Most Recent Run", format=settings.SHORT_DATETIME_FORMAT)
     crontab = tables.Column()
     total_run_count = tables.Column(verbose_name="Total Run Count")
-    actions = ButtonsColumn(ScheduledJob, buttons=("delete"), prepend_template=SCHEDULED_JOB_BUTTONS)
+    actions = ButtonsColumn(ScheduledJob, buttons=("delete",), prepend_template=SCHEDULED_JOB_BUTTONS)
 
     class Meta(BaseTable.Meta):
         model = ScheduledJob