def post(self, testcase):
"""Server crash stats."""
end = helpers.cast(request.get('end'), int, "'end' is not an int.")
days = helpers.cast(request.get('days'), int, "'days' is not an int.")
group_by = helpers.cast(request.get('groupBy'), str,
"'groupBy' is not a string.")
block = helpers.cast(request.get('block'), str,
"'block' is not a string.")
return self.render_json(
get_result(testcase, end, block, days, group_by))
def get_result():
"""Get the result for the crash stats page."""
params = dict(request.iterparams())
params['type'] = params.get('type', 'regression')
page = helpers.cast(request.get('page') or 1, int, "'page' is not an int.")
is_revision_empty = 'revision' not in params
query = big_query_query.Query()
crash_access.add_scope(query, params, 'security_flag', 'job_type',
'fuzzer_name')
if is_revision_empty:
total_count = 0
rows = []
else:
filters.add(query, params, FILTERS)
rows, total_count = get(
params=params,
query=query,
offset=(page - 1) * PAGE_SIZE,
limit=PAGE_SIZE)
helpers.log('Regression', helpers.VIEW_OPERATION)
result = {
'totalPages': (total_count // PAGE_SIZE) + 1,
'page': page,
'pageSize': PAGE_SIZE,
'items': rows,
'totalCount': total_count,
'isRevisionEmpty': is_revision_empty
}
return result, params
def add(self, query, params):
"""Add group filter."""
value = params.get(self.param_key, '')
if filters.is_empty(value):
query.filter('is_leader', True)
return
query.filter('group_id', helpers.cast(value, int, "'group' must be int."))
def wrapper(self):
"""Wrapper."""
testcase_id = helpers.cast(self.request.get('testcaseId'), int,
"The param 'testcaseId' is not a number.")
testcase = access.check_access_and_get_testcase(testcase_id)
return func(self, testcase)
def add(self, query, params):
"""Set query according to revision and type params."""
if not params.get('revision'):
raise helpers.EarlyExitException('Please specify the revision.', 400)
prefix = params['type']
revision = helpers.cast(params['revision'], int,
"'revision' must be an integer")
query.raw_filter('{prefix}_range_start < {revision} AND '
'{revision} <= {prefix}_range_end'.format(
revision=json.dumps(revision), prefix=prefix))
def add(self, query, params):
"""Set query according to end and hours params."""
if 'end' in params:
end = helpers.cast(params['end'], int, "'end' must be an integer")
else:
end = crash_stats_common.get_max_hour()
block = params.get('block', 'day')
if 'days' in params:
days = helpers.cast(params['days'], int, "'days' must be an integer")
else:
days = (
DEFAULT_DAYS_FOR_BY_HOURS
if block == 'hour' else DEFAULT_DAYS_FOR_BY_DAYS)
params['end'] = str(end)
params['days'] = str(days)
params['block'] = str(block)
query.set_time_params(end, days, block)
def get_result(this):
"""Get the result."""
params = {k: v for k, v in this.request.iterparams()}
page = helpers.cast(
this.request.get('page') or 1, int, "'page' is not an int.")
query = datastore_query.Query(data_types.TestcaseUploadMetadata)
query.order('timestamp', is_desc=True)
if not access.has_access(need_privileged_access=True):
query.filter('uploader_email', helpers.get_user_email())
params['permission'] = {'uploaderEmail': helpers.get_user_email()}
entities, total_pages, total_items, has_more = query.fetch_page(
page=page, page_size=PAGE_SIZE, projection=None, more_limit=MORE_LIMIT)
items = []
for entity in entities:
items.append({
'timestamp':
utils.utc_datetime_to_timestamp(entity.timestamp),
'testcaseId':
entity.testcase_id,
'uploaderEmail':
entity.uploader_email,
'filename':
entity.filename,
'bundled':
entity.bundled,
'pathInArchive':
entity.path_in_archive,
'status':
entity.status
})
attach_testcases(items)
result = {
'hasMore': has_more,
'items': items,
'page': page,
'pageSize': PAGE_SIZE,
'totalItems': total_items,
'totalPages': total_pages,
}
return result, params
def get_result(this):
"""Get the result."""
params = {k: v for k, v in this.request.iterparams()}
page = helpers.cast(
this.request.get("page") or 1, int, "'page' is not an int.")
query = datastore_query.Query(data_types.TestcaseUploadMetadata)
query.order("timestamp", is_desc=True)
if not access.has_access(need_privileged_access=True):
query.filter("uploader_email", helpers.get_user_email())
params["permission"] = {"uploaderEmail": helpers.get_user_email()}
entities, total_pages, total_items, has_more = query.fetch_page(
page=page, page_size=PAGE_SIZE, projection=None, more_limit=MORE_LIMIT)
items = []
for entity in entities:
items.append({
"timestamp":
utils.utc_datetime_to_timestamp(entity.timestamp),
"testcaseId":
entity.testcase_id,
"uploaderEmail":
entity.uploader_email,
"filename":
entity.filename,
"bundled":
entity.bundled,
"pathInArchive":
entity.path_in_archive,
"status":
entity.status,
})
attach_testcases(items)
result = {
"hasMore": has_more,
"items": items,
"page": page,
"pageSize": PAGE_SIZE,
"totalItems": total_items,
"totalPages": total_pages,
}
return result, params
def get_result():
"""Get the result for the crash stats page."""
params = dict(request.iterparams())
page = helpers.cast(request.get('page') or 1, int, "'page' is not an int.")
group_by = params.get('group', 'platform')
params['group'] = group_by
sort_by = params.get('sort', 'total_count')
params['sort'] = sort_by
params['number'] = params.get('number', 'count')
# Conditions for individual records.
query = crash_stats.Query()
query.group_by = group_by
query.sort_by = sort_by
crash_access.add_scope(query, params, 'security_flag', 'job_type',
'fuzzer_name')
filters.add(query, params, FILTERS)
# Conditions after grouping.
group_query = crash_stats.Query()
filters.add(group_query, params, GROUP_FILTERS)
try:
total_count, rows = crash_stats.get(
query=query,
group_query=group_query,
offset=(page - 1) * PAGE_SIZE,
limit=PAGE_SIZE)
except ValueError:
raise helpers.EarlyExitException('Invalid filters', 400)
attach_testcases(rows)
helpers.log('CrashStats', helpers.VIEW_OPERATION)
result = {
'totalPages': (total_count // PAGE_SIZE) + 1,
'page': page,
'pageSize': PAGE_SIZE,
'items': rows,
'totalCount': total_count
}
return result, params
def update_issue(testcase, issue_id, needs_summary_update):
"""Associate (or update) an existing issue with the testcase."""
issue_id = helpers.cast(issue_id, int,
'Issue ID (%s) is not a number!' % issue_id)
issue_tracker = helpers.get_issue_tracker_for_testcase(testcase)
issue = helpers.get_or_exit(
lambda: issue_tracker.get_issue(issue_id),
'Issue (id=%d) is not found!' % issue_id,
'Failed to get the issue (id=%s).' % issue_id, Exception)
if not issue.is_open:
raise helpers.EarlyExitException(
('The issue (%d) is already closed and further updates are not'
' allowed. Please file a new issue instead!') % issue_id, 400)
if not testcase.is_crash():
raise helpers.EarlyExitException(
'This is not a crash testcase, so issue update is not applicable.',
400)
issue_comment = data_handler.get_issue_description(
testcase, helpers.get_user_email())
if needs_summary_update:
issue.title = data_handler.get_issue_summary(testcase)
policy = issue_tracker_policy.get(issue_tracker.project)
properties = policy.get_existing_issue_properties()
for label in properties.labels:
for result in issue_filer.apply_substitutions(
policy, label, testcase):
issue.labels.add(result)
issue.save(new_comment=issue_comment)
testcase.bug_information = str(issue_id)
testcase.put()
data_handler.update_group_bug(testcase.group_id)
helpers.log('Updated issue %sd' % issue_id, helpers.MODIFY_OPERATION)
def update_issue(testcase, issue_id, needs_summary_update):
"""Associate (or update) an existing issue with the testcase."""
issue_id = helpers.cast(issue_id, int,
'Issue ID (%s) is not a number!' % issue_id)
itm = helpers.get_issue_tracker_manager(testcase)
issue = helpers.get_or_exit(
lambda: itm.get_issue(issue_id),
'Issue (id=%d) is not found!' % issue_id,
'Failed to get the issue (id=%s).' % issue_id, Exception)
if not issue.open:
raise helpers.EarlyExitException(
('The issue (%d) is already closed and further updates are not'
' allowed. Please file a new issue instead!') % issue_id, 400)
# Create issue parameters.
issue.comment = data_handler.get_issue_description(
testcase, helpers.get_user_email())
issue_summary = data_handler.get_issue_summary(testcase)
# NULL states leads to unhelpful summaries, so do not update in that case.
if needs_summary_update and testcase.crash_state != 'NULL':
issue.summary = issue_summary
# Add label on memory tool used.
issue_filer.add_memory_tool_label_if_needed(issue, testcase)
# Add view restrictions for internal job types.
issue_filer.add_view_restrictions_if_needed(issue, testcase)
# Don't enforce security severity label on an existing issue.
itm.save(issue)
testcase.bug_information = str(issue_id)
testcase.put()
data_handler.update_group_bug(testcase.group_id)
helpers.log('Updated issue %sd' % issue_id, helpers.MODIFY_OPERATION)
def create_issue(testcase, severity, cc_me):
"""Create an issue."""
issue_tracker = helpers.get_issue_tracker_for_testcase(testcase)
user_email = helpers.get_user_email()
if severity is not None:
severity = helpers.cast(
severity, int, 'Invalid value for security severity (%s).' % severity)
additional_ccs = []
if cc_me == 'true':
additional_ccs.append(user_email)
issue_id = issue_filer.file_issue(
testcase,
issue_tracker,
security_severity=severity,
user_email=user_email,
additional_ccs=additional_ccs)
if not issue_id:
raise helpers.EarlyExitException('Unable to create new issue.', 500)
def get_results(this):
"""Get results for the jobs page."""
# Return jobs sorted alphabetically by name
query = datastore_query.Query(data_types.Job)
query.order('name', is_desc=False)
params = dict(this.request.iterparams())
filters.add(query, params, FILTERS)
page = helpers.cast(
this.request.get('page') or 1, int, "'page' is not an int.")
items, total_pages, total_items, has_more = query.fetch_page(
page=page, page_size=PAGE_SIZE, projection=None, more_limit=MORE_LIMIT)
result = {
'hasMore': has_more,
'items': [_job_to_dict(item) for item in items],
'page': page,
'pageSize': PAGE_SIZE,
'totalItems': total_items,
'totalPages': total_pages,
}
return result, params
def get_results():
"""Get results for the bots page."""
# Return bots sorted alphabetically by bot_name
query = datastore_query.Query(data_types.Heartbeat)
query.order('bot_name', is_desc=False)
params = dict(request.iterparams())
filters.add(query, params, FILTERS)
page = helpers.cast(request.get('page', 1), int, "'page' is not an int.")
items, total_pages, total_items, has_more = query.fetch_page(
page=page, page_size=PAGE_SIZE, projection=None, more_limit=MORE_LIMIT)
items = _convert_heartbeats_to_dicts(items)
helpers.log('Bots', helpers.VIEW_OPERATION)
result = {
'hasMore': has_more,
'items': items,
'page': page,
'pageSize': PAGE_SIZE,
'totalItems': total_items,
'totalPages': total_pages,
}
return result, params
def get_result(this):
"""Get the result for the testcase list page."""
params = {k: v for k, v in this.request.iterparams()}
page = helpers.cast(
this.request.get('page') or 1, int, "'page' is not an int.")
query = datastore_query.Query(data_types.Testcase)
crash_access.add_scope(query, params, 'security_flag', 'job_type',
'fuzzer_name_indices')
add_filters(query, params)
testcases, total_pages, total_items, has_more = query.fetch_page(
page=page,
page_size=PAGE_SIZE,
projection=FIELDS,
more_limit=MORE_LIMIT)
items = []
for testcase in testcases:
regression_range = ''
fixed_range = ''
if testcase.regression and testcase.regression != 'NA':
regression_range = testcase.regression
if testcase.fixed and testcase.fixed != 'NA':
fixed_range = testcase.fixed
item = {
'id': testcase.key.id(),
'crashType': ' '.join(testcase.crash_type.splitlines()),
'crashStateLines': testcase.crash_state.strip().splitlines(),
'jobType': testcase.job_type,
'isClosed': not testcase.open,
'isFixed': testcase.fixed and testcase.fixed != 'NA',
'isReproducible': not testcase.one_time_crasher_flag,
'isSecurity': testcase.security_flag,
'isImpactSet': testcase.is_impact_set_flag,
'impacts': {
'stable': testcase.impact_stable_version,
'beta': testcase.impact_beta_version,
},
'regressionRange': regression_range,
'fixedRange': fixed_range,
'groupId': testcase.group_id,
'projectName': testcase.project_name,
'platform': testcase.platform,
'issueId': testcase.bug_information
or testcase.group_bug_information,
'showImpacts': testcase.has_impacts(),
'impactsProduction': testcase.impacts_production()
}
if testcase.timestamp:
item['timestamp'] = utils.utc_datetime_to_timestamp(
testcase.timestamp)
items.append(item)
helpers.log('Testcases', helpers.VIEW_OPERATION)
result = {
'hasMore': has_more,
'items': items,
'page': page,
'pageSize': PAGE_SIZE,
'totalItems': total_items,
'totalPages': total_pages,
}
return result, params
