Roll Chrome into Mojo.

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>]
 """
 
+import argparse
 import logging
-import optparse
 import os
 import re
 import subprocess
 import sys
 import time
 
 from pylib import android_commands
 from pylib import constants
 from pylib import device_settings
 from pylib.device import device_blacklist
@@ skipping 47 matching lines @@
   logging.info('  Pushing adb_reboot ...')
   adb_reboot = os.path.join(constants.DIR_SOURCE_ROOT,
                             'out/%s/adb_reboot' % target)
   device.PushChangedFiles([(adb_reboot, '/data/local/tmp/')])
   # Launch adb_reboot
   logging.info('  Launching adb_reboot ...')
   device.old_interface.GetAndroidToolStatusAndOutput(
       '/data/local/tmp/adb_reboot')
 
 
-def _ConfigureLocalProperties(device, is_perf):
+def _ConfigureLocalProperties(device, java_debug=True):
   """Set standard readonly testing device properties prior to reboot."""
   local_props = [
       'persist.sys.usb.config=adb',
       'ro.monkey=1',
       'ro.test_harness=1',
       'ro.audio.silent=1',
       'ro.setupwizard.mode=DISABLED',
       ]
-  if not is_perf:
+  if java_debug:
     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 %s' % constants.DEVICE_LOCAL_PROPERTIES_PATH,
+        ['chmod', '644', constants.DEVICE_LOCAL_PROPERTIES_PATH],
         as_root=True)
   except device_errors.CommandFailedError as e:
     logging.warning(str(e))
 
   # LOCAL_PROPERTIES_PATH = '/data/local.prop'
 
 
 def WipeDeviceData(device):
   """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
   """
   device_authorized = device.FileExists(constants.ADB_KEYS_FILE)
   if device_authorized:
-    adb_keys = device.RunShellCommand('cat %s' % constants.ADB_KEYS_FILE,
-                                      as_root=True)
+    adb_keys = device.ReadFile(constants.ADB_KEYS_FILE, as_root=True)
   device.RunShellCommand('wipe data', as_root=True)
   if device_authorized:
     path_list = constants.ADB_KEYS_FILE.split('/')
     dir_path = '/'.join(path_list[:len(path_list)-1])
     device.RunShellCommand('mkdir -p %s' % dir_path, as_root=True)
     device.RunShellCommand('restorecon %s' % dir_path, as_root=True)
-    device.RunShellCommand('echo %s > %s' %
-                           (adb_keys[0], constants.ADB_KEYS_FILE), as_root=True)
-    for adb_key in adb_keys[1:]:
-      device.RunShellCommand(
-        'echo %s >> %s' % (adb_key, constants.ADB_KEYS_FILE), as_root=True)
+    device.WriteFile(constants.ADB_KEYS_FILE, adb_keys, as_root=True)
     device.RunShellCommand('restorecon %s' % constants.ADB_KEYS_FILE,
                            as_root=True)
 
 
-def WipeDeviceIfPossible(device):
+def WipeDeviceIfPossible(device, timeout):
   try:
     device.EnableRoot()
     WipeDeviceData(device)
-    # TODO(jbudorick): Tune the timeout per OS version.
-    device.Reboot(True, timeout=600, retries=0)
+    device.Reboot(True, timeout=timeout, retries=0)
   except (errors.DeviceUnresponsiveError, device_errors.CommandFailedError):
     pass
 
 
-def ProvisionDevice(device, options, is_perf):
+def ProvisionDevice(device, options):
   try:
     if not options.skip_wipe:
-      WipeDeviceIfPossible(device)
+      WipeDeviceIfPossible(device, options.reboot_timeout)
     try:
       device.EnableRoot()
     except device_errors.CommandFailedError as e:
       logging.warning(str(e))
-    _ConfigureLocalProperties(device, is_perf)
+    _ConfigureLocalProperties(device, options.enable_java_debug)
     device_settings.ConfigureContentSettings(
         device, device_settings.DETERMINISTIC_DEVICE_SETTINGS)
     if options.disable_location:
       device_settings.ConfigureContentSettings(
           device, device_settings.DISABLE_LOCATION_SETTINGS)
     else:
       device_settings.ConfigureContentSettings(
           device, device_settings.ENABLE_LOCATION_SETTINGS)
     device_settings.SetLockScreenSettings(device)
-    if is_perf:
-      # TODO(tonyg): We eventually want network on. However, currently radios
-      # can cause perfbots to drain faster than they charge.
+    if options.disable_network:
       device_settings.ConfigureContentSettings(
           device, device_settings.NETWORK_DISABLED_SETTINGS)
-      # Some perf bots run benchmarks with USB charging disabled which leads
-      # to gradual draining of the battery. We must wait for a full charge
-      # before starting a run in order to keep the devices online.
+    if options.wait_for_battery:
       try:
         battery_info = device.old_interface.GetBatteryInfo()
       except Exception as e:
         battery_info = {}
         logging.error('Unable to obtain battery info for %s, %s',
                       str(device), e)
 
       while int(battery_info.get('level', 100)) < options.min_battery_level:
         if not device.old_interface.IsDeviceCharging():
           if device.old_interface.CanControlUsbCharging():
             device.old_interface.EnableUsbCharging()
           else:
             logging.error('Device is not charging')
             break
         logging.info('Waiting for device to charge. Current level=%s',
                      battery_info.get('level', 0))
         time.sleep(60)
         battery_info = device.old_interface.GetBatteryInfo()
     if not options.skip_wipe:
-      # TODO(jbudorick): Tune the timeout per OS version.
-      device.Reboot(True, timeout=600, retries=0)
+      device.Reboot(True, timeout=options.reboot_timeout, retries=0)
     device.RunShellCommand('date -s %s' % time.strftime('%Y%m%d.%H%M%S',
                                                         time.gmtime()),
                            as_root=True)
     props = device.RunShellCommand('getprop')
     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)])
 
 
 def ProvisionDevices(options):
-  is_perf = 'perf' in os.environ.get('BUILDBOT_BUILDERNAME', '').lower()
   if options.device is not None:
     devices = [options.device]
   else:
     devices = android_commands.GetAttachedDevices()
 
   parallel_devices = device_utils.DeviceUtils.parallel(devices)
-  parallel_devices.pMap(ProvisionDevice, options, is_perf)
+  parallel_devices.pMap(ProvisionDevice, options)
   if options.auto_reconnect:
     LaunchHostHeartbeat()
   blacklist = device_blacklist.ReadBlacklist()
   if all(d in blacklist for d in devices):
     raise device_errors.NoDevicesError
   return 0
 
 
-def main(argv):
+def main():
   custom_handler = logging.StreamHandler(sys.stdout)
   custom_handler.setFormatter(run_tests_helper.CustomFormatter())
   logging.getLogger().addHandler(custom_handler)
   logging.getLogger().setLevel(logging.INFO)
 
-  parser = optparse.OptionParser()
-  parser.add_option('--min-battery-level', default=95, type='int',
-                    help="Minimum battery level for performance testing "
-                         "(default: 95).")
-  parser.add_option('--skip-wipe', action='store_true', default=False,
-                    help="Don't wipe device data during provisioning.")
-  parser.add_option('--disable-location', action='store_true', default=False,
-                    help="Disallow Google location services on devices.")
-  parser.add_option('-d', '--device',
-                    help='The serial number of the device to be provisioned')
-  parser.add_option('-t', '--target', default='Debug', help='The build target')
-  parser.add_option(
-      '-r', '--auto-reconnect', action='store_true',
-      help='Push binary which will reboot the device on adb disconnections.')
-  options, args = parser.parse_args(argv[1:])
-  constants.SetBuildType(options.target)
+  # TODO(perezju): This script used to rely on the builder name to determine
+  # the desired device configuration for perf bots. To safely phase this out,
+  # we now:
+  # - expose these configuration settings as command line options
+  # - set default values for these options based on the builder name, thus
+  #   matching the previous behaviour of the script on all bots.
+  # - explicitly adding these options on the perf bots will also maintain the
+  #   script behaviour, namely:
+  #     --wait-for-battery --disable-network --disable-java-debug
+  # - after all perf-bot recipes are updated, we can remove the following
+  #   builder-name-sniffing code and replace |is_perf| with |False|.
+  is_perf = 'perf' in os.environ.get('BUILDBOT_BUILDERNAME', '').lower()
 
-  if args:
-    print >> sys.stderr, 'Unused args %s' % args
-    return 1
+  # Recommended options on perf bots:
+  # --disable-network
+  #     TODO(tonyg): We eventually want network on. However, currently radios
+  #     can cause perfbots to drain faster than they charge.
+  # --wait-for-battery
+  #     Some perf bots run benchmarks with USB charging disabled which leads
+  #     to gradual draining of the battery. We must wait for a full charge
+  #     before starting a run in order to keep the devices online.
 
-  return ProvisionDevices(options)
+  parser = argparse.ArgumentParser(
+      description='Provision Android devices with settings required for bots.')
+  parser.add_argument('-d', '--device', metavar='SERIAL',
+                      help='the serial number of the device to be provisioned'
+                      ' (the default is to provision all devices attached)')
+  parser.add_argument('--skip-wipe', action='store_true', default=False,
+                      help="don't wipe device data during provisioning")
+  parser.add_argument('--reboot-timeout', default=600, type=int,
+                      metavar='SECS',
+                      help='when wiping the device, max number of seconds to'
+                      ' wait after each reboot (default: %(default)s)')
+  parser.add_argument('--wait-for-battery', action='store_true',
+                      default=is_perf,
+                      help='wait for the battery on the devices to charge')
+  parser.add_argument('--min-battery-level', default=95, type=int,
+                      metavar='NUM',
+                      help='when waiting for battery, minimum battery level'
+                      ' required to continue (default: %(default)s)')
+  parser.add_argument('--disable-location', action='store_true',
+                      help='disable Google location services on devices')
+  parser.add_argument('--disable-network', action='store_true',
+                      default=is_perf,
+                      help='disable network access on devices')
+  parser.add_argument('--disable-java-debug', action='store_false',
+                      dest='enable_java_debug', default=not is_perf,
+                      help='disable Java property asserts and JNI checking')
+  parser.add_argument('-t', '--target', default='Debug',
+                      help='the build target (default: %(default)s)')
+  parser.add_argument('-r', '--auto-reconnect', action='store_true',
+                      help='push binary which will reboot the device on adb'
+                      ' disconnections')
+  args = parser.parse_args()
+  constants.SetBuildType(args.target)
+
+  return ProvisionDevices(args)
 
 
 if __name__ == '__main__':
-  sys.exit(main(sys.argv))
+  sys.exit(main())