[Android] Reland splitting of device recovery and device status.

scripts/slave/recipe_modules/chromium_android/api.py

 # 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.
 
 import contextlib
 import datetime
 import json
 import os
 import re
 import sys
@@ skipping 14 matching lines @@
 
   def get_config_defaults(self):
     return {
       'REVISION': self.m.properties.get('revision', ''),
       'CHECKOUT_PATH': self.m.path['checkout'],
     }
 
   @property
   def devices(self):
     assert self._devices is not None,\
-        'devices is only available after device_status_check()'
+        'devices is only available after device_status()'
     return self._devices
 
   @property
   def out_path(self):
     return self.m.path['checkout'].join('out')
 
   @property
   def coverage_dir(self):
     return self.out_path.join(self.c.BUILD_CONFIG, 'coverage')
 
@@ skipping 276 matching lines @@
     args = ['--verbose', '--adb-path', self.m.adb.adb_path()]
     return self.m.python('authorize_adb_devices', script, args, infra_step=True,
                          env=self.m.chromium.get_env())
 
   def detect_and_setup_devices(self, restart_usb=False, skip_wipe=False,
                                disable_location=False, min_battery_level=None,
                                disable_network=False, disable_java_debug=False,
                                reboot_timeout=None, max_battery_temp=None,
                                remove_system_webview=False):
     self.authorize_adb_devices()
-    self.device_status_check(restart_usb=restart_usb)
+    self.device_recovery()
     self.provision_devices(
       skip_wipe=skip_wipe, disable_location=disable_location,
       min_battery_level=min_battery_level, disable_network=disable_network,
       disable_java_debug=disable_java_debug, reboot_timeout=reboot_timeout,
       max_battery_temp=max_battery_temp,
       remove_system_webview=remove_system_webview)
+    self.device_status()
 
   @property
   def blacklist_file(self):
     return self.out_path.join('bad_devices.json')
 
 
   def revert_device_file_format(self):
     # If current device file is jsonified, revert it back to original format.
     if self.m.path.exists(self.known_devices_file):
       with self.m.step.nest('fix_device_file_format'):
@@ skipping 10 matching lines @@
         except ValueError:
           # File wasn't json, so no need to revert.
           self.m.step.active_result.presentation.step_text += (
               'file format is compatible')
 
   def device_status_check(self, restart_usb=False, **kwargs):
     # TODO(bpastene): Remove once chromium revisions prior to
     # crrev.com/1faecde0c03013b6cd725da413339c60223f8948 are no longer tested.
     # See crbug.com/619707 for context.
     self.revert_device_file_format()
+    self.device_recovery()
+    self.device_status()
 
-    # TODO(phajdan.jr): Remove path['build'] usage, http://crbug.com/437264 .
+  def device_recovery(self, restart_usb=False, **kwargs):
     args = [
+        '--blacklist-file', self.blacklist_file,
+        '--known-devices-file', self.known_devices_file,
         '--adb-path', self.m.adb.adb_path(),
+        '-v'
+    ]
+    self.m.step(
+        'device_recovery',
+        [self.m.path['checkout'].join('third_party', 'catapult', 'devil',
+                                      'devil', 'android', 'tools',
+                                      'device_recovery.py')] + args,
+        env=self.m.chromium.get_env(),
+        infra_step=True,
+        **kwargs)
+
+  def device_status(self, **kwargs):
+    buildbot_file = '/home/chrome-bot/.adb_device_info'
+    args = [
+        '--json-output', self.m.json.output(),
         '--blacklist-file', self.blacklist_file,
-        '--json-output', self.m.json.output(),
-        '--known-devices-file', self.known_devices_file
+        '--known-devices-file', self.known_devices_file,
+        '--buildbot-path', buildbot_file,
+        '--adb-path', self.m.adb.adb_path(),
+        '-v', '--overwrite-known-devices-files',
     ]
