Reland "Allow multiple devices on bisects hosts "

scripts/slave/recipe_modules/auto_bisect/local_bisect.py

 # Copyright 2015 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 base64
 import collections
 import json
 
 
-def perform_bisect(api, **flags):  # pragma: no cover
-  bisect_config = api.m.properties.get('bisect_config')
-  assert isinstance(bisect_config, collections.Mapping)
-  bisector = api.create_bisector(bisect_config, **flags)
-  with api.m.step.nest('Gathering reference values'):
-    _gather_reference_range(api, bisector)
-  if (not bisector.failed and bisector.check_improvement_direction() and
-      bisector.check_initial_confidence()):
-    if bisector.check_reach_adjacent_revision(bisector.good_rev):
-      # Only show this step if bisect has reached adjacent revisions.
-      with api.m.step.nest(str('Check bisect finished on revision ' +
-                               bisector.good_rev.revision_string())):
-        if bisector.check_bisect_finished(bisector.good_rev):
-          bisector.bisect_over = True
-    if not bisector.bisect_over:
-      _bisect_main_loop(bisector)
-  else:
-    bisector.bisect_over = True
-  bisector.print_result_debug_info()
-  bisector.post_result(halt_on_failure=True)
+def perform_bisect(api, **flags):
+  # pick an available device if targe platform is android
+  if api.m.chromium.c.TARGET_PLATFORM == 'android':
+    connected_devices = _get_connected_devices(api)
+    if not _pick_available_device(api, connected_devices):
+      raise api.m.step.StepFailure('No Android test devices are available')
+  try:
+      bisect_config = api.m.properties.get('bisect_config')
+      assert isinstance(bisect_config, collections.Mapping)
+      bisector = api.create_bisector(bisect_config, **flags)
+      with api.m.step.nest('Gathering reference values'):
+        _gather_reference_range(api, bisector)
+      if (not bisector.failed and bisector.check_improvement_direction() and
+          bisector.check_initial_confidence()):
+        if bisector.check_reach_adjacent_revision(
+            bisector.good_rev): # pragma: no cover
+          # Only show this step if bisect has reached adjacent revisions.
+          with api.m.step.nest(str('Check bisect finished on revision ' +
+                                   bisector.good_rev.revision_string())):
+            if bisector.check_bisect_finished(bisector.good_rev):
+              bisector.bisect_over = True
+        if not bisector.bisect_over:
+          _bisect_main_loop(bisector)
+      else:
+        bisector.bisect_over = True
+      bisector.print_result_debug_info()
+      bisector.post_result(halt_on_failure=True)
+  except api.m.step.StepFailure:
+      # Redo the bisect job if target platform is android and bisect failed
+      # because the test device disconnected
+      if api.m.chromium.c.TARGET_PLATFORM == 'android':
+        connected_devices = _get_connected_devices(api)
+        if api.m.bisect_tester.device_to_test not in connected_devices:
+          perform_bisect(api, **flags)

[jbudorick, 2016/07/15 01:23:19]

o_o

+        else:
+          raise
+      else: # pragma: no cover
+        raise
 
+def _get_connected_devices(api):
+  api.m.chromium_android.multiple_device_test = True
+  api.m.chromium_android.device_status_check()

[jbudorick, 2016/07/15 01:23:19]

Use device_status now.

[Ziqi Xiong, 2016/07/15 01:36:06]

Done.

+  api.m.chromium_android.multiple_device_test = False
+  return api.m.chromium_android.devices
+
+def _pick_available_device(api, connected_devices):

[jbudorick, 2016/07/15 01:23:19]

This is basically reimplementing the blacklist that we use elsewhere
(https://github.com/catapult-project/catapult/blob/master/devil/docs/device_bl...).
I'd strongly prefer if we use that mechanism rather than reinventing it.

[Ziqi Xiong, 2016/07/15 01:36:06]

Sure, I will use blacklist instead. Thanks for letting me know!

[jbudorick, 2016/07/15 02:51:41]

Thought about this a bit more, and I think the blacklist is overly complicated
for this use case. What about looping through the devices & breaking out of the
loop on success? Something like this:

def perform_bisect(...):
  # you may have to do device_status here, I'm not sure if all recipes that use
perform_bisect
  # call it beforehand.

  for d in api.m.chromium_android.devices:
    # name subject to change
    perform_single_bisect(d, ...)
    return
  except api.m.step.StepFailure:
    pass

  raise api.m.step.StepFailure

def perform_single_bisect(device, ...):
  # body of try block above


?

[Ziqi Xiong, 2016/07/15 04:38:08]

That's definitely less convoluted than the current implementation. My concern is
that it only checks chromium_android.devices once and then starts a long for
loop. One of available devices in the list may fail during the test run, or a
device that was not in the list may be back online, and the device list should
be updated, but in a for loop we can't really change the iterated list. Those
cases must be a really rare but I still feel a bit uneasy about that.

[Ziqi Xiong, 2016/07/15 19:14:34]

Done.

+  tested_devices = api.m.bisect_tester.devices_tested
+  available_devices = [device for device in connected_devices
+                              if device not in tested_devices]
+  if available_devices:
+    picked_device = available_devices[0]
+    api.m.bisect_tester.device_to_test = picked_device
+    api.m.bisect_tester.devices_tested.append(picked_device)
+    return picked_device
+  return None
 
 def _gather_reference_range(api, bisector):  # pragma: no cover
   bisector.good_rev.start_job()
   bisector.bad_rev.start_job()
   bisector.wait_for_all([bisector.good_rev, bisector.bad_rev])
   if bisector.good_rev.failed:
     bisector.surface_result('REF_RANGE_FAIL')
     api.m.halt('Testing the "good" revision failed')
     bisector.failed = True
   elif bisector.bad_rev.failed:
@@ skipping 23 matching lines @@
       revision_to_check.start_job()
       bisector.wait_for(revision_to_check)
 
     if bisector.check_reach_adjacent_revision(revision_to_check):
       # Only show this step if bisect has reached adjacent revisions.
       with bisector.api.m.step.nest(
           str('Check bisect finished on revision ' +
               revision_to_check.revision_string())):
         if bisector.check_bisect_finished(revision_to_check):
             bisector.bisect_over = True