def Create(cls, luci_project, luci_bucket, luci_builder, build_id,
gitiles_host, gitiles_project, gitiles_ref,
last_passed_gitiles_id, last_passed_commit_position,
first_failed_gitiles_id, first_failed_commit_position,
rerun_builder_id, test_failure_keys):
instance = super(TestFailureAnalysis, cls).Create(build_id)
last_passed_commit = GitilesCommit(
gitiles_host=gitiles_host,
gitiles_project=gitiles_project,
gitiles_ref=gitiles_ref,
gitiles_id=last_passed_gitiles_id,
commit_position=last_passed_commit_position)
first_failed_commit = GitilesCommit(
gitiles_host=gitiles_host,
gitiles_project=gitiles_project,
gitiles_ref=gitiles_ref,
gitiles_id=first_failed_gitiles_id,
commit_position=first_failed_commit_position)
instance.builder_id = '{}/{}/{}'.format(luci_project, luci_bucket,
luci_builder)
instance.build_id = build_id
instance.last_passed_commit = last_passed_commit
instance.first_failed_commit = first_failed_commit
instance.rerun_builder_id = rerun_builder_id
instance.test_failure_keys = test_failure_keys
return instance
def Create(cls, luci_project, luci_bucket, build_id, gitiles_host,
gitiles_project, gitiles_ref, last_passed_gitiles_id,
last_passed_commit_position, first_failed_gitiles_id,
first_failed_commit_position): # pragma: no cover.
"""Creates an entity for a failure group.
Args:
build_id (str): Id of the first build when creating the group.
"""
last_passed_commit = GitilesCommit(
gitiles_host=gitiles_host,
gitiles_project=gitiles_project,
gitiles_ref=gitiles_ref,
gitiles_id=last_passed_gitiles_id,
commit_position=last_passed_commit_position)
first_failed_commit = GitilesCommit(
gitiles_host=gitiles_host,
gitiles_project=gitiles_project,
gitiles_ref=gitiles_ref,
gitiles_id=first_failed_gitiles_id,
commit_position=first_failed_commit_position)
return cls(
luci_project=luci_project,
bucket_id='{}/{}'.format(luci_project, luci_bucket),
last_passed_commit=last_passed_commit,
first_failed_commit=first_failed_commit,
id=build_id)
def _CreateCompileRerunBuild(self, commit_position=6000002):
rerun_commit = GitilesCommit(
gitiles_host=self.context.gitiles_host,
gitiles_project=self.context.gitiles_project,
gitiles_ref=self.context.gitiles_ref,
gitiles_id=str(commit_position),
commit_position=commit_position)
rerun_builder = BuilderID(project='chromium',
bucket='findit',
builder='findit-variables')
rerun_build = CompileRerunBuild.Create(
luci_project=rerun_builder.project,
luci_bucket=rerun_builder.bucket,
luci_builder=rerun_builder.builder,
build_id=8000000000789,
legacy_build_number=60789,
gitiles_host=rerun_commit.gitiles_host,
gitiles_project=rerun_commit.gitiles_project,
gitiles_ref=rerun_commit.gitiles_ref,
gitiles_id=rerun_commit.gitiles_id,
commit_position=rerun_commit.commit_position,
status=1,
create_time=datetime(2019, 3, 28),
parent_key=self.analysis.key)
rerun_build.put()
return rerun_build
def testLuciRerunBuildSearch(self):
build_id = 1234567890
commit_position = 65432
commit = GitilesCommit(gitiles_host='chromium.googlesource.com',
gitiles_project='chromium/src',
gitiles_ref='refs/heads/master',
gitiles_id='git_hash',
commit_position=commit_position)
analysis = self._CreateCompileFailureAnalysis()
self._CreateCompileRerunBuild(build_id, commit_position, analysis.key)
rerun_builds = CompileRerunBuild.SearchBuildOnCommit(
analysis.key, commit)
self.assertEqual(1, len(rerun_builds))
self.assertEqual(build_id, rerun_builds[0].build_id)
def BisectGitilesCommit(context, left_bound_commit, right_bound_commit,
commit_position_to_git_hash_map):
"""Uses bisection to get the gitiles to check.
Args:
context (findit_v2.services.context.Context): Scope of the analysis.
left_bound_commit (GitilesCommit): left bound of the regression range, not
included. It should be the last passed commit found so far.
right_bound_commit (GitilesCommit): right bound of the regression range,
included. It should be the first failed commit found so far.
commit_position_to_git_hash_map (dict): A map of commit_positions to
git_hashes.
Return:
(GitilesCommit, GitilesCommit): Commit to bisect next, or the culprit
commit. If the next commit is identified, there will be no culprit
commit and vice versa.
"""
assert left_bound_commit and right_bound_commit, (
'Requiring two bounds to determine a bisecting commit')
left_commit_position = left_bound_commit.commit_position
right_commit_position = right_bound_commit.commit_position
assert left_commit_position <= right_commit_position, (
'left bound commit is after right.')
if right_commit_position == left_commit_position + 1:
# Cannot further divide the regression range, culprit is the
# ight_bound_commit.
return None, right_bound_commit
bisect_commit_position = left_commit_position + (right_commit_position -
left_commit_position) / 2
bisect_commit_gitiles_id = commit_position_to_git_hash_map.get(
bisect_commit_position) if commit_position_to_git_hash_map else None
if not bisect_commit_gitiles_id:
logging.error('Failed to get git_hash for change %s/%s/%s/%d',
context.gitiles_host, context.gitiles_project,
context.gitiles_ref, bisect_commit_position)
return None, None
return GitilesCommit(gitiles_host=context.gitiles_host,
gitiles_project=context.gitiles_project,
gitiles_ref=context.gitiles_ref,
gitiles_id=bisect_commit_gitiles_id,
commit_position=bisect_commit_position), None
def Create(cls,
luci_project,
luci_bucket,
luci_builder,
build_id,
legacy_build_number,
gitiles_host,
gitiles_project,
gitiles_ref,
gitiles_id,
commit_position,
status,
create_time,
parent_key=None):
gitiles_commit = GitilesCommit(gitiles_host=gitiles_host,
gitiles_project=gitiles_project,
gitiles_ref=gitiles_ref,
gitiles_id=gitiles_id,
commit_position=commit_position)
if parent_key: # pragma: no cover. (tested when testing CompileRerunBuild)
# Rerun builds belong to each analysis, so they need to also set their
# parent.
return cls(luci_project=luci_project,
bucket_id='{}/{}'.format(luci_project, luci_bucket),
builder_id=GetBuilderIdString(luci_project, luci_bucket,
luci_builder),
build_id=build_id,
legacy_build_number=legacy_build_number,
gitiles_commit=gitiles_commit,
create_time=create_time,
status=status,
id=build_id,
parent=parent_key)
return cls(luci_project=luci_project,
bucket_id='{}/{}'.format(luci_project, luci_bucket),
builder_id=GetBuilderIdString(luci_project, luci_bucket,
luci_builder),
build_id=build_id,
legacy_build_number=legacy_build_number,
gitiles_commit=gitiles_commit,
create_time=create_time,
status=status,
id=build_id)
def testTriggerRerunBuildFailedToGetProperty(self, mock_trigger_build, _):
"""This test is for the case where there's already an existing rerun build,
so no new rerun-build should be scheduled."""
rerun_commit = GitilesCommit(
gitiles_host=self.context.gitiles_host,
gitiles_project=self.context.gitiles_project,
gitiles_ref=self.context.gitiles_ref,
gitiles_id='6000002',
commit_position=6000002)
rerun_builder = BuilderID(project='chromium',
bucket='findit',
builder='findit-variables')
output_targets = {'compile': ['a.o']}
compile_failure_rerun_analysis.TriggerRerunBuild(
self.context, self.build_id, self.build, self.analysis.key,
rerun_builder, rerun_commit, output_targets)
self.assertFalse(mock_trigger_build.called)
def testTriggerRerunBuild(self, mock_trigger_build, _):
new_build_id = 800000024324
new_build = Build(id=new_build_id, number=300)
new_build.status = common_pb2.SCHEDULED
new_build.create_time.FromDatetime(datetime(2019, 4, 20))
rerun_builder = BuilderID(project='chromium',
bucket='findit',
builder='findit-variables')
rerun_commit = GitilesCommit(
gitiles_host=self.context.gitiles_host,
gitiles_project=self.context.gitiles_project,
gitiles_ref=self.context.gitiles_ref,
gitiles_id='6000002',
commit_position=6000002)
output_targets = {'compile': ['a.o']}
mock_trigger_build.return_value = new_build
compile_failure_rerun_analysis.TriggerRerunBuild(
self.context, self.build_id, self.build, self.analysis.key,
rerun_builder, rerun_commit, output_targets)
rerun_build = CompileRerunBuild.get_by_id(new_build_id,
parent=self.analysis.key)
self.assertIsNotNone(rerun_build)
mock_trigger_build.assert_called_once_with(
rerun_builder,
common_pb2.GitilesCommit(project=rerun_commit.gitiles_project,
host=rerun_commit.gitiles_host,
ref=rerun_commit.gitiles_ref,
id=rerun_commit.gitiles_id),
{'recipe': 'compile'},
tags=[{
'value': 'compile-failure-culprit-finding',
'key': 'purpose'
}, {
'value': str(self.build.id),
'key': 'analyzed_build_id'
}])
def testEntitiesCreation(self, _):
group = self.analysis_api._CreateFailureGroup(
self.context, self.build, [self.compile_failure.key], '122', 122,
123)
group.put()
groups = CompileFailureGroup.query().fetch()
self.assertEqual(1, len(groups))
self.assertEqual(self.build_id, groups[0].key.id())
analysis = self.analysis_api._CreateFailureAnalysis(
'chromium', self.context, self.build, 'git_sha_122', 122, 123,
'preject/bucket/builder', [self.compile_failure.key])
analysis.Save()
analysis = self.analysis_api._GetFailureAnalysis(self.build_id)
self.assertIsNotNone(analysis)
self.assertEqual(self.build_id, analysis.build_id)
self.assertEqual([self.compile_failure],
self.analysis_api._GetFailuresInAnalysis(analysis))
rerun_commit = GitilesCommit(
gitiles_host=self.context.gitiles_host,
gitiles_project=self.context.gitiles_project,
gitiles_ref=self.context.gitiles_ref,
gitiles_id=self.context.gitiles_id,
commit_position=123)
rerun_build_id = 8000000000050
self.analysis_api._CreateRerunBuild(self.rerun_builder,
Build(id=rerun_build_id),
rerun_commit, analysis.key).put()
all_rerun_builds = self.analysis_api._FetchRerunBuildsOfAnalysis(
analysis)
self.assertEqual(1, len(all_rerun_builds))
self.assertEqual(rerun_build_id, all_rerun_builds[0].build_id)
existing_rerun_builds = self.analysis_api._GetExistingRerunBuild(
analysis.key, rerun_commit)
self.assertEqual(1, len(existing_rerun_builds))
self.assertEqual(rerun_build_id, existing_rerun_builds[0].build_id)
def _CreateGitilesCommit(self, gitiles_id, commit_position):
return GitilesCommit(gitiles_host=self.gitiles_host,
gitiles_project=self.gitiles_project,
gitiles_ref=self.gitiles_ref,
gitiles_id=gitiles_id,
commit_position=commit_position)
