nautobot 2.4.0__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/extras/views.py

@@ -1,6 +1,8 @@
 import logging
 from urllib.parse import parse_qs
 
+from celery import chain
+from django.conf import settings
 from django.contrib import messages
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
@@ -66,7 +68,10 @@ from nautobot.dcim.tables import (
     RackTable,
     VirtualDeviceContextTable,
 )
+from nautobot.extras.constants import JOB_OVERRIDABLE_FIELDS
 from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
+from nautobot.extras.signals import change_context_state
+from nautobot.extras.tasks import delete_custom_field_data
 from nautobot.extras.utils import get_base_template, get_job_queue, get_worker_count
 from nautobot.ipam.models import IPAddress, Prefix, VLAN
 from nautobot.ipam.tables import IPAddressTable, PrefixTable, VLANTable
@@ -654,7 +659,37 @@ class CustomFieldBulkDeleteView(generic.BulkDeleteView):
     queryset = CustomField.objects.all()
     table = tables.CustomFieldTable
     filterset = filters.CustomFieldFilterSet
-    form = forms.CustomFieldBulkDeleteForm
+
+    def construct_custom_field_delete_tasks(self, queryset):
+        """
+        Helper method to construct a list of celery tasks to execute when bulk deleting custom fields.
+        """
+        change_context = change_context_state.get()
+        if change_context is None:
+            context = None
+        else:
+            context = change_context.as_dict(queryset)
+            context["context_detail"] = "bulk delete custom field data"
+        tasks = [
+            delete_custom_field_data.si(obj.key, set(obj.content_types.values_list("pk", flat=True)), context)
+            for obj in queryset
+        ]
+        return tasks
+
+    def perform_pre_delete(self, request, queryset):
+        """
+        Remove all Custom Field Keys/Values from _custom_field_data of the related ContentType in the background.
+        """
+        if not get_worker_count():
+            messages.error(
+                request, "Celery worker process not running. Object custom fields may fail to reflect this deletion."
+            )
+            return
+        tasks = self.construct_custom_field_delete_tasks(queryset)
+        # Executing the tasks in the background sequentially using chain() aligns with how a single
+        # CustomField object is deleted.  We decided to not check the result because it needs at least one worker
+        # to be active and comes with extra performance penalty.
+        chain(*tasks).apply_async()
 
 
 #
@@ -1062,10 +1097,10 @@ class GitRepositoryEditView(generic.ObjectEditView):
         obj.user = request.user
         return super().alter_obj(obj, request, url_args, url_kwargs)
 
-    def get_return_url(self, request, obj=None, default_return_url=None):
+    def get_return_url(self, request, obj):
         if request.method == "POST":
             return reverse("extras:gitrepository_result", kwargs={"pk": obj.pk})
-        return super().get_return_url(request, obj=obj, default_return_url=default_return_url)
+        return super().get_return_url(request, obj)
 
 
 class GitRepositoryDeleteView(generic.ObjectDeleteView):
@@ -1213,27 +1248,27 @@ class ImageAttachmentEditView(generic.ObjectEditView):
             return get_object_or_404(self.queryset, pk=kwargs["pk"])
         return self.queryset.model()
 
-    def alter_obj(self, obj, request, url_args, url_kwargs):
-        if not obj.present_in_database:
+    def alter_obj(self, imageattachment, request, args, kwargs):
+        if not imageattachment.present_in_database:
             # Assign the parent object based on URL kwargs
-            model = url_kwargs.get("model")
-            if "object_id" in url_kwargs:
-                obj.parent = get_object_or_404(model, pk=url_kwargs["object_id"])
-            elif "slug" in url_kwargs:
-                obj.parent = get_object_or_404(model, slug=url_kwargs["slug"])
+            model = kwargs.get("model")
+            if "object_id" in kwargs:
+                imageattachment.parent = get_object_or_404(model, pk=kwargs["object_id"])
+            elif "slug" in kwargs:
+                imageattachment.parent = get_object_or_404(model, slug=kwargs["slug"])
             else:
                 raise RuntimeError("Neither object_id nor slug were provided?")
