Add swarming support for IsolatedScriptTest.

scripts/slave/recipe_modules/swarming/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.
 
 import datetime
 import functools
 
 from recipe_engine.types import freeze
 from recipe_engine import recipe_api
 
@@ skipping 328 matching lines @@
     # idempotent. As of this writing, Telemetry itself downloads some
     # data from remote servers; additionally, some tests like the
     # pixel_tests download reference images from cloud storage. It's
     # safest to assume that these tests aren't idempotent, though we
     # should work toward making them so.
     task = self.task(title, isolated_hash, extra_args=extra_args,
                      idempotent=False, **kwargs)
     task.collect_step = self._telemetry_gpu_collect_step
     return task
 
+  def isolated_script_task(self, title, isolated_hash, extra_args=None,
+                           idempotent=False, **kwargs):
+    """Returns a new SwarmingTask to run an isolated script test on Swarming.
+
+    Swarming recipe module knows how collect JSON file with test execution
+    summary produced by isolated script tests launcher. Since isolated script
+    tests do not support sharding, no merging of the results is performed.
+    Parsed JSON summary is returned from the collect step.
+
+    For meaning of the rest of the arguments see 'task' method.
+    """
+    extra_args = list(extra_args or [])
+
+    # Ensure --isolated-script-test-output is not already passed. We are going
+    # to overwrite it.
+    bad_args = any(
+        x.startswith('--isolated-script-test-output=') for x in extra_args)
+    if bad_args:  # pragma: no cover
+      raise ValueError('--isolated-script-test-output should not be used.')
+
+    # Append it. output.json name is expected by collect_gtest_task.py.
+    extra_args.append(
+        '--isolated-script-test-output=${ISOLATED_OUTDIR}/output.json')
+
+    task = self.task(title, isolated_hash, extra_args=extra_args,
+                     idempotent=idempotent, **kwargs)
+    task.collect_step = self._isolated_script_collect_step
+    return task
+
   def check_client_version(self, step_test_data=None):
     """Yields steps to verify compatibility with swarming_client version."""
     return self.m.swarming_client.ensure_script_version(
         'swarming.py', MINIMAL_SWARMING_VERSION, step_test_data)
 
   def trigger_task(self, task, **kwargs):
     """Triggers one task.
 
     It the task is sharded, will trigger all shards. This steps justs posts
     the task and immediately returns. Use 'collect_task' to wait for a task to
@@ skipping 288 matching lines @@
         if step_result.retcode == 0 and results_raw == '':
           step_result.telemetry_results = {'per_page_values': [], 'pages': []}
         else:
           step_result.telemetry_results = self.m.json.loads(results_raw)
 
         self._display_pending(summary, step_result.presentation)
       except Exception as e:
         self.m.step.active_result.presentation.logs['no_results_exc'] = [str(e)]
         self.m.step.active_result.telemetry_results = None
 
+  def _isolated_script_collect_step(self, task, **kwargs):
+    step_test_data = kwargs.pop('step_test_data', None)
+    if not step_test_data:
+      step_test_data = self.m.test_utils.test_api.canned_isolated_script_output(
+          passing=True, is_win=self.m.platform.is_win, swarming=True)
+
+    args=self.get_collect_cmd_args(task)
+    args.extend(['--task-output-dir', self.m.raw_io.output_dir()])
+
+    try:
+      self.m.python(
+          name=self._get_step_name('', task),
+          script=self.m.swarming_client.path.join('swarming.py'),
+          args=args, step_test_data=lambda: step_test_data,
+          **kwargs)
+    finally:
+      # Regardless of the outcome of the test (pass or fail), we try to parse
+      # the results. If any error occurs while parsing results, then we set them
+      # to None, which caller should treat as invalid results.
+      # Note that try-except block below will not mask the
+      # recipe_api.StepFailure exception from the collect step above. Instead
+      # it is being allowed to propagate after the results have been parsed.
+      try:
+        step_result = self.m.step.active_result
+        outdir_json = self.m.json.dumps(step_result.raw_io.output_dir, indent=2)
+        step_result.presentation.logs['outdir_json'] = outdir_json.splitlines()
+
+        # Check if it's an internal failure.
+        summary = self.m.json.loads(
+            step_result.raw_io.output_dir['summary.json'])
+        if any(shard['internal_failure'] for shard in summary['shards']):
+          raise recipe_api.InfraFailure('Internal swarming failure.')
+
+        # TODO(nednguyen, kbr): Combine isolated script results from multiple
+        # shards rather than assuming that there is always just one shard.
+        assert len(summary['shards']) == 1
+        results_raw = step_result.raw_io.output_dir[
+            self.m.path.join('0', 'output.json')]
+        step_result.isolated_script_results = self.m.json.loads(results_raw)
+
+        self._display_pending(summary, step_result.presentation)
+      except Exception as e:
+        self.m.step.active_result.presentation.logs['no_results_exc'] = [str(e)]
+        self.m.step.active_result.isolated_script_results = None
 
   def _get_step_name(self, prefix, task):
     """SwarmingTask -> name of a step of a waterfall.
 
     Will take a task title (+ step name prefix) and optionally append
     OS dimension to it in case the task is triggered on OS that is different
     from OS this recipe is running on. It shortens step names for the most
     common case of triggering a task on the same OS as one that recipe
     is running on.
 
@@ skipping 169 matching lines @@
 
   def get_shard_view_url(self, index):
     """Returns URL of HTML page with shard details or None if not available.
 
     Works only after the task has been successfully triggered.
     """
     if self._trigger_output and self._trigger_output.get('tasks'):
       for shard_dict in self._trigger_output['tasks'].itervalues():
         if shard_dict['shard_index'] == index:
           return shard_dict['view_url']