nautobot 3.0.3__py3-none-any.whl → 3.0.5__py3-none-any.whl

nautobot/core/authentication.py

@@ -52,7 +52,6 @@ class ObjectPermissionBackend(ModelBackend):
             return user_obj.is_active and (user_obj.is_staff or user_obj.is_superuser)
 
         app_label, _action, model_name = resolve_permission(perm)
-
         if app_label == "users" and model_name == "admingroup":
             perm = perm.replace("users", "auth").replace("admingroup", "group")
 

nautobot/core/celery/schedulers.py

@@ -138,9 +138,7 @@ class NautobotDatabaseScheduler(DatabaseScheduler):
                         task_name=scheduled_job.job_model.class_path,
                         celery_kwargs=entry.options,
                     )
-                    job_result = run_kubernetes_job_and_return_job_result(
-                        job_queue, job_result, json.dumps(entry_kwargs)
-                    )
+                    job_result = run_kubernetes_job_and_return_job_result(job_result, json.dumps(entry_kwargs))
                     # Return an AsyncResult object to mimic the behavior of Celery tasks after the job is finished by Kubernetes Job Pod.
                     resp = AsyncResult(job_result.id)
                 else:

nautobot/core/cli/__init__.py

@@ -3,7 +3,9 @@ Utilities and primitives for the `nautobot-server` CLI command.
 """
 
 import argparse
+from copy import deepcopy
 import importlib.util
+import logging
 import os
 import sys
 
@@ -34,43 +36,46 @@ USAGE = """%(prog)s --help
        %(prog)s [-c CONFIG_PATH] SUBCOMMAND ..."""
 
 
-def _preprocess_settings(settings, config_path):
+logger = logging.getLogger(__name__)
+
+
+def _preprocess_settings(settings_module, config_path):
     """
     After loading nautobot_config.py and nautobot.core.settings, but before starting Django, modify the settings module.
 
-    - Set settings.SETTINGS_PATH for ease of reference
+    - Set settings_module.SETTINGS_PATH for ease of reference
     - Handle `EXTRA_*` settings
     - Create Nautobot storage directories if they don't already exist
     - Change database backends to django-prometheus if appropriate
     - Set up 'job_logs' database mirror
     - Handle our custom `STORAGE_BACKEND` setting.
