def run(self, request, class_path): if not request.user.has_perm("extras.run_job"): raise PermissionDenied("This user does not have permission to run jobs.") job_class = self._get_job_class(class_path) job = job_class() input_serializer = serializers.JobInputSerializer(data=request.data) input_serializer.is_valid(raise_exception=True) data = input_serializer.data["data"] commit = input_serializer.data["commit"] if commit is None: commit = getattr(job_class.Meta, "commit_default", True) job_content_type = ContentType.objects.get(app_label="extras", model="job") job_result = JobResult.enqueue_job( run_job, job.class_path, job_content_type, request.user, data=data, request=copy_safe_request(request), commit=commit, ) job.result = job_result serializer = serializers.JobDetailSerializer(job, context={"request": request}) return Response(serializer.data)
def dry_run(self, request, pk): if not request.user.has_perm("extras.run_job"): raise PermissionDenied() scheduled_job = get_object_or_404(ScheduledJob, pk=pk) job_class = get_job(scheduled_job.job_class) if job_class is None: raise Http404 job = job_class() grouping, module, class_name = job_class.class_path.split("/", 2) # Immediately enqueue the job with commit=False job_content_type = ContentType.objects.get(app_label="extras", model="job") job_result = JobResult.enqueue_job( run_job, job.class_path, job_content_type, scheduled_job.user, data=scheduled_job.kwargs["data"], request=copy_safe_request(request), commit=False, # force a dry-run ) serializer = serializers.JobResultSerializer( job_result, context={"request": request}) return Response(serializer.data)
def run(self, request, class_path): if not request.user.has_perm("extras.run_job"): raise PermissionDenied( "This user does not have permission to run jobs.") job_class = self._get_job_class(class_path) job = job_class() input_serializer = serializers.JobInputSerializer(data=request.data) input_serializer.is_valid(raise_exception=True) data = input_serializer.data["data"] or {} commit = input_serializer.data["commit"] if commit is None: commit = getattr(job_class.Meta, "commit_default", True) try: job.validate_data(data) except FormsValidationError as e: # message_dict can only be accessed if ValidationError got a dict # in the constructor (saved as error_dict). Otherwise we get a list # of errors under messages return Response( { "errors": e.message_dict if hasattr(e, "error_dict") else e.messages }, status=400) if not get_worker_count(): raise CeleryWorkerNotRunningException() job_content_type = ContentType.objects.get(app_label="extras", model="job") schedule = input_serializer.data.get("schedule") if schedule: schedule = self._create_schedule(schedule, data, commit, job, job_class, request) else: job_result = JobResult.enqueue_job( run_job, job.class_path, job_content_type, request.user, data=data, request=copy_safe_request(request), commit=commit, ) job.result = job_result serializer = serializers.JobDetailSerializer( job, context={"request": request}) return Response(serializer.data)
def enqueue_pull_git_repository_and_refresh_data(repository, request): """ Convenience wrapper for JobResult.enqueue_job() to enqueue the pull_git_repository_and_refresh_data job. """ git_repository_content_type = ContentType.objects.get_for_model(GitRepository) JobResult.enqueue_job( pull_git_repository_and_refresh_data, repository.name, git_repository_content_type, request.user, repository_pk=repository.pk, request=copy_safe_request(request), )
def enqueue_git_repository_helper(repository, request, func, **kwargs): """ Wrapper for JobResult.enqueue_job() to enqueue one of several possible Git repository functions. """ git_repository_content_type = ContentType.objects.get_for_model( GitRepository) JobResult.enqueue_job( func, repository.name, git_repository_content_type, request.user, repository_pk=repository.pk, request=copy_safe_request(request), )
def post(self, request, class_path): if not request.user.has_perm("extras.run_job"): return HttpResponseForbidden() job_class = get_job(class_path) if job_class is None: raise Http404 job = job_class() grouping, module, class_name = class_path.split("/", 2) form = job.as_form(request.POST, request.FILES) # Allow execution only if RQ worker process is running if not Worker.count(get_connection("default")): messages.error( request, "Unable to run job: RQ worker process not running.") elif form.is_valid(): # Run the job. A new JobResult is created. commit = form.cleaned_data.pop("_commit") job_content_type = ContentType.objects.get(app_label="extras", model="job") job_result = JobResult.enqueue_job( run_job, job.class_path, job_content_type, request.user, data=form.cleaned_data, request=copy_safe_request(request), commit=commit, ) return redirect("extras:job_jobresult", pk=job_result.pk) return render( request, "extras/job.html", { "grouping": grouping, "module": module, "job": job, "form": form, }, )
def _create_schedule(serializer, data, commit, job, job_model, request): """ This is an internal function to create a scheduled job from API data. It has to handle boths once-offs (i.e. of type TYPE_FUTURE) and interval jobs. """ job_kwargs = { "data": data, "request": copy_safe_request(request), "user": request.user.pk, "commit": commit, "name": job.class_path, } type_ = serializer["interval"] if type_ == JobExecutionType.TYPE_IMMEDIATELY: time = datetime.now() name = serializer.get("name") or f"{job.name} - {time}" else: time = serializer["start_time"] name = serializer["name"] # 2.0 TODO: To revisit this as part of a larger Jobs cleanup in 2.0. # # We pass in job_class and job_model here partly for forward/backward compatibility logic, and # part fallback safety. It's mildly useful to store both the class_path string and the JobModel # FK on the ScheduledJob, as in the case where the JobModel gets deleted (and the FK becomes # null) you still have a bit of context on the ScheduledJob as to what it was originally # scheduled for. scheduled_job = ScheduledJob( name=name, task="nautobot.extras.jobs.scheduled_job_handler", job_class=job.class_path, job_model=job_model, start_time=time, description=f"Nautobot job {name} scheduled by {request.user} on {time}", kwargs=job_kwargs, interval=type_, one_off=(type_ == JobExecutionType.TYPE_FUTURE), user=request.user, approval_required=job_model.approval_required, ) scheduled_job.save() return scheduled_job
def run(self, request, class_path): if not request.user.has_perm("extras.run_job"): raise PermissionDenied( "This user does not have permission to run jobs.") # Check that at least one RQ worker is running if not Worker.count(get_connection("default")): raise RQWorkerNotRunningException() job_class = self._get_job_class(class_path) job = job_class() input_serializer = serializers.JobInputSerializer(data=request.data) if not input_serializer.is_valid(): return Response(input_serializer.errors, status=status.HTTP_400_BAD_REQUEST) data = input_serializer.data["data"] commit = input_serializer.data["commit"] if commit is None: commit = getattr(job_class.Meta, "commit_default", True) job_content_type = ContentType.objects.get(app_label="extras", model="job") job_result = JobResult.enqueue_job( run_job, job.class_path, job_content_type, request.user, data=data, request=copy_safe_request(request), commit=commit, ) job.result = job_result serializer = serializers.JobDetailSerializer( job, context={"request": request}) return Response(serializer.data)
def dry_run(self, request, pk): scheduled_job = get_object_or_404(ScheduledJob, pk=pk) job_model = scheduled_job.job_model if job_model is None or not job_model.runnable: raise MethodNotAllowed("This job cannot be dry-run at this time.") if not Job.objects.check_perms(request.user, instance=job_model, action="run"): raise PermissionDenied("You do not have permission to run this job.") # Immediately enqueue the job with commit=False job_content_type = get_job_content_type() job_result = JobResult.enqueue_job( run_job, job_model.class_path, job_content_type, request.user, data=scheduled_job.kwargs.get("data", {}), request=copy_safe_request(request), commit=False, # force a dry-run ) serializer = serializers.JobResultSerializer(job_result, context={"request": request}) return Response(serializer.data)
def _create_schedule(self, serializer, data, commit, job, job_class, request): """ This is an internal function to create a scheduled job from API data. It has to handle boths once-offs (i.e. of type TYPE_FUTURE) and interval jobs. """ job_kwargs = { "data": data, "request": copy_safe_request(request), "user": request.user.pk, "commit": commit, "name": job.class_path, } type_ = serializer["interval"] if type_ == JobExecutionType.TYPE_IMMEDIATELY: time = datetime.now() name = serializer.get("name") or f"{job.name} - {time}" else: time = serializer["start_time"] name = serializer["name"] scheduled_job = ScheduledJob( name=name, task="nautobot.extras.jobs.scheduled_job_handler", job_class=job.class_path, start_time=time, description= f"Nautobot job {name} scheduled by {request.user} on {time}", kwargs=job_kwargs, interval=type_, one_off=(type_ == JobExecutionType.TYPE_FUTURE), user=request.user, approval_required=job_class.approval_required, ) scheduled_job.save() return scheduled_job
def _run_job(request, job_model, legacy_response=False): """An internal function providing logic shared between JobModelViewSet.run() and JobViewSet.run().""" if not request.user.has_perm("extras.run_job"): raise PermissionDenied("This user does not have permission to run jobs.") if not job_model.enabled: raise PermissionDenied("This job is not enabled to be run.") if not job_model.installed: raise MethodNotAllowed(request.method, detail="This job is not presently installed and cannot be run") job_class = job_model.job_class if job_class is None: raise MethodNotAllowed(request.method, detail="This job's source code could not be located and cannot be run") job = job_class() input_serializer = serializers.JobInputSerializer(data=request.data) input_serializer.is_valid(raise_exception=True) data = input_serializer.data["data"] or {} commit = input_serializer.data["commit"] if commit is None: commit = job_model.commit_default try: job.validate_data(data) except FormsValidationError as e: # message_dict can only be accessed if ValidationError got a dict # in the constructor (saved as error_dict). Otherwise we get a list # of errors under messages return Response({"errors": e.message_dict if hasattr(e, "error_dict") else e.messages}, status=400) if not get_worker_count(): raise CeleryWorkerNotRunningException() job_content_type = get_job_content_type() schedule_data = input_serializer.data.get("schedule") # Default to a null JobResult. job_result = None # Assert that a job with `approval_required=True` has a schedule that enforces approval and # executes immediately. if schedule_data is None and job_model.approval_required: schedule_data = {"interval": JobExecutionType.TYPE_IMMEDIATELY} # Try to create a ScheduledJob, or... if schedule_data: schedule = _create_schedule(schedule_data, data, commit, job, job_model, request) else: schedule = None # ... If we can't create one, create a JobResult instead. if schedule is None: job_result = JobResult.enqueue_job( run_job, job.class_path, job_content_type, request.user, data=data, request=copy_safe_request(request), commit=commit, ) job.result = job_result if legacy_response: # Old-style JobViewSet response - serialize the Job class in the response for some reason? serializer = serializers.JobClassDetailSerializer(job, context={"request": request}) return Response(serializer.data) else: # New-style JobModelViewSet response - serialize the schedule or job_result as appropriate data = {"schedule": None, "job_result": None} if schedule: data["schedule"] = nested_serializers.NestedScheduledJobSerializer( schedule, context={"request": request} ).data if job_result: data["job_result"] = nested_serializers.NestedJobResultSerializer( job_result, context={"request": request} ).data return Response(data, status=status.HTTP_201_CREATED)
def handle(self, *args, **options): if "/" not in options["job"]: raise CommandError( 'Job must be specified in the form "grouping_name/module_name/JobClassName"' ) job_class = get_job(options["job"]) if not job_class: raise CommandError('Job "%s" not found' % options["job"]) user = None request = None if options["commit"] and not options["username"]: # Job execution with commit=True uses change_logging(), which requires a user as the author of any changes raise CommandError("--username is mandatory when --commit is used") if options["username"]: User = get_user_model() try: user = User.objects.get(username=options["username"]) except User.DoesNotExist as exc: raise CommandError("No such user") from exc request = RequestFactory().request( SERVER_NAME="nautobot_server_runjob") request.id = uuid.uuid4() request.user = user job_content_type = get_job_content_type() # Run the job and create a new JobResult self.stdout.write("[{:%H:%M:%S}] Running {}...".format( timezone.now(), job_class.class_path)) job_result = JobResult.enqueue_job( run_job, job_class.class_path, job_content_type, user, data= {}, # TODO: parsing CLI args into a data dictionary is not currently implemented request=copy_safe_request(request) if request else None, commit=options["commit"], ) # Wait on the job to finish while job_result.status not in JobResultStatusChoices.TERMINAL_STATE_CHOICES: time.sleep(1) job_result = JobResult.objects.get(pk=job_result.pk) # Report on success/failure groups = set( JobLogEntry.objects.filter(job_result=job_result).values_list( "grouping", flat=True)) for group in sorted(groups): logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group) success_count = logs.filter( log_level=LogLevelChoices.LOG_SUCCESS).count() info_count = logs.filter( log_level=LogLevelChoices.LOG_INFO).count() warning_count = logs.filter( log_level=LogLevelChoices.LOG_WARNING).count() failure_count = logs.filter( log_level=LogLevelChoices.LOG_FAILURE).count() self.stdout.write( "\t{}: {} success, {} info, {} warning, {} failure".format( group, success_count, info_count, warning_count, failure_count, )) for log_entry in logs: status = log_entry.log_level if status == "success": status = self.style.SUCCESS(status) elif status == "info": status = status elif status == "warning": status = self.style.WARNING(status) elif status == "failure": status = self.style.NOTICE(status) if log_entry.log_object: self.stdout.write( f"\t\t{status}: {log_entry.log_object}: {log_entry.message}" ) else: self.stdout.write(f"\t\t{status}: {log_entry.message}") if job_result.data["output"]: self.stdout.write(job_result.data["output"]) if job_result.status == JobResultStatusChoices.STATUS_FAILED: status = self.style.ERROR("FAILED") elif job_result.status == JobResultStatusChoices.STATUS_ERRORED: status = self.style.ERROR("ERRORED") else: status = self.style.SUCCESS("SUCCESS") self.stdout.write("[{:%H:%M:%S}] {}: {}".format( timezone.now(), job_class.class_path, status)) # Wrap things up self.stdout.write("[{:%H:%M:%S}] {}: Duration {}".format( timezone.now(), job_class.class_path, job_result.duration)) self.stdout.write("[{:%H:%M:%S}] Finished".format(timezone.now()))