nautobot 2.4.4__tar.gz → 2.4.6__tar.gz

nautobot-2.4.6/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.1
+Name: nautobot
+Version: 2.4.6
+Summary: Source of truth and network automation platform.
+Home-page: https://nautobot.com
+License: Apache-2.0
+Keywords: Nautobot
+Author: Network to Code
+Author-email: opensource@networktocode.com
+Requires-Python: >=3.9.2,<3.13
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.9
+Provides-Extra: all
+Provides-Extra: ldap
+Provides-Extra: mysql
+Provides-Extra: napalm
+Provides-Extra: remote-storage
+Provides-Extra: sso
+Requires-Dist: Django (>=4.2.20,<4.3.0)
+Requires-Dist: GitPython (>=3.1.44,<3.2.0)
+Requires-Dist: Jinja2 (>=3.1.6,<3.2.0)
+Requires-Dist: Markdown (>=3.6,<3.7)
+Requires-Dist: Pillow (>=11.0.0,<11.1.0)
+Requires-Dist: PyYAML (>=6.0.2,<6.1.0)
+Requires-Dist: celery (>=5.3.6,<5.4.0)
+Requires-Dist: cryptography (>=44.0.2,<44.1.0)
+Requires-Dist: django-ajax-tables (>=1.1.1,<1.2.0)
+Requires-Dist: django-auth-ldap (>=5.1.0,<5.2.0) ; extra == "all" or extra == "ldap"
+Requires-Dist: django-celery-beat (>=2.6.0,<2.7.0)
+Requires-Dist: django-celery-results (>=2.5.1,<2.6.0)
+Requires-Dist: django-constance (>=4.3.0,<4.4.0)
+Requires-Dist: django-cors-headers (>=4.4.0,<4.5.0)
+Requires-Dist: django-db-file-storage (>=0.5.6.1,<0.6.0.0)
+Requires-Dist: django-extensions (>=3.2.3,<3.3.0)
+Requires-Dist: django-filter (>=25.1,<25.2)
+Requires-Dist: django-health-check (>=3.18.3,<3.19.0)
+Requires-Dist: django-jinja (>=2.11.0,<2.12.0)
+Requires-Dist: django-prometheus (>=2.3.1,<2.4.0)
+Requires-Dist: django-redis (>=5.4.0,<5.5.0)
+Requires-Dist: django-silk (>=5.3.2,<5.4.0)
+Requires-Dist: django-storages (==1.14.3) ; extra == "all" or extra == "remote-storage"
+Requires-Dist: django-structlog[celery] (>=9.0.1,<10.0.0)
+Requires-Dist: django-tables2 (>=2.7.5,<2.8.0)
+Requires-Dist: django-taggit (>=6.1.0,<6.2.0)
+Requires-Dist: django-timezone-field (>=7.0,<7.1)
+Requires-Dist: django-tree-queries (>=0.19.0,<0.20.0)
+Requires-Dist: django-webserver (>=1.2.0,<1.3.0)
+Requires-Dist: djangorestframework (>=3.15.2,<3.16.0)
+Requires-Dist: drf-spectacular[sidecar] (>=0.27.2,<0.28.0)
+Requires-Dist: emoji (>=2.12.1,<2.13.0)
+Requires-Dist: graphene-django (>=2.16.0,<2.17.0)
+Requires-Dist: graphene-django-optimizer (>=0.8.0,<0.9.0)
+Requires-Dist: jsonschema (>=4.7.0,<5.0.0)
+Requires-Dist: kombu (>=5.4.2,<5.5.0)
+Requires-Dist: kubernetes (>=32.0.1,<33.0.0)
+Requires-Dist: mysqlclient (>=2.2.7,<2.3.0) ; extra == "all" or extra == "mysql"
+Requires-Dist: napalm (>=4.1.0,<6.0.0) ; extra == "all" or extra == "napalm"
+Requires-Dist: netaddr (>=1.3.0,<1.4.0)
+Requires-Dist: netutils (>=1.6.0,<2.0.0)
+Requires-Dist: nh3 (>=0.2.21,<0.3.0)
+Requires-Dist: packaging (>=23.1)
+Requires-Dist: prometheus-client (>=0.20.0,<0.21.0)
+Requires-Dist: psycopg2-binary (>=2.9.10,<2.10.0)
+Requires-Dist: python-slugify (>=8.0.3,<8.1.0)
+Requires-Dist: pyuwsgi (>=2.0.26,<2.1.0)
+Requires-Dist: social-auth-app-django (>=5.4.3,<5.5.0)
+Requires-Dist: social-auth-core[saml] (>=4.5.6,<4.6.0) ; extra == "all" or extra == "sso"
+Requires-Dist: svgwrite (>=1.4.2,<1.5.0)
+Project-URL: Documentation, https://docs.nautobot.com
+Project-URL: Repository, https://github.com/nautobot/nautobot
+Description-Content-Type: text/markdown
+
+# Nautobot
+
+![Nautobot](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/nautobot_logo.svg "Nautobot logo")
+
+Nautobot is a Network Source of Truth and Network Automation Platform built as a web application atop the [Django](https://www.djangoproject.com/) Python framework with a
+[PostgreSQL](https://www.postgresql.org/) or [MySQL](https://www.mysql.com) database.
+
+## Key Use Cases
+
+**1. Flexible Source of Truth for Networking** - Nautobot core data models are used to define the intended state of network infrastructure enabling it as a Source of Truth. While a baseline set of models are provided (such as IP networks and addresses, devices and racks, circuits and cable, etc.) it is Nautobot's goal to offer maximum data model flexibility. This is enabled through features such as user-defined relationships, custom fields on any model, and data validation that permits users to codify everything from naming standards to having automated tests run before data can be populated into Nautobot.
+
+**2. Extensible Data Platform for Automation** - Nautobot has a rich feature set to seamlessly integrate with network automation solutions. Nautobot offers GraphQL and native Git integration along with REST APIs and webhooks. Git integration dynamically loads YAML data files as Nautobot config contexts. Nautobot also has an evolving plugin system that enables users to create custom models, APIs, and UI elements. The plugin system is also used to unify and aggregate disparate data sources creating a Single Source of Truth to streamline data management for network automation.
+
+**3. Platform for Network Automation Apps** - The Nautobot plugin system enables users to create Network Automation Apps. Apps can be as lightweight or robust as needed based on user needs. Using Nautobot for creating custom applications saves up to 70% development time by re-using features such as authentication, permissions, webhooks, GraphQL, change logging, etc. all while having access to the data already stored in Nautobot. Some production ready applications include:
+
+The complete documentation for Nautobot can be found at [Read the Docs](https://docs.nautobot.com/).
+
+Questions? Comments? Start by perusing our [GitHub discussions](https://github.com/nautobot/nautobot/discussions) for the topic you have in mind, or join the `#nautobot` channel on [Network to Code's Slack community](https://slack.networktocode.com/)!
+
+## Build Status
+
+| Branch      | Status |
+|-------------|------------|
+| **[main](https://github.com/nautobot/nautobot/tree/main)** | [![Build Status](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml/badge.svg?branch=main)](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml) |
+| **[develop](https://github.com/nautobot/nautobot/tree/develop)** | [![Build Status](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml/badge.svg?branch=develop)](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml) |
+| **[next](https://github.com/nautobot/nautobot/tree/next)** | [![Build Status](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml/badge.svg?branch=next)](https://github.com/nautobot/nautobot/actions/workflows/ci_integration.yml) |
+
+## Screenshots
+
+![Gif of main page](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_mainpage.gif?raw=true "Main page")
+
+---
+
+![Gif of config contexts](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_config_context.gif?raw=true "Config Contexts")
+
+---
+
+![Gif of prefix hierarchy](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_prefix_hierarchy.gif?raw=true "Prefix hierarchy")
+
+---
+
+![Gif of GraphQL](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_graphql.gif?raw=true "GraphQL API")
+
+---
+
+![Gif of Modes](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_modes.gif?raw=true "Modes")
+
+## Installation
+
+Please see [the documentation](https://docs.nautobot.com/projects/core/en/stable/user-guide/administration/installation/) for instructions on installing Nautobot.
+
+## Application Stack
+
+Below is a simplified overview of the Nautobot application stack for reference:
+
+![Application stack diagram](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_application_stack_high_level.png "Application stack diagram")
+
+## Plugins and Extensibility
+
+Nautobot offers the ability to customize your setup to better align with your direct business needs. It does so through the use of various plugins that have been developed for network automation, and are designed to be used in environments where needed.
+
+There are many plugins available within the Nautobot Apps ecosystem. The below screenshots are an example of some popular ones that are currently available.
+
+### Plugin Screenshots
+
+#### Golden Config Plugin
+
+![Gif of golden config](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_golden_config.gif?raw=true "Golden config")
+
+#### ChatOps Plugin
+
+![Gif of chatops](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_chatops.gif?raw=true "ChatOps")
+
+#### Device Lifecycle Management Plugin
+
+![Gif of DLM](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/media/nautobot_device_lifecycle_management.gif?raw=true "Device Lifecycle Management")
+
+## Providing Feedback
+
+The best platform for general feedback, assistance, and other discussion is our [GitHub discussions](https://github.com/nautobot/nautobot/discussions). To report a bug or request a specific feature, please open a GitHub issue using the [appropriate template](https://github.com/nautobot/nautobot/issues/new/choose).
+
+If you are interested in contributing to the development of Nautobot, please read our [contributing guide](https://docs.nautobot.com/projects/core/en/stable/development/core/#contributing) prior to beginning any work.
+
+## Related projects
+
+Please check out [the GitHub `nautobot` topic](https://github.com/topics/nautobot) for a list of relevant community projects.
+
+## Notices
+
+> Nautobot was initially developed as a fork of NetBox (v2.10.4).  NetBox was originally developed by Jeremy Stretch at DigitalOcean and the NetBox Community.
+

nautobot-2.4.6/nautobot/__init__.py

@@ -0,0 +1,68 @@
+from importlib import metadata
+import logging
+import os
+import sys
+
+import django
+
+# Primary package version
+__version__ = metadata.version(__name__)
+
+# Sentinel to make sure we only initialize once.
+__initialized = False
+
+
+def add_success_logger():
+    """Add a custom log level for success messages."""
+    SUCCESS = 25  # between INFO and WARNING
+    logging.addLevelName(SUCCESS, "SUCCESS")
+
+    def success(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "success"
+        if self.isEnabledFor(SUCCESS):
+            self._log(SUCCESS, message, args, **kwargs)
+
+    logging.Logger.success = success
+    return success
+
+
+def add_failure_logger():
+    """Add a custom log level for failure messages less severe than an ERROR."""
+    FAILURE = 35  # between WARNING and ERROR
+    logging.addLevelName(FAILURE, "FAILURE")
+
+    def failure(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "failure"
+        if self.isEnabledFor(FAILURE):
+            self._log(FAILURE, message, args, **kwargs)
+
+    logging.Logger.failure = failure
+    return failure
+
+
+add_success_logger()
+add_failure_logger()
+logger = logging.getLogger(__name__)
+
+
+def setup(config_path=None):
+    """Similar to `django.setup()`, this configures Django with the appropriate Nautobot settings data."""
+    from nautobot.core.cli import get_config_path, load_settings
+
+    global __initialized
+
+    if __initialized:
+        return
+
+    if config_path is None:
+        config_path = get_config_path()
+
+    # Point Django to our 'nautobot_config' pseudo-module that we'll load from the provided config path
+    os.environ["DJANGO_SETTINGS_MODULE"] = "nautobot_config"
+
+    if "nautobot_config" not in sys.modules:
+        load_settings(config_path)
+    django.setup()
+
+    logger.info("Nautobot %s initialized!", __version__)
+    __initialized = True

nautobot-2.4.6/nautobot/core/api/mixins.py

@@ -0,0 +1,124 @@
+import logging
+import uuid
+
+from django.core.exceptions import (
+    FieldError,
+    MultipleObjectsReturned,
+    ObjectDoesNotExist,
+)
+from django.db.models import AutoField, Model
+from rest_framework.exceptions import ValidationError
+
+from nautobot.core.api.utils import dict_to_filter_params
+from nautobot.core.utils.data import is_url
+
+logger = logging.getLogger(__name__)
+
+
+class LimitQuerysetChoicesSerializerMixin:
+    """Mixin field that restricts queryset choices to those accessible
+    for the queryset model that implemented it."""
+
+    def get_queryset(self):
+        """Only emit options for this model/field combination."""
+        queryset = super().get_queryset()
+        # Get objects model e.g Location, Device... etc.
+        # Tags model can be gotten using self.parent.parent, while others uses self.parent
+        try:
+            model = self.parent.Meta.model
+        except AttributeError:
+            model = self.parent.parent.Meta.model
+        return queryset.get_for_model(model)
+
+
+class WritableSerializerMixin:
+    """
+    WritableSerializerMixin provides the to_internal_value() function.
+    The function provides the ability to write API requests that identify unique objects based on
+    combinations of fields other than the primary key.
+    e.g:
+    "parent": { "location_type__parent": {"name": "Campus"}, "parent__name": "Campus-29" }
+    vs
+    "parent": "10dff139-7333-46b0-bef6-f6a5a7b5497c"
+    """
+
+    def remove_non_filter_fields(self, filter_params):
+        """
+        Make output from a WritableSerializer "round-trip" capable by automatically stripping from the
+        data any serializer fields that do not correspond to a specific model field
+        """
+        if hasattr(self, "fields"):
+            for field_name, field_instance in self.fields.items():
+                if field_name in filter_params and field_instance.source == "*":
+                    logger.debug("Discarding non-filter field %s", field_name)
+                    del filter_params[field_name]
+        return filter_params
+
+    def get_queryset_filter_params(self, data, queryset):
+        """
+        Data could be a dictionary and an int (for the User model) or a str that represents the primary key.
+        If it is a dictionary, we return it after remove non-filter fields.
+        If it is a primary key, we return a dictionary object formatted like this {"pk": pk}
+        """
+
+        if isinstance(data, dict):
+            params = dict_to_filter_params(data)
+            return self.remove_non_filter_fields(params)
+
+        # Account for the fact that HyperlinkedIdentityFields might pass in URLs.
+        if is_url(data):
+            # Strip the trailing slash and split on slashes, taking the last value as the PK.
+            data = data.rstrip("/").split("/")[-1]
+
+        # If we're passing the validated_data from one serializer as input to another serializer,
+        # data might already be a model instance:
+        if isinstance(data, Model):
+            return {"pk": data.pk}
+
+        try:
+            # The int case here is taking into account for the User model we inherit from django
+            pk = int(data) if isinstance(queryset.model._meta.pk, AutoField) else uuid.UUID(str(data))
+        except (TypeError, ValueError) as e:
+            raise ValidationError(
+                "Related objects must be referenced by ID or by dictionary of attributes. Received an "
+                f"unrecognized value: {data}"
+            ) from e
+        return {"pk": pk}
+
+    def get_object(self, data, queryset):
+        """
+        Retrieve an unique object based on a dictionary of data attributes and raise errors accordingly if the object is not found.
+        """
+        filter_params = self.get_queryset_filter_params(data=data, queryset=queryset)
+        try:
+            return queryset.get(**filter_params)
+        except ObjectDoesNotExist as e:
+            raise ValidationError(f"Related object not found using the provided attributes: {filter_params}") from e
+        except MultipleObjectsReturned as e:
+            raise ValidationError(f"Multiple objects match the provided attributes: {filter_params}") from e
+        except FieldError as e:
+            raise ValidationError(e) from e
+
+    def to_internal_value(self, data):
+        """
+        Return an object or a list of objects based on a dictionary of data attributes or an UUID.
+        """
+        if data is None:
+            return None
+        if hasattr(self, "queryset"):
+            queryset = self.queryset
+        else:
+            queryset = self.Meta.model.objects
+
+        # Apply user permission on related objects
+        if (
+            "request" in self.context
+            and self.context["request"]
+            and self.context["request"].user
+            and hasattr(queryset, "restrict")
+        ):
+            queryset = queryset.restrict(self.context["request"].user, "view")
+
+        if isinstance(data, list):
+            return [self.get_object(data=entry, queryset=queryset) for entry in data]
+        return self.get_object(data=data, queryset=queryset)

nautobot-2.4.6/nautobot/core/celery/__init__.py

@@ -0,0 +1,243 @@
+import json
+import logging
+import os
+from pathlib import Path
+import shutil
+
+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 OperationalError, ProgrammingError
+from django.utils.functional import SimpleLazyObject
+from django.utils.module_loading import import_string
+from kombu.serialization import register
+from prometheus_client import CollectorRegistry, multiprocess, start_http_server
+
+from nautobot import add_failure_logger, add_success_logger
+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__)
+
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "nautobot_config")
+
+
+class NautobotCelery(Celery):
+    task_cls = "nautobot.core.celery.task:NautobotTask"
+
+
+app = NautobotCelery("nautobot")
+
+# Using a string here means the worker doesn't have to serialize
+# the configuration object to child processes.
+# - namespace='CELERY' means all celery-related configuration keys
+#   should have a `CELERY_` prefix.
+app.config_from_object("django.conf:settings", namespace="CELERY")
+
+# Load task modules from all registered Django apps.
+app.autodiscover_tasks()
+
+
+@signals.import_modules.connect
+def import_jobs(sender=None, **kwargs):
+    """
+    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()
+
+    try:
+        _import_jobs_from_git_repositories()
+    except (
+        OperationalError,  # Database not present, as may be the case when running pylint-nautobot
+        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.
+    """
+    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
+
+            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, ignore_errors=True)
+
+    # 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):
+    """Add NautobotDatabaseHandler to logger and update logger level filtering to send all log levels to our handler."""
+    if any(isinstance(h, NautobotDatabaseHandler) for h in logger_instance.handlers):
+        return
+    if logger_instance.level not in (logging.NOTSET, logging.DEBUG):
+        for handler in logger_instance.handlers:
+            handler.setLevel(logger_instance.level)
+    logger_instance.setLevel(logging.DEBUG)
+
+    if log_format is None:
+        log_format = app.conf.worker_task_log_format
+    handler = NautobotDatabaseHandler()
+    handler.setFormatter(TaskFormatter(log_format, use_color=False))
+    logger_instance.addHandler(handler)
+
+
+@signals.after_setup_logger.connect
+def setup_nautobot_global_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
+    """Add SUCCESS and FAILURE logs to celery global logger."""
+    logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
+
+
+@signals.after_setup_task_logger.connect
+def setup_nautobot_task_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
+    """Add SUCCESS and FAILURE logs to celery task logger."""
+    logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
+
+
+@signals.celeryd_after_setup.connect
+def setup_nautobot_job_logging(sender, instance, conf, **kwargs):
+    """Add nautobot database logging handler to celery stdout/stderr redirect logger and celery task logger."""
+    task_logger = get_logger("celery.task")
+    add_nautobot_log_handler(task_logger)
+    if conf.worker_redirect_stdouts:
+        redirect_logger = get_logger("celery.redirected")
+        add_nautobot_log_handler(redirect_logger)
+
+
+@signals.worker_ready.connect
+def setup_prometheus(**kwargs):
+    """This sets up an HTTP server to serve prometheus metrics from the celery workers."""
+    # Don't set up the server if the port is undefined
+    if not settings.CELERY_WORKER_PROMETHEUS_PORTS:
+        return
+
+    logger.info("Setting up prometheus metrics HTTP server for celery worker.")
+
+    # Ensure that the multiprocess coordination directory exists. Note that we explicitly don't clear this directory
+    # out because the worker might share its filesystem with the core app or another worker. The multiprocess
+    # mechanism from prometheus-client takes care of this.
+    multiprocess_coordination_directory = Path(os.environ["prometheus_multiproc_dir"])
+    multiprocess_coordination_directory.mkdir(parents=True, exist_ok=True)
+
+    # Set up the collector registry
+    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=collector_registry)
+            break
+        except OSError:
+            continue
+    else:
+        logger.warning("Cannot export Prometheus metrics from worker, no available ports in range.")
+
+
+def nautobot_kombu_json_loads_hook(data):
+    """
+    In concert with the NautobotKombuJSONEncoder json encoder, this object hook method decodes
+    objects that implement the `__nautobot_type__` interface via the `nautobot_deserialize()` class method.
+    """
+    if "__nautobot_type__" in data:
+        qual_name = data.pop("__nautobot_type__")
+        logger.debug("Performing nautobot deserialization for type %s", qual_name)
+        cls = import_string(qual_name)  # fully qualified dotted import path
+        if cls:
+            return SimpleLazyObject(lambda: cls.objects.get(id=data["id"]))
+        else:
+            raise TypeError(f"Unable to import {qual_name} during nautobot deserialization")
+    else:
+        return data
+
+
+# Encoder function
+def _dumps(obj):
+    return json.dumps(obj, cls=NautobotKombuJSONEncoder, ensure_ascii=False)
+
+
+# Decoder function
+def _loads(obj):
+    return json.loads(obj, object_hook=nautobot_kombu_json_loads_hook)
+
+
+# Register the custom serialization type
+register("nautobot_json", _dumps, _loads, content_type="application/x-nautobot-json", content_encoding="utf-8")
+
+
+#
+# nautobot_task
+#
+# By exposing `shared_task` within our own namespace, we leave the door open to
+# extending and expanding the usage and meaning of shared_task without having
+# to undergo further refactoring of task's decorators. We could also transparently
+# swap out shared_task to a custom base task.
+#
+
+nautobot_task = shared_task
+
+
+registry["jobs"] = {}
+
+
+def register_jobs(*jobs):
+    """
+    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:
+        if job.class_path not in registry["jobs"]:
+            registry["jobs"][job.class_path] = job

nautobot-2.4.6/nautobot/core/celery/encoders.py

@@ -0,0 +1,56 @@
+import logging
+
+from django.db import models
+from rest_framework.utils.encoders import JSONEncoder
+
+logger = logging.getLogger(__name__)
+
+
+class NautobotKombuJSONEncoder(JSONEncoder):
+    """
+    Custom json encoder based on restframework's JSONEncoder that serializes objects that implement
+    the `nautobot_serialize()` method via the `__nautobot_type__` interface. This is useful
+    in passing special objects to and from Celery tasks.
+
+    This pattern should generally be avoided by passing pointers to persisted objects to the
+    Celery tasks and retrieving them from within the task execution. While this is always possible
+    for model instances (which covers 99% of use cases), for rare instances where it does not,
+    and the actual object must be passed, this pattern allows for encoding and decoding
+    of such objects.
+
+    It requires a conforming class to implement the instance method `nautobot_serialize()` which
+    returns a json serializable dictionary of the object representation. The class must also implement
+    the `nautobot_deserialize()` class method which takes the dictionary representation and returns
+    an actual instance of the class.
+    """
+
+    def default(self, obj):
+        # Import here to avoid django.core.exceptions.ImproperlyConfigured Error.
+        # Core App is not set up yet if we import this at the top of the file.
+        from nautobot.core.models.managers import TagsManager
+
+        if isinstance(obj, models.Model):
+            cls = obj.__class__
+            module = cls.__module__
+            qual_name = ".".join([module, cls.__qualname__])  # fully qualified dotted import path
+            logger.debug("Performing nautobot serialization on %s for type %s", obj, qual_name)
+            data = {
+                "id": obj.id,
+                "__nautobot_type__": qual_name,
+                # TODO: change to natural key to provide additional context if object is deleted from the db
+                "display": getattr(obj, "display", str(obj)),
+            }
+            return data
+
+        elif isinstance(obj, set):
+            # Convert a set to a list for passing to and from a task
+            return list(obj)
+        elif isinstance(obj, TagsManager):
+            obj = obj.values_list("id", flat=True)
+            return obj
+        elif isinstance(obj, Exception):
+            # JobResult.result uses NautobotKombuJSONEncoder as an encoder and expects a JSONSerializable object,
+            # although an exception, such as a RuntimeException, can be supplied as the obj.
+            return f"{obj.__class__.__name__}: {obj}"
+        else:
+            return super().default(obj)