-    - Load plugins based on settings.PLUGINS (potentially affecting INSTALLED_APPS, MIDDLEWARE, and CONSTANCE_CONFIG)
-    - Load event brokers based on settings.EVENT_BROKERS
+    - Load plugins based on settings_module.PLUGINS (may affect INSTALLED_APPS, MIDDLEWARE, and CONSTANCE_CONFIG)
+    - Load event brokers based on settings_module.EVENT_BROKERS
     """
-    settings.SETTINGS_PATH = config_path
+    settings_module.SETTINGS_PATH = config_path
 
     # Any setting that starts with EXTRA_ and matches a setting that is a list or tuple
     # will automatically append the values to the current setting.
     # "It might make sense to make this less magical"
     extras = {}
-    for setting in dir(settings):
+    for setting in dir(settings_module):
         if setting == setting.upper() and setting.startswith("EXTRA_"):
             base_setting = setting[6:]
-            if isinstance(getattr(settings, base_setting), (list, tuple)):
-                extras[base_setting] = getattr(settings, setting)
+            if isinstance(getattr(settings_module, base_setting), (list, tuple)):
+                extras[base_setting] = getattr(settings_module, setting)
     for base_setting, extra_values in extras.items():
-        base_value = getattr(settings, base_setting)
-        setattr(settings, base_setting, base_value + type(base_value)(extra_values))
+        base_value = getattr(settings_module, base_setting)
+        setattr(settings_module, base_setting, base_value + type(base_value)(extra_values))
 
     #
     # Storage directories
     #
-    os.makedirs(settings.GIT_ROOT, exist_ok=True)
-    os.makedirs(settings.JOBS_ROOT, exist_ok=True)
-    os.makedirs(settings.MEDIA_ROOT, exist_ok=True)
-    os.makedirs(os.path.join(settings.MEDIA_ROOT, "devicetype-images"), exist_ok=True)
-    os.makedirs(os.path.join(settings.MEDIA_ROOT, "image-attachments"), exist_ok=True)
-    os.makedirs(settings.STATIC_ROOT, exist_ok=True)
+    os.makedirs(settings_module.GIT_ROOT, exist_ok=True)
+    os.makedirs(settings_module.JOBS_ROOT, exist_ok=True)
+    os.makedirs(settings_module.MEDIA_ROOT, exist_ok=True)
+    os.makedirs(os.path.join(settings_module.MEDIA_ROOT, "devicetype-images"), exist_ok=True)
+    os.makedirs(os.path.join(settings_module.MEDIA_ROOT, "image-attachments"), exist_ok=True)
+    os.makedirs(settings_module.STATIC_ROOT, exist_ok=True)
 
     #
     # Databases
@@ -78,62 +83,99 @@ def _preprocess_settings(settings, config_path):
 
     # If metrics are enabled and postgres is the backend, set the driver to the
     # one provided by django-prometheus.
-    if settings.METRICS_ENABLED:
-        if "postgres" in settings.DATABASES["default"]["ENGINE"]:
-            settings.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.postgresql"
-        elif "mysql" in settings.DATABASES["default"]["ENGINE"]:
-            settings.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.mysql"
+    if settings_module.METRICS_ENABLED:
+        # Avoid modifying nautobot.core.settings.DATABASES by accident!
+        settings_module.DATABASES = deepcopy(settings_module.DATABASES)
+
+        if "postgres" in settings_module.DATABASES["default"]["ENGINE"]:
+            settings_module.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.postgresql"
+        elif "mysql" in settings_module.DATABASES["default"]["ENGINE"]:
+            settings_module.DATABASES["default"]["ENGINE"] = "django_prometheus.db.backends.mysql"
 
     # Create secondary db connection for job logging. This still writes to the default db, but because it's a separate
     # connection, it allows allows us to "escape" from transaction.atomic() and ensure that job log entries are saved
     # to the database even when the rest of the job transaction is rolled back.
-    settings.DATABASES["job_logs"] = settings.DATABASES["default"].copy()
+    settings_module.DATABASES["job_logs"] = deepcopy(settings_module.DATABASES["default"])
     # When running unit tests, treat it as a mirror of the default test DB, not a separate test DB of its own
-    settings.DATABASES["job_logs"]["TEST"] = {"MIRROR": "default"}
+    settings_module.DATABASES["job_logs"]["TEST"] = {"MIRROR": "default"}
 
     #
     # Media storage
     #
 
-    if hasattr(settings, "JOB_FILE_IO_STORAGE"):
-        settings.STORAGES.setdefault("nautobotjobfiles", {})["BACKEND"] = settings.JOB_FILE_IO_STORAGE
+    # Avoid modifying nautobot.core.settings.STORAGES by accident!
+    settings_module.STORAGES = deepcopy(settings_module.STORAGES)
 
-    if hasattr(settings, "STORAGE_BACKEND") and settings.STORAGE_BACKEND is not None:
-        settings.STORAGES["default"]["BACKEND"] = settings.STORAGE_BACKEND
+    if hasattr(settings_module, "JOB_FILE_IO_STORAGE"):
+        settings_module.STORAGES.setdefault("nautobotjobfiles", {})["BACKEND"] = settings_module.JOB_FILE_IO_STORAGE
+
+    if hasattr(settings_module, "STORAGE_BACKEND") and settings_module.STORAGE_BACKEND is not None:
+        settings_module.STORAGES["default"]["BACKEND"] = settings_module.STORAGE_BACKEND
 
         # django-storages
-        if hasattr(settings, "STORAGE_BACKEND") and settings.STORAGE_BACKEND.startswith("storages."):
+        if hasattr(settings_module, "STORAGE_BACKEND") and settings_module.STORAGE_BACKEND.startswith("storages."):
             try:
                 import storages.utils
             except ModuleNotFoundError as e:
                 if getattr(e, "name") == "storages":
                     raise ImproperlyConfigured(
-                        f"STORAGE_BACKEND is set to {settings.STORAGE_BACKEND} but django-storages is not present. It "
-                        f"can be installed by running 'pip install django-storages'."
+                        f"STORAGE_BACKEND is set to {settings_module.STORAGE_BACKEND} but django-storages is not present. "
+                        "It can be installed by running 'pip install django-storages'."
                     )
                 raise e
 
             # Monkey-patch django-storages to fetch settings from STORAGE_CONFIG or fall back to settings
             def _setting(name, default=None):
-                if name in settings.STORAGE_CONFIG:
-                    return settings.STORAGE_CONFIG[name]
-                return getattr(settings, name, default)
+                if name in settings_module.STORAGE_CONFIG:
+                    return settings_module.STORAGE_CONFIG[name]
+                return getattr(settings_module, name, default)
 
             storages.utils.setting = _setting
 
+    # Django 4.2 will throw an exception if both:
+    # - DEFAULT_FILE_STORAGE/STATICFILES_STORAGE is set in nautobot_config.py (recommended until Nautobot v2.4.24)
+    # - STORAGES is configured in nautobot.core.settings (which it is nowadays).
+    # Unfortunately, it's not implemented as a standard system check (which we could opt out of) but is instead
+    # hard-coded, so we hack around it instead by explicitly copying any non-default *_STORAGE to STORAGES
+    # and then unsetting *_STORAGE.
+    for setting_name, storages_key, default_value in [
+        ("DEFAULT_FILE_STORAGE", "default", "django.core.files.storage.FileSystemStorage"),
+        ("STATICFILES_STORAGE", "staticfiles", "django.contrib.staticfiles.storage.StaticFilesStorage"),
+    ]:
+        if hasattr(settings_module, setting_name):
+            # Make sure we don't clobber any existing explicit configuration in STORAGES:
+            if settings_module.STORAGES[storages_key]["BACKEND"] not in (
+                default_value,  # Nautobot/Django default
+                getattr(settings_module, setting_name),  # same as explicitly set value for setting_name
+            ):
+                raise ImproperlyConfigured(
+                    f"It looks like you've configured both {setting_name} and STORAGES['{storages_key}']['BACKEND'],"
+                    "but their values do not match."
+                )
+
+            # No clobbering, but undesired, so warn the user and handle it:
+            logger.warning(
+                f"It looks like you've configured {setting_name} in {settings_module.SETTINGS_PATH}. "
+                "This setting is deprecated since Nautobot v2.4.24, and support will be removed in Nautobot v3.1. "
+                f"You should migrate to configuring STORAGES['{storages_key}']['BACKEND'] instead. Refer to "
+                "https://docs.nautobot.com/projects/core/en/stable/user-guide/administration/configuration/settings/#storages for guidance."
+            )
+            settings_module.STORAGES[storages_key]["BACKEND"] = getattr(settings_module, setting_name)
+            delattr(settings_module, setting_name)
+
     #
     # Plugins
     #
 
     # Process the plugins and manipulate the specified config settings that are
     # passed in.
-    load_plugins(settings)
+    load_plugins(settings_module)
 
     #
     # Event Broker
     #
 
-    load_event_brokers(settings.EVENT_BROKERS)
+    load_event_brokers(settings_module.EVENT_BROKERS)
 
 
 def load_settings(config_path):
@@ -144,10 +186,10 @@ def load_settings(config_path):
             "Please provide a valid --config-path path, or use 'nautobot-server init' to create a new configuration."
         )
     spec = importlib.util.spec_from_file_location("nautobot_config", config_path)
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["nautobot_config"] = module
-    spec.loader.exec_module(module)
-    _preprocess_settings(module, config_path)
+    settings_module = importlib.util.module_from_spec(spec)
+    sys.modules["nautobot_config"] = settings_module
+    spec.loader.exec_module(settings_module)
+    _preprocess_settings(settings_module, config_path)
 
 
 class _VerboseHelpFormatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptionHelpFormatter):

nautobot/core/settings.yaml

@@ -1886,8 +1886,8 @@ properties:
           For an example of using `django-storages` with AWS S3 buckets, visit the
           [django-storages with S3](../guides/s3-django-storage.md) user-guide.
 
-      The configuration parameters for the specified storage backend are defined under the
-      [`STORAGE_CONFIG`](#storage_config) setting.
+      The configuration parameters for the specified storage backend are defined under the settings
+      [`STORAGE_CONFIG`](#storage_config) (deprecated) or [`STORAGES`](#storages) (recommended).
     see_also:
       "`STORAGES`": "#storages"
     type: "string"
@@ -1895,8 +1895,16 @@ properties:
     description: "(Deprecated) Dictionary of config parameters for the storage backend configured as STORAGE_BACKEND."
     details: |-
       !!! warning
-          This setting is deprecated and will be removed in Nautobot v3.1.
-          In its place, you should set [`STORAGES["default"]["OPTIONS"]`](#storages).
+          This setting is deprecated and will be removed in Nautobot v3.1. In its place, you should set
+          [`STORAGES["default"]["OPTIONS"]` and/or `STORAGES["staticfiles"]["OPTIONS"]`](#storages).
+
+          Note that `STORAGE_CONFIG` is implemented to provide a bit of configuration "magic" that
+          `STORAGES["..."]["OPTIONS"]` does not; specifically, when `STORAGE_BACKEND` is using any module from
+          `django-storages`, if `STATICFILES_STORAGE` is also using `django-storages`, the `STORAGE_CONFIG` will be
+          automatically applied to both file storage types. When using `STORAGES` instead of `STORAGE_CONFIG`, this is
+          not automatically the case, permitting the two types to be configured independently, but also potentially
+          requiring duplicate configuration under `STORAGES["default"]["OPTIONS"]` and
+          `STORAGES["staticfiles"]["OPTIONS"]` if both types are using the same backend.
 
       The specific parameters to be used here are specific to each backend.
 

nautobot/core/tables.py

@@ -9,7 +9,7 @@ from django.db.models import Prefetch, QuerySet
 from django.db.models.fields.related import ForeignKey, RelatedField
 from django.db.models.fields.reverse_related import ManyToOneRel
 from django.urls import reverse
-from django.utils.html import escape, format_html, format_html_join
+from django.utils.html import format_html, format_html_join
 from django.utils.http import urlencode
 from django.utils.safestring import mark_safe
 from django.utils.text import Truncator
@@ -36,6 +36,7 @@ class BaseTable(django_tables2.Table):
         attrs = {
             "class": "table table-hover nb-table-headings",
         }
+        default = helpers.HTML_NONE
 
     def __init__(
         self,
@@ -579,7 +580,13 @@ class ColoredLabelColumn(django_tables2.TemplateColumn):
 
     template_code = """
     {% load helpers %}
