nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/core/api/views.py

@@ -23,10 +23,11 @@ from drf_spectacular.utils import extend_schema
 from drf_spectacular.views import SpectacularAPIView, SpectacularRedocView, SpectacularSwaggerView
 from graphene_django.settings import graphene_settings
 from graphene_django.views import GraphQLView, HttpError, instantiate_middleware
-from graphql import get_default_backend
+from graphql import execute, get_operation_ast, OperationType, parse, validate_schema
 from graphql.execution import ExecutionResult
 from graphql.execution.middleware import MiddlewareManager
 from graphql.type.schema import GraphQLSchema
+from graphql.validation import validate
 import redis.exceptions
 from rest_framework import routers, serializers as drf_serializers, status
 from rest_framework.exceptions import APIException, ParseError, PermissionDenied
@@ -440,6 +441,10 @@ class APIRootView(AuthenticatedAPIRootView):
                         "cloud",
                         reverse("cloud-api:api-root", request=request, format=format),
                     ),
+                    (
+                        "data-validation",
+                        reverse("data_validation-api:api-root", request=request, format=format),
+                    ),
                     (
                         "dcim",
                         reverse("dcim-api:api-root", request=request, format=format),
@@ -474,6 +479,14 @@ class APIRootView(AuthenticatedAPIRootView):
                             format=format,
                         ),
                     ),
