1#!/usr/bin/env python
2#
3# Copyright (c) 2013 The Chromium Authors. All rights reserved.
4# Use of this source code is governed by a BSD-style license that can be
5# found in the LICENSE file.
6
7"""Provisions Android devices with settings required for bots.
8
9Usage:
10  ./provision_devices.py [-d <device serial number>]
11"""
12
13import logging
14import optparse
15import os
16import re
17import subprocess
18import sys
19import time
20
21from pylib import android_commands
22from pylib import constants
23from pylib import device_settings
24from pylib.device import device_blacklist
25from pylib.device import device_errors
26from pylib.device import device_utils
27from pylib.utils import run_tests_helper
28
29sys.path.append(os.path.join(constants.DIR_SOURCE_ROOT,
30                             'third_party', 'android_testrunner'))
31import errors
32
33def KillHostHeartbeat():
34  ps = subprocess.Popen(['ps', 'aux'], stdout = subprocess.PIPE)
35  stdout, _ = ps.communicate()
36  matches = re.findall('\\n.*host_heartbeat.*', stdout)
37  for match in matches:
38    logging.info('An instance of host heart beart running... will kill')
39    pid = re.findall('(\S+)', match)[1]
40    subprocess.call(['kill', str(pid)])
41
42
43def LaunchHostHeartbeat():
44  # Kill if existing host_heartbeat
45  KillHostHeartbeat()
46  # Launch a new host_heartbeat
47  logging.info('Spawning host heartbeat...')
48  subprocess.Popen([os.path.join(constants.DIR_SOURCE_ROOT,
49                                 'build/android/host_heartbeat.py')])
50
51
52def PushAndLaunchAdbReboot(device, target):
53  """Pushes and launches the adb_reboot binary on the device.
54
55  Arguments:
56    device: The DeviceUtils instance for the device to which the adb_reboot
57            binary should be pushed.
58    target: The build target (example, Debug or Release) which helps in
59            locating the adb_reboot binary.
60  """
61  logging.info('Will push and launch adb_reboot on %s' % str(device))
62  # Kill if adb_reboot is already running.
63  try:
64    # Don't try to kill adb_reboot more than once. We don't expect it to be
65    # running at all.
66    device.KillAll('adb_reboot', blocking=True, timeout=2, retries=0)
67  except device_errors.CommandFailedError:
68    # We can safely ignore the exception because we don't expect adb_reboot
69    # to be running.
70    pass
71  # Push adb_reboot
72  logging.info('  Pushing adb_reboot ...')
73  adb_reboot = os.path.join(constants.DIR_SOURCE_ROOT,
74                            'out/%s/adb_reboot' % target)
75  device.PushChangedFiles(adb_reboot, '/data/local/tmp/')
76  # Launch adb_reboot
77  logging.info('  Launching adb_reboot ...')
78  device.old_interface.GetAndroidToolStatusAndOutput(
79      '/data/local/tmp/adb_reboot')
80
81
82def _ConfigureLocalProperties(device, is_perf):
83  """Set standard readonly testing device properties prior to reboot."""
84  local_props = [
85      'persist.sys.usb.config=adb',
86      'ro.monkey=1',
87      'ro.test_harness=1',
88      'ro.audio.silent=1',
89      'ro.setupwizard.mode=DISABLED',
90      ]
91  if not is_perf:
92    local_props.append('%s=all' % android_commands.JAVA_ASSERT_PROPERTY)
93    local_props.append('debug.checkjni=1')
94  try:
95    device.WriteFile(
96        constants.DEVICE_LOCAL_PROPERTIES_PATH,
97        '\n'.join(local_props), as_root=True)
98    # Android will not respect the local props file if it is world writable.
99    device.RunShellCommand(
100        'chmod 644 %s' % constants.DEVICE_LOCAL_PROPERTIES_PATH,
101        as_root=True)
102  except device_errors.CommandFailedError as e:
103    logging.warning(str(e))
104
105  # LOCAL_PROPERTIES_PATH = '/data/local.prop'
106
107
108def WipeDeviceData(device):
109  """Wipes data from device, keeping only the adb_keys for authorization.
110
111  After wiping data on a device that has been authorized, adb can still
112  communicate with the device, but after reboot the device will need to be
113  re-authorized because the adb keys file is stored in /data/misc/adb/.
114  Thus, adb_keys file is rewritten so the device does not need to be
115  re-authorized.
116
117  Arguments:
118    device: the device to wipe
119  """
120  device_authorized = device.FileExists(constants.ADB_KEYS_FILE)
121  if device_authorized:
122    adb_keys = device.RunShellCommand('cat %s' % constants.ADB_KEYS_FILE,
123                                      as_root=True)
124  device.RunShellCommand('wipe data', as_root=True)
125  if device_authorized:
126    path_list = constants.ADB_KEYS_FILE.split('/')
127    dir_path = '/'.join(path_list[:len(path_list)-1])
128    device.RunShellCommand('mkdir -p %s' % dir_path, as_root=True)
129    device.RunShellCommand('restorecon %s' % dir_path, as_root=True)
130    device.RunShellCommand('echo %s > %s' %
131                           (adb_keys[0], constants.ADB_KEYS_FILE), as_root=True)
132    for adb_key in adb_keys[1:]:
133      device.RunShellCommand(
134        'echo %s >> %s' % (adb_key, constants.ADB_KEYS_FILE), as_root=True)
135    device.RunShellCommand('restorecon %s' % constants.ADB_KEYS_FILE,
136                           as_root=True)
137
138
139def WipeDeviceIfPossible(device):
140  try:
141    device.EnableRoot()
142    WipeDeviceData(device)
143    # TODO(jbudorick): Tune the timeout per OS version.
144    device.Reboot(True, timeout=600, retries=0)
145  except (errors.DeviceUnresponsiveError, device_errors.CommandFailedError):
146    pass
147
148
149def ProvisionDevice(device, options, is_perf):
150  try:
151    if not options.skip_wipe:
152      WipeDeviceIfPossible(device)
153    try:
154      device.EnableRoot()
155    except device_errors.CommandFailedError as e:
156      logging.warning(str(e))
157    _ConfigureLocalProperties(device, is_perf)
158    device_settings.ConfigureContentSettings(
159        device, device_settings.DETERMINISTIC_DEVICE_SETTINGS)
160    if options.disable_location:
161      device_settings.ConfigureContentSettings(
162          device, device_settings.DISABLE_LOCATION_SETTINGS)
163    else:
164      device_settings.ConfigureContentSettings(
165          device, device_settings.ENABLE_LOCATION_SETTINGS)
166    device_settings.SetLockScreenSettings(device)
167    if is_perf:
168      # TODO(tonyg): We eventually want network on. However, currently radios
169      # can cause perfbots to drain faster than they charge.
170      device_settings.ConfigureContentSettings(
171          device, device_settings.NETWORK_DISABLED_SETTINGS)
172      # Some perf bots run benchmarks with USB charging disabled which leads
173      # to gradual draining of the battery. We must wait for a full charge
174      # before starting a run in order to keep the devices online.
175      try:
176        battery_info = device.old_interface.GetBatteryInfo()
177      except Exception as e:
178        battery_info = {}
179        logging.error('Unable to obtain battery info for %s, %s',
180                      str(device), e)
181
182      while int(battery_info.get('level', 100)) < 95:
183        if not device.old_interface.IsDeviceCharging():
184          if device.old_interface.CanControlUsbCharging():
185            device.old_interface.EnableUsbCharging()
186          else:
187            logging.error('Device is not charging')
188            break
189        logging.info('Waiting for device to charge. Current level=%s',
190                     battery_info.get('level', 0))
191        time.sleep(60)
192        battery_info = device.old_interface.GetBatteryInfo()
193    device.RunShellCommand('date -u %f' % time.time(), as_root=True)
194    # TODO(jbudorick): Tune the timeout per OS version.
195    device.Reboot(True, timeout=600, retries=0)
196    props = device.RunShellCommand('getprop')
197    for prop in props:
198      logging.info('  %s' % prop)
199    if options.auto_reconnect:
200      PushAndLaunchAdbReboot(device, options.target)
201  except (errors.WaitForResponseTimedOutError,
202          device_errors.CommandTimeoutError):
203    logging.info('Timed out waiting for device %s. Adding to blacklist.',
204                 str(device))
205    # Device black list is reset by bb_device_status_check.py per build.
206    device_blacklist.ExtendBlacklist([str(device)])
207  except (device_errors.CommandFailedError):
208    logging.info('Failed to provision device %s. Adding to blacklist.',
209                 str(device))
210    device_blacklist.ExtendBlacklist([str(device)])
211
212
213def ProvisionDevices(options):
214  is_perf = 'perf' in os.environ.get('BUILDBOT_BUILDERNAME', '').lower()
215  if options.device is not None:
216    devices = [options.device]
217  else:
218    devices = android_commands.GetAttachedDevices()
219
220  parallel_devices = device_utils.DeviceUtils.parallel(devices)
221  parallel_devices.pMap(ProvisionDevice, options, is_perf)
222  if options.auto_reconnect:
223    LaunchHostHeartbeat()
224  blacklist = device_blacklist.ReadBlacklist()
225  if all(d in blacklist for d in devices):
226    raise device_errors.NoDevicesError
227  return 0
228
229
230def main(argv):
231  custom_handler = logging.StreamHandler(sys.stdout)
232  custom_handler.setFormatter(run_tests_helper.CustomFormatter())
233  logging.getLogger().addHandler(custom_handler)
234  logging.getLogger().setLevel(logging.INFO)
235
236  parser = optparse.OptionParser()
237  parser.add_option('--skip-wipe', action='store_true', default=False,
238                    help="Don't wipe device data during provisioning.")
239  parser.add_option('--disable-location', action='store_true', default=False,
240                    help="Disallow Google location services on devices.")
241  parser.add_option('-d', '--device',
242                    help='The serial number of the device to be provisioned')
243  parser.add_option('-t', '--target', default='Debug', help='The build target')
244  parser.add_option(
245      '-r', '--auto-reconnect', action='store_true',
246      help='Push binary which will reboot the device on adb disconnections.')
247  options, args = parser.parse_args(argv[1:])
248  constants.SetBuildType(options.target)
249
250  if args:
251    print >> sys.stderr, 'Unused args %s' % args
252    return 1
253
254  return ProvisionDevices(options)
255
256
257if __name__ == '__main__':
258  sys.exit(main(sys.argv))
259