"""

mandatory_data = [

'commitid',

'branch',

'project',

'executable',

'benchmark',

'environment',

'result_value',

]

error = True

for key in mandatory_data:

if key not in item:

return 'Key "' + key + '" missing from request', error

elif key in item and item[key] == "":

return 'Value for key "' + key + '" empty in request', error

# 'source' is optional: uploaders that predate it (pyperformance on

# speed.python.org) get the 'legacy' default.

if 'source' in item and item['source'] not in dict(Benchmark.S_TYPES):

return 'Invalid source "%s"' % item['source'], error

try:

result_value = float(item['result_value'])

except (TypeError, ValueError):

return 'Value for key "result_value" is not a number', error

if result_value >= SENTINEL_THRESHOLD:

return ('Result value %s rejected: at or above the failed-run '

'sentinel threshold (%s)' % (

item['result_value'], SENTINEL_THRESHOLD), error)

# Check that the Environment exists

try:

e = Environment.objects.get(name=item['environment'])

error = False

return e, error

except Environment.DoesNotExist:

res, error = validate_result(data)

if error:

return res, True

else:

assert isinstance(res, Environment)

env = res

p, created = Project.objects.get_or_create(name=data["project"])

branch, created = Branch.objects.get_or_create(name=data["branch"],

project=p)

b, created = Benchmark.objects.get_or_create(

name=data["benchmark"], source=data.get("source", "legacy"))

if created:

if "description" in data:

b.description = data["description"]

if "units" in data:

b.units = data["units"]

if "units_title" in data:

b.units_title = data["units_title"]

if "lessisbetter" in data:

b.lessisbetter = data["lessisbetter"]

b.full_clean()

b.save()

try:

rev = branch.revisions.get(commitid=data['commitid'].split(":")[-1])

except Revision.DoesNotExist:

commitid = data['commitid'].split(':')[-1]

conflict = Revision.objects.filter(

commitid=commitid, branch__project=p

).exclude(branch=branch).first()

if conflict:

return (

"Revision %s already exists on branch '%s'; "

"refusing to add it to branch '%s'" % (

commitid, conflict.branch.name, data['branch'])

), True

rev_date = data.get("revision_date")

# "None" (as string) can happen when we urlencode the POST data

if not rev_date or rev_date in ["", "None"]:

rev_date = datetime.today()

# Only take the hash of a mercurial nnn:xxxhash commitid

rev = Revision(branch=branch, project=p,

commitid=commitid,

date=rev_date)

try:

rev.full_clean()

except ValidationError as e:

return str(e), True

if p.repo_type not in ("N", ""):

try:

commit_logs = commits.get_logs(rev, rev, update=update_repo)

except commits.exceptions.CommitLogError as e:

logger.warning("unable to save revision %s info: %s", rev, e,

exc_info=True)

else:

if commit_logs:

log = commit_logs[0]

rev.author = log['author']

rev.date = log['date']

rev.message = log['message']

rev.tag = log['tag']

rev.save()

exe, created = Executable.objects.get_or_create(

name=data['executable'],

project=p

)

try:

r = Result.objects.get(

revision=rev, executable=exe, benchmark=b, environment=env)

except Result.DoesNotExist:

r = Result(revision=rev, executable=exe, benchmark=b, environment=env)

r.value = data["result_value"]

if 'result_date' in data:

r.date = data["result_date"]

elif rev.date:

r.date = rev.date

else:

r.date = datetime.now()

r.std_dev = data.get('std_dev')

r.val_min = data.get('min')

r.val_max = data.get('max')

r.q1 = data.get('q1')

r.q3 = data.get('q3')

r.suite_version = data.get('suite_version', '')

r.full_clean()

r.save()

"""Triggers Report creation when there are enough results"""

if exe.project.track is not True:

return False

last_revs = Revision.objects.filter(

branch=rev.branch

).order_by('-date')[:2]

if len(last_revs) > 1:

current_results = rev.results.filter(executable=exe, environment=e)

last_results = last_revs[1].results.filter(

executable=exe, environment=e)

# If there is are at least as many results as in the last revision,

# create new report

if len(current_results) >= len(last_results):

logger.debug("create_report_if_enough_data: About to create new report")

report, created = Report.objects.get_or_create(

executable=exe, environment=e, revision=rev

)

report.full_clean()

report.save()

logger.debug("Created new report for branch %s and revision %s",