Revert "Add CIPD package support to swarming recipe api"

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
 
 
 # Minimally supported version of swarming.py script (reported by --version).
-MINIMAL_SWARMING_VERSION = (0, 8, 6)
+MINIMAL_SWARMING_VERSION = (0, 4, 10)
 
 
 def parse_time(value):
   """Converts serialized time from the API to datetime.datetime."""
   # When microseconds are 0, the '.123456' suffix is elided. This means the
   # serialized format is not consistent, which confuses the hell out of python.
   # TODO(maruel): Remove third format once we enforce version >=0.8.2.
   for fmt in ('%Y-%m-%dT%H:%M:%S.%f', '%Y-%m-%dT%H:%M:%S', '%Y-%m-%d %H:%M:%S'):
     try:
       return datetime.datetime.strptime(value, fmt)
@@ skipping 296 matching lines @@
     example WinXP try bot recipe may explicitly specify 'Windows-XP-SP3'
     dimension.
     """
     return {
       'linux': 'Ubuntu-12.04',
       'mac': 'Mac-10.9',
       'win': 'Windows-7-SP1',
     }[platform]
 
   def task(self, title, isolated_hash, shards=1, task_output_dir=None,
-           extra_args=None, idempotent=None, cipd_packages=None):
+           extra_args=None, idempotent=None):
     """Returns a new SwarmingTask instance to run an isolated executable on
     Swarming.
 
     The return value can be customized if necessary (see SwarmingTask class
     below). Pass it to 'trigger_task' to launch it on swarming. Later pass the
     same instance to 'collect_task' to wait for the task to finish and fetch its
     results.
 
     Args:
       title: name of the test, used as part of a task ID.
       isolated_hash: hash of isolated test on isolate server, the test should
           be already isolated there, see 'isolate' recipe module.
       shards: if defined, the number of shards to use for the task. By default
           this value is either 1 or based on the title.
       task_output_dir: if defined, the directory where task results are placed.
           The caller is responsible for removing this folder when finished.
       extra_args: list of command line arguments to pass to isolated tasks.
       idempotent: whether this task is considered idempotent. Defaults
           to self.default_idempotent if not specified.
-      cipd_packages:  list of 3-tuples corresponding to CIPD packages needed for
-          the task: ('path', 'package_name', 'version'), defined as follows:
-              path: Path relative to the Swarming root dir in which to install
-                  the package.
-              package_name: Name of the package to install,
-                  eg. "infra/tools/authutil/${platform}"
-              version: Version of the package, either a package instance ID,
-                  ref, or tag key/value pair.
     """
     if idempotent is None:
       idempotent = self.default_idempotent
     return SwarmingTask(
         title=title,
         isolated_hash=isolated_hash,
         dimensions=self._default_dimensions,
         env=self._default_env,
         priority=self.default_priority,
         shards=shards,
         buildername=self.m.properties.get('buildername'),
         buildnumber=self.m.properties.get('buildnumber'),
         user=self.default_user,
         expiration=self.default_expiration,
         io_timeout=self.default_io_timeout,
         hard_timeout=self.default_hard_timeout,
         idempotent=idempotent,
         extra_args=extra_args,
         collect_step=self._default_collect_step,
-        task_output_dir=task_output_dir,
-        cipd_packages=cipd_packages)
+        task_output_dir=task_output_dir)
 
   def gtest_task(self, title, isolated_hash, test_launcher_summary_output=None,
                  extra_args=None, **kwargs):
     """Returns a new SwarmingTask instance to run an isolated gtest on Swarming.
 
     Swarming recipe module knows how collect and interpret JSON files with test
     execution summary produced by chromium test launcher. It will combine JSON
     results from multiple shards and place it in path provided by
     |test_launcher_summary_output| placeholder.
 
@@ skipping 120 matching lines @@
       assert ':' in tag, tag
       args.extend(['--tag', tag])
 
     if self.verbose:
       args.append('--verbose')
     if task.idempotent:
       args.append('--idempotent')
     if task.user:
       args.extend(['--user', task.user])
 
-    if task.cipd_packages:
-      for path, pkg, version in task.cipd_packages:
-        args.extend(['--cipd-package', '%s:%s:%s' % (path, pkg, version)])
-
     # What isolated command to trigger.
     args.append(task.isolated_hash)
 
     # Additional command line args for isolated command.
     if task.extra_args:
       args.append('--')
       args.extend(task.extra_args)
 
     # The step can fail only on infra failures, so mark it as 'infra_step'.
     try:
