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

nautobot/extras/views.py

@@ -1,8 +1,6 @@
 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
@@ -68,10 +66,7 @@ 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
@@ -659,37 +654,7 @@ class CustomFieldBulkDeleteView(generic.BulkDeleteView):
     queryset = CustomField.objects.all()
     table = tables.CustomFieldTable
     filterset = filters.CustomFieldFilterSet
-
-    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()
+    form = forms.CustomFieldBulkDeleteForm
 
 
 #
@@ -1097,10 +1062,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):
+    def get_return_url(self, request, obj=None, default_return_url=None):
         if request.method == "POST":
             return reverse("extras:gitrepository_result", kwargs={"pk": obj.pk})
-        return super().get_return_url(request, obj)
+        return super().get_return_url(request, obj=obj, default_return_url=default_return_url)
 
 
 class GitRepositoryDeleteView(generic.ObjectDeleteView):
@@ -1248,27 +1213,27 @@ class ImageAttachmentEditView(generic.ObjectEditView):
             return get_object_or_404(self.queryset, pk=kwargs["pk"])
         return self.queryset.model()
 
-    def alter_obj(self, imageattachment, request, args, kwargs):
-        if not imageattachment.present_in_database:
+    def alter_obj(self, obj, request, url_args, url_kwargs):
+        if not obj.present_in_database:
             # Assign the parent object based on URL kwargs
-            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"])
+            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"])
             else:
                 raise RuntimeError("Neither object_id nor slug were provided?")
-        return imageattachment
+        return obj
 
-    def get_return_url(self, request, imageattachment):
-        return imageattachment.parent.get_absolute_url()
+    def get_return_url(self, request, obj=None, default_return_url=None):
+        return obj.parent.get_absolute_url()
 
 
 class ImageAttachmentDeleteView(generic.ObjectDeleteView):
     queryset = ImageAttachment.objects.all()
 
-    def get_return_url(self, request, imageattachment):
-        return imageattachment.parent.get_absolute_url()
+    def get_return_url(self, request, obj=None, default_return_url=None):
+        return obj.parent.get_absolute_url()
 
 
 #
@@ -1365,6 +1330,9 @@ 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(
@@ -1379,7 +1347,9 @@ 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 "{template_name}": {err}')
+                    messages.error(
+                        request, f'Unable to render requested custom job template "{job_class.template_name}": {err}'
+                    )
         except RuntimeError as err:
             messages.error(request, f"Unable to run or schedule '{job_model}': {err}")
             return redirect("extras:job_list")
@@ -1447,6 +1417,7 @@ 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:
@@ -1460,6 +1431,7 @@ 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),
                 )
 
@@ -1477,6 +1449,7 @@ 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),
                 )
@@ -1502,7 +1475,9 @@ 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 "{template_name}": {err}')
+                messages.error(
+                    request, f'Unable to render requested custom job template "{job_class.template_name}": {err}'
+                )
 
         return render(
             request,
@@ -1533,52 +1508,6 @@ 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()
@@ -2098,6 +2027,9 @@ 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, value):
+    def to_internal_value(self, data):
         """Convert API (string) representation to internal (IPNetwork) representation."""
         try:
-            return netaddr.IPNetwork(value)
+            return netaddr.IPNetwork(data)
         except netaddr.AddrFormatError:
-            raise serializers.ValidationError(f"Invalid IP address format: {value}")
+            raise serializers.ValidationError(f"Invalid IP address format: {data}")
         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, data):
-        if data.get("device"):
+    def validate(self, attrs):
+        if attrs.get("device"):
             validator = UniqueTogetherValidator(queryset=VRFDeviceAssignment.objects.all(), fields=("device", "vrf"))
-            validator(data, self)
-        if data.get("virtual_machine"):
+            validator(attrs, self)
+        if attrs.get("virtual_machine"):
             validator = UniqueTogetherValidator(
                 queryset=VRFDeviceAssignment.objects.all(), fields=("virtual_machine", "vrf")
             )
-            validator(data, self)
-        return super().validate(data)
+            validator(attrs, self)
+        return super().validate(attrs)
 
 
 class VRFPrefixAssignmentSerializer(ValidatedModelSerializer):
