def __get_kwargs(self, report, data):
kwargs = {'page': int(data.get('page', 1)), 'report': report}
if 'confirmed' in data:
kwargs['confirmed'] = True
self.title = '{0}: {1}'.format(_("Unsafes"), _('confirmed'))
# Either verdict, tag or attr is supported in kwargs
if 'verdict' in data:
verdict_title = ReportUnsafe(verdict=data['verdict']).get_verdict_display()
if 'confirmed' in data:
self.title = '{0}: {1} {2}'.format(_("Unsafes"), _('confirmed'), verdict_title)
else:
self.title = '{0}: {1}'.format(_("Unsafes"), verdict_title)
kwargs['verdict'] = data['verdict']
elif 'tag' in data:
try:
tag = UnsafeTag.objects.get(id=data['tag'])
except ObjectDoesNotExist:
raise BridgeException(_("The tag was not found"))
self.title = '{0}: {1}'.format(_("Unsafes"), tag.tag)
kwargs['tag'] = tag
elif 'attr' in data:
try:
attr = Attr.objects.select_related('name').get(id=data['attr'])
except ObjectDoesNotExist:
raise BridgeException(_("The attribute was not found"))
self.title = _('Unsafes where %(a_name)s is %(a_val)s') % {'a_name': attr.name.name, 'a_val': attr.value}
kwargs['attr'] = attr
return kwargs
def __get_response(self, *args, **kwargs):
self.__is_not_used(*args, **kwargs)
try:
generator = self.get_generator()
except Exception as e:
if not isinstance(e, BridgeException):
logger.exception(e)
raise BridgeException()
raise
if generator is None:
raise BridgeException()
file_name = getattr(generator, 'name', None) or self.get_filename()
if not isinstance(file_name, str) or len(file_name) == 0:
raise BridgeException()
file_size = getattr(generator, 'size', None)
mimetype = mimetypes.guess_type(os.path.basename(file_name))[0]
response = StreamingHttpResponse(generator, content_type=mimetype)
if file_size is not None:
response['Content-Length'] = file_size
response['Content-Disposition'] = 'attachment; filename="{}"'.format(
file_name)
return response
def upload_mark(self, archive):
mark_data = None
versions_data = {}
with zipfile.ZipFile(archive, 'r') as zfp:
for file_name in zfp.namelist():
if file_name == 'mark.json':
mark_data = json.loads(zfp.read(file_name).decode('utf8'))
elif file_name.startswith('version-'):
try:
version_id = int(os.path.splitext(file_name)[0].replace('version-', ''))
versions_data[version_id] = json.loads(zfp.read(file_name).decode('utf8'))
except ValueError:
raise BridgeException(_("The mark archive is corrupted"))
if mark_data is None or len(versions_data) == 0:
raise BridgeException(_("The mark archive is corrupted: it doesn't contain necessary data"))
if not isinstance(mark_data, dict):
raise ValueError('Unsupported mark data type: %s' % type(mark_data))
mark_type = mark_data.pop('type', None)
if mark_type == 'safe':
return mark_type, self.__create_safe_mark(mark_data, versions_data)
elif mark_type == 'unsafe':
return mark_type, self.__create_unsafe_mark(mark_data, versions_data)
elif mark_type == 'unknown':
return mark_type, self.__create_unknown_mark(mark_data, versions_data)
raise ValueError('Unsupported mark type: %s' % mark_type)
def __init__(self, func_name, pattern_error_trace, unsafe):
"""
If you want to pass exception message (can be translatable) to user,
raise BridgeException(message) then.
In case of success you need just self.result.
:param func_name: name of the function (str).
:param pattern_error_trace: pattern error trace of the mark (str).
:param unsafe: unsafe (ReportUnsafe).
:return: nothing.
"""
self.unsafe = unsafe
try:
self.pattern_error_trace = json.loads(pattern_error_trace)
except Exception as e:
raise BridgeException(
"Can't parse error trace pattern (it must be JSON serializable): %s"
% e)
self.result = 0.0
if func_name.startswith('_'):
raise BridgeException("Function name mustn't start with '_'")
try:
func = getattr(self, func_name)
if not isinstance(func, MethodType):
raise BridgeException('Wrong function name')
except AttributeError:
raise BridgeException(
'The error trace comparison function does not exist')
self.result = func()
if isinstance(self.result, int):
self.result = float(self.result)
if not (isinstance(self.result, float) and 0 <= self.result <= 1):
raise BridgeException(
"Compare function returned incorrect result: %s" % self.result)
def delete_marks(user, marks_type, mark_ids, report_id=None):
if marks_type == 'safe':
marks = MarkSafe.objects.filter(id__in=mark_ids)
elif marks_type == 'unsafe':
marks = MarkUnsafe.objects.filter(id__in=mark_ids)
elif marks_type == 'unknown':
marks = MarkUnknown.objects.filter(id__in=mark_ids)
else:
raise ValueError('Unsupported marks type: %s' % marks_type)
if not all(MarkAccess(user, mark=mark).can_delete() for mark in marks):
if len(marks) > 1:
raise BridgeException(_("You can't delete one of the selected marks"))
elif len(marks) == 1:
raise BridgeException(_("You don't have an access to delete this mark"))
else:
raise BridgeException(_('Nothing to delete'))
if marks_type == 'safe':
SafeUtils.delete_marks(marks)
reports_model = ReportSafe
elif marks_type == 'unsafe':
UnsafeUtils.delete_marks(marks)
reports_model = ReportUnsafe
else:
UnknownUtils.delete_marks(marks)
reports_model = ReportUnknown
if report_id:
try:
report = reports_model.objects.get(id=report_id)
except ObjectDoesNotExist:
return None
return report.id if not isinstance(report, ReportUnsafe) else report.trace_id
def copy_files_with_replace(request, decision_id, files_qs):
new_job_files = []
files_to_replace = {}
# Upload provided files first
if request.data.get('files'):
if isinstance(request.data['files'], str):
try:
files_map = json.loads(request.data['files'])
except Exception as e:
logger.error("Can't decode files data: {}".format(
request.data['files']))
raise BridgeException("Can't decode files data: {}".format(e))
elif isinstance(request.data['files'], dict):
files_map = request.data['files']
else:
raise BridgeException('Wrong files data: "{}" ({})'.format(
request.data['files'], type(request.data['files'])))
for fname, fkey in files_map.items():
if fkey in request.FILES:
files_to_replace[fname] = request.FILES[fkey]
new_file = file_get_or_create(files_to_replace[fname], fname,
JobFile)
new_job_files.append(
FileSystem(decision_id=decision_id,
file_id=new_file.id,
name=fname))
# Copy other files
for f_id, f_name in files_qs:
if f_name in files_to_replace:
continue
new_job_files.append(
FileSystem(decision_id=decision_id, file_id=f_id, name=f_name))
FileSystem.objects.bulk_create(new_job_files)
def get_context_data(self, **kwargs):
# Get decisions
try:
decision1 = Decision.objects.select_related('job').get(
identifier=self.kwargs['decision1'])
decision2 = Decision.objects.select_related('job').get(
identifier=self.kwargs['decision2'])
except Decision.DoesNotExist:
raise BridgeException(
_("One of the selected decisions wasn't found"))
# Check jobs access
if not JobAccess(self.request.user, job=decision1.job).can_view\
or not JobAccess(self.request.user, job=decision2.job).can_view:
raise BridgeException(code=401)
# Get or create comparison cache
try:
comparison_info = CompareDecisionsInfo.objects.get(
decision1=decision1, decision2=decision2)
except CompareDecisionsInfo.DoesNotExist:
obj = FillComparisonCache(self.request.user, decision1, decision2)
comparison_info = obj.info
return {
'decision1':
decision1,
'decision2':
decision2,
'data':
ComparisonTableData(decision1,
decision2,
comparison_info=comparison_info)
}
def post(self, *args, **kwargs):
self.is_not_used(*args, **kwargs)
self.object = self.get_object()
if self.kwargs['action'] == 'create' \
and not mutils.MarkAccess(self.request.user, report=self.object).can_create():
raise BridgeException(
_("You don't have an access to create new marks"),
response_type='json')
elif self.kwargs['action'] == 'edit' \
and not mutils.MarkAccess(self.request.user, mark=self.object).can_edit():
raise BridgeException(
_("You don't have an access to edit this mark"),
response_type='json')
try:
res = mutils.NewMark(self.request.user, self.object,
json.loads(self.request.POST['data']))
if self.kwargs['action'] == 'edit':
res.change_mark()
else:
res.create_mark()
cache_id = MarkChangesTable(self.request.user, res.mark,
res.changes).cache_id
except BridgeException as e:
raise BridgeException(str(e), response_type='json')
except Exception as e:
logger.exception(e)
raise BridgeException(response_type='json')
return JsonResponse({'cache_id': cache_id})
def upload_mark(self):
if 'format' not in self._args:
raise BridgeException(_('Safe mark format is required'))
if isinstance(self._args.get('identifier'),
str) and 0 < len(self._args['identifier']) < 255:
if MarkSafe.objects.filter(
identifier=self._args['identifier']).count() > 0:
raise BridgeException(
_("The mark with identifier specified in the archive already exists"
))
else:
self._args['identifier'] = unique_id()
mark = MarkSafe.objects.create(
identifier=self._args['identifier'],
author=self._user,
change_date=now(),
format=self._args['format'],
type=MARK_TYPE[2][0],
status=self._args['status'],
description=str(self._args.get('description', '')),
is_modifiable=self._args['is_modifiable'],
verdict=self._args['verdict'])
try:
markversion = self.__create_version(mark)
self.__create_attributes(markversion.id)
except Exception:
mark.delete()
raise
return mark
def __get_kwargs(self, report, data):
kwargs = {'page': int(data.get('page', 1)), 'report': report}
if 'component' in data:
kwargs['component'] = data['component']
if 'problem' in data:
problem_id = int(data['problem'])
if problem_id == 0:
self.title = _("Unknowns without marks")
kwargs['problem'] = 0
else:
try:
problem = UnknownProblem.objects.get(id=problem_id)
except ObjectDoesNotExist:
raise BridgeException(_("The problem was not found"))
self.title = '{0}: {1}'.format(_("Unknowns"), problem.name)
kwargs['problem'] = problem
elif 'attr' in data:
try:
attr = Attr.objects.select_related('name').get(id=data['attr'])
except ObjectDoesNotExist:
raise BridgeException(_("The attribute was not found"))
self.title = _('Unknowns where %(a_name)s is %(a_val)s') % {'a_name': attr.name.name, 'a_val': attr.value}
kwargs['attr'] = attr
return kwargs
def __get_schedulers(self):
schedulers = []
try:
klever_sch = Scheduler.objects.get(type=SCHEDULER_TYPE[0][0])
except ObjectDoesNotExist:
raise BridgeException(_('Population has to be done first'))
try:
cloud_sch = Scheduler.objects.get(type=SCHEDULER_TYPE[1][0])
except ObjectDoesNotExist:
raise BridgeException(_('Population has to be done first'))
if klever_sch.status == SCHEDULER_STATUS[1][0]:
self.job_sch_err = _("The Klever scheduler is ailing")
elif klever_sch.status == SCHEDULER_STATUS[2][0]:
raise BridgeException(_('The Klever scheduler is disconnected'))
schedulers.append([
klever_sch.type,
'{0} ({1})'.format(klever_sch.get_type_display(),
klever_sch.get_status_display())
])
if cloud_sch.status != SCHEDULER_STATUS[2][0]:
schedulers.append([
cloud_sch.type,
'{0} ({1})'.format(cloud_sch.get_type_display(),
cloud_sch.get_status_display())
])
elif self.conf['scheduler'] == SCHEDULER_TYPE[1][0]:
raise BridgeException(_('The scheduler for tasks is disconnected'))
return schedulers
def get(self, *args, **kwargs):
self.__is_not_used(*args, **kwargs)
try:
self.generator = self.get_generator()
except Exception as e:
if not isinstance(e, BridgeException):
logger.exception(e)
raise BridgeException()
raise
if self.generator is None:
raise BridgeException()
self.file_name = self.get_filename()
if not isinstance(self.file_name, str) or len(self.file_name) == 0:
raise BridgeException()
mimetype = mimetypes.guess_type(os.path.basename(self.file_name))[0]
response = StreamingHttpResponse(self.generator, content_type=mimetype)
if self.file_size is not None:
response['Content-Length'] = self.file_size
response[
'Content-Disposition'] = 'attachment; filename="%s"' % self.file_name
return response
def __get_decisions(self, decisions_ids):
decisions = Decision.objects.filter(id__in=decisions_ids)\
.exclude(status=DECISION_STATUS[0][0]).select_related('job')
if len(decisions) < len(decisions_ids):
raise BridgeException(_('One of the selected decisions was not found'))
if len(decisions) == 0:
raise BridgeException(_('Please select decisions to recalculate caches for them'))
return decisions
def get_context_data(self, **kwargs):
if not TagAccess(self.request.user, None).create():
raise BridgeException(_("You don't have an access to upload tags"))
if 'file' not in self.request.FILES:
raise BridgeException()
CreateTagsFromFile(self.request.user, self.request.FILES['file'],
self.kwargs['type'])
return {}
def get_job_by_identifier(identifier):
found_jobs = Job.objects.filter(identifier__startswith=identifier)
if len(found_jobs) == 0:
raise BridgeException(_('The job with specified identifier was not found'))
elif len(found_jobs) > 1:
raise BridgeException(_('Several jobs match the specified identifier, '
'please increase the length of the job identifier'))
return found_jobs[0]
def get_object(self, queryset=None):
try:
obj = self.get_queryset().get(job_id=self.kwargs['job_id'], version=self.kwargs['version'])
except ObjectDoesNotExist:
raise BridgeException(_('Job version was not found'))
if not jobs.utils.JobAccess(self.request.user, obj.job).can_view():
raise BridgeException(code=400)
return obj
def get_context_data(self, **kwargs):
context = {'versions': [], 'action': self.kwargs['action']}
if self.kwargs['action'] == 'edit':
access = mutils.MarkAccess(self.request.user, mark=self.object)
if not access.can_edit():
raise BridgeException(
_("You don't have an access to edit this mark"))
context['mark'] = self.object
context['selected_version'] = int(
self.request.GET.get('version', self.object.version))
for m in self.object.versions.order_by('-version'):
if m.version == self.object.version:
title = _("Current version")
else:
change_time = m.change_date.astimezone(
pytz.timezone(self.request.user.extended.timezone))
title = change_time.strftime("%d.%m.%Y %H:%M:%S")
if m.author is not None:
title += " (%s)" % m.author.get_full_name()
if len(m.comment) > 0:
title += ': ' + m.comment
context['versions'].append({
'version': m.version,
'title': title
})
if context['selected_version'] == m.version:
context['markdata'] = MarkData(self.kwargs['type'],
mark_version=m)
if 'markdata' not in context:
raise BridgeException(_('The mark version was not found'))
context['cancel_url'] = reverse(
'marks:mark', args=[self.kwargs['type'], self.object.id])
else:
if self.kwargs['type'] == 'unknown':
try:
context['problem_description'] = \
ArchiveFileContent(self.object, 'problem_description', PROBLEM_DESC_FILE).content.decode('utf8')
except Exception as e:
logger.exception(
"Can't get problem description for unknown '%s': %s" %
(self.object.id, e))
raise BridgeException()
access = mutils.MarkAccess(self.request.user, report=self.object)
if not access.can_create():
raise BridgeException(
_("You don't have an access to create new marks"))
context['report'] = self.object
context['markdata'] = MarkData(self.kwargs['type'],
report=self.object)
context['cancel_url'] = reverse(
'reports:{0}'.format(self.kwargs['type']),
args=[
self.object.trace_id
if self.kwargs['type'] == 'unsafe' else self.object.id
])
context['access'] = access
return context
def get_generator(self):
decision = self.get_object()
if not DecisionAccess(self.request.user,
decision).can_download_verifier_files:
raise BridgeException(code=400)
if 'filters' not in self.request.GET:
raise BridgeException()
return FilesForCompetitionArchive(
decision, json.loads(self.request.GET['filters']))
def __get_parent(self, identifier):
parent = None
if len(identifier) > 0:
parent = get_job_by_identifier(identifier)
if not self.__is_parent_valid(parent):
raise BridgeException(_("The specified parent can't be set for this job"))
elif self._user.extended.role != USER_ROLES[2][0]:
raise BridgeException(_("The parent identifier is required for this job"))
return parent
def get_context_data(self, **kwargs):
try:
j1 = Job.objects.get(id=self.request.POST.get('job1', 0))
j2 = Job.objects.get(id=self.request.POST.get('job2', 0))
except ObjectDoesNotExist:
raise BridgeException(code=405)
if not can_compare(self.request.user, j1, j2):
raise BridgeException(code=401)
return {}
def get_context_data(self, **kwargs):
for job_id in json.loads(self.request.POST.get('jobs', '[]')):
try:
job = Job.objects.get(id=int(job_id))
except ObjectDoesNotExist:
raise BridgeException(code=405)
if not jobs.utils.JobAccess(self.request.user, job).can_download():
raise BridgeException(code=401)
return {}
def get_view(self, view_type):
if not hasattr(self, 'request'):
raise BridgeException()
request = getattr(self, 'request')
if view_type not in VIEW_TYPES:
raise BridgeException()
return ViewData(
request.user, view_type,
request.POST if request.method == 'POST' else request.GET)
def __get_verdicts(self, verdict):
m = re.match(r'^(\d)_(\d)$', verdict)
if m is None:
raise BridgeException()
v1 = m.group(1)
v2 = m.group(2)
if any(v not in list(x[0] for x in COMPARE_VERDICT) for v in [v1, v2]):
raise BridgeException()
return v1, v2
def post(self, *args, **kwargs):
self.is_not_used(*args, **kwargs)
self.object = self.get_object()
try:
return self.render_to_response(self.get_context_data(object=self.object))
except BridgeException as e:
raise BridgeException(e, back=reverse('jobs:prepare_run', args=[self.object.pk]))
except Exception as e:
logger.exception(e)
raise BridgeException(back=reverse('jobs:prepare_run', args=[self.object.pk]))
def get_context_data(self, **kwargs):
if self.request.user.extended.role != USER_ROLES[2][0]:
raise BridgeException(_("You don't have an access to upload jobs tree"))
if Job.objects.filter(status__in=[JOB_STATUS[1][0], JOB_STATUS[2][0]]).count() > 0:
raise BridgeException(_("There are jobs in progress right now, uploading may corrupt it results. "
"Please wait until it will be finished."))
jobs_dir = extract_archive(self.request.FILES['file'])
UploadTree(self.request.POST['parent_id'], self.request.user, jobs_dir.name)
return {}
def post(self, *args, **kwargs):
self.is_not_used(*args, **kwargs)
try:
return JsonResponse({'job_id': JobForm(self.request.user, self.get_object(),
self.kwargs['action']).save(self.request.POST).id})
except BridgeException as e:
raise BridgeException(str(e), response_type='json')
except Exception as e:
logger.exception(e)
raise BridgeException(response_type='json')
def get_context_data(self, **kwargs):
try:
job1 = Job.objects.get(id=self.kwargs['job1_id'])
job2 = Job.objects.get(id=self.kwargs['job2_id'])
except ObjectDoesNotExist:
raise BridgeException(code=405)
if not jobs.utils.JobAccess(self.request.user, job1).can_view() \
or not jobs.utils.JobAccess(self.request.user, job2).can_view():
raise BridgeException(code=401)
return {'job1': job1, 'job2': job2, 'data': jobs.utils.CompareFileSet(job1, job2).data}
def __check_name(self, name):
if len(name) == 0:
raise BridgeException(_('The job name is required'))
try:
job = Job.objects.get(name=name)
except ObjectDoesNotExist:
return name
if not self._copy and job.id == self._job.id:
return name
raise BridgeException(_('The job name is already used'))
def save(self, data):
if self._copy:
if not JobAccess(self._user).can_create():
raise BridgeException(_("You don't have an access to create new jobs"))
self.__create_job(data)
else:
if not JobAccess(self._user, self._job).can_edit():
raise BridgeException(_("You don't have an access to edit this job"))
self.__update_job(data)
return self._job
def get_job_by_name_or_id(name_or_id):
try:
return Job.objects.get(name=name_or_id)
except ObjectDoesNotExist:
found_jobs = Job.objects.filter(identifier__startswith=name_or_id)
if len(found_jobs) == 0:
raise BridgeException(_('The job with specified identifier or name was not found'))
elif len(found_jobs) > 1:
raise BridgeException(_('Several jobs match the specified identifier, '
'please increase the length of the job identifier'))
return found_jobs[0]
