Make the status reporting of devices in status_check more verbose.

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 117 matching lines @@
   adb_devices = {
     a[0].GetDeviceSerial(): a
     for a in adb_wrapper.AdbWrapper.Devices(desired_state=None, long_list=True)
   }
   usb_devices = set(lsusb.get_android_devices())
 
   def blacklisting_device_status(device):
     serial = device.adb.GetDeviceSerial()
     adb_status = (
         adb_devices[serial][1] if serial in adb_devices
-        else 'unknown')
+        else 'missing')
     usb_status = bool(serial in usb_devices)
 
     device_status = {
       'serial': serial,
       'adb_status': adb_status,
       'usb_status': usb_status,
     }
 
-    if adb_status == 'device':
-      if not _IsBlacklisted(serial, blacklist):
+    if not _IsBlacklisted(serial, blacklist):
+      if adb_status == 'device':
         try:
           build_product = device.build_product
           build_id = device.build_id
           build_fingerprint = device.GetProp('ro.build.fingerprint', cache=True)
           wifi_ip = device.GetProp('dhcp.wlan0.ipaddress')
           battery_info = _BatteryStatus(device, blacklist)
           imei_slice = _IMEISlice(device)
 
           if (device.product_name == 'mantaray' and
               battery_info.get('AC powered', None) != 'true'):
@@ skipping 18 matching lines @@
                             str(device))
           if blacklist:
             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], reason='status_check_timeout')
 
-    elif blacklist:
-      blacklist.Extend([serial], reason=adb_status)
+      else:

[jbudorick, 2016/03/08 23:13:27]

er, this should stay elif blacklist s.t. it doesn't wind up calling a method on
None.

[bpastene, 2016/03/08 23:36:31]

Done.

+        blacklist.Extend([serial],
+                         reason=adb_status if usb_status else '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
 
 
 def RecoverDevices(devices, blacklist):
   """Attempts to recover any inoperable devices in the provided list.
 
   Args:
     devices: The list of devices to attempt to recover.
     blacklist: The current device blacklist, which will be used then
       reset.
   Returns:
     Nothing.
   """
 
   statuses = DeviceStatus(devices, blacklist)
 
   should_restart_usb = set(
       status['serial'] for status in statuses
       if (not status['usb_status']
-          or status['adb_status'] in ('offline', 'unknown')))
+          or status['adb_status'] in ('offline', 'missing')))
   should_restart_adb = should_restart_usb.union(set(
       status['serial'] for status in statuses
       if status['adb_status'] == 'unauthorized'))
   should_reboot_device = should_restart_adb.union(set(
       status['serial'] for status in statuses
       if status['blacklisted']))
 
   logging.debug('Should restart USB for:')
   for d in should_restart_usb:
     logging.debug('  %s', d)
   logging.debug('Should restart ADB for:')
   for d in should_restart_adb:
     logging.debug('  %s', d)
   logging.debug('Should reboot:')
   for d in should_reboot_device:
     logging.debug('  %s', d)
 
   if blacklist:
     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):
+    except IOError:
       logging.exception('Unable to reset USB for %s.', serial)
       if blacklist:
         blacklist.Extend([serial], reason='usb_failure')
+    except device_errors.DeviceUnreachableError:
+      logging.exception('Unable to reset USB for %s.', serial)
+      if blacklist:
+        blacklist.Extend([serial], reason='offline')
 
   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
@@ skipping 133 matching lines @@
           if status['adb_status'] == 'device':
             f.write('{serial} {adb_status} {build_product} {build_id} '
                     '{temperature:.1f}C {level}%\n'.format(
                 serial=status['serial'],
                 adb_status=status['adb_status'],
                 build_product=status['type'],
                 build_id=status['build'],
                 temperature=float(status['battery']['temperature']) / 10,
                 level=status['battery']['level']
             ))
-          else:
-            f.write('{serial} {adb_status}'.format(
+          elif status.get('usb_status', False):
+            f.write('{serial} {adb_status}\n'.format(
                 serial=status['serial'],
                 adb_status=status['adb_status']
             ))
+          else:
+            f.write('{serial} offline\n'.format(
+                serial=status['serial']
+            ))
         except Exception: # pylint: disable=broad-except
           pass
 
   # Dump the device statuses to JSON.
   if args.json_output:
     with open(args.json_output, 'wb') as f:
       f.write(json.dumps(statuses, indent=4))
 
   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 exit_codes.INFRA
 
 
 if __name__ == '__main__':
   sys.exit(main())