def post(self):
commit = bool(self.request.get('commit'))
delete = bool(self.request.get('delete'))
if commit == delete:
return self._error('Invalid request')
try:
log = ReportLog.get_by_id(int(self.request.get('id', 0)))
except:
return self._error('Invalid log id "%s"' %
self.request.get('id', ''))
if not log:
return self._error('No log found for "%s"' %
self.request.get('id', ''))
if commit:
log.commit = True
log.put()
schedule_report_process(log)
else:
log.delete()
self.response.out.write(
template.render('report_logs.html', {
'logs': ReportLog.all(),
'status': 'OK'
}))
def post(self):
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
log_id = int(self.request.get('id', 0))
log = ReportLog.get_by_id(log_id)
if not log or not log.commit:
self.response.out.write("Not processed")
return
branch = log.branch()
platform = log.platform()
build = Build.get_or_insert_from_log(log)
for test_name, result_value in log.results().iteritems():
test = Test.update_or_insert(test_name, branch, platform)
result = TestResult.get_or_insert_from_parsed_json(test_name, build, result_value)
runs = Runs.get_by_objects(branch, platform, test)
regenerate_runs = True
if runs:
runs.update_incrementally(build, result)
regenerate_runs = False
schedule_runs_update(test.id, branch.id, platform.id, regenerate_runs)
log = ReportLog.get(log.key())
log.delete()
# We need to update dashboard and manifest because they are affected by the existance of test results
schedule_dashboard_update()
schedule_manifest_update()
self.response.out.write('OK')
def test_get_or_insert_from_log(self):
branch, platform, builder = _create_some_builder()
timestamp = datetime.now().replace(microsecond=0)
log = ReportLog(
timestamp=timestamp,
headers='some headers',
payload=
'{"branch": "some-branch", "platform": "some-platform", "builder-name": "some-builder",'
+ '"build-number": 123, "webkit-revision": 456, "timestamp": %d}' %
int(mktime(timestamp.timetuple())))
self.assertThereIsNoInstanceOf(Build)
build = Build.get_or_insert_from_log(log)
self.assertTrue(build)
self.assertEqual(build.branch.key(), branch.key())
self.assertEqual(build.platform.key(), platform.key())
self.assertEqual(build.builder.key(), builder.key())
self.assertEqual(build.buildNumber, 123)
self.assertEqual(build.revision, 456)
self.assertEqual(build.chromiumRevision, None)
self.assertEqual(build.timestamp, timestamp)
self.assertOnlyInstance(build)
def post(self):
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
headers = "\n".join([key + ': ' + value for key, value in self.request.headers.items()])
# Do as best as we can to remove the password
request_body_without_password = re.sub(r'"password"\s*:\s*".+?",', '', self.request.body)
log = ReportLog(timestamp=datetime.now(), headers=headers, payload=request_body_without_password)
log.put()
try:
self._body = json.loads(self.request.body)
except ValueError:
return self._output('Failed to parse the payload as a json. Report key: %d' % log.key().id())
builder = self._modelByKeyNameInBodyOrError(Builder, 'builder-name')
branch = self._modelByKeyNameInBodyOrError(Branch, 'branch')
platform = self._modelByKeyNameInBodyOrError(Platform, 'platform')
buildNumber = self._integerInBody('build-number')
revision = self._integerInBody('revision')
timestamp = self._timestampInBody()
failed = False
if builder and not (self.bypassAuthentication() or builder.authenticate(self._body.get('password', ''))):
self._output('Authentication failed')
failed = True
if not self._resultsAreValid():
self._output("The payload doesn't contain results or results are malformed")
failed = True
if not (builder and branch and platform and buildNumber and revision and timestamp) or failed:
return
build = self._createBuildIfPossible(builder, buildNumber, branch, platform, revision, timestamp)
if not build:
return
for testName, result in self._body['results'].iteritems():
test = self._addTestIfNeeded(testName, branch, platform)
memcache.delete(Test.cacheKey(test.id, branch.id, platform.id))
if isinstance(result, dict):
TestResult(name=testName, build=build, value=float(result.get('avg', 0)), valueMedian=float(result.get('median', 0)),
valueStdev=float(result.get('stdev', 0)), valueMin=float(result.get('min', 0)), valueMax=float(result.get('max', 0))).put()
else:
TestResult(name=testName, build=build, value=float(result)).put()
log = ReportLog.get(log.key())
log.delete()
# We need to update dashboard and manifest because they are affected by the existance of test results
memcache.delete('dashboard')
memcache.delete('manifest')
return self._output('OK')
def post(self):
commit = bool(self.request.get('commit'))
delete = bool(self.request.get('delete'))
if commit == delete:
return self._error('Invalid request')
try:
log = ReportLog.get_by_id(int(self.request.get('id', 0)))
except:
return self._error('Invalid log id "%s"' % self.request.get('id', ''))
if not log:
return self._error('No log found for "%s"' % self.request.get('id', ''))
if commit:
log.commit = True
log.put()
schedule_report_process(log)
else:
log.delete()
self.response.out.write(template.render('report_logs.html', {'logs': ReportLog.all(), 'status': 'OK'}))
def post(self):
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
logs = ReportLog.all()
limit = 50
count = 0
for log in logs.fetch(limit):
log.commit = True
log.put()
schedule_report_process(log)
count += 1
if count == limit:
schedule_commit_all()
self.response.out.write('OK')
def post(self):
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
log_id = int(self.request.get('id', 0))
log = ReportLog.get_by_id(log_id)
if not log or not log.commit:
self.response.out.write("Not processed")
return
branch = log.branch()
platform = log.platform()
build = Build.get_or_insert_from_log(log)
for test_name, result_value in log.results().iteritems():
unit = result_value.get('unit') if isinstance(result_value,
dict) else None
test = Test.update_or_insert(test_name, branch, platform, unit)
result = TestResult.get_or_insert_from_parsed_json(
test_name, build, result_value)
if not result:
continue
runs = Runs.get_by_objects(branch, platform, test)
regenerate_runs = True
if runs:
runs.update_incrementally(build, result)
regenerate_runs = False
schedule_runs_update(test.id, branch.id, platform.id,
regenerate_runs)
log = ReportLog.get(log.key())
log.delete()
# We need to update dashboard and manifest because they are affected by the existance of test results
schedule_dashboard_update()
schedule_manifest_update()
self.response.out.write('OK')
def post(self):
commit = bool(self.request.get("commit"))
delete = bool(self.request.get("delete"))
if commit == delete:
return self._error("Invalid request")
try:
log = ReportLog.get_by_id(int(self.request.get("id", 0)))
except:
return self._error('Invalid log id "%s"' % self.request.get("id", ""))
if not log:
return self._error('No log found for "%s"' % self.request.get("id", ""))
if commit:
log.commit = True
log.put()
schedule_report_process(log)
else:
log.delete()
self.response.out.write(
template.render("report_logs.html", {"logs": ReportLog.all().fetch(20), "status": "OK"})
)
def post(self):
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
headers = "\n".join([key + ': ' + value for key, value in self.request.headers.items()])
# Do as best as we can to remove the password
request_body_without_password = re.sub(r',\s*"password"\s*:\s*".+?"', '', self.request.body)
log = ReportLog(timestamp=datetime.now(), headers=headers, payload=request_body_without_password)
log.put()
self._encountered_error = False
try:
parsedPayload = json.loads(self.request.body)
password = parsedPayload.get('password', '')
except ValueError:
return self._output('Failed to parse the payload as a json. Report key: %d' % log.key().id())
builder = log.builder()
builder != None or self._output('No builder named "%s"' % log.get_value('builder-name'))
log.branch() != None or self._output('No branch named "%s"' % log.get_value('branch'))
log.platform() != None or self._output('No platform named "%s"' % log.get_value('platform'))
log.build_number() != None or self._output('Invalid build number "%s"' % log.get_value('build-number'))
log.timestamp() != None or self._output('Invalid timestamp "%s"' % log.get_value('timestamp'))
log.webkit_revision() != None or self._output('Invalid webkit revision "%s"' % log.get_value('webkit-revision'))
failed = False
if builder and not (self.bypass_authentication() or builder.authenticate(password)):
self._output('Authentication failed')
if not log.results_are_well_formed():
self._output("The payload doesn't contain results or results are malformed")
if self._encountered_error:
return
log.commit = True
log.put()
schedule_report_process(log)
self._output("OK")
def get(self):
self.response.out.write(template.render('report_logs.html', {'logs': ReportLog.all()}))
def post(self):
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
headers = "\n".join([
key + ': ' + value for key, value in self.request.headers.items()
])
# Do as best as we can to remove the password
request_body_without_password = re.sub(r',\s*"password"\s*:\s*".+?"',
'', self.request.body)
log = ReportLog(timestamp=datetime.now(),
headers=headers,
payload=request_body_without_password)
log.put()
self._encountered_error = False
try:
parsedPayload = json.loads(self.request.body)
if isinstance(parsedPayload, list):
parsedPayload = parsedPayload[0]
password = parsedPayload.get('password', '')
except:
return self._output(
'Failed to parse the payload as a json. Report key: %d' %
log.key().id())
builder = log.builder()
builder != None or self._output(
'No builder named "%s"' % log.get_value('builder-name'))
log.branch() != None or self._output(
'No branch named "%s"' % log.get_value('branch'))
log.platform() != None or self._output(
'No platform named "%s"' % log.get_value('platform'))
log.build_number() != None or self._output(
'Invalid build number "%s"' % log.get_value('build-number'))
log.timestamp() != None or self._output(
'Invalid timestamp "%s"' % log.get_value('timestamp'))
log.webkit_revision() != None or self._output(
'Invalid webkit revision "%s"' % log.get_value('webkit-revision'))
failed = False
if builder and not (self.bypass_authentication()
or builder.authenticate(password)):
self._output('Authentication failed')
if not log.results_are_well_formed():
self._output(
"The payload doesn't contain results or results are malformed")
if self._encountered_error:
return
log.commit = True
log.put()
schedule_report_process(log)
self._output("OK")
def post(self):
self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'
headers = "\n".join([key + ': ' + value for key, value in self.request.headers.items()])
# Do as best as we can to remove the password
request_body_without_password = re.sub(r'"password"\s*:\s*".+?",', '', self.request.body)
log = ReportLog(timestamp=datetime.now(), headers=headers, payload=request_body_without_password)
log.put()
try:
self._body = json.loads(self.request.body)
except ValueError:
return self._output('Failed to parse the payload as a json. Report key: %d' % log.key().id())
builder = self._model_by_key_name_in_body_or_error(Builder, 'builder-name')
branch = self._model_by_key_name_in_body_or_error(Branch, 'branch')
platform = self._model_by_key_name_in_body_or_error(Platform, 'platform')
build_number = self._integer_in_body('build-number')
timestamp = self._timestamp_in_body()
revision = self._integer_in_body('webkit-revision')
chromium_revision = self._integer_in_body('webkit-revision') if 'chromium-revision' in self._body else None
failed = False
if builder and not (self.bypass_authentication() or builder.authenticate(self._body.get('password', ''))):
self._output('Authentication failed')
failed = True
if not self._results_are_valid():
self._output("The payload doesn't contain results or results are malformed")
failed = True
if not (builder and branch and platform and build_number and revision and timestamp) or failed:
return
build = self._create_build_if_possible(builder, build_number, branch, platform, timestamp, revision, chromium_revision)
if not build:
return
def _float_or_none(dictionary, key):
value = dictionary.get(key)
if value:
return float(value)
return None
for test_name, result in self._body['results'].iteritems():
test = self._add_test_if_needed(test_name, branch, platform)
memcache.delete(Test.cache_key(test.id, branch.id, platform.id))
if isinstance(result, dict):
TestResult(name=test_name, build=build, value=float(result['avg']), valueMedian=_float_or_none(result, 'median'),
valueStdev=_float_or_none(result, 'stdev'), valueMin=_float_or_none(result, 'min'), valueMax=_float_or_none(result, 'max')).put()
else:
TestResult(name=test_name, build=build, value=float(result)).put()
log = ReportLog.get(log.key())
log.delete()
# We need to update dashboard and manifest because they are affected by the existance of test results
memcache.delete('dashboard')
memcache.delete('manifest')
return self._output('OK')
def _create_log_with_payload(self, payload):
return ReportLog(timestamp=datetime.now(), headers='some headers', payload=payload)
def get(self):
self.response.out.write(
template.render('report_logs.html', {'logs': ReportLog.all()}))
def get(self):
self.response.out.write(template.render("report_logs.html", {"logs": ReportLog.all().fetch(20)}))
