nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/views.py

@@ -1,4 +1,3 @@
-import inspect
 from datetime import timedelta
 import logging
 
@@ -26,16 +25,16 @@ from nautobot.core.models.querysets import count_related
 from nautobot.core.models.utils import pretty_print_query
 from nautobot.core.tables import ButtonsColumn
 from nautobot.core.utils.lookup import get_table_for_model
-from nautobot.core.utils.requests import copy_safe_request, normalize_querydict
+from nautobot.core.utils.requests import normalize_querydict
 from nautobot.core.views import generic, viewsets
 from nautobot.core.views.viewsets import NautobotUIViewSet
 from nautobot.core.views.mixins import ObjectPermissionRequiredMixin
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
-from nautobot.core.views.utils import csv_format, prepare_cloned_fields
+from nautobot.core.views.utils import prepare_cloned_fields
 from nautobot.dcim.models import Device
 from nautobot.dcim.tables import DeviceTable
 from nautobot.extras.tasks import delete_custom_field_data
-from nautobot.extras.utils import get_base_template, get_job_content_type, get_worker_count
+from nautobot.extras.utils import get_base_template, get_worker_count
 from nautobot.ipam.tables import IPAddressTable, PrefixTable, VLANTable
 from nautobot.virtualization.models import VirtualMachine
 from nautobot.virtualization.tables import VirtualMachineTable
@@ -49,9 +48,8 @@ from .datasources import (
     get_datasource_contents,
 )
 from .filters import RoleFilterSet