-    {% if value %}<span class="badge" style="color: {{ value.color|fgcolor }}; background-color: #{{ value.color }}">{{ value }}</span>{% else %}&mdash;{% endif %}
+    {% if value %}
+        <span class="badge" style="color: {{ value.color|fgcolor }}; background-color: #{{ value.color }}">
+            {{ value }}
+        </span>
+    {% else %}
+        <span class="text-secondary">&mdash;</span>
+    {% endif %}
     """
 
     def __init__(self, *args, **kwargs):
@@ -757,29 +764,33 @@ class CustomFieldColumn(django_tables2.Column):
     Display custom fields in the appropriate format.
     """
 
-    # Add [] to empty_values so when there is no choice populated for multiselect_cf i.e. [], "—" is returned automatically.
-    empty_values = (None, "", [])
-
     def __init__(self, customfield, *args, **kwargs):
         self.customfield = customfield
         kwargs["accessor"] = Accessor(f"_custom_field_data__{customfield.key}")
         kwargs["verbose_name"] = customfield.label
+        if self.customfield.type == choices.CustomFieldTypeChoices.TYPE_MULTISELECT:
+            # Add [] to empty_values so when there is no choice populated i.e. [], "—" is returned automatically.
+            kwargs.setdefault("empty_values", (None, "", []))
 
         super().__init__(*args, **kwargs)
 
     def render(self, *, record, bound_column, value):  # pylint: disable=arguments-differ  # tables2 varies its kwargs
