def pt_update(self, json_data, file_data=None):
j = PTJson(json_data,
obj_name="artifact json",
exception_type=SuspiciousOperation)
try:
self.description = j.get_str('description',
defval=self.description)
self.ttl_days = j.get_int('ttl_days', defval=self.ttl_days)
self.uploaded_dt = timezone.now()
self.filename = j.get_str('filename',
defval=self.filename,
require=False if self.filename else True)
self.mime = j.get_str('mime', defval=self.mime)
self.expires_dt = timezone.now() + timedelta(days=self.ttl_days)
self.inline = j.get_bool('inline', defval=self.inline)
self.compression = j.get_bool('compression',
defval=self.compression)
linked_uuids = j.get_list('linked_uuids', [])
unlinked_uuids = j.get_list('unlinked_uuids', [])
except SuspiciousOperation as e:
return pt_rest_bad_req(str(e))
if not self.mime:
self.mime = mimetypes.guess_type(self.filename)[0]
if not self.mime:
self.mime = 'application/octet-stream'
if file_data:
data = file_data.get('file', None)
if data is None:
return pt_rest_bad_req("can't get file data")
ret = self._pt_save_file(data.read())
if ret is not None:
return ret
for uuid in linked_uuids:
if not pt_is_valid_uuid(uuid):
return pt_rest_bad_req(
"trying to link resource with invalid UUID format: %s" %
uuid)
for uuid in unlinked_uuids:
if not pt_is_valid_uuid(uuid):
return pt_rest_bad_req(
"trying to unlink resource with invalid UUID format: %s" %
uuid)
exists = self.id
self.save()
for uuid in linked_uuids:
try:
al = ArtifactLinkModel.objects.get(artifact=self,
linked_uuid=uuid)
if al.deleted:
al.deleted = False
al.save()
continue
except ArtifactLinkModel.DoesNotExist as e:
al = ArtifactLinkModel(artifact=self, linked_uuid=uuid)
al.save()
for uuid in unlinked_uuids:
try:
al = ArtifactLinkModel.objects.get(artifact=self,
linked_uuid=uuid)
except ArtifactLinkModel.DoesNotExist as e:
continue
al.deleted = True
al.save()
return pt_rest_ok(message="Artifact has been %s, uuid: %s" %
("updated" if exists else "created", self.uuid),
uuid=self.uuid)
def pt_update(self, job, json_data, validate_only=False):
j = PTJson(json_data, obj_name="test json", exception_type=SuspiciousOperation)
if 'seq_num' in json_data:
self.seq_num = json_data['seq_num']
if not self.seq_num:
self.seq_num = 0
self.tag = j.get_str('tag', require=True)
j.obj_name = self.tag
self.binary = j.get_str('binary')
self.cmdline = j.get_str('cmdline')
self.description = j.get_str('description')
scores = j.get_list('scores', require=True)
deviations = j.get_list('deviations')
self.scores = str(scores)
self.deviations = str(deviations) if deviations else str([0] * len(scores))
self.category = j.get_str('category')
self.metrics = j.get_str('metrics', 'loops/sec')
self.links = json.dumps(j.get_dict('links'))
self.attribs = json.dumps(j.get_dict('attribs'))
self.less_better = j.get_bool('less_better')
self.begin = j.get_datetime('begin')
self.end = j.get_datetime('end')
self.status = j.get_str('status', "SUCCESS")
if self.status not in TEST_STATUSES:
raise SuspiciousOperation("invalid 'status' value '%s', must be one of: %s" % (self.status, str(TEST_STATUSES)))
e = j.get('errors', 0)
if type(e) is int:
self.errors = e
else:
self.errors = len(j.get_list('errors'))
w = j.get('warnings', 0)
if type(w) is int:
self.warnings = w
else:
self.warnings = len(j.get_list('warnings'))
dur_sec = j.get_float('duration_sec', 0)
self.duration = timedelta(seconds=int(dur_sec)) if dur_sec else self.end - self.begin
self.job = job
self.group = j.get_str('group')
TestGroupModel.pt_get_by_tag(self.group) # ensure appropriate TestGroupModel object exists
self.samples = j.get_int('samples', len(scores))
self.avg_score = numpy.mean(scores)
self.min_score = min(scores)
self.max_score = max(scores)
self.avg_dev = numpy.mean(deviations) if deviations else numpy.std(scores)
self.min_dev = min(deviations) if deviations else self.avg_dev
self.max_dev = max(deviations) if deviations else self.avg_dev
self.avg_plusmin = int(round(100 * abs(self.avg_dev / self.avg_score))) if self.avg_score else 0
self.min_plusmin = int(round(100 * abs(self.min_dev / self.min_score))) if self.min_score else 0
self.max_plusmin = int(round(100 * abs(self.max_dev / self.max_score))) if self.max_score else 0
if self.begin and (self.begin.tzinfo is None or self.begin.tzinfo.utcoffset(self.begin) is None):
raise SuspiciousOperation("'begin' datetime object must include timezone: %s" % str(self.begin))
if self.end and (self.end.tzinfo is None or self.end.tzinfo.utcoffset(self.end) is None):
raise SuspiciousOperation("'end' datetime object must include timezone: %s" % str(self.end))
if not validate_only:
try:
obj = TestModel.objects.get(uuid=self.uuid)
except TestModel.DoesNotExist:
obj = None
if obj is None or not self.pt_is_equal_to(obj):
self.save()