@@ skipping 291 matching lines @@
   def get_collect_cmd_args(self, task):
     """SwarmingTask -> argument list for 'swarming.py' command."""
     args = [
       'collect',
       '--swarming', self.swarming_server,
       '--decorate',
       '--print-status-updates',
     ]
     if self.verbose:
       args.append('--verbose')
-    script_version = self.m.swarming_client.get_script_version('swarming.py')
-    if script_version < (0, 5):  # pragma: nocover
+    if self.m.swarming_client.get_script_version('swarming.py') < (0, 5):
       args.extend(('--shards', str(task.shards)))
       args.append(task.task_name)
     else:
       args.extend(('--json', self.m.json.input(task.trigger_output)))
     return args
 
   def _gen_trigger_step_test_data(self, task):
     """Generates an expected value of --dump-json in 'trigger' step.
 
     Used when running recipes to generate test expectations.
@@ skipping 52 matching lines @@
       ],
     })
 
 
 class SwarmingTask(object):
   """Definition of a task to run on swarming."""
 
   def __init__(self, title, isolated_hash, dimensions, env, priority,
                shards, buildername, buildnumber, expiration, user, io_timeout,
                hard_timeout, idempotent, extra_args, collect_step,
-               task_output_dir, cipd_packages=None):
+               task_output_dir):
     """Configuration of a swarming task.
 
     Args:
       title: display name of the task, hints to what task is doing. Usually
           corresponds to a name of a test executable. Doesn't have to be unique.
       isolated_hash: hash of isolated file that describes all files needed to
           run the task as well as command line to launch. See 'isolate' recipe
           module.
-      cipd_packages: list of 3-tuples corresponding to CIPD packages needed for
-          the task: ('path', 'package_name', 'version'), defined as follows:
-              path: Path relative to the Swarming root dir in which to install
-                  the package.
-              package_name: Name of the package to install,
-                  eg. "infra/tools/authutil/${platform}"
-              version: Version of the package, either a package instance ID,
-                  ref, or tag key/value pair.
-      collect_step: callback that will be called to collect and processes
-          results of task execution, signature is collect_step(task, **kwargs).
       dimensions: key-value mapping with swarming dimensions that specify
           on what Swarming slaves task can run. One important dimension is 'os',
           which defines platform flavor to run the task on. See Swarming doc.
       env: key-value mapping with additional environment variables to add to
           environment before launching the task executable.
       priority: integer [0, 255] that defines how urgent the task is.
           Lower value corresponds to higher priority. Swarming service executes
           tasks with higher priority first.
       shards: how many concurrent shards to run, makes sense only for
           isolated tests based on gtest. Swarming uses GTEST_SHARD_INDEX
           and GTEST_TOTAL_SHARDS environment variables to tell the executable
           what shard to run.
       buildername: buildbot builder this task was triggered from.
       buildnumber: build number of a build this task was triggered from.
       expiration: number of schedule until the task shouldn't even be run if it
           hadn't started yet.
       user: user that requested this task, if applicable.
       io_timeout: number of seconds that the task is allowed to not emit any
           stdout bytes, after which it is forcibly killed.
       hard_timeout: number of seconds for which the task is allowed to run,
           after which it is forcibly killed.
       idempotent: True if the results from a previous task can be reused. E.g.
           this task has no side-effects.
       extra_args: list of command line arguments to pass to isolated tasks.
+      collect_step: callback that will be called to collect and processes
+          results of task execution, signature is collect_step(task, **kwargs).
       task_output_dir: if defined, the directory where task results are placed
           during the collect step.
     """
     self._trigger_output = None
     self.buildnumber = buildnumber
     self.buildername = buildername
-    self.cipd_packages = cipd_packages
+    self.task_output_dir = task_output_dir
     self.collect_step = collect_step
     self.dimensions = dimensions.copy()
     self.env = env.copy()
     self.expiration = expiration
     self.extra_args = tuple(extra_args or [])
     self.hard_timeout = hard_timeout
     self.idempotent = idempotent
     self.io_timeout = io_timeout
     self.isolated_hash = isolated_hash
     self.priority = priority
     self.shards = shards
     self.tags = set()
-    self.task_output_dir = task_output_dir
     self.title = title
     self.user = user
 
   @property
   def task_name(self):
     """Name of this task, derived from its other properties.
 
     The task name is purely to make sense of the task and is not used in any
     other way.
     """
@@ skipping 10 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']