[Android] Fix provisioning for non-rooted devices.

build/android/provision_devices.py

 #!/usr/bin/env python
 #
 # Copyright (c) 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.
 
 """Provisions Android devices with settings required for bots.
 
 Usage:
   ./provision_devices.py [-d <device serial number>]
@@ skipping 67 matching lines @@
   def should_run_phase(phase_name):
     return not options.phases or phase_name in options.phases
 
   def run_phase(phase_func, reboot=True):
     device.WaitUntilFullyBooted(timeout=reboot_timeout)
     phase_func(device, options)
     if reboot:
       device.Reboot(False, retries=0)
       device.adb.WaitForDevice()
 
-  if should_run_phase(_PHASES.WIPE):
-    run_phase(WipeDevice)
+  try:
+    if should_run_phase(_PHASES.WIPE):
+      run_phase(WipeDevice)
 
-  if should_run_phase(_PHASES.PROPERTIES):
-    run_phase(SetProperties)
+    if should_run_phase(_PHASES.PROPERTIES):
+      run_phase(SetProperties)
 
-  if should_run_phase(_PHASES.FINISH):
-    run_phase(FinishProvisioning, reboot=False)
+    if should_run_phase(_PHASES.FINISH):
+      run_phase(FinishProvisioning, reboot=False)
+
+  except (errors.WaitForResponseTimedOutError,
+          device_errors.CommandTimeoutError):
+    logging.exception('Timed out waiting for device %s. Adding to blacklist.',
+                      str(device))
+    device_blacklist.ExtendBlacklist([str(device)])
+
+  except device_errors.CommandFailedError:
+    logging.exception('Failed to provision device %s. Adding to blacklist.',
+                      str(device))
+    device_blacklist.ExtendBlacklist([str(device)])
 
 
 def WipeDevice(device, options):
   """Wipes data from device, keeping only the adb_keys for authorization.
 
   After wiping data on a device that has been authorized, adb can still
   communicate with the device, but after reboot the device will need to be
   re-authorized because the adb keys file is stored in /data/misc/adb/.
   Thus, adb_keys file is rewritten so the device does not need to be
   re-authorized.
 
   Arguments:
     device: the device to wipe
   """
   if options.skip_wipe:
     return
 
-  device.EnableRoot()
-  device_authorized = device.FileExists(constants.ADB_KEYS_FILE)
-  if device_authorized:
-    adb_keys = device.ReadFile(constants.ADB_KEYS_FILE,
-                               as_root=True).splitlines()
   try:
+    device.EnableRoot()
+    device_authorized = device.FileExists(constants.ADB_KEYS_FILE)
+    if device_authorized:
+      adb_keys = device.ReadFile(constants.ADB_KEYS_FILE,
+                                 as_root=True).splitlines()
     device.RunShellCommand(['wipe', 'data'],
                            as_root=True, check_return=True)
+    device.adb.WaitForDevice()
+
+    if device_authorized:
+      adb_keys_set = set(adb_keys)
+      for adb_key_file in options.adb_key_files or []:
+        try:
+          with open(adb_key_file, 'r') as f:
+            adb_public_keys = f.readlines()
+          adb_keys_set.update(adb_public_keys)
+        except IOError:
+          logging.warning('Unable to find adb keys file %s.' % adb_key_file)
+      _WriteAdbKeysFile(device, '\n'.join(adb_keys_set))
   except device_errors.CommandFailedError:
     logging.exception('Possible failure while wiping the device. '
                       'Attempting to continue.')
-  device.adb.WaitForDevice()
-
-  if device_authorized:
-    adb_keys_set = set(adb_keys)
-    for adb_key_file in options.adb_key_files or []:
-      try:
-        with open(adb_key_file, 'r') as f:
-          adb_public_keys = f.readlines()
-        adb_keys_set.update(adb_public_keys)
-      except IOError:
-        logging.warning('Unable to find adb keys file %s.' % adb_key_file)
-    _WriteAdbKeysFile(device, '\n'.join(adb_keys_set))
 
 
 def _WriteAdbKeysFile(device, adb_keys_string):
   dir_path = posixpath.dirname(constants.ADB_KEYS_FILE)
   device.RunShellCommand(['mkdir', '-p', dir_path],
                          as_root=True, check_return=True)
   device.RunShellCommand(['restorecon', dir_path],
                          as_root=True, check_return=True)
   device.WriteFile(constants.ADB_KEYS_FILE, adb_keys_string, as_root=True)
   device.RunShellCommand(['restorecon', constants.ADB_KEYS_FILE],
@@ skipping 41 matching lines @@
     local_props.append('%s=all' % android_commands.JAVA_ASSERT_PROPERTY)
     local_props.append('debug.checkjni=1')
   try:
     device.WriteFile(
         constants.DEVICE_LOCAL_PROPERTIES_PATH,
         '\n'.join(local_props), as_root=True)
     # Android will not respect the local props file if it is world writable.
     device.RunShellCommand(
         ['chmod', '644', constants.DEVICE_LOCAL_PROPERTIES_PATH],
         as_root=True, check_return=True)
-  except device_errors.CommandFailedError as e:
-    logging.warning(str(e))
+  except device_errors.CommandFailedError:
+    logging.exception('Failed to configure local properties.')
 
 
 def FinishProvisioning(device, options):
-  try:
-    device.RunShellCommand(
-        ['date', '-s', time.strftime('%Y%m%d.%H%M%S', time.gmtime())],
-        as_root=True, check_return=True)
-    props = device.RunShellCommand('getprop', check_return=True)
-    for prop in props:
-      logging.info('  %s' % prop)
-    if options.auto_reconnect:
-      _PushAndLaunchAdbReboot(device, options.target)
-  except (errors.WaitForResponseTimedOutError,
-          device_errors.CommandTimeoutError):
-    logging.info('Timed out waiting for device %s. Adding to blacklist.',
-                 str(device))
-    # Device black list is reset by bb_device_status_check.py per build.
-    device_blacklist.ExtendBlacklist([str(device)])
-  except device_errors.CommandFailedError:
-    logging.exception('Failed to provision device %s. Adding to blacklist.',
-                      str(device))
-    device_blacklist.ExtendBlacklist([str(device)])
+  device.RunShellCommand(
+      ['date', '-s', time.strftime('%Y%m%d.%H%M%S', time.gmtime())],
+      as_root=True, check_return=True)
+  props = device.RunShellCommand('getprop', check_return=True)
+  for prop in props:
+    logging.info('  %s' % prop)
+  if options.auto_reconnect:
+    _PushAndLaunchAdbReboot(device, options.target)
 
 
 def _PushAndLaunchAdbReboot(device, target):
   """Pushes and launches the adb_reboot binary on the device.
 
   Arguments:
     device: The DeviceUtils instance for the device to which the adb_reboot
             binary should be pushed.
     target: The build target (example, Debug or Release) which helps in
             locating the adb_reboot binary.
@@ skipping 86 matching lines @@
   args = parser.parse_args()
   constants.SetBuildType(args.target)
 
   run_tests_helper.SetLogLevel(args.verbose)
 
   return ProvisionDevices(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())