-        return obj
+        return imageattachment
 
-    def get_return_url(self, request, obj=None, default_return_url=None):
-        return obj.parent.get_absolute_url()
+    def get_return_url(self, request, imageattachment):
+        return imageattachment.parent.get_absolute_url()
 
 
 class ImageAttachmentDeleteView(generic.ObjectDeleteView):
     queryset = ImageAttachment.objects.all()
 
-    def get_return_url(self, request, obj=None, default_return_url=None):
-        return obj.parent.get_absolute_url()
+    def get_return_url(self, request, imageattachment):
+        return imageattachment.parent.get_absolute_url()
 
 
 #
@@ -1330,9 +1365,6 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
                             pass
                     initial["_job_queue"] = jq
                     initial["_profile"] = job_result.celery_kwargs.get("nautobot_job_profile", False)
-                    initial["_ignore_singleton_lock"] = job_result.celery_kwargs.get(
-                        "nautobot_job_ignore_singleton_lock", False
-                    )
                     initial.update(explicit_initial)
                 except JobResult.DoesNotExist:
                     messages.warning(
@@ -1347,9 +1379,7 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
                     get_template(job_class.template_name)
                     template_name = job_class.template_name
                 except TemplateDoesNotExist as err:
-                    messages.error(
-                        request, f'Unable to render requested custom job template "{job_class.template_name}": {err}'
-                    )
+                    messages.error(request, f'Unable to render requested custom job template "{template_name}": {err}')
         except RuntimeError as err:
             messages.error(request, f"Unable to run or schedule '{job_model}': {err}")
             return redirect("extras:job_list")
@@ -1417,7 +1447,6 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
             dryrun = job_form.cleaned_data.get("dryrun", False)
             # Run the job. A new JobResult is created.
             profile = job_form.cleaned_data.pop("_profile")
-            ignore_singleton_lock = job_form.cleaned_data.pop("_ignore_singleton_lock", False)
             schedule_type = schedule_form.cleaned_data["_schedule_type"]
 
             if (not dryrun and job_model.approval_required) or schedule_type in JobExecutionType.SCHEDULE_CHOICES:
@@ -1431,7 +1460,6 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
                     approval_required=job_model.approval_required,
                     task_queue=jq.name if jq else None,
                     profile=profile,
-                    ignore_singleton_lock=ignore_singleton_lock,
                     **job_class.serialize_data(job_form.cleaned_data),
                 )
 
@@ -1449,7 +1477,6 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
                     job_model,
                     request.user,
                     profile=profile,
-                    ignore_singleton_lock=ignore_singleton_lock,
                     task_queue=jq.name if jq else None,
                     **job_class.serialize_data(job_kwargs),
                 )
@@ -1475,9 +1502,7 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
                 get_template(job_class.template_name)
                 template_name = job_class.template_name
             except TemplateDoesNotExist as err:
-                messages.error(
-                    request, f'Unable to render requested custom job template "{job_class.template_name}": {err}'
-                )
+                messages.error(request, f'Unable to render requested custom job template "{template_name}": {err}')
 
         return render(
             request,
@@ -1508,6 +1533,52 @@ class JobBulkEditView(generic.BulkEditView):
     form = forms.JobBulkEditForm
     template_name = "extras/job_bulk_edit.html"
 
+    def extra_post_save_action(self, obj, form):
+        cleaned_data = form.cleaned_data
+
+        # Handle text related fields
+        for overridable_field in JOB_OVERRIDABLE_FIELDS:
+            override_field = overridable_field + "_override"
+            clear_override_field = "clear_" + overridable_field + "_override"
+            reset_override = cleaned_data.get(clear_override_field, False)
+            override_value = cleaned_data.get(overridable_field)
+            if reset_override:
+                setattr(obj, override_field, False)
+            elif not reset_override and override_value not in [None, ""]:
+                setattr(obj, override_field, True)
+                setattr(obj, overridable_field, override_value)
+
+        # Handle job queues
+        clear_override_field = "clear_job_queues_override"
+        reset_override = cleaned_data.get(clear_override_field, False)
+        if reset_override:
+            meta_task_queues = obj.job_class.task_queues
+            job_queues = []
+            for queue_name in meta_task_queues:
+                try:
+                    job_queues.append(JobQueue.objects.get(name=queue_name))
+                except JobQueue.DoesNotExist:
+                    # Do we want to create the Job Queue for the users here if we do not have it in the database?
+                    pass
+            obj.job_queues_override = False
+            obj.job_queues.set(job_queues)
+        elif cleaned_data["job_queues"]:
+            obj.job_queues_override = True
+
+        # Handle default job queue
+        clear_override_field = "clear_default_job_queue_override"
+        reset_override = cleaned_data.get(clear_override_field, False)
+        if reset_override:
+            meta_task_queues = obj.job_class.task_queues
+            obj.default_job_queue_override = False
+            obj.default_job_queue, _ = JobQueue.objects.get_or_create(
+                name=meta_task_queues[0] if meta_task_queues else settings.CELERY_TASK_DEFAULT_QUEUE
+            )
+        elif cleaned_data["default_job_queue"]:
+            obj.default_job_queue_override = True
+
+        obj.validated_save()
+
 
 class JobDeleteView(generic.ObjectDeleteView):
     queryset = JobModel.objects.all()
@@ -2027,9 +2098,6 @@ def get_annotated_jobresult_queryset():
             debug_log_count=count_related(
                 JobLogEntry, "job_result", filter_dict={"log_level": LogLevelChoices.LOG_DEBUG}
             ),
-            success_log_count=count_related(
-                JobLogEntry, "job_result", filter_dict={"log_level": LogLevelChoices.LOG_SUCCESS}
-            ),
             info_log_count=count_related(
                 JobLogEntry, "job_result", filter_dict={"log_level": LogLevelChoices.LOG_INFO}
             ),

nautobot/ipam/api/fields.py

@@ -7,11 +7,11 @@ class IPFieldSerializer(serializers.CharField):
         """Convert internal (IPNetwork) representation to API (string) representation."""
         return str(value)
 
-    def to_internal_value(self, data):
+    def to_internal_value(self, value):
         """Convert API (string) representation to internal (IPNetwork) representation."""
         try:
-            return netaddr.IPNetwork(data)
+            return netaddr.IPNetwork(value)
         except netaddr.AddrFormatError:
-            raise serializers.ValidationError(f"Invalid IP address format: {data}")
+            raise serializers.ValidationError(f"Invalid IP address format: {value}")
         except (TypeError, ValueError) as e:
             raise serializers.ValidationError(e)

nautobot/ipam/api/serializers.py

@@ -62,16 +62,16 @@ class VRFDeviceAssignmentSerializer(ValidatedModelSerializer):
         fields = "__all__"
         validators = []
 
-    def validate(self, attrs):
-        if attrs.get("device"):
+    def validate(self, data):
+        if data.get("device"):
             validator = UniqueTogetherValidator(queryset=VRFDeviceAssignment.objects.all(), fields=("device", "vrf"))
-            validator(attrs, self)
-        if attrs.get("virtual_machine"):
+            validator(data, self)
+        if data.get("virtual_machine"):
             validator = UniqueTogetherValidator(
                 queryset=VRFDeviceAssignment.objects.all(), fields=("virtual_machine", "vrf")
             )
-            validator(attrs, self)
-        return super().validate(attrs)
+            validator(data, self)
+        return super().validate(data)
 
 
 class VRFPrefixAssignmentSerializer(ValidatedModelSerializer):
@@ -133,17 +133,17 @@ class VLANSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
         validators = []
         extra_kwargs = {"locations": {"read_only": True}}
 
-    def validate(self, attrs):
+    def validate(self, data):
         # Validate uniqueness of vid and name if a group has been assigned.
-        if attrs.get("vlan_group", None):
+        if data.get("vlan_group", None):
             for field in ["vid", "name"]:
                 validator = UniqueTogetherValidator(queryset=VLAN.objects.all(), fields=("vlan_group", field))
-                validator(attrs, self)
+                validator(data, self)
 
         # Enforce model validation
-        super().validate(attrs)
+        super().validate(data)
 
-        return attrs
+        return data
 
 
 class VLANLegacySerializer(VLANSerializer):
@@ -205,12 +205,6 @@ class PrefixSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
         write_only=True,
     )
 