-        if self.customfield.type == choices.CustomFieldTypeChoices.TYPE_BOOLEAN:
-            template = helpers.render_boolean(value)
-        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_MULTISELECT:
-            template = format_html_join(" ", '<span class="badge bg-secondary">{}</span>', ((v,) for v in value))
-        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_SELECT:
-            template = format_html('<span class="badge bg-secondary">{}</span>', value)
-        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_URL:
-            template = format_html('<a href="{}">{}</a>', value, value)
-        else:
-            template = escape(value)
+        # TODO: this logic could be unified with _ObjectCustomFieldsPanel.render_value
+        if self.customfield.type == choices.CustomFieldTypeChoices.TYPE_BOOLEAN and value is not None:
+            value = helpers.render_boolean(value)
+        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_JSON and value is not None:
+            value = helpers.render_json(value, pretty_print=True)
+        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_MARKDOWN and value is not None:
+            value = helpers.render_markdown(value)
+        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_MULTISELECT and value:
+            value = format_html_join(" ", '<span class="badge bg-secondary">{}</span>', ((v,) for v in value))
+        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_SELECT and value is not None:
+            value = format_html('<span class="badge bg-secondary">{}</span>', value)
+        elif self.customfield.type == choices.CustomFieldTypeChoices.TYPE_URL and value:
+            value = format_html('<a href="{}">{}</a>', value, value)
+        # else (TEXT, INTEGER, DATE) or None value -- no need to do special rendering
 
