Skia: Run recipes as swarming tasks

scripts/slave/recipe_modules/skia_swarming/api.py

 # Copyright 2016 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 recipe_engine import recipe_api
 import shlex
 
 
 class SkiaSwarmingApi(recipe_api.RecipeApi):
@@ skipping 38 matching lines @@
     dest = self.m.path['slave_build'].join('luci-go')
     self.m.file.rmtree('Go binary dir', dest)
     self.m.file.copytree('Copy Go binary',
                          source=luci_go_dir,
                          dest=dest)
 
   def isolate_and_trigger_task(self, isolate_path, isolate_base_dir, task_name,
                                isolate_vars, swarm_dimensions,
                                isolate_blacklist=None,
                                extra_isolate_hashes=None, idempotent=False,
-                               store_output=True):
+                               store_output=True, extra_args=None):
     """Isolate inputs and trigger the task to run."""
     isolated_hash = self.isolate_task(isolate_path, isolate_base_dir, task_name,
                                       isolate_vars, blacklist=isolate_blacklist,
                                       extra_hashes=extra_isolate_hashes)
     tasks = self.trigger_swarming_tasks([(task_name, isolated_hash)],
                                         swarm_dimensions,
                                         idempotent=idempotent,
-                                        store_output=store_output)
+                                        store_output=store_output,
+                                        extra_args=extra_args)
     assert len(tasks) == 1
     return tasks[0]
 
   def isolate_task(self, isolate_path, base_dir, task_name,
                    isolate_vars, blacklist=None, extra_hashes=None):
     """Isolate inputs for the given task."""
     self.create_isolated_gen_json(isolate_path, base_dir, 'linux',
                                   task_name, isolate_vars,
                                   blacklist=blacklist)
     hashes = self.batcharchive([task_name])
@@ skipping 67 matching lines @@
     Returns:
       Updated hash of the .isolated file.
     """
     isolated_file = self.isolated_file_path(task_name)
     self.m.python.inline('add_isolated_input', program="""
       import json
       import sys
       with open(sys.argv[1]) as f:
         isolated = json.load(f)
       for h in sys.argv[2:]:
-        isolated['includes'].append(sys.argv[2])
+        isolated['includes'].append(h)
       with open(sys.argv[1], 'w') as f:
         json.dump(isolated, f, sort_keys=True)
     """, args=[isolated_file] + include_hashes)
     isolateserver = self.m.swarming_client.path.join('isolateserver.py')
     r = self.m.python('upload new .isolated file for %s' % task_name,
                       script=isolateserver,
                       args=['archive', '--isolate-server',
                             self.m.isolate.isolate_server, isolated_file],
                       stdout=self.m.raw_io.output())
     return shlex.split(r.stdout)[0]
 
   def trigger_swarming_tasks(self, swarm_hashes, dimensions, idempotent=False,
-                             store_output=True):
+                             store_output=True, extra_args=None):
     """Triggers swarming tasks using swarm hashes.
 
     Args:
       swarm_hashes: list of str. List of swarm hashes from the isolate server.
       dimensions: dict of str to str. The dimensions to run the task on.
                   Eg: {'os': 'Ubuntu', 'gpu': '10de', 'pool': 'Skia'}
       idempotent: whether or not to de-duplicate tasks.
     Returns:
       List of swarming.SwarmingTask instances.
     """
     swarming_tasks = []
     for task_name, swarm_hash in swarm_hashes:
       swarming_task = self.m.swarming.task(
           title=task_name,
           isolated_hash=swarm_hash)
       if store_output:
         swarming_task.task_output_dir = self.tasks_output_dir.join(task_name)
       swarming_task.dimensions = dimensions
       swarming_task.idempotent = idempotent
       swarming_task.priority = 90
       swarming_task.expiration = 4*60*60
+      if extra_args:
+        swarming_task.extra_args = extra_args
       swarming_tasks.append(swarming_task)
     self.m.swarming.trigger(swarming_tasks)
     return swarming_tasks
 
   def collect_swarming_task(self, swarming_task):
     """Collects the specified swarming task.
 
     Args:
       swarming_task: An instance of swarming.SwarmingTask.
     """
     return self.m.swarming.collect_task(swarming_task)
 
   def collect_swarming_task_isolate_hash(self, swarming_task):
     """Wait for the given swarming task to finish and return its output hash.
 
     Args:
       swarming_task: An instance of swarming.SwarmingTask.
     Returns:
       the hash of the isolate output of the task.
     """
     res = self.collect_swarming_task(swarming_task)
     return res.json.output['shards'][0]['isolated_out']['isolated']