Use always_run v can_fail_build

scripts/slave/annotated_run.py

 #!/usr/bin/env python
 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Entry point for fully-annotated builds.
 
 This script is part of the effort to move all builds to annotator-based
 systems. Any builder configured to use the AnnotatorFactory.BaseFactory()
 found in scripts/master/factory/annotator_factory.py executes a single
@@ skipping 158 matching lines @@
     }
     status_mapping.get(self.status, lambda: None)()
 
 
 class StepData(object):
   def __init__(self, step, retcode):
     self._retcode = retcode
     self._step = step
 
     self._presentation = StepPresentation()
+    self.abort_reason = None
 
   @property
   def step(self):
     return copy.deepcopy(self._step)
 
   @property
   def retcode(self):
     return self._retcode
 
   @property
@@ skipping 89 matching lines @@
 
     step_history[step['name']] = step_result
     annotator_step.annotation_stream.step_cursor(step['name'])
     if step_result.retcode != 0 and test_data_item is None:
       # To avoid cluttering the expectations, don't emit this in testmode.
       annotator_step.emit('step returned non-zero exit code: %d' %
                           step_result.retcode)
 
     call_placeholders(step_result, placeholders, test_data_item)
 
-    if followup_fn:
-      followup_fn(step_result)
+    try:
+      if followup_fn:
+        followup_fn(step_result)
+    except recipe_api.RecipeAbort as e:
+      step_result.abort_reason = str(e)
 
     step_result.presentation.finalize(annotator_step)
     return step_result
   if followup_fn:
     _inner.__name__ = followup_fn.__name__
 
   return _inner
 
 
 def get_args(argv):
@@ skipping 115 matching lines @@
       with stream.step(step['name']) as s:
         s.stream = cStringIO.StringIO()
         step_result = callback(s, test_data_item.pop('$R', 0))
         lines = filter(None, s.stream.getvalue().splitlines())
         if lines:
           # Note that '~' sorts after 'z' so that this will be last on each
           # step. Also use _step to get access to the mutable step dictionary.
           # pylint: disable=W0212
           step_result._step['~followup_annotations'] = lines
 
+    if step_result.abort_reason:
+      stream.emit('Aborted: %s' % step_result.abort_reason)
+      test_data = {}  # Dump the rest of the test data
+      break
+
     # TODO(iannucci): Pull this failure calculation into callback.
     failed = annotator.update_build_failure(failed, step_result.retcode, **step)
 
   assert not test_mode or test_data == {}, (
     "Unconsumed test data! %s" % (test_data,))
 
   return MakeStepsRetval(0 if not failed else 1, step_history)
 
 
 def UpdateScripts():
@@ skipping 16 matching lines @@
 
 def shell_main(argv):
   if UpdateScripts():
     return subprocess.call([sys.executable] + argv)
   else:
     return main(argv)
 
 
 if __name__ == '__main__':
   sys.exit(shell_main(sys.argv))