Small improvements to api.platforms.android.

appengine/swarming/swarming_bot/api/platforms/android.py

 # Copyright 2015 The Swarming Authors. All rights reserved.
 # Use of this source code is governed by the Apache v2.0 license that can be
 # found in the LICENSE file.
 
 """Android specific utility functions.
 
 This file serves as an API to bot_config.py. bot_config.py can be replaced on
 the server to allow additional server-specific functionality.
 """
 
@@ skipping 34 matching lines @@
   def __init__(self):
     self._buf = ''
   def update(self, msg):
     self._buf += msg
   def digest(self):
     return self._buf
 pkcs1.HASH_METHODS['SHA-1-PREHASHED'] = _Accum
 pkcs1.HASH_ASN1['SHA-1-PREHASHED'] = pkcs1.HASH_ASN1['SHA-1']
 
 
-# Set when ADB is initialized. It contains one or multiple key used to
-# authenticate to Android debug protocol (adb).
+# Both following are set when ADB is initialized.
+# _ADB_KEYS is set to a list of _PythonRSASigner instances. It contains one or
+# multiple key used to authenticate to Android debug protocol (adb).
 _ADB_KEYS = None
+# _ADB_KEYS_RAW is set to a dict(pub: priv) when initialized, with the raw
+# content of each key.
+_ADB_KEYS_RAW = None
 
 
 # Cache of /system/build.prop on Android devices connected to this host.
 _BUILD_PROP_ANDROID = {}
 
 
 class _PythonRSASigner(object):
   """Implements adb_protocol.AuthSigner using http://stuvel.eu/rsa."""
   def __init__(self, pub, priv):
     self.priv_key = _load_rsa_private_key(priv)
@@ skipping 110 matching lines @@
       logging.warning(
           'Trying unpluging and pluging it back: %s: %s', port_path, e)
   # Always create a Device, even if it points to nothing. It makes using the
   # client code much easier.
   return Device(cmd, port_path)
 
 
 ### Public API.
 
 
+# List of known CPU scaling governor values.
+KNOWN_CPU_SCALING_GOVERNOR_VALUES = (
+  'conservative',  # Not available on Nexus 10
+  'interactive',   # Default on Nexus 10.
+  'ondemand',      # Not available on Nexus 10. Default on Nexus 4 and later.
+  'performance',
+  'powersave',     # Not available on Nexus 10.
+  'userspace',
+)
+
+
 class Device(object):
   """Wraps an AdbCommands to make it exception safe.
 
   The fact that exceptions can be thrown any time makes the client code really
   hard to write safely. Convert USBError* to None return value.
   """
   def __init__(self, adb_cmd, port_path):
     if adb_cmd:
       assert isinstance(adb_cmd, adb.adb_commands.AdbCommands), adb_cmd
     self.adb_cmd = adb_cmd
@@ skipping 80 matching lines @@
     return '', int(parts[0])
 
 
 def initialize(pub_key, priv_key):
   """Initialize Android support through adb.
 
   You can steal pub_key, priv_key pair from ~/.android/adbkey and
   ~/.android/adbkey.pub.
   """
   global _ADB_KEYS
+  global _ADB_KEYS_RAW
+  if _ADB_KEYS is not None:
+    assert False, 'initialize() was called repeatedly: ignoring keys'
   assert bool(pub_key) == bool(priv_key)
-  if _ADB_KEYS is None:
-    _ADB_KEYS = []
-    if pub_key:
-      try:
-        _ADB_KEYS.append(_PythonRSASigner(pub_key, priv_key))
-      except ValueError as exc:
-        logging.warning('Ignoring adb private key: %s', exc)
+  pub_key = pub_key.strip() if pub_key else pub_key
+  priv_key = priv_key.strip() if priv_key else priv_key
 