-        return template
+        return value
 
 
 class RelationshipColumn(django_tables2.Column):
@@ -811,7 +822,7 @@ class RelationshipColumn(django_tables2.Column):
         # Handle Symmetric Relationships
         # List `value` could be empty here [] after the filtering from above
         if len(value) < 1:
-            return "—"
+            return helpers.HTML_NONE
 
         v = value[0]
         peer = v.get_peer(record)

nautobot/core/templates/graphene/graphiql.html

@@ -81,11 +81,9 @@ add "&raw" to the end of the URL within a browser.
         <!-- As Nautobot may be run without internet access, we source these files locally rather than from an online CDN -->
         <link rel="stylesheet"
               href="{% static 'dist/css/graphql-libraries.css' %}"
-              onerror="window.location='{% url 'media_failure' %}?filename=dist/css/graphql-libraries.css'">
-        <script src="{% static 'dist/js/graphql-libraries.js' %}"
-                onerror="window.location='{% url 'media_failure' %}?filename=dist/js/graphiql-libraries.js'"></script>
-        <script src="{% static 'dist/js/nautobot-graphiql.js' %}"
-                onerror="window.location='{% url 'media_failure' %}?filename=dist/js/nautobot-graphiql.js'"></script>
+              onerror="nb.media.handleFailure(this)">
+        <script src="{% static 'dist/js/graphql-libraries.js' %}" onerror="nb.media.handleFailure(this)"></script>
+        <script src="{% static 'dist/js/nautobot-graphiql.js' %}" onerror="nb.media.handleFailure(this)"></script>
     </head>
     <body>
         <!-- Nautobot page contents -->

nautobot/core/templates/inc/javascript.html

@@ -2,16 +2,11 @@
 {% load plugins %}
 {% load static %}
 
-<script src="{% static 'dist/js/nautobot.js' %}"
-        onerror="window.location='{% url 'media_failure' %}?filename=dist/js/nautobot.js'"></script>
-<script src="{% static 'dist/js/libraries.js' %}"
-        onerror="window.location='{% url 'media_failure' %}?filename=dist/js/libraries.js'"></script>
-<script src="{% versioned_static 'js/forms.js' %}"
-        onerror="window.location='{% url 'media_failure' %}?filename=js/forms.js'"></script>
-<script src="{% versioned_static 'js/table_sorting_indicator.js' %}"
-        onerror="window.location='{% url 'media_failure' %}?filename=js/table_sorting_indicator.js'"></script>
-<script src="{% versioned_static 'js/dropdown.js' %}"
-        onerror="window.location='{% url 'media_failure' %}?filename=js/dropdown.js'"></script>
+<script src="{% static 'dist/js/nautobot.js' %}" onerror="nb.media.handleFailure(this)"></script>
+<script src="{% static 'dist/js/libraries.js' %}" onerror="nb.media.handleFailure(this)"></script>
+<script src="{% versioned_static 'js/forms.js' %}" onerror="nb.media.handleFailure(this)"></script>
+<script src="{% versioned_static 'js/table_sorting_indicator.js' %}" onerror="nb.media.handleFailure(this)"></script>
+<script src="{% versioned_static 'js/dropdown.js' %}" onerror="nb.media.handleFailure(this)"></script>
 <script type="text/javascript">
     var nautobot_static_url = "{% static '' %}";
     var nautobot_api_path = "{% url 'api-root' %}";

