specify the reason for blacklisting

build/android/buildbot/bb_device_status_check.py

 #!/usr/bin/env python
 #
 # Copyright 2013 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.
 
 """A class to keep track of devices across builds and report state."""
 
 import argparse
 import json
@@ skipping 54 matching lines @@
     battery = battery_utils.BatteryUtils(device)
     battery_info = battery.GetBatteryInfo(timeout=5)
     battery_level = int(battery_info.get('level', 100))
 
     if battery_level < 15:
       logging.error('Critically low battery level (%d)', battery_level)
       battery = battery_utils.BatteryUtils(device)
       if not battery.GetCharging():
         battery.SetCharging(True)
       if blacklist:
-        blacklist.Extend([device.adb.GetDeviceSerial()])
+        blacklist.Extend([device.adb.GetDeviceSerial()], reason='low_battery')
 
   except device_errors.CommandFailedError:
     logging.exception('Failed to get battery information for %s',
                       str(device))
 
   return battery_info
 
 
 def _IMEISlice(device):
   imei_slice = ''
@@ skipping 80 matching lines @@
             # TODO(jbudorick): Remove these once no clients depend on them.
             'type': build_product,
             'build': build_id,
             'build_detail': build_fingerprint,
           })
 
         except device_errors.CommandFailedError:
           logging.exception('Failure while getting device status for %s.',
                             str(device))
           if blacklist:
-            blacklist.Extend([serial])
+            blacklist.Extend([serial], reason='status_check_failure')
 
         except device_errors.CommandTimeoutError:
           logging.exception('Timeout while getting device status for %s.',
                             str(device))
           if blacklist:
-            blacklist.Extend([serial])
+            blacklist.Extend([serial], reason='status_check_timeout')
 
     elif blacklist:
-      blacklist.Extend([serial])
+      blacklist.Extend([serial], reason='offline')
 
     device_status['blacklisted'] = _IsBlacklisted(serial, blacklist)
 
     return device_status
 
   parallel_devices = device_utils.DeviceUtils.parallel(devices)
   statuses = parallel_devices.pMap(blacklisting_device_status).pGet(None)
   return statuses
 
 
@@ skipping 35 matching lines @@
     blacklist.Reset()
 
   if should_restart_adb:
     KillAllAdb()
   for serial in should_restart_usb:
     try:
       reset_usb.reset_android_usb(serial)
     except (IOError, device_errors.DeviceUnreachableError):
       logging.exception('Unable to reset USB for %s.', serial)
       if blacklist:
-        blacklist.Extend([serial])
+        blacklist.Extend([serial], reason='usb_failure')
 
   def blacklisting_recovery(device):
     if _IsBlacklisted(device.adb.GetDeviceSerial(), blacklist):
       logging.debug('%s is blacklisted, skipping recovery.', str(device))
       return
 
     if str(device) in should_reboot_device:
       try:
         device.WaitUntilFullyBooted(retries=0)
         return
       except (device_errors.CommandTimeoutError,
               device_errors.CommandFailedError):
         logging.exception('Failure while waiting for %s. '
                           'Attempting to recover.', str(device))
 
       try:
         try:
           device.Reboot(block=False, timeout=5, retries=0)
         except device_errors.CommandTimeoutError:
           logging.warning('Timed out while attempting to reboot %s normally.'
                           'Attempting alternative reboot.', str(device))
           # The device drops offline before we can grab the exit code, so
           # we don't check for status.
           device.adb.Root()
           device.adb.Shell('echo b > /proc/sysrq-trigger', expect_status=None,
                            timeout=5, retries=0)
       except device_errors.CommandFailedError:
         logging.exception('Failed to reboot %s.', str(device))
         if blacklist:
-          blacklist.Extend([device.adb.GetDeviceSerial()])
+          blacklist.Extend([device.adb.GetDeviceSerial()],
+                           reason='reboot_failure')
       except device_errors.CommandTimeoutError:
         logging.exception('Timed out while rebooting %s.', str(device))
         if blacklist:
-          blacklist.Extend([device.adb.GetDeviceSerial()])
+          blacklist.Extend([device.adb.GetDeviceSerial()],
+                           reason='reboot_timeout')
 
       try:
         device.WaitUntilFullyBooted(retries=0)
       except device_errors.CommandFailedError:
         logging.exception('Failure while waiting for %s.', str(device))
         if blacklist:
-          blacklist.Extend([device.adb.GetDeviceSerial()])
+          blacklist.Extend([device.adb.GetDeviceSerial()],
+                           reason='reboot_failure')
       except device_errors.CommandTimeoutError:
         logging.exception('Timed out while waiting for %s.', str(device))
         if blacklist:
-          blacklist.Extend([device.adb.GetDeviceSerial()])
+          blacklist.Extend([device.adb.GetDeviceSerial()],
+                           reason='reboot_timeout')
 
   device_utils.DeviceUtils.parallel(devices).pMap(blacklisting_recovery)
 
 
 def main():
   parser = argparse.ArgumentParser()
   parser.add_argument('--out-dir',
                       help='Directory where the device path is stored',
                       default=os.path.join(constants.DIR_SOURCE_ROOT, 'out'))
   parser.add_argument('--restart-usb', action='store_true',
@@ skipping 84 matching lines @@
   live_devices = [status['serial'] for status in statuses
                   if (status['adb_status'] == 'device'
                       and not _IsBlacklisted(status['serial'], blacklist))]
 
   # If all devices failed, or if there are no devices, it's an infra error.
   return 0 if live_devices else constants.INFRA_EXIT_CODE
 
 
 if __name__ == '__main__':
   sys.exit(main())