def test_rollout_reason(self):
sheriff = Sheriff(MockTool(), MockSheriffBot())
builders = [
Builder("Foo", None),
Builder("Bar", None),
]
reason = "Caused builders Foo and Bar to fail."
self.assertEquals(sheriff._rollout_reason(builders), reason)
def test_post_blame_comment_on_bug(self):
sheriff = Sheriff(MockTool(), MockSheriffBot())
builders = [
Builder("Foo", None),
Builder("Bar", None),
]
commit_info = Mock()
commit_info.bug_id = lambda: None
commit_info.revision = lambda: 4321
commit_info.committer = lambda: None
commit_info.committer_email = lambda: "*****@*****.**"
commit_info.reviewer = lambda: None
commit_info.author = lambda: None
sheriff.post_automatic_rollout_patch(commit_info, builders)
def run():
tool = MockTool()
tool.buildbot.light_tree_on_fire()
sheriff = Sheriff(tool, MockSheriffBot())
revisions_causing_failures = {}
sheriff.provoke_flaky_builders(revisions_causing_failures)
def run():
sheriff = Sheriff(MockTool(), MockSheriffBot())
builders = [
Builder("Foo", None),
Builder("Bar", None),
]
commit_info = Mock()
commit_info.bug_id = lambda: None
commit_info.revision = lambda: 4321
# Should do nothing with no bug_id
sheriff.post_blame_comment_on_bug(commit_info, builders, [])
sheriff.post_blame_comment_on_bug(commit_info, builders, [2468, 5646])
# Should try to post a comment to the bug, but MockTool.bugs does nothing.
commit_info.bug_id = lambda: 1234
sheriff.post_blame_comment_on_bug(commit_info, builders, [])
sheriff.post_blame_comment_on_bug(commit_info, builders, [3432])
sheriff.post_blame_comment_on_bug(commit_info, builders, [841, 5646])
class SheriffBot(AbstractQueue, StepSequenceErrorHandler):
name = "sheriff-bot"
watchers = AbstractQueue.watchers + [
"*****@*****.**",
"*****@*****.**",
]
def _update(self):
self.run_webkit_patch(["update", "--force-clean", "--quiet"])
# AbstractQueue methods
def begin_work_queue(self):
AbstractQueue.begin_work_queue(self)
self._sheriff = Sheriff(self._tool, self)
self._irc_bot = SheriffIRCBot(self._tool, self._sheriff)
self._tool.ensure_irc_connected(self._irc_bot.irc_delegate())
def work_item_log_path(self, failure_map):
return None
def _is_old_failure(self, revision):
return self._tool.status_server.svn_revision(revision)
def next_work_item(self):
self._irc_bot.process_pending_messages()
self._update()
# FIXME: We need to figure out how to provoke_flaky_builders.
failure_map = self._tool.buildbot.failure_map()
failure_map.filter_out_old_failures(self._is_old_failure)
if failure_map.is_empty():
return None
return failure_map
def should_proceed_with_work_item(self, failure_map):
# Currently, we don't have any reasons not to proceed with work items.
return True
def process_work_item(self, failure_map):
failing_revisions = failure_map.failing_revisions()
for revision in failing_revisions:
builders = failure_map.builders_failing_for(revision)
tests = failure_map.tests_failing_for(revision)
try:
commit_info = self._tool.checkout().commit_info_for_revision(revision)
if not commit_info:
print "FAILED to fetch CommitInfo for r%s, likely missing ChangeLog" % revision
continue
self._sheriff.post_irc_warning(commit_info, builders)
self._sheriff.post_blame_comment_on_bug(commit_info, builders, tests)
finally:
for builder in builders:
self._tool.status_server.update_svn_revision(revision, builder.name())
return True
def handle_unexpected_error(self, failure_map, message):
log(message)
# StepSequenceErrorHandler methods
@classmethod
def handle_script_error(cls, tool, state, script_error):
# Ideally we would post some information to IRC about what went wrong
# here, but we don't have the IRC password in the child process.
pass
def begin_work_queue(self):
AbstractQueue.begin_work_queue(self)
self._sheriff = Sheriff(self._tool, self)
self._irc_bot = SheriffIRCBot(self._tool, self._sheriff)
self._tool.ensure_irc_connected(self._irc_bot.irc_delegate())
class SheriffBot(AbstractQueue, StepSequenceErrorHandler):
name = "sheriff-bot"
watchers = AbstractQueue.watchers + [
"*****@*****.**",
"*****@*****.**",
]
def _update(self):
self.run_webkit_patch(["update", "--force-clean", "--quiet"])
# AbstractQueue methods
def begin_work_queue(self):
AbstractQueue.begin_work_queue(self)
self._sheriff = Sheriff(self.tool, self)
self._irc_bot = SheriffIRCBot(self.tool, self._sheriff)
self.tool.ensure_irc_connected(self._irc_bot.irc_delegate())
def work_item_log_path(self, new_failures):
return os.path.join("%s-logs" % self.name, "%s.log" % new_failures.keys()[0])
def _new_failures(self, revisions_causing_failures, old_failing_svn_revisions):
# We ignore failures that might have been caused by svn_revisions that
# we've already complained about. This is conservative in the sense
# that we might be ignoring some new failures, but our experience has
# been that skipping this check causes a lot of spam for builders that
# take a long time to cycle.
old_failing_builder_names = []
for svn_revision in old_failing_svn_revisions:
old_failing_builder_names.extend(
[builder.name() for builder in revisions_causing_failures[svn_revision]])
new_failures = {}
for svn_revision, builders in revisions_causing_failures.items():
if svn_revision in old_failing_svn_revisions:
# FIXME: We should re-process the work item after some time delay.
# https://bugs.webkit.org/show_bug.cgi?id=36581
continue
new_builders = [builder for builder in builders
if builder.name() not in old_failing_builder_names]
if new_builders:
new_failures[svn_revision] = new_builders
return new_failures
def next_work_item(self):
self._irc_bot.process_pending_messages()
self._update()
# We do one read from buildbot to ensure a consistent view.
revisions_causing_failures = self.tool.buildbot.revisions_causing_failures()
# Similarly, we read once from our the status_server.
old_failing_svn_revisions = []
for svn_revision in revisions_causing_failures.keys():
if self.tool.status_server.svn_revision(svn_revision):
old_failing_svn_revisions.append(svn_revision)
new_failures = self._new_failures(revisions_causing_failures,
old_failing_svn_revisions)
self._sheriff.provoke_flaky_builders(revisions_causing_failures)
return new_failures
def should_proceed_with_work_item(self, new_failures):
# Currently, we don't have any reasons not to proceed with work items.
return True
def process_work_item(self, new_failures):
blame_list = new_failures.keys()
for svn_revision, builders in new_failures.items():
try:
commit_info = self.tool.checkout().commit_info_for_revision(svn_revision)
if not commit_info:
print "FAILED to fetch CommitInfo for r%s, likely missing ChangeLog" % revision
continue
self._sheriff.post_irc_warning(commit_info, builders)
self._sheriff.post_blame_comment_on_bug(commit_info,
builders,
blame_list)
self._sheriff.post_automatic_rollout_patch(commit_info,
builders)
finally:
for builder in builders:
self.tool.status_server.update_svn_revision(svn_revision,
builder.name())
return True
def handle_unexpected_error(self, new_failures, message):
log(message)
# StepSequenceErrorHandler methods
@classmethod
def handle_script_error(cls, tool, state, script_error):
# Ideally we would post some information to IRC about what went wrong
# here, but we don't have the IRC password in the child process.
pass
class SheriffBot(AbstractQueue, StepSequenceErrorHandler):
name = "sheriff-bot"
watchers = AbstractQueue.watchers + [
"*****@*****.**",
"*****@*****.**",
]
def _update(self):
self.run_webkit_patch(["update", "--force-clean", "--quiet"])
# AbstractQueue methods
def begin_work_queue(self):
AbstractQueue.begin_work_queue(self)
self._sheriff = Sheriff(self.tool, self)
self._irc_bot = SheriffIRCBot(self.tool, self._sheriff)
self.tool.ensure_irc_connected(self._irc_bot.irc_delegate())
def work_item_log_path(self, new_failures):
return os.path.join("%s-logs" % self.name, "%s.log" % new_failures.keys()[0])
def next_work_item(self):
self._irc_bot.process_pending_messages()
self._update()
new_failures = {}
revisions_causing_failures = self.tool.buildbot.revisions_causing_failures()
for svn_revision, builders in revisions_causing_failures.items():
if self.tool.status_server.svn_revision(svn_revision):
# FIXME: We should re-process the work item after some time delay.
# https://bugs.webkit.org/show_bug.cgi?id=36581
continue
new_failures[svn_revision] = builders
self._sheriff.provoke_flaky_builders(revisions_causing_failures)
return new_failures
def should_proceed_with_work_item(self, new_failures):
# Currently, we don't have any reasons not to proceed with work items.
return True
def process_work_item(self, new_failures):
blame_list = new_failures.keys()
for svn_revision, builders in new_failures.items():
try:
commit_info = self.tool.checkout().commit_info_for_revision(svn_revision)
if not commit_info:
print "FAILED to fetch CommitInfo for r%s, likely missing ChangeLog" % revision
continue
self._sheriff.post_irc_warning(commit_info, builders)
self._sheriff.post_blame_comment_on_bug(commit_info,
builders,
blame_list)
self._sheriff.post_automatic_rollout_patch(commit_info,
builders)
finally:
for builder in builders:
self.tool.status_server.update_svn_revision(svn_revision,
builder.name())
return True
def handle_unexpected_error(self, new_failures, message):
log(message)
# StepSequenceErrorHandler methods
@classmethod
def handle_script_error(cls, tool, state, script_error):
# Ideally we would post some information to IRC about what went wrong
# here, but we don't have the IRC password in the child process.
pass
def begin_work_queue(self):
self._sheriff = Sheriff(self._tool, self)
self._irc_bot = IRCBot(self.name, self._tool, self._sheriff,
irc_commands)
self._tool.ensure_irc_connected(self._irc_bot.irc_delegate())
def begin_work_queue(self):
AbstractQueue.begin_work_queue(self)
self._sheriff = Sheriff(self._tool, self)
self._irc_bot = IRCBot("perfalizer", self._tool, self._sheriff, self._commands)
self._tool.ensure_irc_connected(self._irc_bot.irc_delegate())
def run(message):
tool = MockTool()
tool.ensure_irc_connected(None)
bot = SheriffIRCBot(tool, Sheriff(tool, MockSheriffBot()))
bot._message_queue.post(["mock_nick", message])
bot.process_pending_messages()