nautobot/core/templates/inc/media.html

@@ -1,25 +1,26 @@
 {% load static %}
 {% load helpers %}
 {% load plugins %}
+{% include 'inc/media_failure.html' %}
 <link rel="stylesheet" id="template-theme"
       href="{% url 'template_css' %}">
 <link rel="stylesheet"
       href="{% static 'dist/css/nautobot.css' %}"
-      onerror="window.location='{% url 'media_failure' %}?filename=dist/css/nautobot.css'">
+      onerror="nb.media.handleFailure(this)">
 <link rel="stylesheet"
       href="{% static 'dist/css/materialdesignicons.css' %}"
-      onerror="window.location='{% url 'media_failure' %}?filename=dist/css/materialdesignicons.css'">
+      onerror="nb.media.handleFailure(this)">
 {% with cookie_theme=request.COOKIES|get_item:'theme' %}
     {% if not cookie_theme or cookie_theme == 'light' %}
         <link rel="stylesheet"
               href="{% static 'dist/css/github.min.css' %}"
-              onerror="window.location='{% url 'media_failure' %}?filename=dist/css/github.min.css'"
+              onerror="nb.media.handleFailure(this)"
               {% if not cookie_theme %}media="not (prefers-color-scheme: dark)"{% endif %}>
     {% endif %}
     {% if not cookie_theme or cookie_theme == 'dark' %}
         <link rel="stylesheet"
               href="{% static 'dist/css/github-dark.min.css' %}"
-              onerror="window.location='{% url 'media_failure' %}?filename=dist/css/github-dark.min.css'"
+              onerror="nb.media.handleFailure(this)"
               {% if not cookie_theme %}media="(prefers-color-scheme: dark)"{% endif %}>
     {% endif %}
 {% endwith %}

nautobot/core/templates/inc/media_failure.html

@@ -0,0 +1,73 @@
+{% load static %}
+
+<script>
+    (function initMediaFailure() {
+        // Create React-style `ref` reference to the media failure alert element.
+        const failureAlertRef = { current: null };
+
+        // Store all media failures inside `Map` containing `Set` values to ensure uniqueness of all reported failures.
+        const failures = new Map();
+
+        function handleFailure(element) {
+            const url = element.href || element.src || '';
+
+            if (url) {
+                // Update `failures` with a proper entry corresponding to the current media failure and update media failure alert.
+                const elements = failures.get(url) || new Set();
+                elements.add(element);
+                failures.set(url, elements);
+                updateFailureAlert();
+            }
+        }
+
+        function updateFailureAlert() {
+            const count = Array.from(failures.values()).reduce((count, elements) => count + elements.size, 0);
+
+            const innerHTML = `
+                <div style="margin: auto; max-width: 50rem;">
+                    <h2 style="margin-top: 0; text-align: center;">Static Media Failure</h2>
+                    <p><strong>${count}</strong> static media file${count > 1 ? 's' : ''} failed to load.</p>
+                    <p style="margin-bottom: 0;">
+                        Check whether
+                        <code><strong>nautobot-server collectstatic</strong></code>
+                        was run during the most recent upgrade and that the HTTP service (e.g. NGINX) is configured to serve static files.
+                        Refer to
+                        <a href="https://docs.nautobot.com/projects/core/en/v{{ settings.VERSION }}/installation/http-server/#static-media-failure" target="_blank">
+                            the installation documentation
+                        </a>
+                        for further guidance.
+                    </p>
+                </div>
+            `;
+
+            // If media failure alert already exists, just update its content and return early.
+            if (failureAlertRef.current) {
+                failureAlertRef.current.innerHTML = innerHTML;
+                return;
+            }
+
+            // If media failure alert does not exist yet, create one.
+            const alert = document.createElement('div');
+            alert.classList.add('alert', 'alert-danger', 'media-failure-banner');
+            alert.setAttribute('role', 'alert');
+            alert.innerHTML = innerHTML;
+
+            // Copy and hardcode Bootstrap `"alert alert-danger"` styles here to make the alert core styles independent of other CSS.
+            alert.style.setProperty('background-color', 'var(--bs-alert-bg, var(--bs-danger-bg-subtle, #fce8e8))');
+            alert.style.setProperty('border', 'var(--bs-alert-border, var(--bs-border-width, 0.0625rem) solid var(--bs-alert-border-color, var(--bs-danger-border-subtle, #f9d2d2)))');
+            alert.style.setProperty('border-radius', '0');
+            alert.style.setProperty('color', 'var(--bs-alert-color, var(--bs-danger-text-emphasis, #e01f1f))');
+            alert.style.setProperty('grid-area', 'banner-global-area');
+            alert.style.setProperty('padding', 'var(--bs-alert-padding-y, 1rem) 1.25rem');
+            alert.style.setProperty('position', 'relative');
+
+            // Update React-style `ref` to simplify later alert updates if required and place the alert as the first child of document body.
+            failureAlertRef.current = alert;
+            document.body.prepend(alert);
+        }
+
+        // Export `media` "API" to `window` global object to enable accessing it from other scripts.
+        window.nb = window.nb || {};
+        window.nb.media = { failures, handleFailure }
+    })();
+</script>