@@ -133,17 +133,17 @@ class VLANSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
         validators = []
         extra_kwargs = {"locations": {"read_only": True}}
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate uniqueness of vid and name if a group has been assigned.
-        if data.get("vlan_group", None):
+        if attrs.get("vlan_group", None):
             for field in ["vid", "name"]:
                 validator = UniqueTogetherValidator(queryset=VLAN.objects.all(), fields=("vlan_group", field))
-                validator(data, self)
+                validator(attrs, self)
 
         # Enforce model validation
-        super().validate(data)
+        super().validate(attrs)
 
-        return data
+        return attrs
 
 
 class VLANLegacySerializer(VLANSerializer):
@@ -205,6 +205,12 @@ 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__"
@@ -213,6 +219,7 @@ class PrefixSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
             "namespace": {"default": get_default_namespace},
             "prefix_length": {"read_only": True},
             "locations": {"read_only": True},
+            "vrfs": {"read_only": True},
         }
 
 
@@ -320,16 +327,16 @@ class IPAddressSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
             "parent": {"required": False},
         }
 
-    def validate(self, data):
-        namespace = data.get("namespace", None)
-        parent = data.get("parent", None)
+    def validate(self, attrs):
+        namespace = attrs.get("namespace", None)
+        parent = attrs.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(data)
-        return data
+        super().validate(attrs)
+        return attrs
 
     def get_field_names(self, declared_fields, info):
         """Add reverse relations to the automatically discovered fields."""
@@ -379,9 +386,9 @@ class IPAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin
             "custom_fields",
         )
 
-    def validate(self, data):
-        data["mask_length"] = self.context["prefix"].prefix_length
-        return super().validate(data)
+    def validate(self, attrs):
+        attrs["mask_length"] = self.context["prefix"].prefix_length
+        return super().validate(attrs)
 
 
 class VLANAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
@@ -391,12 +398,13 @@ class VLANAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMix
 
     vid = serializers.IntegerField(required=False, min_value=constants.VLAN_VID_MIN, max_value=constants.VLAN_VID_MAX)
 
-    def validate(self, data):
+    def validate(self, attrs):
         """
         Skip `ValidatedModel` validation.
+
         This allows to skip `vid` attribute of `VLAN` model, while validate name and status.
         """
-        return data
+        return attrs
 
     class Meta(VLANSerializer.Meta):
         model = VLAN
@@ -425,19 +433,19 @@ class IPAddressToInterfaceSerializer(ValidatedModelSerializer):
         fields = "__all__"
         validators = []
 
-    def validate(self, data):
+    def validate(self, attrs):
         # Validate uniqueness of (parent, name) since we omitted the automatically created validator from Meta.
-        if data.get("interface"):
+        if attrs.get("interface"):
             validator = UniqueTogetherValidator(
                 queryset=IPAddressToInterface.objects.all(), fields=("interface", "ip_address")
             )
-            validator(data, self)
-        if data.get("vm_interface"):
+            validator(attrs, self)
+        if attrs.get("vm_interface"):
             validator = UniqueTogetherValidator(
                 queryset=IPAddressToInterface.objects.all(), fields=("vm_interface", "ip_address")
             )
-            validator(data, self)
-        return super().validate(data)
+            validator(attrs, self)
+        return super().validate(attrs)
 
 
 #
@@ -464,11 +472,11 @@ class ServiceSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
             "virtual_machine": {"help_text": "Required if no device is specified"},
         }
 
-    def validate(self, data):
-        if data.get("device"):
+    def validate(self, attrs):
+        if attrs.get("device"):
             validator = UniqueTogetherValidator(queryset=Service.objects.all(), fields=("name", "device"))
-            validator(data, self)
-        if data.get("virtual_machine"):
+            validator(attrs, self)
+        if attrs.get("virtual_machine"):
             validator = UniqueTogetherValidator(queryset=Service.objects.all(), fields=("name", "virtual_machine"))
-            validator(data, self)
-        return super().validate(data)
+            validator(attrs, self)
+        return super().validate(attrs)