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()))