nautobot/core/templates/media_failure.html

@@ -1,3 +1,4 @@
+{% comment %}4.0 TODO: remove this template, which only exists for backward compatibility with 3.0 and earlier{% endcomment %}
 {% load static %}
 <!DOCTYPE html>
 <html lang="en">

nautobot/core/tests/test_cli.py

@@ -1,4 +1,9 @@
-from nautobot.core.cli import migrate_deprecated_templates
+import importlib.util
+import os.path
+import sys
+from unittest import mock
+
+from nautobot.core.cli import _preprocess_settings, migrate_deprecated_templates
 from nautobot.core.testing import TestCase
 
 
@@ -38,3 +43,117 @@ class TestMigrateTemplates(TestCase):
         replaced_content, was_updated = migrate_deprecated_templates.replace_template_references(original_content)
         self.assertTrue(was_updated)
         self.assertEqual(replaced_content, new_content)
+
+
+@mock.patch("nautobot.core.cli.load_plugins")
+@mock.patch("nautobot.core.cli.load_event_brokers")
+class TestPreprocessSettings(TestCase):
+    """Tests for the `_preprocess_settings` function in nautobot.core.cli, as it's important to Nautobot startup."""
+
+    def load_settings_module(self):
+        # Load the testing nautobot_config.py as a self-contained module
+        config_path = os.path.join(os.path.dirname(__file__), "nautobot_config.py")
+        spec = importlib.util.spec_from_file_location("test_nautobot_config", config_path)
+        settings_module = importlib.util.module_from_spec(spec)
+        # nautobot.core.cli.load_settings would do the below, but obviously we don't want to do that here:
+        # sys.modules["nautobot_config"] = settings_module
+        spec.loader.exec_module(settings_module)
+        return settings_module, config_path
+
+    def test_basic_path(self, mock_load_event_brokers, mock_load_plugins):
+        """Basic operation of the function."""
+        settings_module, config_path = self.load_settings_module()
+
+        # Process the settings module
+        _preprocess_settings(settings_module, config_path)
+
+        # _preprocess_settings should have set SETTINGS_PATH on the module
+        self.assertEqual(settings_module.SETTINGS_PATH, config_path)
+
+        # the default test settings have no EXTRA_* settings to handle
+
+        # all media paths should exist
+        self.assertTrue(os.path.isdir(settings_module.GIT_ROOT))
+        self.assertTrue(os.path.isdir(settings_module.JOBS_ROOT))
+        self.assertTrue(os.path.isdir(settings_module.MEDIA_ROOT))
+        self.assertTrue(os.path.isdir(os.path.join(settings_module.MEDIA_ROOT, "devicetype-images")))
+        self.assertTrue(os.path.isdir(os.path.join(settings_module.MEDIA_ROOT, "image-attachments")))
+        self.assertTrue(os.path.isdir(settings_module.STATIC_ROOT))
+
+        # databases should be using the prometheus backends
+        self.assertTrue(settings_module.METRICS_ENABLED)
+        self.assertIn("django_prometheus.db.backends", settings_module.DATABASES["default"]["ENGINE"])
+
+        # job_logs database connection should exist
+        self.assertIn("job_logs", settings_module.DATABASES)
+        self.assertIn("TEST", settings_module.DATABASES["job_logs"])
+        self.assertEqual(settings_module.DATABASES["job_logs"]["TEST"], {"MIRROR": "default"})
+        for key, value in settings_module.DATABASES["default"].items():
+            if key == "TEST":
+                continue
+            self.assertEqual(value, settings_module.DATABASES["job_logs"][key])
+
+        # STORAGES should remain as default
+        self.assertEqual(
+            settings_module.STORAGES,
+            {
+                "default": {"BACKEND": "django.core.files.storage.FileSystemStorage"},
+                "staticfiles": {"BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage"},
+                "nautobotjobfiles": {"BACKEND": "db_file_storage.storage.DatabaseFileStorage"},
+            },
+        )
+
+        mock_load_plugins.assert_called_with(settings_module)
+        mock_load_event_brokers.assert_called_with(settings_module.EVENT_BROKERS)
+
+    def test_EXTRA_behavior(self, *args):
+        """Handling of special settings like EXTRA_INSTALLED_APPS and EXTRA_MIDDLEWARE."""
+        settings_module, config_path = self.load_settings_module()
+
+        # Inject EXTRA_INSTALLED_APPS and EXTRA_MIDDLEWARE to the settings module for test purposes
+        settings_module.EXTRA_INSTALLED_APPS = ["foo.bar"]
+        settings_module.EXTRA_MIDDLEWARE = ("baz.bat",)
+
+        # Process the settings module
+        _preprocess_settings(settings_module, config_path)
+
+        self.assertIn("foo.bar", settings_module.INSTALLED_APPS)
+        # more specifically:
+        self.assertEqual("foo.bar", settings_module.INSTALLED_APPS[-1])
+        self.assertIn("baz.bat", settings_module.MIDDLEWARE)
+        # more specifically:
+        self.assertEqual("baz.bat", settings_module.MIDDLEWARE[-1])
+
+    def test_legacy_storage_behavior(self, *args):
+        """Handling legacy storage settings."""
+        settings_module, config_path = self.load_settings_module()
+
+        settings_module.DEFAULT_FILE_STORAGE = "storages.some_custom_backend"
+        settings_module.JOB_FILE_IO_STORAGE = "some_custom_job_file_storage"
+        settings_module.STATICFILES_STORAGE = "some_custom_static_storage"
+        settings_module.STORAGE_BACKEND = "storages.some_custom_backend"
+        settings_module.STORAGE_CONFIG = {"MY_BACKEND_OPTION": "some_value"}
+
+        import storages.utils
+
+        original_setting = storages.utils.setting
+        del sys.modules["storages.utils"]
+        del storages.utils
+
+        try:
+            # Process the settings module
+            _preprocess_settings(settings_module, config_path)
+
+            self.assertFalse(hasattr(settings_module, "DEFAULT_FILE_STORAGE"))  # unset to avoid a Django exception
+            self.assertEqual("storages.some_custom_backend", settings_module.STORAGES["default"]["BACKEND"])
+            self.assertEqual("some_custom_job_file_storage", settings_module.STORAGES["nautobotjobfiles"]["BACKEND"])
+            self.assertFalse(hasattr(settings_module, "STATICFILES_STORAGE"))  # unset to avoid a Django exception
+            self.assertEqual("some_custom_static_storage", settings_module.STORAGES["staticfiles"]["BACKEND"])
+
+            self.assertEqual("some_value", storages.utils.setting("MY_BACKEND_OPTION"))
+        finally:
+            # Clean up the STORAGE_CONFIG monkeypatch
+            import storages.utils  # pylint: disable=reimported
+
+            storages.utils.setting = original_setting
+            self.assertIsNone(storages.utils.setting("MY_BACKEND_OPTION"))