-    # Try to add local adb keys if available.
-    path = os.path.expanduser('~/.android/adbkey')
-    if os.path.isfile(path) and os.path.isfile(path+'.pub'):
-      with open(path + '.pub', 'rb') as f:
-        pub = f.read()
-      with open(path, 'rb') as f:
-        priv = f.read()
-      try:
-        _ADB_KEYS.append(_PythonRSASigner(pub, priv))
-      except ValueError as exc:
-        logging.warning('Ignoring adb private key %s: %s', path, exc)
+  _ADB_KEYS = []
+  _ADB_KEYS_RAW = {}
+  if pub_key:
+    _ADB_KEYS.append(_PythonRSASigner(pub_key, priv_key))
+    _ADB_KEYS_RAW[pub_key] = priv_key
 
-    if not _ADB_KEYS:
-      return False
-  else:
-    if pub_key:
-      logging.warning('initialize() was called repeatedly: ignoring keys')
+  # Try to add local adb keys if available.
+  path = os.path.expanduser('~/.android/adbkey')
+  if os.path.isfile(path) and os.path.isfile(path + '.pub'):
+    with open(path + '.pub', 'rb') as f:
+      pub = f.read().strip()
+    with open(path, 'rb') as f:
+      priv = f.read().strip()
+    _ADB_KEYS.append(_PythonRSASigner(pub, priv))
+    _ADB_KEYS_RAW[pub] = priv
+
   return bool(_ADB_KEYS)
 
 
 def kill_adb():
   """Stops the adb daemon.
 
   The Swarming bot doesn't use the Android's SDK adb. It uses python-adb to
   directly communicate with the devices. This works much better when a lot of
   devices are connected to the host.
 
@@ skipping 59 matching lines @@
       _BUILD_PROP_ANDROID.pop(key)
   return devices
 
 
 def close_devices(devices):
   """Closes all devices opened by get_devices()."""
   for _, device in sorted((devices or {}).iteritems()):
     device.close()
 
 
-class CpuScalingGovernor(object):
-  """List of valid CPU scaling governor values."""
-  ON_DEMAND = 'ondemand'
-  PERFORMANCE = 'performance'
-  CONSERVATIVE = 'conservative'
-  POWER_SAVE = 'powersave'
-  USER_DEFINED = 'userspace'
-
-  @classmethod
-  def is_valid(cls, name):
-    return name in [getattr(cls, m) for m in dir(cls) if m[0].isupper()]
-
-
 def set_cpu_scaling_governor(device, governor):
   """Sets the CPU scaling governor to the one specified.
 
   Returns:
     True on success.
   """
   assert isinstance(device, Device), device
-  assert CpuScalingGovernor.is_valid(governor), governor
+  assert governor in KNOWN_CPU_SCALING_GOVERNOR_VALUES, governor
   _, exit_code = device.shell(
       'echo "%s">/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor' %
       governor)
   return exit_code == 0
 
 
 def set_cpu_scaling(device, speed):
   """Enforces strict CPU speed and disable the CPU scaling governor.
 
   Returns:
     True on success.
   """
   assert isinstance(device, Device), device
   assert isinstance(speed, int), speed
   assert 10000 <= speed <= 10000000, speed
-  success = set_cpu_scaling_governor(device, CpuScalingGovernor.USER_DEFINED)
+  success = set_cpu_scaling_governor(device, 'userspace')
   _, exit_code = device.shell(
       'echo "%d">/sys/devices/system/cpu/cpu0/cpufreq/scaling_setspeed' %
       speed)
   return success and exit_code == 0
 
 
 def get_build_prop(device):
   """Returns the system properties for a device.
 
   This isn't really changing through the lifetime of a bot. One corner case is
@@ skipping 131 matching lines @@
 
 def get_ip(device):
   """Returns the IP address."""
   assert isinstance(device, Device), device
   # If ever needed, read wifi.interface from /system/build.prop if a device
   # doesn't use wlan0.
   ip, _ = device.shell('getprop dhcp.wlan0.ipaddress')
   if not ip:
     return None
   return ip.strip()