Write adb public key to devices during provision.

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 95 matching lines @@
         '\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)
   except device_errors.CommandFailedError as e:
     logging.warning(str(e))
 
   # LOCAL_PROPERTIES_PATH = '/data/local.prop'
 
+def WriteAdbKeysFile(device, adb_keys_string):
+  path_list = constants.ADB_KEYS_FILE.split('/')
+  dir_path = '/'.join(path_list[:len(path_list)-1])

[perezju, 2015/02/25 09:35:41]

nit: maybe that's just me, but I would go for:
  dir_path = posixpath.dirname(constants.ADB_KEYS_FILE)

[jbudorick, 2015/02/25 14:09:07]

I didn't know about posixpath. We should be using that elsewhere for device path
manipulations...

[navabi, 2015/02/25 18:57:25]

Yeah I don't like this split. But how about using:
dir_path = os.path.dirname(constants.ADB_KEYS_FILE) 

Is posixpath preferred over os.path.dirname? I changed to use os.path.dirname
for now.

[jbudorick, 2015/02/25 21:47:38]

It depends on the path being manipulated:
 - for host paths, os.path is preferred
 - for device paths, we have historically handrolled path manipulation (e.g.
'/'.join(path_components), path.split('/')). However, posixpath handles paths
the way we want for devices.

+  device.RunShellCommand('mkdir -p %s' % dir_path, as_root=True)
+  device.RunShellCommand('restorecon %s' % dir_path, as_root=True)
+  device.WriteFile(constants.ADB_KEYS_FILE, adb_keys_string, as_root=True)
+  device.RunShellCommand('restorecon %s' % constants.ADB_KEYS_FILE,
+                         as_root=True)
+
 
 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.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.WriteFile(constants.ADB_KEYS_FILE, adb_keys, as_root=True)
-    device.RunShellCommand('restorecon %s' % constants.ADB_KEYS_FILE,
-                           as_root=True)
+    WriteAdbKeysFile(device, adb_keys)
 
 
 def WipeDeviceIfPossible(device, timeout):
   try:
     device.EnableRoot()
     WipeDeviceData(device)
     device.Reboot(True, timeout=timeout, retries=0)
   except (errors.DeviceUnresponsiveError, device_errors.CommandFailedError):
     pass
 
 
 def ProvisionDevice(device, options):
   if options.reboot_timeout:
     reboot_timeout = options.reboot_timeout
   elif (device.build_version_sdk >=
         constants.ANDROID_SDK_VERSION_CODES.LOLLIPOP):
     reboot_timeout = _DEFAULT_TIMEOUTS.LOLLIPOP
   else:
     reboot_timeout = _DEFAULT_TIMEOUTS.PRE_LOLLIPOP
 
+  if options.adb_key_files:
+    adb_keys = set()

[perezju, 2015/02/25 09:35:41]

nit: does it really need to be a set? do we expect passing more than one file
*and* have the same public key appear in multiple files?

[navabi, 2015/02/25 18:57:25]

Not the way the current adb keys on the host are, but following up on your
comment on 168, let's keep it a set in case in the future we end up with
multiple adb keys in a adb key file on the host. Then there may be an
intersection of adb keys between multiple files that are passed in.

+    for adb_key_file in options.adb_key_files:
+      with open(adb_key_file, 'r') as f:
+        adb_public_key = f.readlines()[0]

[perezju, 2015/02/25 09:35:41]

why do we keep only the first line? (earlier versions of your CL kept all of the
lines)

Also, if you only want the first line you can avoid reading the whole file by
doing instead:
  adb_public_key = next(f).rstrip()

[navabi, 2015/02/25 18:57:25]

Because before we were reading the adb keys file on the device which have
multiple lines. Here we are reading individual adb keys on the host, and the way
we have it set up is that we have multiple adb key files each with one adb key.
It *could* have multiple lines per adb key on the host, so I changed it.

+      adb_keys.add(adb_public_key)
+    adb_key_contents = '\n'.join(adb_keys)
+    WriteAdbKeysFile(device, adb_key_contents)

[jbudorick, 2015/02/25 14:09:07]

This will wipe existing keys from the device. Would that cause problems before
the hosts have the private keys? Should this preserve any keys on the device and
just add the keys from the key files?

[navabi, 2015/02/25 18:57:25]

This will not cause problems before the hosts have the private keys. The reason
is when we run this command to put the shared public adb key onto the devices
for the first time, we will be careful to also include the existing public key
on the host, which is currently used to authenticate adb on the devices.

I intend this option to overwrite the adb keys. It is up to the caller to make
sure they overwrite the adb keys the right way (e.g. include the existing public
keys so we don't lose authentication). We have plans on how to do that. We will
test first on one bot before deploying everywhere.

[jbudorick, 2015/02/25 21:47:38]

This makes me a little nervous, but ok.

+
   try:
     if not options.skip_wipe:
       WipeDeviceIfPossible(device, reboot_timeout)
     try:
       device.EnableRoot()
     except device_errors.CommandFailedError as e:
       logging.warning(str(e))
     _ConfigureLocalProperties(device, options.enable_java_debug)
     device_settings.ConfigureContentSettings(
         device, device_settings.DETERMINISTIC_DEVICE_SETTINGS)
@@ skipping 98 matching lines @@
   parser.add_argument('--disable-network', action='store_true',
                       help='disable network access on devices')
   parser.add_argument('--disable-java-debug', action='store_false',
                       dest='enable_java_debug', default=True,
                       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')
+  parser.add_argument('--adb-key-files', type=str, nargs='+',
+                      help='list of adb keys to push to device')
   args = parser.parse_args()
   constants.SetBuildType(args.target)
 
   return ProvisionDevices(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())