-    if restart_usb:
-      args += ['--restart-usb']
-
     try:
       result = self.m.step(
-          'device_status_check',
-          [self.m.path['checkout'].join('build', 'android', 'buildbot',
-                                'bb_device_status_check.py')] + args,
+          'device_status',
+          [self.m.path['checkout'].join('third_party', 'catapult', 'devil',
+                                        'devil', 'android', 'tools',
+                                        'device_status.py')] + args,
           step_test_data=lambda: self.m.json.test_api.output([
               {
                 "battery": {
                     "status": "5",
                     "scale": "100",
                     "temperature": "249",
                     "level": "100",
                     "AC powered": "false",
                     "health": "2",
                     "voltage": "4286",
                     "Wireless powered": "false",
                     "USB powered": "true",
                     "technology": "Li-ion",
                     "present": "true"
                 },
                 "wifi_ip": "",
                 "imei_slice": "Unknown",
-                "build": "LRX21O",
+                "ro.build.id": "LRX21O",
+                "ro.build.product": "product_name",
                 "build_detail":
                     "google/razor/flo:5.0/LRX21O/1570415:userdebug/dev-keys",
                 "serial": "07a00ca4",
-                "type": "flo",
                 "adb_status": "device",
                 "blacklisted": False,
                 "usb_status": True,
             },
             {
               "adb_status": "offline",
               "blacklisted": True,
               "serial": "03e0363a003c6ad4",
               "usb_status": False,
             },
@@ skipping 16 matching lines @@
       self._devices = []
       offline_device_index = 1
       for d in result.json.output:
         try:
           if not d['usb_status']:
             key = '%s: missing' % d['serial']
           elif d['adb_status'] != 'device':
             key = '%s: adb status %s' % (d['serial'], d['adb_status'])
           elif d['blacklisted']:
             key = '%s: blacklisted' % d['serial']
           else:

[rnephew (Reviews Here), 2016/07/12 16:16:47]

Changes from last attempt found here.

[jbudorick, 2016/07/12 16:18:08]

Acknowledged.

-            key = '%s %s %s' % (d['type'], d['build'], d['serial'])
+            key = '%s %s %s' % (d['ro.build.product'], d['ro.build.id'],
+                                d['serial'])
             self._devices.append(d['serial'])
         except KeyError:
           key = 'unknown device %d' % offline_device_index
           offline_device_index += 1
         result.presentation.logs[key] = self.m.json.dumps(
             d, indent=2).splitlines()
       result.presentation.step_text = 'Online devices: %s' % len(self._devices)
       return result
     except self.m.step.InfraFailure as f:
       params = {
         'summary': ('Device Offline on %s %s' %
           (self.m.properties['mastername'], self.m.properties['slavename'])),
         'comment': ('Buildbot: %s\n(Please do not change any labels)' %
           self.m.properties['buildername']),
         'labels': 'Restrict-View-Google,OS-Android,Infra,Infra-Labs',
       }
       link = ('https://code.google.com/p/chromium/issues/entry?%s' %
         urllib.urlencode(params))
       f.result.presentation.links.update({
         'report a bug': link
       })
       raise
 
+
   def provision_devices(self, skip_wipe=False, disable_location=False,
                         min_battery_level=None, disable_network=False,
                         disable_java_debug=False, max_battery_temp=None,
                         disable_system_chrome=False, reboot_timeout=None,
                         remove_system_webview=False, emulators=False,
                         **kwargs):
     args = [
         '--adb-path', self.m.adb.adb_path(),
         '--blacklist-file', self.blacklist_file,
         '--output-device-blacklist', self.m.json.output(add_json_log=False),
@@ skipping 30 matching lines @@
     if emulators:
       args.append('--emulators')
     result = self.m.python(
       'provision_devices',
       self.m.path['checkout'].join(
           'build', 'android', 'provision_devices.py'),
       args=args,
       env=self.m.chromium.get_env(),
       infra_step=True,
       **kwargs)
-    blacklisted_devices = result.json.output
-    if blacklisted_devices:
-      result.presentation.status = self.m.step.WARNING
-      for d in blacklisted_devices:
-        key = 'blacklisted %s' % d
-        result.presentation.logs[key] = [d]
 
   def apk_path(self, apk):
     return self.m.chromium.output_dir.join('apks', apk) if apk else None
 
   def adb_install_apk(self, apk, allow_downgrade=False, devices=None):
     install_cmd = [
         self.m.path['checkout'].join('build',
                                      'android',
                                      'adb_install_apk.py'),
         apk, '-v', '--blacklist-file', self.blacklist_file,
@@ skipping 393 matching lines @@
     self.create_adb_symlink()
     if self.c.gce_setup:
       self.launch_gce_instances(snapshot=self.c.gce_snapshot,
                                 count=self.c.gce_count)
       self.spawn_logcat_monitor()
       self.provision_devices(emulators=True,
                              remove_system_webview=remove_system_webview)
     else:
       self.spawn_logcat_monitor()
       self.authorize_adb_devices()
-      self.device_status_check()
+      self.device_recovery()
       if perf_setup:
         kwargs = {
             'min_battery_level': 95,
             'disable_network': True,
             'disable_java_debug': True,
             'max_battery_temp': 350}
       else:
         kwargs = {}
       self.provision_devices(remove_system_webview=remove_system_webview,
                              **kwargs)
+      self.device_status()
       if self.m.chromium.c.gyp_env.GYP_DEFINES.get('asan', 0) == 1:
         self.asan_device_setup()
 
       self.spawn_device_monitor()
 
   def common_tests_final_steps(self, logcat_gs_bucket='chromium-android'):
     if not self.c.gce_setup:
       self.shutdown_device_monitor()
     self.logcat_dump(gs_bucket=logcat_gs_bucket)
     self.stack_tool_steps()
@@ skipping 402 matching lines @@
       script = self.c.test_runner
       if wrapper_script_suite_name:
         script = self.m.chromium.output_dir.join('bin', 'run_%s' %
                                                  wrapper_script_suite_name)
       else:
         env = kwargs.get('env', {})
         env['CHROMIUM_OUTPUT_DIR'] = env.get('CHROMIUM_OUTPUT_DIR',
                                              self.m.chromium.output_dir)
         kwargs['env'] = env
       return self.m.python(step_name, script, args, **kwargs)