Swarming: conditionally run tests on swarming in chromium_trybot recipe.

scripts/slave/recipe_modules/isolate/api.py

 # Copyright 2014 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.
 
 from slave import recipe_api
 
 
 class IsolateApi(recipe_api.RecipeApi):
   """APIs for interacting with isolates."""
 
@@ skipping 20 matching lines @@
     server during the build. This must be called early in your recipe;
     definitely before the checkout and runhooks steps.
 
     Uses current values of self.isolate_server. It should be property configured
     before calling this method if the default value (production instance of
     Isolate service) is not ok.
     """
     config.gyp_env.GYP_DEFINES['test_isolation_mode'] = 'archive'
     config.gyp_env.GYP_DEFINES['test_isolation_outdir'] = self._isolate_server
 
-  def find_isolated_tests(self, build_dir, targets=None):
+  def find_isolated_tests(self, build_dir, targets=None, **kwargs):
     """Returns a step which finds all *.isolated files in a build directory.
 
     Assigns the dict {target name -> *.isolated file hash} to the swarm_hashes
     build property. This implies this step can currently only be run once
     per recipe.
 
     If |targets| is None, the step will use all *.isolated files it finds.
     Otherwise, it will verify that all |targets| are found and will use only
     them. If some expected targets are missing, will abort the build.
+
+    Also accepts step execution controlling flags (always_run, can_fail_build,
+    etc.) via kwargs.
     """
+    # Failure is fatal by default.
+    kwargs.setdefault('abort_on_failure', True)
+
     def followup_fn(step_result):
       assert isinstance(step_result.json.output, dict)
       self._isolated_tests = step_result.json.output
       if targets is not None and step_result.presentation.status != 'FAILURE':
         found = set(step_result.json.output)
         expected = set(targets)
         if found >= expected:
           # Limit result only to |expected|.
           self._isolated_tests = {
             target: step_result.json.output[target] for target in expected
           }
         else:
           # Some expected targets are missing? Fail the step.
           step_result.presentation.status = 'FAILURE'
           step_result.presentation.logs['missing.isolates'] = (
               ['Failed to find *.isolated files:'] + list(expected - found))
       step_result.presentation.properties['swarm_hashes'] = self._isolated_tests
       # No isolated files found? That looks suspicious, emit warning.
       if (not self._isolated_tests and
           step_result.presentation.status != 'FAILURE'):
         step_result.presentation.status = 'WARNING'
+
     return self.m.python(
         'find isolated tests',
         self.resource('find_isolated_tests.py'),
         [
           '--build-dir', build_dir,
           '--output-json', self.m.json.output(),
         ],
-        abort_on_failure=True,
         followup_fn=followup_fn,
-        step_test_data=lambda: (self.test_api.output_json(targets)))
+        step_test_data=lambda: (self.test_api.output_json(targets)),
+        **kwargs)
 
   @property
   def isolated_tests(self):
     """The dictionary of 'target name -> isolated hash' for this run.
 
     These come either from the incoming swarm_hashes build property,
     or from calling find_isolated_tests, above, at some point during the run.
     """
     hashes = self.m.properties.get('swarm_hashes', self._isolated_tests)
     return {
@@ skipping 56 matching lines @@
         # When running the Telemetry test via an isolate we need to tell
         # run_isolated.py the hash and isolate server first, and then give
         # the isolate the test name and other arguments separately.
         prefix_args=self.runtest_args_list(isolate_name) + ['--'],
         args=args,
         name=name,
         revision=revision,
         webkit_revision=webkit_revision,
         master_class_name=master_class_name,
         **runtest_kwargs)