nautobot 2.4.10__py3-none-any.whl → 2.4.12__py3-none-any.whl

nautobot/extras/api/views.py

@@ -512,12 +512,19 @@ class JobViewSetBase(
     serializer_class = serializers.JobSerializer
     filterset_class = filters.JobFilterSet
 
+    def get_object(self):
+        """Get the Job instance and reload the job class to ensure we have the latest version of the job code."""
+        obj = super().get_object()
+        get_job(obj.class_path, reload=True)
+
+        return obj
+
     @extend_schema(responses={"200": serializers.JobVariableSerializer(many=True)})
     @action(detail=True, filterset_class=None)
     def variables(self, request, *args, **kwargs):
         """Get details of the input variables that may/must be specified to run a particular Job."""
         job_model = self.get_object()
-        job_class = get_job(job_model.class_path, reload=True)
+        job_class = job_model.job_class
         if job_class is None:
             raise Http404
         variables_dict = job_class._get_vars()
@@ -599,7 +606,7 @@ class JobViewSetBase(
                     "One of these two flags must be removed before this job can be scheduled or run."
                 )
 
-        job_class = get_job(job_model.class_path, reload=True)
+        job_class = job_model.job_class
         if job_class is None:
             raise MethodNotAllowed(
                 request.method, detail="This job's source code could not be located and cannot be run"

nautobot/extras/datasources/git.py

@@ -17,7 +17,7 @@ from git import InvalidGitRepositoryError, Repo
 import yaml
 
 from nautobot.core.utils.git import GitRepo
-from nautobot.core.utils.module_loading import import_modules_privately
+from nautobot.core.utils.module_loading import check_name_safe_to_import_privately, import_modules_privately
 from nautobot.dcim.models import Device, DeviceRedundancyGroup, DeviceType, Location, Platform
 from nautobot.extras.choices import (
     LogLevelChoices,
@@ -725,6 +725,14 @@ def refresh_job_code_from_repository(repository_slug, skip_reimport=False, ignor
         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.
     """
+    # Enforced during GitRepository.clean() but just in case someone created a bad record without cleaning:
+    permitted, reason = check_name_safe_to_import_privately(repository_slug)
+    if not permitted:
+        logger.error("The repository_slug %r is invalid as it is %s", repository_slug, reason)
+        if ignore_import_errors:
+            return
+        raise ValueError(f"The repository_slug {repository_slug!r} is invalid as it is {reason}")
+
     # Unload any previous version of this module and its submodules if present
     for job_class_path in list(registry["jobs"]):
         if job_class_path.startswith(f"{repository_slug}."):

nautobot/extras/forms/forms.py

@@ -914,13 +914,13 @@ class ExternalIntegrationBulkEditForm(NautobotBulkEditForm):
     secrets_group = DynamicModelChoiceField(required=False, queryset=SecretsGroup.objects.all())
     verify_ssl = forms.NullBooleanField(required=False, label="Verify SSL", widget=BulkEditNullBooleanSelect)
     timeout = forms.IntegerField(required=False, min_value=0)
-    extra_config = forms.JSONField(required=False)
+    extra_config = JSONField(required=False, widget=forms.Textarea, help_text="JSON data")
     http_method = forms.ChoiceField(
         required=False,
         label="HTTP Method",
         choices=add_blank_choice(WebhookHttpMethodChoices),
     )
-    headers = forms.JSONField(required=False, label="HTTP Request headers")
+    headers = JSONField(required=False, widget=forms.Textarea, help_text="Headers for the HTTP request")
 
     class Meta:
         model = ExternalIntegration
@@ -1487,7 +1487,6 @@ class JobQueueBulkEditForm(TagsBulkEditFormMixin, NautobotBulkEditForm):
     class Meta:
         model = JobQueue
         nullable_fields = [
-            "secrets_group",
             "description",
             "tenant",
         ]
@@ -1910,8 +1909,8 @@ class RelationshipBulkEditForm(BootstrapMixin, CustomFieldModelBulkEditFormMixin
     )
     source_hidden = forms.NullBooleanField(required=False, widget=BulkEditNullBooleanSelect)
     destination_hidden = forms.NullBooleanField(required=False, widget=BulkEditNullBooleanSelect)
-    source_filter = forms.JSONField(required=False, widget=forms.Textarea, help_text="Filter for the source")
-    destination_filter = forms.JSONField(required=False, widget=forms.Textarea, help_text="Filter for the destination")
+    source_filter = JSONField(required=False, widget=forms.Textarea, help_text="Filter for the source")
+    destination_filter = JSONField(required=False, widget=forms.Textarea, help_text="Filter for the destination")
     source_type = CSVContentTypeField(
         queryset=ContentType.objects.filter(FeatureQuery("relationships").get_query()), required=False
     )
@@ -2256,6 +2255,8 @@ class WebhookBulkEditForm(BootstrapMixin, NoteModelBulkEditFormMixin):
     secret = forms.CharField(required=False, max_length=CHARFIELD_MAX_LENGTH)
     ca_file_path = forms.CharField(required=False, max_length=4096)
     http_content_type = forms.CharField(required=False, max_length=CHARFIELD_MAX_LENGTH)
+    additional_headers = forms.CharField(required=False, widget=forms.Textarea)
+    body_template = forms.CharField(required=False, widget=forms.Textarea)
 
     # Choice field
     http_method = forms.ChoiceField(
@@ -2279,6 +2280,8 @@ class WebhookBulkEditForm(BootstrapMixin, NoteModelBulkEditFormMixin):
             "type_delete",
             "http_method",
             "http_content_type",
+            "additional_headers",
+            "body_template",
             "ssl_verification",
             "ca_file_path",
             "payload_url",
@@ -2286,6 +2289,7 @@ class WebhookBulkEditForm(BootstrapMixin, NoteModelBulkEditFormMixin):
             "add_content_types",
             "remove_content_types",
         )
+        nullable_fields = ("additional_headers",)
 
 
 class WebhookForm(BootstrapMixin, forms.ModelForm):

nautobot/extras/jobs.py

@@ -17,6 +17,7 @@ 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.apps import apps
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.cache import cache
@@ -1142,8 +1143,9 @@ def get_job(class_path, reload=False):
             # 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
+            # App provided job - only reload if the app provides dynamic jobs
+            app_config = apps.get_app_config(class_path.split(".")[0])
+            reload = getattr(app_config, "provides_dynamic_jobs", False)
     jobs = get_jobs(reload=reload)
     return jobs.get(class_path, None)
 

nautobot/extras/jobs_ui.py

@@ -0,0 +1,208 @@
+from django.template import Context
+from django.template.loader import render_to_string
+from django.utils.html import format_html, format_html_join
+from django.utils.safestring import mark_safe
+
+from nautobot.core.templatetags import helpers
+from nautobot.core.ui.object_detail import Button, KeyValueTablePanel, ObjectFieldsPanel
+from nautobot.core.views.utils import get_obj_from_context
+
+
+class JobRunScheduleButton(Button):
+    """
+    A custom button for running or scheduling a job.
+
+    This button is rendered only if the user has the 'extras.run_job' permission.
+    It also disables itself (via HTML 'disabled' attribute) if the related object is not
+    installed or not enabled.
+    """
+
+    def get_extra_context(self, context):
+        """Inject dynamic attributes (e.g. 'disabled') based on object state into the rendering context."""
+        extra_context = super().get_extra_context(context)
+        obj = context.get("object")
+        if not obj.installed or not obj.enabled:
+            if extra_context["attributes"] is None:
+                extra_context["attributes"] = {}
+            extra_context["attributes"]["disabled"] = "disabled"
+        return extra_context
+
+
+class JobKeyValueOverrideValueTablePanel(KeyValueTablePanel):
+    """A table panel for displaying key-value pairs of job-related attributes, along with any override values defined on the job object."""
+
+    def _render_overridden_text(self, text):
+        """
+        Render a simple overridden value inside a muted <span>, with a customizable prefix.
+
+        Args:
+            value (str): The content to display.
+            prefix (str): The label shown before the value (default: 'default is').
+        """
+        return format_html('<span class="text-muted">overridden; default is {}</span>', mark_safe(text))  # noqa: S308
+
+    def _render_overridden_block(self, content):
+        """
+        Render a more complex block of HTML content (like rendered markdown or JSON)
+        in a div with a muted label indicating it's an overridden value.
+        """
+        return format_html('<div class="text-muted">overridden; default is:<br>{}</div>', content)
+
+    def render_description_default(self, default_value):
+        """
+        Render a description field's default value as markdown.
+
+        If the default value is a string, it is rendered as markdown;
+        otherwise, a placeholder is shown.
+        """
+        rendered = (
+            helpers.render_markdown(default_value)
+            if isinstance(default_value, str)
+            else helpers.placeholder(default_value)
+        )
+        return self._render_overridden_block(rendered)
+
+    def render_time_limit_default(self, default_value, system_default_value, override=True):
+        """
+        Render a time limit value, falling back to the system default if needed.
+        """
+        message = "{} seconds" if default_value > 0 else "{} seconds (system default)"
+        value = default_value if default_value > 0 else system_default_value
+        if not override:
+            return message.format(value)
+        return self._render_overridden_text(message.format(value))
+
+    def render_job_queues_default(self, obj):
+        """
+        Render the job's default task queues as JSON.
+
+        Attempts to retrieve the `task_queues` from the job's class and render
+        it using a JSON template. Falls back to a placeholder on error.
+        """
+        try:
+            data = obj.job_class.task_queues
+            rendered = render_to_string("extras/inc/json_data.html", {"data": data, "format": "json"})
+        except Exception:
+            rendered = helpers.placeholder(None)
+        return self._render_overridden_block(rendered)
+
+    def render_default_job_queue_default(self, obj):
+        """
+        Render the default job queue name from the job class.
+
+        Retrieves the first queue from `task_queues` if available.
+        Falls back to a placeholder if no queues are present.
+        """
+        try:
+            queue = obj.job_class.task_queues[0]
+        except (AttributeError, IndexError, TypeError):
+            queue = helpers.placeholder("not specified")
+        return self._render_overridden_text(queue)
+
+    def render_boolean_default(self, default_value):
+        """Render a boolean default value using a standardized visual format."""
+        return self._render_overridden_text(helpers.render_boolean(default_value))
+
+    def render_override_value(self, key, obj):
+        """Render the override value for a given key on a job object."""
+        override_attr = f"{key}_override"
+
+        if not getattr(obj, override_attr, None):
+            return ""
+
+        if not obj.installed:
+            return self._render_overridden_text("default is unknown (not currently installed)")
+
+        try:
+            default_value = getattr(obj.job_class, key)
+        except Exception:
+            default_value = "unknown"
+
+        renderers = {
+            "description": self.render_description_default,
+            "soft_time_limit": lambda v: self.render_time_limit_default(
+                v, helpers.settings_or_config("CELERY_TASK_SOFT_TIME_LIMIT")
+            ),
+            "time_limit": lambda v: self.render_time_limit_default(
+                v, helpers.settings_or_config("CELERY_TASK_TIME_LIMIT")
+            ),
+            "job_queues": lambda _: self.render_job_queues_default(obj),
+            "default_job_queue": lambda _: self.render_default_job_queue_default(obj),
+        }
+
+        if key in renderers:
+            return renderers[key](default_value)
+
+        if isinstance(default_value, bool):
+            return self.render_boolean_default(default_value)
+
+        return self._render_overridden_text(f'"{default_value}"')
+
+    def render_job_queues_list(self, value):
+        """Renders a <ul> HTML list of job queues with hyperlinks, or a placeholder if none exist."""
+        if not value or not value.exists():
+            return helpers.placeholder(None)
+
+        items = format_html_join("\n", "<li>{}</li>", ((helpers.hyperlinked_object(q),) for q in value.all()))
+        return format_html("<ul>{}</ul>", items)
+
+    def render_body_content(self, context: Context):
+        """Render the body content of the panel as a table of key-value rows, including any override information."""
+        data = self.get_data(context)
+        obj = get_obj_from_context(context)
+
+        if not data:
+            return format_html('<tr><td colspan="2">{}</td></tr>', helpers.placeholder(data))
+
+        result = format_html("")
+        panel_label = helpers.slugify(self.label or "")
+        for key, value in data.items():
+            key_display = self.render_key(key, value, context)
+            override_value_display = self.render_override_value(key, obj)
+            if value_display := self.render_value(key, value, context):
+                if value_display is helpers.HTML_NONE:
+                    value_tag = value_display
+                else:
+                    value_tag = format_html(
+                        """
+                            <span class="hover_copy">
+                                <span id="{unique_id}_value_{key}">{value}</span>
+                                <button class="btn btn-inline btn-default hover_copy_button" data-clipboard-target="#{unique_id}_value_{key}">
+                                    <span class="mdi mdi-content-copy"></span>
+                                </button>
+                            </span>
+                        """,
+                        # key might not be globally unique in a page, but is unique to a panel;
+                        # Hence we add the panel label to make it globally unique to the page
+                        unique_id=panel_label,
+                        key=helpers.slugify(key),
+                        value=value_display,
+                    )
+                result += format_html(
+                    "<tr><td>{}</td><td>{}</td><td>{}</td></tr>",
+                    key_display,
+                    value_tag,
+                    override_value_display,
+                )
+
+        return result
+
+
+class JobObjectFieldsPanel(ObjectFieldsPanel, JobKeyValueOverrideValueTablePanel):
+    """
+    ObjectFieldsPanel that renders its fields in a 3-column layout.
+    Inherits behavior from ObjectFieldsPanel but overrides rendering with JobKeyValueOverrideValueTablePanel.
+    """
+
+    def render_value(self, key, value, context: Context):
+        if key == "job_queues":
+            return self.render_job_queues_list(value)
+        if key == "soft_time_limit":
+            value = self.render_time_limit_default(
+                value, helpers.settings_or_config("CELERY_TASK_SOFT_TIME_LIMIT"), override=False
+            )
+        if key == "time_limit":
+            value = self.render_time_limit_default(
+                value, helpers.settings_or_config("CELERY_TASK_TIME_LIMIT"), override=False
+            )
+        return super().render_value(key, value, context)

nautobot/extras/models/datasources.py

@@ -1,7 +1,6 @@
 """Models for representing external data sources."""
 
 from contextlib import contextmanager
-from importlib.util import find_spec
 import logging
 import os
 import shutil
@@ -17,7 +16,8 @@ from nautobot.core.models.fields import AutoSlugField, LaxURLField, slugify_dash
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.models.validators import EnhancedURLValidator
 from nautobot.core.utils.git import GitRepo
-from nautobot.extras.utils import check_if_key_is_graphql_safe, extras_features
+from nautobot.core.utils.module_loading import check_name_safe_to_import_privately
+from nautobot.extras.utils import extras_features
 
 logger = logging.getLogger(__name__)
 
@@ -105,12 +105,9 @@ 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.
-            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.'
-                )
+            permitted, reason = check_name_safe_to_import_privately(self.slug)
+            if not permitted:
+                raise ValidationError({"slug": f"Please choose a different slug; {self.slug!r} is {reason}"})
 
         if self.provided_contents:
             q = models.Q()

nautobot/extras/models/jobs.py

@@ -1383,6 +1383,11 @@ class ScheduledJob(BaseModel):
         if job_model.time_limit > 0:
             celery_kwargs["time_limit"] = job_model.time_limit
 
+        # We do this because when a job creates an approval workflow, a scheduled job is also created.
+        # If the scheduled job has an "immediate" interval, the scheduler will not send this task.
+        # since TYPE_IMMEDIATELY is not a valid value in JobExecutionType.SCHEDULE_CHOICES
+        if interval == JobExecutionType.TYPE_IMMEDIATELY:
+            interval = JobExecutionType.TYPE_FUTURE
         # 2.0 TODO: To revisit this as part of a larger Jobs cleanup in 2.0.
         #
         # We pass in task and job_model here partly for forward/backward compatibility logic, and

nautobot/extras/models/tags.py

@@ -1,5 +1,6 @@
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
+from django.utils.html import format_html
 from taggit.models import GenericUUIDTaggedItemBase
 
 from nautobot.core.choices import ColorChoices
@@ -65,6 +66,9 @@ class Tag(
     class Meta:
         ordering = ["name"]
 
+    def get_color_display(self):
+        return format_html('<span class="label color-block" style="background-color: #{}">&nbsp;</span>', self.color)
+
     def validate_content_types_removal(self, content_types_id):
         """Validate content_types to be removed are not tagged to a model"""
         errors = {}

nautobot/extras/plugins/__init__.py

@@ -81,6 +81,9 @@ class NautobotAppConfig(NautobotConfig):
     config_view_name = None
     docs_view_name = None
 
+    # Dynamic jobs. Set to True if the app's job code should be reloaded at runtime
+    provides_dynamic_jobs = False
+
     # Default integration paths. Plugin authors can override these to customize the paths to
     # integrated components.
     banner_function = "banner.banner"

nautobot/extras/tables.py

@@ -1,9 +1,13 @@
 from django.conf import settings
+from django.db.models import QuerySet
 from django.utils.html import format_html, format_html_join
 import django_tables2 as tables
+from django_tables2.data import TableData
+from django_tables2.rows import BoundRows
 from django_tables2.utils import Accessor
 from jsonschema.exceptions import ValidationError as JSONSchemaValidationError
 
+from nautobot.core.models.querysets import count_related
 from nautobot.core.tables import (
     BaseTable,
     BooleanColumn,
@@ -19,7 +23,7 @@ from nautobot.core.tables import (
 from nautobot.core.templatetags.helpers import render_boolean, render_json, render_markdown
 from nautobot.tenancy.tables import TenantColumn
 
-from .choices import MetadataTypeDataTypeChoices
+from .choices import LogLevelChoices, MetadataTypeDataTypeChoices
 from .models import (
     ComputedField,
     ConfigContext,
@@ -891,7 +895,7 @@ class JobResultTable(BaseTable):
     )
     summary = tables.Column(
         empty_values=(),
-        verbose_name="Results",
+        verbose_name="Summary",
         orderable=False,
         attrs={"td": {"class": "text-nowrap report-stats"}},
     )
@@ -901,6 +905,40 @@ class JobResultTable(BaseTable):
     )
     actions = ButtonsColumn(JobResult, buttons=("delete",), prepend_template=JOB_RESULT_BUTTONS)
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Only calculate log counts for "summary" column if it's actually visible.
+        if "summary" in self.columns and self.columns["summary"].visible and isinstance(self.data.data, QuerySet):
+            self.data = TableData.from_data(
+                self.data.data.annotate(
+                    debug_log_count=count_related(
+                        JobLogEntry, "job_result", filter_dict={"log_level": LogLevelChoices.LOG_DEBUG}
+                    ),
+                    success_log_count=count_related(
+                        JobLogEntry, "job_result", filter_dict={"log_level": LogLevelChoices.LOG_SUCCESS}
+                    ),
+                    info_log_count=count_related(
+                        JobLogEntry, "job_result", filter_dict={"log_level": LogLevelChoices.LOG_INFO}
+                    ),
+                    warning_log_count=count_related(
+                        JobLogEntry, "job_result", filter_dict={"log_level": LogLevelChoices.LOG_WARNING}
+                    ),
+                    error_log_count=count_related(
+                        JobLogEntry,
+                        "job_result",
+                        filter_dict={
+                            "log_level__in": [
+                                LogLevelChoices.LOG_FAILURE,
+                                LogLevelChoices.LOG_ERROR,
+                                LogLevelChoices.LOG_CRITICAL,
+                            ],
+                        },
+                    ),
+                )
+            )
+            self.data.set_table(self)
+            self.rows = BoundRows(data=self.data, table=self, pinned_data=self.pinned_data)
+
     def render_summary(self, record):
         """
         Define custom rendering for the summary column.
@@ -940,7 +978,6 @@ class JobResultTable(BaseTable):
             "job_model",
             "user",
             "status",
-            "summary",
             "actions",
         )