Download the Android SDK as a CIPD package

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
 
 
 DEFAULT_TASK_EXPIRATION = 20*60*60
@@ skipping 14 matching lines @@
     """Directory where the outputs of the swarming tasks will be stored."""
     return self.swarming_temp_dir.join('outputs')
 
   def isolated_file_path(self, task_name):
     """Get the path to the given task's .isolated file."""
     return self.swarming_temp_dir.join('skia-task-%s.isolated' % task_name)
 
   def setup(self, luci_go_dir, swarming_rev=None):
     """Performs setup steps for swarming."""
     self.m.swarming_client.checkout(revision=swarming_rev)
-    self.m.swarming.check_client_version()
+    self.m.swarming.check_client_version(step_test_data=(0, 8, 6))
     self.setup_go_isolate(luci_go_dir)
 
   # TODO(rmistry): Remove once the Go binaries are moved to recipes or buildbot.
   def setup_go_isolate(self, luci_go_dir):
     """Generates and puts in place the isolate Go binary."""
     self.m.step('download luci-go linux',
                 ['download_from_google_storage', '--no_resume',
                  '--platform=linux*', '--no_auth', '--bucket', 'chromium-luci',
                  '-d', luci_go_dir.join('linux64')])
     self.m.step('download luci-go mac',
                 ['download_from_google_storage', '--no_resume',
                  '--platform=darwin', '--no_auth', '--bucket', 'chromium-luci',
                  '-d', luci_go_dir.join('mac64')])
     self.m.step('download luci-go win',
                 ['download_from_google_storage', '--no_resume',
                  '--platform=win32', '--no_auth', '--bucket', 'chromium-luci',
                  '-d', luci_go_dir.join('win64')])
     # Copy binaries to the expected location.
     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, extra_args=None, expiration=None,
-      hard_timeout=None, io_timeout=None):
+      hard_timeout=None, io_timeout=None, cipd_packages=None):
     """Isolate inputs and trigger the task to run."""
     os_type = swarm_dimensions.get('os', 'linux')
     isolated_hash = self.isolate_task(
         isolate_path, isolate_base_dir, os_type, 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,
                                         extra_args=extra_args,
                                         expiration=expiration,
                                         hard_timeout=hard_timeout,
-                                        io_timeout=io_timeout)
+                                        io_timeout=io_timeout,
+                                        cipd_packages=cipd_packages)
     assert len(tasks) == 1
     return tasks[0]
 
   def isolate_task(self, isolate_path, base_dir, os_type, task_name,
                    isolate_vars, blacklist=None, extra_hashes=None):
     """Isolate inputs for the given task."""
     self.create_isolated_gen_json(isolate_path, base_dir, os_type,
                                   task_name, isolate_vars,
                                   blacklist=blacklist)
     hashes = self.batcharchive([task_name])
@@ skipping 83 matching lines @@
     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,
-      extra_args=None, expiration=None, hard_timeout=None, io_timeout=None):
+      extra_args=None, expiration=None, hard_timeout=None, io_timeout=None,
+      cipd_packages=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: bool. Whether or not to de-duplicate tasks.
       store_output: bool. Whether task output should be stored.
       extra_args: list of str. Extra arguments to pass to the task.
       expiration: int. Task will expire if not picked up within this time.
                   DEFAULT_TASK_EXPIRATION is used if this argument is None.
       hard_timeout: int. Task will timeout if not completed within this time.
                     DEFAULT_TASK_TIMEOUT is used if this argument is None.
       io_timeout: int. Task will timeout if there is no output within this time.
                   DEFAULT_IO_TIMEOUT is used if this argument is None.
+      cipd_packages: CIPD packages which these tasks depend on.
 
     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,
+          cipd_packages=cipd_packages,
           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 = (
           expiration if expiration else DEFAULT_TASK_EXPIRATION)
       swarming_task.hard_timeout = (
           hard_timeout if hard_timeout else DEFAULT_TASK_TIMEOUT)
@@ skipping 29 matching lines @@
   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']