def has_permission(self, request, view):
if admin_check(request.user):
return True
if request.method in permissions.SAFE_METHODS:
return True
return developer_check(
request.user) and request.method in ("POST", "PATCH")
def get_context_data(self, **kwargs):
context = super(ContainerRunUpdate, self).get_context_data(**kwargs)
context['is_dev'] = developer_check(self.request.user)
state_names = dict(ContainerRun.STATES)
context['state_name'] = state_names.get(self.object.state)
data_entries = []
if self.object.original_run:
dataset_comparisons = compare_rerun_datasets(
self.object.original_run, self.object)
data_entries = [dict(**c._asdict()) for c in dataset_comparisons]
else:
data_entries = [
dict(type=run_dataset.argument.get_type_display(),
url=run_dataset.dataset.get_view_url(),
name=run_dataset.dataset.name,
size=run_dataset.dataset.get_formatted_filesize(),
created=run_dataset.dataset.date_created)
for run_dataset in self.object.datasets.all()
]
inputtype = dict(ContainerArgument.TYPES)[ContainerArgument.INPUT]
input_count = sum(d["type"] == inputtype for d in data_entries)
log_names = dict(ContainerLog.TYPES)
for log in self.object.logs.order_by('type'):
data_entries.insert(
input_count,
dict(type='Log',
url=log.get_absolute_url(),
name=log_names[log.type],
size=log.size_display,
created=self.object.end_time))
context['data_entries'] = data_entries
return context
def pipelines(self, request, pk=None):
"""In this routine, we are responding to an API request which looks something
like: 'hostname:/api/pipelinefamilies/2/pipelines/'
"""
qp = self.request.query_params
if qp.get('is_granted') == 'true':
is_developer = False
else:
is_developer = developer_check(self.request.user)
only_is_published = qp.get('only_is_published') == 'true'
LOGGER.debug("ISPUBLISHED {} ISADMIN {}".format(only_is_published, is_developer))
qs = self.get_object().members.all()
# Filter out the unpublished ones if necessary.
if only_is_published:
qs = qs.filter(published=True)
member_pipelines = AccessControl.filter_by_user(request.user,
is_admin=is_developer,
queryset=qs)
member_serializer = PipelineSerializer(member_pipelines, many=True,
context={"request": request})
return Response(member_serializer.data)
def pipelines(self, request, pk=None):
"""In this routine, we are responding to an API request which looks something
like: 'hostname:/api/pipelinefamilies/2/pipelines/'
"""
qp = self.request.query_params
if qp.get('is_granted') == 'true':
is_developer = False
else:
is_developer = developer_check(self.request.user)
only_is_published = qp.get('only_is_published') == 'true'
LOGGER.debug("ISPUBLISHED {} ISADMIN {}".format(
only_is_published, is_developer))
qs = self.get_object().members.all()
# Filter out the unpublished ones if necessary.
if only_is_published:
qs = qs.filter(published=True)
member_pipelines = AccessControl.filter_by_user(request.user,
is_admin=is_developer,
queryset=qs)
member_serializer = PipelineSerializer(member_pipelines,
many=True,
context={"request": request})
return Response(member_serializer.data)
def get_serializer_context(self):
"""
Return the context for the serializer.
Here, we add the only_is_published flag to the context.
"""
context = super(PipelineFamilyViewSet, self).get_serializer_context()
is_developer = developer_check(self.request.user)
context["only_is_published"] = not is_developer
return context
def get_serializer_context(self):
"""
Return the context for the serializer.
Here, we add the only_is_published flag to the context.
"""
context = super(PipelineFamilyViewSet, self).get_serializer_context()
is_developer = developer_check(self.request.user)
context["only_is_published"] = not is_developer
return context
def get_context_data(self, **kwargs):
context = super(ContainerRunUpdate, self).get_context_data(**kwargs)
context['is_dev'] = developer_check(self.request.user)
state_names = dict(ContainerRun.STATES)
context['state_name'] = state_names.get(self.object.state)
data_entries = []
type_names = dict(ContainerArgument.TYPES)
input_count = 0
for run_dataset in self.object.datasets.all():
data_entry = dict(
type=type_names[run_dataset.argument.type],
url=run_dataset.dataset.get_view_url(),
name=run_dataset.dataset.name,
size=run_dataset.dataset.get_formatted_filesize(),
created=run_dataset.dataset.date_created)
if self.object.original_run:
# noinspection PyUnresolvedReferences
try:
original_container_dataset = self.object.original_run.datasets.get(
argument=run_dataset.argument)
except ContainerDataset.DoesNotExist:
original_md5 = None
else:
original_dataset = original_container_dataset.dataset
original_md5 = original_dataset.MD5_checksum
is_changed = original_md5 == run_dataset.dataset.MD5_checksum
data_entry['is_changed'] = 'no' if is_changed else 'YES'
data_entries.append(data_entry)
if run_dataset.argument.type == ContainerArgument.INPUT:
input_count += 1
log_names = dict(ContainerLog.TYPES)
for log in self.object.logs.order_by('type'):
data_entries.insert(
input_count,
dict(type='Log',
url=log.get_absolute_url(),
name=log_names[log.type],
size=log.size_display,
created=self.object.end_time))
context['data_entries'] = data_entries
return context
def get_context_data(self, **kwargs):
context = super(ContainerRunUpdate, self).get_context_data(**kwargs)
context['is_dev'] = developer_check(self.request.user)
state_names = dict(ContainerRun.STATES)
context['state_name'] = state_names.get(self.object.state)
data_entries = []
type_names = dict(ContainerArgument.TYPES)
input_count = 0
for run_dataset in self.object.datasets.all():
data_entry = dict(type=type_names[run_dataset.argument.type],
url=run_dataset.dataset.get_view_url(),
name=run_dataset.dataset.name,
size=run_dataset.dataset.get_formatted_filesize(),
created=run_dataset.dataset.date_created)
if self.object.original_run:
# noinspection PyUnresolvedReferences
try:
original_container_dataset = self.object.original_run.datasets.get(
argument=run_dataset.argument)
except ContainerDataset.DoesNotExist:
original_md5 = None
else:
original_dataset = original_container_dataset.dataset
original_md5 = original_dataset.MD5_checksum
is_changed = original_md5 == run_dataset.dataset.MD5_checksum
data_entry['is_changed'] = 'no' if is_changed else 'YES'
data_entries.append(data_entry)
if run_dataset.argument.type == ContainerArgument.INPUT:
input_count += 1
log_names = dict(ContainerLog.TYPES)
for log in self.object.logs.order_by('type'):
data_entries.insert(input_count, dict(
type='Log',
url=log.get_absolute_url(),
name=log_names[log.type],
size=log.size_display,
created=self.object.end_time))
context['data_entries'] = data_entries
return context
def view_results(request, run_id):
"""View outputs from a pipeline run."""
go_back_to_view = request.GET.get('back_to_view', None) == 'true'
four_oh_four = False
try:
# If we're going to change the permissions, this will make it faster.
# FIXME punch this up so it gets the top-level runs of the ExecRecords it reuses
run = Run.objects.prefetch_related(
"runsteps__RSICs__outputs__integrity_checks__usurper",
"runsteps__outputs__integrity_checks__usurper",
"runoutputcables__outputs__integrity_checks__usurper",
"runsteps__execrecord__generator__record__runstep__run",
"runsteps__RSICs__execrecord__generator__record__runsic__runstep__run",
"runoutputcables__execrecord__generator__record__runoutputcable__run"
).get(pk=run_id)
if run.is_subrun():
four_oh_four = True
if not run.can_be_accessed(request.user) and not admin_check(request.user):
four_oh_four = True
except Run.DoesNotExist:
four_oh_four = True
if four_oh_four:
raise Http404("ID {} does not exist or is not accessible".format(run_id))
with transaction.atomic():
run_complete = run.is_complete()
if request.method == "POST":
# We don't allow changing anything until after the Run is finished.
if not run_complete:
# A form which we can use to make submission and editing easier.
run_form = RunDetailsForm(
users_allowed=User.objects.none(),
groups_allowed=Group.objects.none(),
initial={"name": run.name, "description": run.description}
)
run_form.add_error(None, "This run cannot be modified until it is complete.")
else:
# We are going to try and update this Run. We don't bother restricting the
# PermissionsField here; instead we will catch errors at the model validation
# step.
run_form = RunDetailsForm(
request.POST,
instance=run
)
try:
if run_form.is_valid():
with transaction.atomic():
run.name = run_form.cleaned_data["name"]
run.description = run_form.cleaned_data["description"]
run.save()
run.increase_permissions_from_json(run_form.cleaned_data["permissions"])
run.clean()
if go_back_to_view:
return HttpResponseRedirect("/view_run/{}".format(run_id))
else:
return HttpResponseRedirect("/runs")
except (AttributeError, ValidationError, ValueError) as e:
LOGGER.exception(e.message)
run_form.add_error(None, e)
else:
# A form which we can use to make submission and editing easier.
run_form = RunDetailsForm(
users_allowed=User.objects.none(),
groups_allowed=Group.objects.none(),
initial={"name": run.name, "description": run.description}
)
template = loader.get_template("sandbox/view_results.html")
context = {
"run": run,
"outputs": JSONRenderer().render(RunOutputsSerializer(run, context={'request': request}).data),
"run_form": run_form,
"is_complete": run_complete,
"is_owner": run.user == request.user,
"is_user_admin": admin_check(request.user),
"is_user_developer": developer_check(request.user),
"back_to_view": go_back_to_view
}
return HttpResponse(template.render(context, request))
def view_results(request, run_id):
"""View outputs from a pipeline run."""
go_back_to_view = request.GET.get('back_to_view', None) == 'true'
four_oh_four = False
try:
# If we're going to change the permissions, this will make it faster.
# FIXME punch this up so it gets the top-level runs of the ExecRecords it reuses
run = Run.objects.prefetch_related(
"runsteps__RSICs__outputs__integrity_checks__usurper",
"runsteps__outputs__integrity_checks__usurper",
"runoutputcables__outputs__integrity_checks__usurper",
"runsteps__execrecord__generator__record__runstep__run",
"runsteps__RSICs__execrecord__generator__record__runsic__runstep__run",
"runoutputcables__execrecord__generator__record__runoutputcable__run"
).get(pk=run_id)
if run.is_subrun():
four_oh_four = True
if not run.can_be_accessed(request.user) and not admin_check(
request.user):
four_oh_four = True
except Run.DoesNotExist:
four_oh_four = True
if four_oh_four:
raise Http404(
"ID {} does not exist or is not accessible".format(run_id))
with transaction.atomic():
run_complete = run.is_complete()
if request.method == "POST":
# We don't allow changing anything until after the Run is finished.
if not run_complete:
# A form which we can use to make submission and editing easier.
run_form = RunDetailsForm(users_allowed=User.objects.none(),
groups_allowed=Group.objects.none(),
initial={
"name": run.name,
"description": run.description
})
run_form.add_error(
None, "This run cannot be modified until it is complete.")
else:
# We are going to try and update this Run. We don't bother restricting the
# PermissionsField here; instead we will catch errors at the model validation
# step.
run_form = RunDetailsForm(request.POST, instance=run)
try:
if run_form.is_valid():
with transaction.atomic():
run.name = run_form.cleaned_data["name"]
run.description = run_form.cleaned_data["description"]
run.save()
run.increase_permissions_from_json(
run_form.cleaned_data["permissions"])
run.clean()
if go_back_to_view:
return HttpResponseRedirect(
"/view_run/{}".format(run_id))
else:
return HttpResponseRedirect("/runs")
except (AttributeError, ValidationError, ValueError) as e:
LOGGER.exception(e.message)
run_form.add_error(None, e)
else:
# A form which we can use to make submission and editing easier.
run_form = RunDetailsForm(users_allowed=User.objects.none(),
groups_allowed=Group.objects.none(),
initial={
"name": run.name,
"description": run.description
})
template = loader.get_template("sandbox/view_results.html")
context = {
"run":
run,
"outputs":
JSONRenderer().render(
RunOutputsSerializer(run, context={
'request': request
}).data),
"run_form":
run_form,
"is_complete":
run_complete,
"is_owner":
run.user == request.user,
"is_user_admin":
admin_check(request.user),
"is_user_developer":
developer_check(request.user),
"back_to_view":
go_back_to_view
}
return HttpResponse(template.render(context, request))