nautobot 2.2.2__py3-none-any.whl → 2.2.3__py3-none-any.whl

nautobot/dcim/views.py

@@ -1,8 +1,10 @@
 from collections import OrderedDict
+import logging
 import uuid
 
 from django.contrib import messages
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
 from django.core.paginator import EmptyPage, PageNotAnInteger
 from django.db import transaction
 from django.db.models import F, Prefetch
@@ -12,15 +14,19 @@ from django.forms import (
     MultipleHiddenInput,
 )
 from django.shortcuts import get_object_or_404, HttpResponse, redirect, render
+from django.utils.encoding import iri_to_uri
 from django.utils.functional import cached_property
 from django.utils.html import format_html
+from django.utils.http import url_has_allowed_host_and_scheme
 from django.views.generic import View
 from django_tables2 import RequestConfig
 
 from nautobot.circuits.models import Circuit
-from nautobot.core.forms import ConfirmationForm
+from nautobot.core.forms import ConfirmationForm, restrict_form_fields
 from nautobot.core.models.querysets import count_related
+from nautobot.core.templatetags.helpers import has_perms
 from nautobot.core.utils.permissions import get_permission_for_model
+from nautobot.core.utils.requests import normalize_querydict
 from nautobot.core.views import generic
 from nautobot.core.views.mixins import (
     GetReturnURLMixin,
@@ -30,7 +36,10 @@ from nautobot.core.views.mixins import (
 )
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.viewsets import NautobotUIViewSet
+from nautobot.dcim.choices import LocationDataToContactActionChoices
+from nautobot.dcim.forms import LocationMigrateDataToContactForm
 from nautobot.dcim.utils import get_all_network_driver_mappings, get_network_driver_mapping_tool_names
+from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Team
 from nautobot.extras.views import ObjectChangeLogView, ObjectConfigContextView, ObjectDynamicGroupsView
 from nautobot.ipam.models import IPAddress, Prefix, Service, VLAN
 from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable
@@ -83,6 +92,8 @@ from .models import (
     VirtualChassis,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class BulkDisconnectView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     """
@@ -283,6 +294,9 @@ class LocationView(generic.ObjectView):
             "children_table": children_table,
             "rack_groups": rack_groups,
             "stats": stats,
+            "contact_association_permission": ["extras.add_contactassociation"],
+            # show the button if any of these fields have non-empty value.
+            "show_convert_to_contact_button": instance.contact_name or instance.contact_phone or instance.contact_email,
         }
 
 
@@ -314,6 +328,140 @@ class LocationBulkDeleteView(generic.BulkDeleteView):
     table = tables.LocationTable
 
 
+class MigrateLocationDataToContactView(generic.ObjectEditView):
+    queryset = Location.objects.all()
+    model_form = LocationMigrateDataToContactForm
+    template_name = "dcim/location_migrate_data_to_contact.html"
+
+    def get(self, request, *args, **kwargs):
+        obj = self.alter_obj(self.get_object(kwargs), request, args, kwargs)
+
+        initial_data = normalize_querydict(request.GET, form_class=self.model_form)
+        # remove status from the location itself
+        initial_data["status"] = None
+        initial_data["location"] = obj.pk
+
+        # populate contact tab fields initial data
+        initial_data["name"] = obj.contact_name
+        initial_data["phone"] = obj.contact_phone
+        initial_data["email"] = obj.contact_email
+        form = self.model_form(instance=obj, initial=initial_data)
+        restrict_form_fields(form, request.user)
+        return render(
+            request,
+            self.template_name,
+            {
+                "obj": obj,
+                "obj_type": self.queryset.model._meta.verbose_name,
+                "form": form,
+                "return_url": self.get_return_url(request, obj),
+                "editing": obj.present_in_database,
+                "active_tab": "assign",
+                **self.get_extra_context(request, obj),
+            },
+        )
+
+    def post(self, request, *args, **kwargs):
+        obj = self.alter_obj(self.get_object(kwargs), request, args, kwargs)
+        form = self.model_form(data=request.POST, files=request.FILES, instance=obj)
+        restrict_form_fields(form, request.user)
+
+        associated_object_id = obj.pk
+        associated_object_content_type = ContentType.objects.get_for_model(Location)
+        action = request.POST.get("action")
+        try:
+            with transaction.atomic():
+                if not has_perms(request.user, ["extras.add_contactassociation"]):
+                    raise PermissionDenied(
+                        "ObjectPermission extras.add_contactassociation is needed to perform this action"
+                    )
+                contact = None
+                team = None
+                if action == LocationDataToContactActionChoices.CREATE_AND_ASSIGN_NEW_CONTACT:
+                    if not has_perms(request.user, ["extras.add_contact"]):
+                        raise PermissionDenied("ObjectPermission extras.add_contact is needed to perform this action")
+                    contact = Contact(
+                        name=request.POST.get("name"),
+                        phone=request.POST.get("phone"),
+                        email=request.POST.get("email"),
+                    )
+                    contact.validated_save()
+                    # Trigger permission check
+                    Contact.objects.restrict(request.user, "view").get(pk=contact.pk)
+                elif action == LocationDataToContactActionChoices.CREATE_AND_ASSIGN_NEW_TEAM:
+                    if not has_perms(request.user, ["extras.add_team"]):
+                        raise PermissionDenied("ObjectPermission extras.add_team is needed to perform this action")
+                    team = Team(
+                        name=request.POST.get("name"),
+                        phone=request.POST.get("phone"),
+                        email=request.POST.get("email"),
+                    )
+                    team.validated_save()
+                    # Trigger permission check
+                    Team.objects.restrict(request.user, "view").get(pk=team.pk)
+                elif action == LocationDataToContactActionChoices.ASSOCIATE_EXISTING_CONTACT:
+                    contact = Contact.objects.restrict(request.user, "view").get(pk=request.POST.get("contact"))
+                elif action == LocationDataToContactActionChoices.ASSOCIATE_EXISTING_TEAM:
+                    team = Team.objects.restrict(request.user, "view").get(pk=request.POST.get("team"))
+                else:
+                    raise ValueError(f"Invalid action {action} passed from the form")
+
+                association = ContactAssociation(
+                    contact=contact,
+                    team=team,
+                    associated_object_type=associated_object_content_type,
+                    associated_object_id=associated_object_id,
+                    status=Status.objects.get(pk=request.POST.get("status")),
+                    role=Role.objects.get(pk=request.POST.get("role")),
+                )
+                association.validated_save()
+                # Trigger permission check
+                ContactAssociation.objects.restrict(request.user, "view").get(pk=association.pk)
+
+                # Clear out contact fields from location
+                location = self.get_object(kwargs)
+                location.contact_name = ""
+                location.contact_phone = ""
+                location.contact_email = ""
+                location.validated_save()
+
+                object_created = not form.instance.present_in_database
+
+            self.successful_post(request, obj, object_created, logger)
+
+            return_url = request.POST.get("return_url")
+            if url_has_allowed_host_and_scheme(url=return_url, allowed_hosts=request.get_host()):
+                return redirect(iri_to_uri(return_url))
+            else:
+                return redirect(self.get_return_url(request, obj))
+
+        except ObjectDoesNotExist:
+            msg = "Object save failed due to object-level permissions violation"
+            logger.debug(msg)
+            form.add_error(None, msg)
+        except PermissionDenied as e:
+            msg = e
+            logger.debug(msg)
+            form.add_error(None, msg)
+        except ValueError:
+            msg = f"Invalid action {action} passed from the form"
+            logger.debug(msg)
+            form.add_error(None, msg)
+
+        return render(
+            request,
+            self.template_name,
+            {
+                "obj": obj,
+                "obj_type": self.queryset.model._meta.verbose_name,
+                "form": form,
+                "return_url": self.get_return_url(request, obj),
+                "editing": obj.present_in_database,
+                **self.get_extra_context(request, obj),
+            },
+        )
+
+
 #
 # Rack groups
 #

nautobot/extras/api/views.py

@@ -33,6 +33,7 @@ from nautobot.core.models.querysets import count_related
 from nautobot.extras import filters
 from nautobot.extras.choices import JobExecutionType
 from nautobot.extras.filters import RoleFilterSet
+from nautobot.extras.jobs import get_job
 from nautobot.extras.models import (
     ComputedField,
     ConfigContext,
@@ -484,7 +485,7 @@ def _create_schedule(serializer, data, job_model, user, approval_required, task_
     # scheduled for.
     scheduled_job = ScheduledJob(
         name=name,
-        task=job_model.job_class.registered_name,
+        task=job_model.class_path,
         job_model=job_model,
         start_time=time,
         description=f"Nautobot job {name} scheduled by {user} for {time}",
@@ -520,7 +521,7 @@ class JobViewSetBase(
     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 = job_model.job_class
+        job_class = get_job(job_model.class_path, reload=True)
         if job_class is None:
             raise Http404
         variables_dict = job_class._get_vars()
@@ -602,14 +603,15 @@ class JobViewSetBase(
                     "One of these two flags must be removed before this job can be scheduled or run."
                 )
 
-        job_class = job_model.job_class
+        job_class = get_job(job_model.class_path, reload=True)
         if job_class is None:
             raise MethodNotAllowed(
                 request.method, detail="This job's source code could not be located and cannot be run"
             )
 
         valid_queues = job_model.task_queues if job_model.task_queues else [settings.CELERY_TASK_DEFAULT_QUEUE]
-        # Get a default queue from either the job model's specified task queue or system default to fall back on if request doesn't provide one
+        # Get a default queue from either the job model's specified task queue or
+        # the system default to fall back on if request doesn't provide one
         default_valid_queue = valid_queues[0]
 
         # We need to call request.data for both cases as this is what pulls and caches the request data
@@ -621,7 +623,8 @@ class JobViewSetBase(
         # - Job Form data (for submission to the job itself)
         # - Schedule data
         # - Desired task queue
-        # Depending on request content type (largely for backwards compatibility) the keys at which these are found are different
+        # Depending on request content type (largely for backwards compatibility) the keys at which these are found
+        # are different
         if "multipart/form-data" in request.content_type:
             data = request._data.dict()  # .data will return data and files, we just want the data
             files = request.FILES
@@ -639,7 +642,8 @@ class JobViewSetBase(
             for non_job_key in non_job_keys:
                 data.pop(non_job_key, None)
 
-            # List of keys in serializer that are effectively exploded versions of the schedule dictionary from JobInputSerializer
+            # List of keys in serializer that are effectively exploded versions of the schedule dictionary
+            # from JobInputSerializer
             schedule_keys = ("_schedule_name", "_schedule_start_time", "_schedule_interval", "_schedule_crontab")
 
             # Assign the key from the validated_data output to dictionary without prefixed "_schedule_"
@@ -666,7 +670,7 @@ class JobViewSetBase(
         cleaned_data = None
         try:
             cleaned_data = job_class.validate_data(data, files=files)
-            cleaned_data = job_model.job_class.prepare_job_kwargs(cleaned_data)
+            cleaned_data = job_class.prepare_job_kwargs(cleaned_data)
 
         except FormsValidationError as e:
             # message_dict can only be accessed if ValidationError got a dict
@@ -948,7 +952,13 @@ class ScheduledJobViewSet(ReadOnlyModelViewSet):
         responses={"200": serializers.JobResultSerializer},
         request=None,
     )
-    @action(detail=True, url_path="dry-run", methods=["post"], permission_classes=[ScheduledJobViewPermissions])
+    @action(
+        detail=True,
+        name="Dry Run",
+        url_path="dry-run",
+        methods=["post"],
+        permission_classes=[ScheduledJobViewPermissions],
+    )
     def dry_run(self, request, pk):
         scheduled_job = get_object_or_404(ScheduledJob, pk=pk)
         job_model = scheduled_job.job_model
@@ -960,13 +970,14 @@ class ScheduledJobViewSet(ReadOnlyModelViewSet):
             raise PermissionDenied("You do not have permission to run this job.")
 
         # Immediately enqueue the job
-        job_kwargs = job_model.job_class.prepare_job_kwargs(scheduled_job.kwargs.get("data", {}))
+        job_class = get_job(job_model.class_path, reload=True)
+        job_kwargs = job_class.prepare_job_kwargs(scheduled_job.kwargs or {})
         job_kwargs["dryrun"] = True
         job_result = JobResult.enqueue_job(
             job_model,
             request.user,
             celery_kwargs=scheduled_job.celery_kwargs or {},
-            **job_model.job_class.serialize_data(job_kwargs),
+            **job_class.serialize_data(job_kwargs),
         )
         serializer = serializers.JobResultSerializer(job_result, context={"request": request})
 

nautobot/extras/constants.py

@@ -5,16 +5,16 @@ HTTP_CONTENT_TYPE_JSON = "application/json"
 EXTRAS_FEATURES = [
     "cable_terminations",
     "config_context_owners",
-    "custom_fields",
+    "custom_fields",  # Deprecated - see nautobot.extras.utils.populate_model_features_registry
     "custom_links",
     "custom_validators",
     "dynamic_groups",
     "export_template_owners",
     "export_templates",
     "graphql",
-    "job_results",
+    "job_results",  # No longer used
     "locations",
-    "relationships",
+    "relationships",  # Deprecated - see nautobot.extras.utils.populate_model_features_registry
     "statuses",
     "webhooks",
 ]

nautobot/extras/datasources/git.py

@@ -7,7 +7,6 @@ import mimetypes
 import os
 from pathlib import Path
 import re
-import sys
 from urllib.parse import quote
 
 from django.conf import settings
@@ -17,9 +16,9 @@ from django.db import transaction
 from git import InvalidGitRepositoryError, Repo
 import yaml
 
-from nautobot.core.celery import app as celery_app
 from nautobot.core.utils.git import GitRepo
-from nautobot.dcim.models import Device, DeviceType, Location, Platform
+from nautobot.core.utils.module_loading import import_modules_privately
+from nautobot.dcim.models import Device, DeviceRedundancyGroup, DeviceType, Location, Platform
 from nautobot.extras.choices import (
     LogLevelChoices,
     SecretsGroupAccessTypeChoices,
@@ -36,7 +35,7 @@ from nautobot.extras.models import (
     Role,
     Tag,
 )
-from nautobot.extras.registry import DatasourceContent, register_datasource_contents
+from nautobot.extras.registry import DatasourceContent, register_datasource_contents, registry
 from nautobot.extras.utils import refresh_job_model_from_job_class
 from nautobot.tenancy.models import Tenant, TenantGroup
 from nautobot.virtualization.models import Cluster, ClusterGroup, VirtualMachine
@@ -186,7 +185,7 @@ def ensure_git_repository(repository_record, logger=None, head=None):  # pylint:
 def git_repository_dry_run(repository_record, logger):  # pylint: disable=redefined-outer-name
     """Log the difference between local branch and remote branch files.
     Args:
-        repository_record (GitRepository): The GitRepostiory instance to diff.
+        repository_record (GitRepository): The GitRepository instance to diff.
         logger (logging.Logger): Logger to log results to.
     """
     from_url, to_path, from_branch = get_repo_from_url_to_path_and_from_branch(repository_record)
@@ -272,6 +271,7 @@ def update_git_config_contexts(repository_record, job_result):
         "tenants",
         "tags",
         "dynamic_groups",
+        "device_redundancy_groups",
     ):
         if os.path.isdir(os.path.join(repository_record.filesystem_path, filter_type)):
             msg = (
@@ -402,6 +402,7 @@ def import_config_context(context_data, repository_record, job_result):
         ("tenants", Tenant),
         ("tags", Tag),
         ("dynamic_groups", DynamicGroup),
+        ("device_redundancy_groups", DeviceRedundancyGroup),
     ]:
         relations[key] = []
         for object_data in context_metadata.get(key, ()):
@@ -714,56 +715,41 @@ def delete_git_config_context_schemas(repository_record, job_result, preserve=()
 #
 
 
-def refresh_code_from_repository(repository_slug, consumer=None, skip_reimport=False):
+def refresh_job_code_from_repository(repository_slug, skip_reimport=False, ignore_import_errors=True):
     """
-    After cloning/updating a GitRepository on disk, call this function to reload and reregister the repo's Python code.
+    After cloning/updating/deleting a GitRepository on disk, call this function to reload and reregister its Python.
 
     Args:
-        repository_slug (str): Repository directory in GIT_ROOT that was refreshed.
-        consumer (celery.worker.Consumer): Celery Consumer to update as well
+        repository_slug (str): Repository directory in GIT_ROOT that was updated or deleted.
         skip_reimport (bool): If True, unload existing code from this repository but do not re-import it.
+        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.
     """
-    if settings.GIT_ROOT not in sys.path:
-        sys.path.append(settings.GIT_ROOT)
-
-    app = consumer.app if consumer is not None else celery_app
-    # TODO: This is ugly, but when app.use_fast_trace_task is set (true by default), Celery calls
-    # celery.app.trace.fast_trace_task(...) which assumes that all tasks are cached and have a valid `__trace__()`
-    # function defined. In theory consumer.update_strategies() (below) should ensure this, but it doesn't
-    # go far enough (possibly a discrepancy between the main worker process and the prefork executors?)
-    # as we can and do still encounter errors where `task.__trace__` is unexpectedly None.
-    # For now, simply disabling use_fast_trace_task forces the task trace function to be rebuilt each time,
-    # which avoids the issue at the cost of very slight overhead.
-    app.use_fast_trace_task = False
-
     # Unload any previous version of this module and its submodules if present
-    for module_name in list(sys.modules):
-        if module_name == repository_slug or module_name.startswith(f"{repository_slug}."):
-            logger.debug("Unloading module %s", module_name)
-            if module_name in app.loader.task_modules:
-                app.loader.task_modules.remove(module_name)
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-
-    # Unregister any previous Celery tasks from this module
-    for task_name in list(app.tasks):
-        if task_name.startswith(f"{repository_slug}."):
-            logger.debug("Unregistering Celery task %s", task_name)
-            app.tasks.unregister(task_name)
-            if consumer is not None and task_name in consumer.strategies:
-                del consumer.strategies[task_name]
-
-    if not skip_reimport:
-        try:
-            repository = GitRepository.objects.get(slug=repository_slug)
-            if "extras.job" in repository.provided_contents:
-                # Re-import Celery tasks from this module
-                logger.debug("Importing Jobs from %s.jobs in GIT_ROOT", repository_slug)
-                app.loader.import_task_module(f"{repository_slug}.jobs")
-                if consumer is not None:
-                    consumer.update_strategies()
-        except GitRepository.DoesNotExist as exc:
-            logger.error("Unable to reload Jobs from %s.jobs: %s", repository_slug, exc)
+    for job_class_path in list(registry["jobs"]):
+        if job_class_path.startswith(f"{repository_slug}."):
+            del registry["jobs"][job_class_path]
+
+    if skip_reimport:
+        return
+
+    try:
+        repository = GitRepository.objects.get(slug=repository_slug)
+        if "extras.job" in repository.provided_contents:
+            if not (
+                os.path.isdir(os.path.join(repository.filesystem_path, "jobs"))
+                or os.path.isfile(os.path.join(repository.filesystem_path, "jobs.py"))
+            ):
+                logger.error("No `jobs` submodule found in Git repository %s", repository)
+                if not ignore_import_errors:
+                    raise FileNotFoundError(f"No `jobs` submodule found in Git repository {repository}")
+            else:
+                import_modules_privately(
+                    settings.GIT_ROOT, module_path=[repository_slug, "jobs"], ignore_import_errors=ignore_import_errors
+                )
+    except GitRepository.DoesNotExist as exc:
+        logger.error("Unable to reload Jobs from %s.jobs: %s", repository_slug, exc)
+        if not ignore_import_errors:
             raise
 
 
@@ -773,13 +759,13 @@ def refresh_git_jobs(repository_record, job_result, delete=False):
     if "extras.job" in repository_record.provided_contents and not delete:
         found_jobs = False
         try:
-            refresh_code_from_repository(repository_record.slug)
+            refresh_job_code_from_repository(repository_record.slug, ignore_import_errors=False)
 
-            for task_name, task in celery_app.tasks.items():
-                if not task_name.startswith(f"{repository_record.slug}."):
+            for job_class_path, job_class in registry["jobs"].items():
+                if not job_class_path.startswith(f"{repository_record.slug}.jobs."):
                     continue
                 found_jobs = True
-                job_model, created = refresh_job_model_from_job_class(Job, task.__class__)
+                job_model, created = refresh_job_model_from_job_class(Job, job_class)
 
                 if job_model is None:
                     msg = "Failed to create Job record; check Nautobot logs for details"
@@ -788,15 +774,18 @@ def refresh_git_jobs(repository_record, job_result, delete=False):
                     continue
 
                 if created:
-                    message = "Created Job record"
+                    message = f"Created Job record for {job_class_path}"
                 else:
-                    message = "Refreshed Job record"
+                    message = f"Refreshed Job record for {job_class_path}"
                 logger.info(message)
                 job_result.log(message=message, obj=job_model, grouping="jobs", level_choice=LogLevelChoices.LOG_INFO)
                 installed_jobs.append(job_model)
 
             if not found_jobs:
-                msg = "No jobs were registered on loading the `jobs` submodule. Did you miss a `register_jobs()` call?"
+                msg = (
+                    f"No jobs were registered on loading the `{repository_record.slug}.jobs` submodule. "
+                    "Did you miss a `register_jobs()` call? Or was there a syntax error or similar in your code?"
+                )
                 logger.warning(msg)
                 job_result.log(msg, grouping="jobs", level_choice=LogLevelChoices.LOG_WARNING)
         except Exception as exc:
@@ -804,8 +793,8 @@ def refresh_git_jobs(repository_record, job_result, delete=False):
             logger.error(msg)
             job_result.log(msg, grouping="jobs", level_choice=LogLevelChoices.LOG_ERROR)
     else:
-        # Unload code from this repository, do not reimport it
-        refresh_code_from_repository(repository_record.slug, skip_reimport=True)
+        # Flush this repository's job classes
+        refresh_job_code_from_repository(repository_record.slug, skip_reimport=True)
 
     for job_model in Job.objects.filter(module_name__startswith=f"{repository_record.slug}."):
         if job_model.installed and job_model not in installed_jobs:

nautobot/extras/forms/forms.py

@@ -844,8 +844,10 @@ class JobEditForm(NautobotModelForm):
         """
         For all overridable fields, if they aren't marked as overridden, revert them to the underlying value if known.
         """
+        from nautobot.extras.jobs import get_job  # avoid circular import
+
         cleaned_data = super().clean() or self.cleaned_data
-        job_class = self.instance.job_class
+        job_class = get_job(self.instance.class_path, reload=True)
         if job_class is not None:
             for field_name in JOB_OVERRIDABLE_FIELDS:
                 if not cleaned_data.get(f"{field_name}_override", False):