-    def get_field_names(self, declared_fields, info):
-        """Add reverse M2M for VRF's to the fields for this serializer."""
-        field_names = list(super().get_field_names(declared_fields, info))
-        self.extend_field_names(field_names, "vrfs")
-        return field_names
-
     class Meta:
         model = Prefix
         fields = "__all__"
@@ -219,7 +213,6 @@ class PrefixSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
             "namespace": {"default": get_default_namespace},
             "prefix_length": {"read_only": True},
             "locations": {"read_only": True},
-            "vrfs": {"read_only": True},
         }
 
 
@@ -327,16 +320,16 @@ class IPAddressSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
             "parent": {"required": False},
         }
 
-    def validate(self, attrs):
-        namespace = attrs.get("namespace", None)
-        parent = attrs.get("parent", None)
+    def validate(self, data):
+        namespace = data.get("namespace", None)
+        parent = data.get("parent", None)
 
         # Only assert namespace/parent on create.
         if self.instance is None and not any([namespace, parent]):
             raise ValidationError({"__all__": "One of parent or namespace must be provided"})
 
-        super().validate(attrs)
-        return attrs
+        super().validate(data)
+        return data
 
     def get_field_names(self, declared_fields, info):
         """Add reverse relations to the automatically discovered fields."""
@@ -386,9 +379,9 @@ class IPAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin
             "custom_fields",
         )
 
-    def validate(self, attrs):
-        attrs["mask_length"] = self.context["prefix"].prefix_length
-        return super().validate(attrs)
+    def validate(self, data):
+        data["mask_length"] = self.context["prefix"].prefix_length
+        return super().validate(data)
 
 
 class VLANAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
@@ -398,13 +391,12 @@ class VLANAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMix
 
     vid = serializers.IntegerField(required=False, min_value=constants.VLAN_VID_MIN, max_value=constants.VLAN_VID_MAX)
 
-    def validate(self, attrs):
+    def validate(self, data):
         """
         Skip `ValidatedModel` validation.
-
         This allows to skip `vid` attribute of `VLAN` model, while validate name and status.
         """
-        return attrs
+        return data
 
     class Meta(VLANSerializer.Meta):
         model = VLAN
@@ -433,19 +425,19 @@ class IPAddressToInterfaceSerializer(ValidatedModelSerializer):
         fields = "__all__"
         validators = []
 
-    def validate(self, attrs):
+    def validate(self, data):
         # Validate uniqueness of (parent, name) since we omitted the automatically created validator from Meta.
-        if attrs.get("interface"):
+        if data.get("interface"):
             validator = UniqueTogetherValidator(
                 queryset=IPAddressToInterface.objects.all(), fields=("interface", "ip_address")
             )
-            validator(attrs, self)
-        if attrs.get("vm_interface"):
+            validator(data, self)
+        if data.get("vm_interface"):
             validator = UniqueTogetherValidator(
                 queryset=IPAddressToInterface.objects.all(), fields=("vm_interface", "ip_address")
             )
-            validator(attrs, self)
-        return super().validate(attrs)
+            validator(data, self)
+        return super().validate(data)
 
 
 #
@@ -472,11 +464,11 @@ class ServiceSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
             "virtual_machine": {"help_text": "Required if no device is specified"},
         }
 
-    def validate(self, attrs):
-        if attrs.get("device"):
+    def validate(self, data):
+        if data.get("device"):
             validator = UniqueTogetherValidator(queryset=Service.objects.all(), fields=("name", "device"))
-            validator(attrs, self)
-        if attrs.get("virtual_machine"):
+            validator(data, self)
+        if data.get("virtual_machine"):
             validator = UniqueTogetherValidator(queryset=Service.objects.all(), fields=("name", "virtual_machine"))
-            validator(attrs, self)
-        return super().validate(attrs)
+            validator(data, self)
+        return super().validate(data)