[pinpoint] Support multiple Swarming tasks.

dashboard/dashboard/pinpoint/models/quest/run_test.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.
 
 """Quest and Execution for running a test in Swarming.
 
 This is the only Quest/Execution where the Execution has a reference back to
 modify the Quest.
 """
 
@@ skipping 72 matching lines @@
 class _RunTestExecution(execution_module.Execution):
 
   def __init__(self, dimensions, extra_args, isolate_hash,
                first_execution=None):
     super(_RunTestExecution, self).__init__()
     self._dimensions = dimensions
     self._extra_args = extra_args
     self._isolate_hash = isolate_hash
     self._first_execution = first_execution
 
-    self._task_id = None
-    self._bot_id = None
+    self._task_ids = []
+    self._bot_ids = []
 
   @property
-  def bot_id(self):
-    return self._bot_id
+  def bot_ids(self):
+    return tuple(self._bot_ids)
 
   def _Poll(self):
-    if not self._task_id:
+    if not self._task_ids:
       self._StartTask()
       return
 
-    result = swarming_service.Task(self._task_id).Result()
+    isolate_hashes = []
+    for task_id in self._task_ids:
+      result = swarming_service.Task(task_id).Result()
 
-    if 'bot_id' in result:
-      # Set bot_id to pass the info back to the Quest.
-      self._bot_id = result['bot_id']
+      if 'bot_id' in result:
+        # Set bot_id to pass the info back to the Quest.
+        self._bot_ids.append(result['bot_id'])
 
-    if result['state'] == 'PENDING' or result['state'] == 'RUNNING':
-      return
+      if result['state'] == 'PENDING' or result['state'] == 'RUNNING':
+        return
 
-    if result['state'] != 'COMPLETED':
-      raise SwarmingTaskError(self._task_id, result['state'])
+      if result['state'] != 'COMPLETED':
+        raise SwarmingTaskError(task_id, result['state'])
 
-    if result['failure']:
-      raise SwarmingTestError(self._task_id, result['exit_code'])
+      if result['failure']:
+        raise SwarmingTestError(task_id, result['exit_code'])
 
-    result_arguments = {'isolate_hash': result['outputs_ref']['isolated']}
+      isolate_hashes.append(result['outputs_ref']['isolated'])
+
+    result_arguments = {'isolate_hashes': tuple(isolate_hashes)}
     self._Complete(result_arguments=result_arguments)
 
 
   def _StartTask(self):
     """Kick off a Swarming task to run a test."""
-    if self._first_execution and not self._first_execution._bot_id:
+    if self._first_execution and not self._first_execution.bot_ids:
       if self._first_execution.failed:
         # If the first Execution fails before it gets a bot ID, it's likely it
         # couldn't find any device to run on. Subsequent Executions probably
         # wouldn't have any better luck, and failing fast is less complex than
         # handling retries.
         raise RunTestError('There are no bots available to run the test.')
       else:
         return
 
     dimensions = [{'key': 'pool', 'value': 'Chrome-perf-pinpoint'}]
     if self._first_execution:
-      dimensions.append({'key': 'id', 'value': self._first_execution.bot_id})
+      dimensions.append({
+          'key': 'id',
+          # TODO: Use all the bot ids.
+          'value': self._first_execution.bot_ids[0]
+      })
     else:
       dimensions += self._dimensions
 
     body = {
         'name': 'Pinpoint job',
         'user': 'Pinpoint',
         'priority': '100',
         'expiration_secs': '600',
         'properties': {
             'inputs_ref': {'isolated': self._isolate_hash},
             'extra_args': self._extra_args,
             'dimensions': dimensions,
             'execution_timeout_secs': '3600',
             'io_timeout_secs': '3600',
         },
     }
     response = swarming_service.Tasks().New(body)
 
-    self._task_id = response['task_id']
+    self._task_ids.append(response['task_id'])