+                    (
+                        "vpn",
+                        reverse(
+                            "vpn-api:api-root",
+                            request=request,
+                            format=format,
+                        ),
+                    ),
                     (
                         "wireless",
                         reverse(
@@ -606,12 +619,15 @@ class NautobotSpectacularSwaggerView(APIVersioningGetSchemaURLMixin, Spectacular
 
         # Add additional data so drf-spectacular will use the Token keyword in authorization header.
         response.data["schema_auth_names"] = ["tokenAuth"]
+
         return response
 
 
 class NautobotSpectacularRedocView(APIVersioningGetSchemaURLMixin, SpectacularRedocView):
     """Extend SpectacularRedocView to support Nautobot's ?api_version=<version> query parameter."""
 
+    template_name = "redoc_ui.html"
+
 
 @method_decorator(gzip_page, name="dispatch")
 class NautobotSpectacularAPIView(SpectacularAPIView):
@@ -662,18 +678,25 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
     # https://github.com/graphql-python/graphene-django/blob/main/graphene_django/views.py#L57
 
     permission_classes = [IsAuthenticated]
-    graphql_schema = None
-    executor = None
-    backend = None
+    execution_context_class = None
     middleware = None
     root_value = None
-
-    def __init__(self, schema=None, executor=None, middleware=None, root_value=None, backend=None, **kwargs):
+    validation_rules = None
+
+    def __init__(
+        self,
+        schema=None,
+        execution_context_class=None,
+        middleware=None,
+        root_value=None,
+        validation_rules=None,
+        **kwargs,
+    ):
         self.schema = schema
-        self.executor = executor
+        self.execution_context_class = execution_context_class
         self.middleware = middleware
         self.root_value = root_value
-        self.backend = backend
+        self.validation_rules = validation_rules
         super().__init__(**kwargs)
 
     def get_root_value(self, request):
@@ -685,9 +708,6 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
     def get_context(self, request):
         return request
 
-    def get_backend(self, request):
-        return self.backend
-
     @extend_schema(
         request=serializers.GraphQLAPISerializer,
         description="Query the database using a GraphQL query",
@@ -719,21 +739,16 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
         if not self.schema:
             self.schema = graphene_settings.SCHEMA
 
-        if self.backend is None:
-            self.backend = get_default_backend()
-
-        self.graphql_schema = self.graphql_schema or self.schema
-
         if self.middleware is not None:
             if isinstance(self.middleware, MiddlewareManager):
                 self.middleware = graphene_settings.MIDDLEWARE
             else:
                 self.middleware = list(instantiate_middleware(self.middleware))
 
-        self.executor = self.executor
+        self.execution_context_class = self.execution_context_class
         self.root_value = self.root_value
 
-        if not isinstance(self.graphql_schema, GraphQLSchema):
+        if not isinstance(self.schema.graphql_schema, GraphQLSchema):
             raise ValueError("A Schema is required to be provided to GraphQLAPIView.")
 
     def get_response(self, request, data):
@@ -757,7 +772,7 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
             if execution_result.errors:
                 response["errors"] = [GraphQLView.format_error(e) for e in execution_result.errors]
 
-            if execution_result.invalid:
+            if execution_result.errors and any(not getattr(e, "path", None) for e in execution_result.errors):
                 status_code = 400
             else:
                 response["data"] = execution_result.data
@@ -809,38 +824,44 @@ class GraphQLDRFAPIView(NautobotAPIVersionMixin, APIView):
         if not query:
             raise HttpError(HttpResponseBadRequest("Must provide query string."))
 
+        schema = self.schema.graphql_schema
+
+        schema_validation_errors = validate_schema(schema)
+        if schema_validation_errors:
+            return ExecutionResult(data=None, errors=schema_validation_errors)
+
         try:
-            backend = self.get_backend(request)
-            document = backend.document_from_string(self.graphql_schema, query)
+            document = parse(query)
         except Exception as e:
-            return ExecutionResult(errors=[e], invalid=True)
+            return ExecutionResult(errors=[e])
+
+        operation_ast = get_operation_ast(document, operation_name)
 
-        operation_type = document.get_operation_type(operation_name)
-        if operation_type and operation_type != "query":
+        if operation_ast is not None and operation_ast.operation != OperationType.QUERY:
             raise HttpError(
-                HttpResponseBadRequest(f"'{operation_type}' is not a supported operation, Only query are supported.")
+                HttpResponseBadRequest(
+                    f"'{operation_ast.operation}' is not a supported operation, Only query are supported."
+                )
             )
 
-        try:
-            extra_options = {}
-            if self.executor:
-                # We only include it optionally since
-                # executor is not a valid argument in all backends
-                extra_options["executor"] = self.executor
+        validation_errors = validate(schema, document, self.validation_rules, graphene_settings.MAX_VALIDATION_ERRORS)
+        if validation_errors:
+            return ExecutionResult(data=None, errors=validation_errors)
 
-            options = {
+        try:
+            execute_options = {
                 "root_value": self.get_root_value(request),
+                "context_value": self.get_context(request),
                 "variable_values": variables,
                 "operation_name": operation_name,
-                "context_value": self.get_context(request),
                 "middleware": self.get_middleware(request),
             }
-            options.update(extra_options)
+            if self.execution_context_class:
+                execute_options["execution_context_class"] = self.execution_context_class
 
-            operation_type = document.get_operation_type(operation_name)
-            return document.execute(**options)
+            return execute(schema=schema, document=document, **execute_options)
         except Exception as e:
-            return ExecutionResult(errors=[e], invalid=True)
+            return ExecutionResult(errors=[e])
 
 
 #

nautobot/core/apps/__init__.py

@@ -9,7 +9,6 @@ from django.db.models.signals import post_migrate
 from django.urls import reverse
 from django.urls.exceptions import NoReverseMatch
 from django.utils.http import urlencode
-from django.utils.module_loading import import_string
 from graphene.types import generic, String
 
 from nautobot.core.signals import nautobot_database_ready
@@ -31,6 +30,7 @@ from nautobot.core.ui.nav import (  # isort: skip  # noqa: F401
     NavMenuTab,
     NAV_CONTEXT_NAMES,
 )
+from nautobot.core.utils.module_loading import import_string_optional
 from nautobot.core.utils.patch_social_django import patch_django_storage
 from nautobot.extras.registry import registry
 
@@ -60,17 +60,11 @@ class NautobotConfig(AppConfig):
         """
         Ready function initiates the import application.
         """
-        try:
-            homepage_layout = import_string(f"{self.name}.{self.homepage_layout}")
+        if homepage_layout := import_string_optional(f"{self.name}.{self.homepage_layout}"):
             register_homepage_panels(self.path, self.label, homepage_layout)
-        except ImportError:
-            pass
 
-        try:
-            menu_items = import_string(f"{self.name}.{self.menu_tabs}")
+        if menu_items := import_string_optional(f"{self.name}.{self.menu_tabs}"):
             register_menu_items(menu_items)
-        except ImportError:
-            pass
 
 
 def create_or_check_entry(grouping, record, key, path):
@@ -334,9 +328,9 @@ class CoreConfig(NautobotConfig):
             # Register in django_jinja
             library.filter(name=name, fn=func)
 
+        from graphene.types.scalars import BigInt
         from graphene_django.converter import convert_django_field
 
-        from nautobot.core.graphql import BigInteger
         import nautobot.core.jobs  # noqa: F401  # unused-import -- but this import registers the system jobs
 
         @convert_django_field.register(JSONField)
@@ -351,8 +345,8 @@ class CoreConfig(NautobotConfig):
 
         @convert_django_field.register(BigIntegerField)
         def convert_biginteger(field, registry=None):  # pylint: disable=redefined-outer-name
-            """Convert BigIntegerField to BigInteger scalar."""
-            return BigInteger()
+            """Convert BigIntegerField to BigInt scalar."""
+            return BigInt()
 
         from django.conf import settings
         from django.contrib.auth.models import update_last_login

nautobot/core/branching.py

@@ -0,0 +1,83 @@
+import logging
+
+from django.conf import settings
+from django.db import connections
+
+LOGGER = logging.getLogger(__name__)
+
+
+class BranchContext:
+    def __init__(self, branch_name=None, using=None, user=None, autocommit=True):
+        """
+        Instantiate a BranchContext context manager.
+
+        Example:
+            with BranchContext(branch_name="my-branch", user=request.user):
+                ...
+
+        Args:
+            branch_name (str): The Dolt branch name (if any) to potentially switch to.
+                If left as the default `None`, this context manager does nothing, allowing it to be safely used in
+                code that can execute in a non-version-controlled Nautobot deployment as well.
+            using (str, list[str]): The database connection alias(es) to potentially switch to the specified branch.
+                Note it can be a *list* of connections, or a single connection alias string like most Django built-ins.
+                If omitted, only the `"default"` connection will be used.
+            user (User): The user account to associate with any Dolt Commit created when using `autocommit=True`.
+            autocommit (bool): Whether to create an automatic Dolt Commit record when exiting this context.
+        """
+        self.branch_name = branch_name
+        if not using:
+            self.using = ["default"]
+        elif isinstance(using, str):
+            self.using = [using]
+        else:
+            self.using = using
+        self.user = user
+        self.autocommit = autocommit
+
+        self.cursors = {}
+        self.original_branches = {}
+        self.auto_dolt_commit = None
+
+    def __enter__(self):
+        if self.branch_name is None or "nautobot_version_control" not in settings.PLUGINS:
+            if self.branch_name is not None:
+                LOGGER.warning(
+                    "nautobot_version_control is not installed, ignoring requested branch %s", self.branch_name
+                )
+            return
+
+        from nautobot_version_control.utils import active_branch, checkout_branch  # pylint: disable=import-error
+
+        for using in self.using:
+            self.cursors[using] = connections[using].cursor()
+            self.cursors[using].__enter__()
+            self.original_branches[using] = active_branch(using=using)
+
+            if self.branch_name != self.original_branches[using]:
+                LOGGER.info("Switching connection %r to branch %r", using, self.branch_name)
+
+                checkout_branch(self.branch_name, using=using)
+
+        if self.autocommit:
+            from nautobot_version_control.middleware import AutoDoltCommit  # pylint: disable=import-error
+
+            self.auto_dolt_commit = AutoDoltCommit(user=self.user)
+            self.auto_dolt_commit.__enter__()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.branch_name is None or "nautobot_version_control" not in settings.PLUGINS:
+            return
+
+        if self.autocommit:
+            self.auto_dolt_commit.__exit__(exc_type, exc_value, traceback)
+
+        for using in self.using:
+            if self.branch_name != self.original_branches[using]:
+                from nautobot_version_control.utils import checkout_branch  # pylint: disable=import-error
+
+                checkout_branch(self.original_branches[using], using=using)
+
+                LOGGER.info("Returned connection %r to branch %r", using, self.original_branches[using])
+
+            self.cursors[using].__exit__(exc_type, exc_value, traceback)

nautobot/core/celery/__init__.py

@@ -12,16 +12,15 @@ from django.apps import apps
 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.branching import BranchContext
 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.plugins.utils import import_object
+from nautobot.core.utils.module_loading import import_modules_privately, import_string_optional
 from nautobot.extras.registry import registry
 
 logger = logging.getLogger(__name__)
@@ -139,7 +138,7 @@ def _import_dynamic_jobs_from_apps():
                 del sys.modules[job.__module__]
 
         # Load app jobs
-        app_config.features["jobs"] = import_object(f"{app_config.__module__}.{app_config.jobs}")
+        app_config.features["jobs"] = import_string_optional(f"{app_config.__module__}.{app_config.jobs}")
 
 
 def add_nautobot_log_handler(logger_instance, log_format=None):
@@ -217,10 +216,16 @@ def nautobot_kombu_json_loads_hook(data):
     """
     if "__nautobot_type__" in data:
         qual_name = data.pop("__nautobot_type__")
+        branch_name = data.pop("__nautobot_branch__", None)
         logger.debug("Performing nautobot deserialization for type %s", qual_name)
-        cls = import_string(qual_name)  # fully qualified dotted import path
+        cls = import_string_optional(qual_name)  # fully qualified dotted import path
         if cls:
-            return SimpleLazyObject(lambda: cls.objects.get(id=data["id"]))
+
+            def get_object():
+                with BranchContext(branch_name=branch_name, autocommit=False):
+                    return cls.objects.get(id=data["id"])
+
+            return SimpleLazyObject(get_object)
         else:
             raise TypeError(f"Unable to import {qual_name} during nautobot deserialization")
     else:

nautobot/core/celery/backends.py

@@ -29,6 +29,7 @@ class NautobotDatabaseBackend(DatabaseBackend):
             "task_args": None,
             "task_kwargs": None,
             "celery_kwargs": None,
+            "branch_name": None,
             "job_model_id": None,
             "scheduled_job_id": None,
             "task_name": None,
@@ -67,6 +68,7 @@ class NautobotDatabaseBackend(DatabaseBackend):
                     "task_args": task_args,
                     "task_kwargs": task_kwargs,
                     "celery_kwargs": celery_kwargs,
+                    "branch_name": properties.get("nautobot_job_branch_name", None),
                     "job_model_id": properties.get("nautobot_job_job_model_id", None),
                     "scheduled_job_id": properties.get("nautobot_job_scheduled_job_id", None),
                     "task_name": task_name,

nautobot/core/celery/encoders.py

@@ -1,6 +1,7 @@
 import logging
 from zoneinfo import ZoneInfo
 
+from django.conf import settings
 from django.db import models
 from rest_framework.utils.encoders import JSONEncoder
 
@@ -41,6 +42,12 @@ class NautobotKombuJSONEncoder(JSONEncoder):
                 # TODO: change to natural key to provide additional context if object is deleted from the db
                 "display": getattr(obj, "display", str(obj)),
             }
+
+            if "nautobot_version_control" in settings.PLUGINS:
+                from nautobot_version_control.utils import active_branch  # pylint: disable=import-error
+
+                data["__nautobot_branch__"] = active_branch()
+
             return data
 
         elif isinstance(obj, set):

nautobot/core/celery/task.py

@@ -4,12 +4,51 @@ from celery.exceptions import Retry
 from celery.result import EagerResult
 from celery.utils.functional import maybe_list
 from celery.utils.nodenames import gethostname
+from django.conf import settings
+from django.contrib.auth import get_user_model
 from kombu.utils.uuid import uuid
 
+from nautobot.core.branching import BranchContext
+from nautobot.extras.models.jobs import JOB_LOGS
+
 
 class NautobotTask(Task):
     """Nautobot extensions to tasks for integrating with Job machinery."""
 
+    def before_start(self, task_id, args, kwargs):
+        super().before_start(task_id, args, kwargs)
+        User = get_user_model()
+        user_id = self.request.properties.get("nautobot_job_user_id", None)
+        self._nautobot_branch_context = BranchContext(
+            branch_name=self.request.properties.get("nautobot_job_branch_name", None),
+            user=User.objects.get(id=user_id) if user_id else None,
+            using=["default", JOB_LOGS],
+        )
+        self._nautobot_branch_context.__enter__()
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        self._nautobot_branch_context.__exit__(None, None, None)  # TODO: good enough?
+        delattr(self, "_nautobot_branch_context")
+        super().after_return(status, retval, task_id, args, kwargs, einfo)
+
+    def apply_async(
+        self,
+        args=None,
+        kwargs=None,
+        task_id=None,
+        producer=None,
+        link=None,
+        link_error=None,
+        shadow=None,
+        **options,
+    ):
+        if "nautobot_version_control" in settings.PLUGINS and "nautobot_job_branch_name" not in options:
+            from nautobot_version_control.utils import active_branch  # pylint: disable=import-error
+
+            options["nautobot_job_branch_name"] = active_branch()
+
+        return super().apply_async(args, kwargs, task_id, producer, link, link_error, shadow, **options)
+
     def apply(
         self,
         args=None,
@@ -39,6 +78,11 @@ class NautobotTask(Task):
         # Make sure we get the task instance, not class.
         task = app._tasks[self.name]
 
+        if "nautobot_version_control" in settings.PLUGINS and "nautobot_job_branch_name" not in options:
+            from nautobot_version_control.utils import active_branch  # pylint: disable=import-error
+
+            options["nautobot_job_branch_name"] = active_branch()
+
         request = {
             "id": task_id,
             "retries": retries,

nautobot/core/checks.py

@@ -6,6 +6,9 @@ from django.core.exceptions import ValidationError
 from django.core.validators import URLValidator
 from django.db import connections
 
+from nautobot.core.utils.config import get_settings_or_config
+from nautobot.dcim.choices import DeviceUniquenessChoices
+
 E002 = Error(
     "'nautobot.core.authentication.ObjectPermissionBackend' must be included in AUTHENTICATION_BACKENDS",
     id="nautobot.core.E002",
@@ -30,12 +33,31 @@ E005 = Error(
     obj=settings,
 )
 
+E006 = Error(
+    "The Data Validation Engine app has been moved directly into Nautobot Core.  Please remove 'nautobot_data_validation_engine' from PLUGINS and PLUGINS_CONFIG in your nautobot_config.py.  After running Nautobot migrations successfully, you can then also uninstall 'nautobot-data-validation-engine' from the Python environment.",
+    id="nautobot.core.E006",
+    obj=settings,
+)
+
 W005 = Warning(
     "STORAGE_CONFIG has been set but STORAGE_BACKEND is not defined. STORAGE_CONFIG will be ignored.",
     id="nautobot.core.W005",
     obj=settings,
 )
 
+W006 = Warning(
+    "The deprecated setting DEVICE_NAME_AS_NATURAL_KEY is still defined.",
+    hint="This setting has been superseded by DEVICE_UNIQUENESS (see Device Constraints).",
+    id="nautobot.core.W006",
+    obj=settings,
+)
+
+W007 = Warning(
+    "Invalid DEVICE_UNIQUENESS configuration value.",
+    hint=f"DEVICE_UNIQUENESS must be one of: {', '.join(DeviceUniquenessChoices.values())}.",
+    id="nautobot.core.W007",
+)
+
 MIN_POSTGRESQL_MAJOR_VERSION = 12
 MIN_POSTGRESQL_MINOR_VERSION = 0
 
@@ -139,3 +161,41 @@ def check_sanitizer_patterns(app_configs, **kwargs):
             )
 
     return errors
+
+
+@register(Tags.compatibility)
+def check_data_validation_engine_installed(app_configs, **kwargs):
+    app_name = "nautobot_data_validation_engine"
+    if app_name in settings.PLUGINS or app_name in settings.PLUGINS_CONFIG:
+        return [E006]
+    return []
+
+
+@register(Tags.compatibility)
+def check_deprecated_device_name_as_natural_key(app_configs, **kwargs):
+    """
+    Warn if the deprecated DEVICE_NAME_AS_NATURAL_KEY setting is still defined.
+
+    This setting existed prior to 3.0 and has been replaced by the
+    DEVICE_UNIQUENESS Constance configuration.
+    """
+    try:
+        get_settings_or_config("DEVICE_NAME_AS_NATURAL_KEY")
+        return [W006]
+    except AttributeError:
+        pass
+    return []
+
+
+@register(Tags.compatibility)
+def check_valid_value_for_device_uniqueness(app_configs, **kwargs):
+    """
+    Warn if the invalid value for DEVICE_UNIQUENESS is set.
+    """
+    try:
+        device_uniqueness = get_settings_or_config("DEVICE_UNIQUENESS")
+        if device_uniqueness not in DeviceUniquenessChoices.values():
+            return [W007]
+    except AttributeError:
+        return [W007]
+    return []