-from .forms import RoleBulkEditForm, RoleCSVForm, RoleForm
-from .jobs import Job as JobClass
-from .jobs import get_job, run_job
+from .forms import RoleBulkEditForm, RoleForm
+from .jobs import get_job
 from .models import (
     ComputedField,
     ConfigContext,
@@ -65,7 +63,6 @@ from .models import (
     ImageAttachment,
     JobButton,
     JobHook,
-    JobLogEntry,
     JobResult,
     Note,
     ObjectChange,
@@ -796,12 +793,12 @@ class GitRepositoryListView(generic.ObjectListView):
     template_name = "extras/gitrepository_list.html"
 
     def extra_context(self):
-        git_repository_content_type = ContentType.objects.get(app_label="extras", model="gitrepository")
         # Get the newest results for each repository name
         results = {
-            r.name: r
+            r.task_kwargs["repository"]: r
             for r in JobResult.objects.filter(
-                obj_type=git_repository_content_type,
+                task_name__startswith="nautobot.core.jobs.GitRepository",
+                task_kwargs__repository__isnull=False,
                 status__in=JobResultStatusChoices.READY_STATES,
             )
             .order_by("date_done")
@@ -827,14 +824,17 @@ class GitRepositoryEditView(generic.ObjectEditView):
     model_form = forms.GitRepositoryForm
     template_name = "extras/gitrepository_object_edit.html"
 
+    # TODO(jathan): Align with changes for v2 where we're not stashing the user on the instance for
+    # magical calls and instead discretely calling `repo.sync(user=user, dry_run=dry_run)`, but
+    # again, this will be moved to the API calls, so just something to keep in mind.
     def alter_obj(self, obj, request, url_args, url_kwargs):
         # A GitRepository needs to know the originating request when it's saved so that it can enqueue using it
-        obj.request = request
+        obj.user = request.user
         return super().alter_obj(obj, request, url_args, url_kwargs)
 
     def get_return_url(self, request, obj):
         if request.method == "POST":
-            return reverse("extras:gitrepository_result", kwargs={"slug": obj.slug})
+            return reverse("extras:gitrepository_result", kwargs={"pk": obj.pk})
         return super().get_return_url(request, obj)
 
 
@@ -844,17 +844,8 @@ class GitRepositoryDeleteView(generic.ObjectDeleteView):
 
 class GitRepositoryBulkImportView(generic.BulkImportView):
     queryset = GitRepository.objects.all()
-    model_form = forms.GitRepositoryCSVForm
     table = tables.GitRepositoryBulkTable
 
-    def _save_obj(self, obj_form, request):
-        """Each GitRepository needs to know the originating request when it's saved so that it can enqueue using it."""
-        instance = obj_form.save(commit=False)
-        instance.request = request
-        instance.save()
-
-        return instance
-
 
 class GitRepositoryBulkEditView(generic.BulkEditView):
     queryset = GitRepository.objects.select_related("secrets_group")
@@ -883,11 +874,11 @@ class GitRepositoryBulkDeleteView(generic.BulkDeleteView):
         }
 
 
-def check_and_call_git_repository_function(request, slug, func):
+def check_and_call_git_repository_function(request, pk, func):
     """Helper for checking Git permissions and worker availability, then calling provided function if all is well
     Args:
         request: request object.
-        slug (str): GitRepository slug value.
+        pk (UUID): GitRepository pk value.
         func (function): Enqueue git repo function.
     Returns:
         HttpResponseForbidden or a redirect
@@ -899,20 +890,20 @@ def check_and_call_git_repository_function(request, slug, func):
     if not get_worker_count():
         messages.error(request, "Unable to run job: Celery worker process not running.")
     else:
-        repository = get_object_or_404(GitRepository, slug=slug)
-        func(repository, request)
+        repository = get_object_or_404(GitRepository, pk=pk)
+        job_result = func(repository, request.user)
 
-    return redirect("extras:gitrepository_result", slug=slug)
+    return redirect(job_result.get_absolute_url())
 
 
 class GitRepositorySyncView(View):
-    def post(self, request, slug):
-        return check_and_call_git_repository_function(request, slug, enqueue_pull_git_repository_and_refresh_data)
+    def post(self, request, pk):
+        return check_and_call_git_repository_function(request, pk, enqueue_pull_git_repository_and_refresh_data)
 
 
 class GitRepositoryDryRunView(View):
-    def post(self, request, slug):
-        return check_and_call_git_repository_function(request, slug, enqueue_git_repository_diff_origin_and_local)
+    def post(self, request, pk):
+        return check_and_call_git_repository_function(request, pk, enqueue_git_repository_diff_origin_and_local)
 
 
 class GitRepositoryResultView(generic.ObjectView):
@@ -927,12 +918,7 @@ class GitRepositoryResultView(generic.ObjectView):
         return "extras.view_gitrepository"
 
     def get_extra_context(self, request, instance):
-        git_repository_content_type = ContentType.objects.get(app_label="extras", model="gitrepository")
-        job_result = (
-            JobResult.objects.filter(obj_type=git_repository_content_type, name=instance.name)
-            .order_by("-date_created")
-            .first()
-        )
+        job_result = instance.get_latest_sync()
 
         return {
             "result": job_result,
@@ -1065,7 +1051,7 @@ class JobView(ObjectPermissionRequiredMixin, View):
     def get_required_permission(self):
         return "extras.run_job"
 
-    def _get_job_model_or_404(self, class_path=None, slug=None):
+    def _get_job_model_or_404(self, class_path=None, pk=None):
         """Helper function for get() and post()."""
         if class_path:
             try:
@@ -1073,30 +1059,32 @@ class JobView(ObjectPermissionRequiredMixin, View):
             except JobModel.DoesNotExist:
                 raise Http404
         else:
-            job_model = get_object_or_404(self.queryset, slug=slug)
+            job_model = get_object_or_404(self.queryset, pk=pk)
 
         return job_model
 
-    def get(self, request, class_path=None, slug=None):
-        job_model = self._get_job_model_or_404(class_path, slug)
+    def get(self, request, class_path=None, pk=None):
+        job_model = self._get_job_model_or_404(class_path, pk)
 
         try:
-            job_class = job_model.job_class()
-            initial = normalize_querydict(request.GET, form_class=job_class.as_form_class())
+            try:
+                job_instance = job_model.job_class()
+            except TypeError as exc:
+                # job_class may be None
+                raise RuntimeError("Job code for this job is not currently installed or loadable") from exc
+            initial = normalize_querydict(request.GET, form_class=job_instance.as_form_class())
             if "kwargs_from_job_result" in initial:
                 job_result_pk = initial.pop("kwargs_from_job_result")
                 try:
-                    job_result = job_model.results.get(pk=job_result_pk)
-                    # Allow explicitly specified arg values in request.GET to take precedence over the saved job_kwargs,
-                    # for example "?kwargs_from_job_result=<UUID>&integervar=22&_commit=False"
+                    job_result = job_model.job_results.get(pk=job_result_pk)
+                    # Allow explicitly specified arg values in request.GET to take precedence over the saved task_kwargs,
+                    # for example "?kwargs_from_job_result=<UUID>&integervar=22"
                     explicit_initial = initial
-                    initial = job_result.job_kwargs.get("data", {}).copy()
-                    commit = job_result.job_kwargs.get("commit")
-                    if commit is not None:
-                        initial.setdefault("_commit", commit)
-                    task_queue = job_result.job_kwargs.get("task_queue")
+                    initial = job_result.task_kwargs.copy()
+                    task_queue = job_result.celery_kwargs.get("queue", None)
                     if task_queue is not None:
-                        initial.setdefault("_task_queue", task_queue)
+                        initial["_task_queue"] = task_queue
+                    initial["_profile"] = job_result.celery_kwargs.get("nautobot_job_profile", False)
                     initial.update(explicit_initial)
                 except JobResult.DoesNotExist:
                     messages.warning(
@@ -1105,11 +1093,11 @@ class JobView(ObjectPermissionRequiredMixin, View):
                     )
 
             template_name = "extras/job.html"
-            job_form = job_class.as_form(initial=initial)
-            if hasattr(job_class, "template_name"):
+            job_form = job_instance.as_form(initial=initial)
+            if hasattr(job_instance, "template_name"):
                 try:
-                    get_template(job_class.template_name)
-                    template_name = job_class.template_name
+                    get_template(job_instance.template_name)
+                    template_name = job_instance.template_name
                 except TemplateDoesNotExist as err:
                     messages.error(request, f'Unable to render requested custom job template "{template_name}": {err}')
         except RuntimeError as err:
@@ -1128,8 +1116,8 @@ class JobView(ObjectPermissionRequiredMixin, View):
             },
         )
 
-    def post(self, request, class_path=None, slug=None):
-        job_model = self._get_job_model_or_404(class_path, slug)
+    def post(self, request, class_path=None, pk=None):
+        job_model = self._get_job_model_or_404(class_path, pk)
 
         job_form = (
             job_model.job_class().as_form(request.POST, request.FILES) if job_model.job_class is not None else None
@@ -1154,11 +1142,13 @@ class JobView(ObjectPermissionRequiredMixin, View):
                 "One of these two flags must be removed before this job can be scheduled or run.",
             )
         elif job_form is not None and job_form.is_valid() and schedule_form.is_valid():
+            task_queue = job_form.cleaned_data.pop("_task_queue", None)
+            dryrun = job_form.cleaned_data.get("dryrun", False)
             # Run the job. A new JobResult is created.
-            commit = job_form.cleaned_data.pop("_commit")
+            profile = job_form.cleaned_data.pop("_profile")
             schedule_type = schedule_form.cleaned_data["_schedule_type"]
 
-            if job_model.approval_required or schedule_type in JobExecutionType.SCHEDULE_CHOICES:
+            if (not dryrun and job_model.approval_required) or schedule_type in JobExecutionType.SCHEDULE_CHOICES:
                 crontab = ""
 
                 if schedule_type == JobExecutionType.TYPE_IMMEDIATELY:
@@ -1184,25 +1174,16 @@ class JobView(ObjectPermissionRequiredMixin, View):
                     else:
                         schedule_datetime = schedule_form.cleaned_data["_schedule_start_time"]
 
-                task_kwargs = {
-                    "data": job_model.job_class.serialize_data(job_form.cleaned_data),
-                    "request": copy_safe_request(request),
-                    "user": request.user.pk,
-                    "commit": commit,
-                    "name": job_model.class_path,
-                    "task_queue": job_form.cleaned_data.get("_task_queue", None),
-                }
-                if task_queue:
-                    task_kwargs["celery_kwargs"] = {"queue": task_queue}
-
+                celery_kwargs = {"nautobot_job_profile": profile, "queue": task_queue}
                 scheduled_job = ScheduledJob(
                     name=schedule_name,
-                    task="nautobot.extras.jobs.scheduled_job_handler",
+                    task=job_model.job_class.registered_name,
                     job_class=job_model.class_path,
                     job_model=job_model,
                     start_time=schedule_datetime,
                     description=f"Nautobot job {schedule_name} scheduled by {request.user} for {schedule_datetime}",
-                    kwargs=task_kwargs,
+                    kwargs=job_model.job_class.serialize_data(job_form.cleaned_data),
+                    celery_kwargs=celery_kwargs,
                     interval=schedule_type,
                     one_off=schedule_type == JobExecutionType.TYPE_FUTURE,
                     queue=task_queue,
@@ -1221,17 +1202,13 @@ class JobView(ObjectPermissionRequiredMixin, View):
 
             else:
                 # Enqueue job for immediate execution
-                job_content_type = get_job_content_type()
+                job_kwargs = job_model.job_class.prepare_job_kwargs(job_form.cleaned_data)
                 job_result = JobResult.enqueue_job(
-                    run_job,
-                    job_model.class_path,
-                    job_content_type,
+                    job_model,
                     request.user,
-                    celery_kwargs={"queue": task_queue},
-                    data=job_model.job_class.serialize_data(job_form.cleaned_data),
-                    request=copy_safe_request(request),
-                    commit=commit,
-                    task_queue=job_form.cleaned_data.get("_task_queue", None),
+                    profile=profile,
+                    task_queue=task_queue,
+                    **job_model.job_class.serialize_data(job_kwargs),
                 )
 
                 return redirect("extras:jobresult", pk=job_result.pk)
@@ -1279,7 +1256,7 @@ class JobApprovalRequestView(generic.ObjectView):
     job's execution, rather than initial job form input.
     """
 
-    queryset = ScheduledJob.objects.filter(task="nautobot.extras.jobs.scheduled_job_handler").needs_approved()
+    queryset = ScheduledJob.objects.needs_approved()
     template_name = "extras/job_approval_request.html"
     additional_permissions = ("extras.view_job",)
 
@@ -1298,8 +1275,9 @@ class JobApprovalRequestView(generic.ObjectView):
 
         if job_class is not None:
             # Render the form with all fields disabled
-            initial = instance.kwargs.get("data", {})
-            initial["_commit"] = instance.kwargs.get("commit", True)
+            initial = instance.kwargs
+            initial["_task_queue"] = instance.queue
+            initial["_profile"] = instance.celery_kwargs.get("profile", False)
             job_form = job_class().as_form(initial=initial, approval_view=True)
         else:
             job_form = None
@@ -1335,22 +1313,17 @@ class JobApprovalRequestView(generic.ObjectView):
                 messages.error(request, "This job cannot be run at this time")
             elif not JobModel.objects.check_perms(self.request.user, instance=job_model, action="run"):
                 messages.error(request, "You do not have permission to run this job")
+            elif not job_model.supports_dryrun:
+                messages.error(request, "This job does not support dryrun")
             else:
-                # Immediately enqueue the job with commit=False and send the user to the normal JobResult view
-                job_content_type = get_job_content_type()
-                initial = scheduled_job.kwargs.get("data", {})
-                initial["_commit"] = False
-                celery_kwargs = scheduled_job.kwargs.get("celery_kwargs", {})
+                # Immediately enqueue the job and send the user to the normal JobResult view
+                job_kwargs = job_model.job_class.prepare_job_kwargs(scheduled_job.kwargs or {})
+                job_kwargs["dryrun"] = True
                 job_result = JobResult.enqueue_job(
-                    run_job,
-                    job_model.job_class.class_path,
-                    job_content_type,
+                    job_model,
                     request.user,
-                    celery_kwargs=celery_kwargs,
-                    data=job_model.job_class.serialize_data(initial),
-                    request=copy_safe_request(request),
-                    commit=False,  # force a dry-run
-                    task_queue=scheduled_job.kwargs.get("task_queue", None),
+                    celery_kwargs=scheduled_job.celery_kwargs,
+                    **job_model.job_class.serialize_data(job_kwargs),
                 )
 
                 return redirect("extras:jobresult", pk=job_result.pk)
@@ -1405,7 +1378,7 @@ class JobApprovalRequestView(generic.ObjectView):
 
 
 class ScheduledJobListView(generic.ObjectListView):
-    queryset = ScheduledJob.objects.filter(task="nautobot.extras.jobs.scheduled_job_handler").enabled()
+    queryset = ScheduledJob.objects.enabled()
     table = tables.ScheduledJobTable
     filterset = filters.ScheduledJobFilterSet
     filterset_form = forms.ScheduledJobFilterForm
@@ -1419,7 +1392,7 @@ class ScheduledJobBulkDeleteView(generic.BulkDeleteView):
 
 
 class ScheduledJobApprovalQueueListView(generic.ObjectListView):
-    queryset = ScheduledJob.objects.filter(task="nautobot.extras.jobs.scheduled_job_handler").needs_approved()
+    queryset = ScheduledJob.objects.needs_approved()
     table = tables.ScheduledJobApprovalQueueTable
     filterset = filters.ScheduledJobFilterSet
     filterset_form = forms.ScheduledJobFilterForm
@@ -1491,7 +1464,7 @@ class JobResultListView(generic.ObjectListView):
     List JobResults
     """
 
-    queryset = JobResult.objects.select_related("job_model", "obj_type", "user").prefetch_related("logs")
+    queryset = JobResult.objects.select_related("job_model", "user").prefetch_related("logs")
     filterset = filters.JobResultFilterSet
     filterset_form = forms.JobResultFilterForm
     table = tables.JobResultTable
@@ -1512,49 +1485,14 @@ class JobResultView(generic.ObjectView):
     Display a JobResult and its Job data.
     """
 
-    queryset = JobResult.objects.prefetch_related("job_model", "obj_type", "user")
+    queryset = JobResult.objects.prefetch_related("job_model", "user")
     template_name = "extras/jobresult.html"
 
-    def instance_to_csv(self, instance):
-        """Format instance to csv."""
-        csv_data = []
-        headers = JobLogEntry.csv_headers.copy()
-        csv_data.append(",".join(headers))
-
-        for log_entry in instance.job_log_entries.all():
-            data = log_entry.to_csv()
-            csv_data.append(csv_format(data))
-
-        return "\n".join(csv_data)
-
-    def get(self, request, *args, **kwargs):
-        """
-        Generic GET handler for accessing an object by PK or slug
-        """
-        instance = get_object_or_404(self.queryset, **kwargs)
-
-        if "export" in request.GET:
-            response = HttpResponse(self.instance_to_csv(instance), content_type="text/csv")
-            underscore_filename = f"{instance.job_model.slug.replace('-', '_')}"
-            formated_completion_time = instance.date_done.strftime("%Y-%m-%d_%H_%M")
-            filename = f"{underscore_filename}_{formated_completion_time}_logs.csv"
-            response["Content-Disposition"] = f"attachment; filename={filename}"
-            return response
-
-        return super().get(request, *args, **kwargs)
-
     def get_extra_context(self, request, instance):
         associated_record = None
         job_class = None
         if instance.job_model is not None:
             job_class = instance.job_model.job_class
-        # 2.0 TODO: remove JobResult.related_object entirely
-        related_object = instance.related_object
-        if inspect.isclass(related_object) and issubclass(related_object, JobClass):
-            if job_class is None:
-                job_class = related_object
-        elif related_object:
-            associated_record = related_object
 
         return {
             "job": job_class,
@@ -1587,7 +1525,6 @@ class JobButtonUIViewSet(NautobotUIViewSet):
     filterset_class = filters.JobButtonFilterSet
     filterset_form_class = forms.JobButtonFilterForm
     form_class = forms.JobButtonForm
-    lookup_field = "pk"
     queryset = JobButton.objects.all()
     serializer_class = serializers.JobButtonSerializer
     table_class = tables.JobButtonTable
@@ -1608,16 +1545,10 @@ class JobButtonRunView(ObjectPermissionRequiredMixin, View):
         job_button = JobButton.objects.get(pk=pk)
         job_model = job_button.job
         result = JobResult.enqueue_job(
-            func=run_job,
-            name=job_model.class_path,
-            obj_type=get_job_content_type(),
+            job_model=job_model,
             user=request.user,
-            data={
-                "object_pk": post_data["object_pk"],
-                "object_model_name": post_data["object_model_name"],
-            },
-            request=copy_safe_request(request),
-            commit=True,
+            object_pk=post_data["object_pk"],
+            object_model_name=post_data["object_model_name"],
         )
         msg = f'Job enqueued. <a href="{result.get_absolute_url()}">Click here for the results.</a>'
         messages.info(request=request, message=mark_safe(msg))
@@ -1852,13 +1783,11 @@ class RoleUIViewSet(viewsets.NautobotUIViewSet):
     """`Roles` UIViewSet."""
 
     queryset = Role.objects.all()
-    bulk_create_form_class = RoleCSVForm
     bulk_update_form_class = RoleBulkEditForm
     filterset_class = RoleFilterSet
     form_class = RoleForm
     serializer_class = serializers.RoleSerializer
     table_class = RoleTable
-    lookup_field = "pk"
 
     def get_extra_context(self, request, instance):
         context = super().get_extra_context(request, instance)
@@ -1999,7 +1928,6 @@ class SecretDeleteView(generic.ObjectDeleteView):
 
 class SecretBulkImportView(generic.BulkImportView):
     queryset = Secret.objects.all()
-    model_form = forms.SecretCSVForm
     table = tables.SecretTable
 
 
@@ -2174,7 +2102,6 @@ class StatusBulkImportView(generic.BulkImportView):
     """Bulk CSV import of multiple `Status` objects."""
 
     queryset = Status.objects.all()
-    model_form = forms.StatusCSVForm
     table = tables.StatusTable
 
 
@@ -2235,7 +2162,6 @@ class TagDeleteView(generic.ObjectDeleteView):
 
 class TagBulkImportView(generic.BulkImportView):
     queryset = Tag.objects.all()
-    model_form = forms.TagCSVForm
     table = tables.TagTable
 
 

nautobot/ipam/api/fields.py

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