Organize adb install cmds and reboot on failure

build/android/pylib/android_commands.py

 # Copyright (c) 2012 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.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
 import datetime
-import io_stats_parser
 import logging
-import optparse
 import os
-import pexpect
 import re
 import shlex
 import subprocess
 import sys
 import tempfile
 import time
 
+import pexpect
+import io_stats_parser
 
 # adb_interface.py is under ../../../third_party/android_testrunner/
 sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), '..',
-   '..', '..', 'third_party', 'android_testrunner'))
+                             '..', '..', 'third_party', 'android_testrunner'))
 import adb_interface
 import cmd_helper
 import errors  #  is under ../../../third_party/android_testrunner/errors.py
 
 
 # Pattern to search for the next whole line of pexpect output and capture it
 # into a match group. We can't use ^ and $ for line start end with pexpect,
 # see http://www.noah.org/python/pexpect/#doc for explanation why.
 PEXPECT_LINE_RE = re.compile('\n([^\r]*)\r')
 
 # Set the adb shell prompt to be a unique marker that will [hopefully] not
 # appear at the start of any line of a command's output.
 SHELL_PROMPT = '~+~PQ\x17RS~+~'
 
 # This only works for single core devices.
 SCALING_GOVERNOR = '/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor'
 DROP_CACHES = '/proc/sys/vm/drop_caches'
 
 # Java properties file
 LOCAL_PROPERTIES_PATH = '/data/local.prop'
 
 # Property in /data/local.prop that controls Java assertions.
 JAVA_ASSERT_PROPERTY = 'dalvik.vm.enableassertions'
 
 BOOT_COMPLETE_RE = re.compile(
     'android.intent.action.MEDIA_MOUNTED path: /\w+/sdcard\d?'
-    + '|' + 'PowerManagerService(\(\s+\d+\))?: bootCompleted')
+    '|PowerManagerService(\(\s+\d+\))?: bootCompleted')
 
 MEMORY_INFO_RE = re.compile('^(?P<key>\w+):\s+(?P<usage_kb>\d+) kB$')
 NVIDIA_MEMORY_INFO_RE = re.compile('^\s*(?P<user>\S+)\s*(?P<name>\S+)\s*'
                                    '(?P<pid>\d+)\s*(?P<usage_bytes>\d+)$')
 
 # Keycode "enum" suitable for passing to AndroidCommands.SendKey().
 KEYCODE_HOME = 3
 KEYCODE_BACK = 4
 KEYCODE_DPAD_UP = 19
 KEYCODE_DPAD_DOWN = 20
@@ skipping 35 matching lines @@
   Example output:
 
     * daemon not running. starting it now on port 5037 *
     * daemon started successfully *
     List of devices attached
     027c10494100b4d7        device
     emulator-5554   offline
   """
   re_device = re.compile('^([a-zA-Z0-9_:.-]+)\tdevice$', re.MULTILINE)
   devices = re_device.findall(cmd_helper.GetCmdOutput(['adb', 'devices']))
-  preferred_device = os.environ.get("ANDROID_SERIAL")
+  preferred_device = os.environ.get('ANDROID_SERIAL')
   if preferred_device in devices:
     devices.remove(preferred_device)
     devices.insert(0, preferred_device)
   return devices
 
 
 def _GetHostFileInfo(file_name):
   """Returns a tuple containing size and modified UTC time for file_name."""
   # The time accuracy on device is only to minute level, remove the second and
   # microsecond from host results.
@@ skipping 68 matching lines @@
         filename = filename[len(path_dir)+1:]
       lastmod = datetime.datetime.strptime(
           file_match.group('date') + ' ' + file_match.group('time')[:5],
           '%Y-%m-%d %H:%M')
       if not utc_offset and 'timezone' in re_file.groupindex:
         utc_offset = file_match.group('timezone')
       if isinstance(utc_offset, str) and len(utc_offset) == 5:
         utc_delta = datetime.timedelta(hours=int(utc_offset[1:3]),
                                        minutes=int(utc_offset[3:5]))
         if utc_offset[0:1] == '-':
-          utc_delta = -utc_delta;
+          utc_delta = -utc_delta
         lastmod -= utc_delta
       files[filename] = (int(file_match.group('size')), lastmod)
   return files
 
 
 def GetLogTimestamp(log_line, year):
   """Returns the timestamp of the given |log_line| in the given year."""
   try:
     return datetime.datetime.strptime('%s-%s' % (year, log_line[:18]),
                                       '%Y-%m-%d %H:%M:%S.%f')
@@ skipping 24 matching lines @@
 
   def Adb(self):
     """Returns our AdbInterface to avoid us wrapping all its methods."""
     return self._adb
 
   def IsRootEnabled(self):
     """Returns whether or not _adb.EnabledAdbRoot() has succeeded."""
     return self._root_enabled
 
   def GetDeviceYear(self):
-    """Returns the year information of the date on device"""
+    """Returns the year information of the date on device."""
     return self.RunShellCommand('date +%Y')[0]
 
   def WaitForDevicePm(self):
     """Blocks until the device's package manager is available.
 
     To workaround http://b/5201039, we restart the shell and retry if the
     package manager isn't back after 120 seconds.
 
     Raises:
       errors.WaitForResponseTimedOutError after max retries reached.
     """
     last_err = None
     retries = 3
     while retries:
       try:
         self._adb.WaitForDevicePm()
         return  # Success
       except errors.WaitForResponseTimedOutError as e:
         last_err = e
-        logging.warning('Restarting and retrying after timeout: %s' % str(e))
+        logging.warning('Restarting and retrying after timeout: %s', e)
         retries -= 1
         self.RestartShell()
     raise last_err  # Only reached after max retries, re-raise the last error.
 
   def SynchronizeDateTime(self):
     """Synchronize date/time between host and device."""
     self._adb.SendShellCommand('date -u %f' % time.time())
 
   def RestartShell(self):
     """Restarts the shell on the device. Does not block for it to return."""
     self.RunShellCommand('stop')
     self.RunShellCommand('start')
 
   def Reboot(self, full_reboot=True):
     """Reboots the device and waits for the package manager to return.
 
     Args:
       full_reboot: Whether to fully reboot the device or just restart the shell.
     """
     # TODO(torne): hive can't reboot the device either way without breaking the
     # connection; work out if we can handle this better
     if os.environ.get('USING_HIVE'):
       logging.warning('Ignoring reboot request as we are on hive')
       return
-    if full_reboot:
+    if full_reboot or not self.IsRootEnabled():
       self._adb.SendCommand('reboot')
+      timeout = 300
     else:
       self.RestartShell()
+      timeout = 120
     self.WaitForDevicePm()
-    self.StartMonitoringLogcat(timeout=120)
+    self.StartMonitoringLogcat(timeout=timeout)
     self.WaitForLogMatch(BOOT_COMPLETE_RE, None)
 
   def Uninstall(self, package):
     """Uninstalls the specified package from the device.
 
     Args:
       package: Name of the package to remove.
 
     Returns:
       A status string returned by adb uninstall
     """
     uninstall_command = 'uninstall %s' % package
 
     logging.info('>>> $' + uninstall_command)
     return self._adb.SendCommand(uninstall_command, timeout_time=60)
 
-  def Install(self, package_file_path):
+  def Install(self, package_file_path, reinstall=False):
     """Installs the specified package to the device.
 
     Args:
       package_file_path: Path to .apk file to install.
+      reinstall: Whether to reinstall over existing package
 
     Returns:
       A status string returned by adb install
     """
     assert os.path.isfile(package_file_path)
 
-    install_command = 'install %s' % package_file_path
+    if reinstall:
+      install_cmd = 'install -r %s'
+    else:
+      install_cmd = 'install %s'
 
-    logging.info('>>> $' + install_command)
-    return self._adb.SendCommand(install_command, timeout_time=2*60)
+    return self._adb.SendCommand(install_cmd % package_file_path,
+                                 timeout_time=2*60, retry_count=0)
+
+  def ManagedInstall(self, apk_path, keep_data, package_name=None,
+                     reboots_on_failure=2):
+    """Installs specified package and reboots device on timeouts.
+
+    Args:
+      apk_path: Path to .apk file to install.
+      keep_data: Whether to keep data if package already exists
+      package_name: Package name (only needed if keep_data=False)
+      reboots_on_failure: number of time to reboot if package manager is frozen.
+
+    Returns:
+      A status string returned by adb install
+    """
+    reboots_left = reboots_on_failure
+    while True:
+      try:
+        if not keep_data:
+          self.Uninstall(package_name)
+        install_status = self.Install(apk_path, keep_data)
+        if 'Success' in install_status:
+          return install_status
+      except errors.WaitForResponseTimedOutError:
+        logging.info('Timout on installing %s' % apk_path)
+
+      if reboots_left <= 0:
+        raise Exception('Install failure')
+
+      # Force a hard reboot on last attempt
+      self.Reboot(full_reboot=(reboots_left == 1))
+      reboots_left -= 1
 
   def MakeSystemFolderWritable(self):
-    """Remounts the /system folder rw.  """
+    """Remounts the /system folder rw."""
     out = self._adb.SendCommand('remount')
     if out.strip() != 'remount succeeded':
       raise errors.MsgException('Remount failed: %s' % out)
 
   def RestartAdbServer(self):
     """Restart the adb server."""
     self.KillAdbServer()
     self.StartAdbServer()
 
   def KillAdbServer(self):
@@ skipping 42 matching lines @@
           'sys.boot_completed flag was not set after %s seconds' % wait_time)
 
   def WaitForSdCardReady(self, timeout_time):
     """Wait for the SD card ready before pushing data into it."""
     logging.info('Waiting for SD card ready...')
     sdcard_ready = False
     attempts = 0
     wait_period = 5
     while not sdcard_ready and attempts * wait_period < timeout_time:
       output = self.RunShellCommand('ls /sdcard/')
-      if len(output) > 0:
+      if output:
         sdcard_ready = True
       else:
         time.sleep(wait_period)
         attempts += 1
     if not sdcard_ready:
       raise errors.WaitForResponseTimedOutError(
           'SD card not ready after %s seconds' % timeout_time)
 
   # It is tempting to turn this function into a generator, however this is not
   # possible without using a private (local) adb_shell instance (to ensure no
   # other command interleaves usage of it), which would defeat the main aim of
   # being able to reuse the adb shell instance across commands.
   def RunShellCommand(self, command, timeout_time=20, log_result=True):
     """Send a command to the adb shell and return the result.
 
     Args:
       command: String containing the shell command to send. Must not include
                the single quotes as we use them to escape the whole command.
       timeout_time: Number of seconds to wait for command to respond before
         retrying, used by AdbInterface.SendShellCommand.
       log_result: Boolean to indicate whether we should log the result of the
                   shell command.
 
     Returns:
       list containing the lines of output received from running the command
     """
     logging.info('>>> $' + command)
     if "'" in command: logging.warning(command + " contains ' quotes")
-    result = self._adb.SendShellCommand("'%s'" % command,
-                                        timeout_time).splitlines()
+    result = self._adb.SendShellCommand(
+        "'%s'" % command, timeout_time).splitlines()
+    if ['error: device not found'] == result:
+      raise errors.DeviceUnresponsiveError('device not found')
     if log_result:
       logging.info('\n>>> '.join(result))
     return result
 
   def KillAll(self, process):
     """Android version of killall, connected via adb.
 
     Args:
       process: name of the process to kill off
 
@@ skipping 41 matching lines @@
         elif isinstance(value, int):
           cmd += ' --ei'
         else:
           raise NotImplementedError(
               'Need to teach StartActivity how to pass %s extras' % type(value))
         cmd += ' %s %s' % (key, value)
     if trace_file_name:
       cmd += ' --start-profiler ' + trace_file_name
     self.RunShellCommand(cmd)
 
-
   def CloseApplication(self, package):
     """Attempt to close down the application, using increasing violence.
 
     Args:
       package: Name of the process to kill off, e.g.
       com.google.android.apps.chrome
     """
     self.RunShellCommand('am force-stop ' + package)
 
   def ClearApplicationState(self, package):
@@ skipping 28 matching lines @@
     local_contents = ListHostPathContents(local_path)
     device_contents = self.ListPathContents(device_path)
     # Only compare the size and timestamp if only copying a file because
     # the filename on device can be renamed.
     if os.path.isfile(local_path):
       assert len(local_contents) == 1
       is_equal = local_contents.values() == device_contents.values()
     else:
       is_equal = local_contents == device_contents
     if is_equal:
-      logging.info('%s is up-to-date. Skipping file push.' % device_path)
+      logging.info('%s is up-to-date. Skipping file push.', device_path)
       return
 
     # They don't match, so remove everything first and then create it.
     if os.path.isdir(local_path):
       self.RunShellCommand('rm -r %s' % device_path, timeout_time=2*60)
       self.RunShellCommand('mkdir -p %s' % device_path)
 
     # NOTE: We can't use adb_interface.Push() because it hardcodes a timeout of
     # 60 seconds which isn't sufficient for a lot of users of this method.
     push_command = 'push %s %s' % (local_path, device_path)
@@ skipping 95 matching lines @@
 
     self.RunShellCommand('setprop %s "%s"' % (JAVA_ASSERT_PROPERTY,
                                               enable and 'all' or ''))
     return True
 
   def DropRamCaches(self):
     """Drops the filesystem ram caches for performance testing."""
     self.RunShellCommand('echo 3 > ' + DROP_CACHES)
 
   def StartMonitoringLogcat(self, clear=True, timeout=10, logfile=None,
-                            filters=[]):
+                            filters=None):
     """Starts monitoring the output of logcat, for use with WaitForLogMatch.
 
     Args:
       clear: If True the existing logcat output will be cleared, to avoiding
              matching historical output lurking in the log.
       timeout: How long WaitForLogMatch will wait for the given match
       filters: A list of logcat filters to be used.
     """
     if clear:
       self.RunShellCommand('logcat -c')
@@ skipping 90 matching lines @@
 
     Returns:
       The logcat output as a string or an empty string if logcat was not
       being recorded at the time.
     """
     if not self.logcat_process:
       return ''
     # Cannot evaluate directly as 0 is a possible value.
     # Better to read the self.logcat_process.stdout before killing it,
     # Otherwise the communicate may return incomplete output due to pipe break.
-    if self.logcat_process.poll() == None:
+    if self.logcat_process.poll() is None:
       self.logcat_process.kill()
     (output, _) = self.logcat_process.communicate()
     self.logcat_process = None
     return output
 
   def SearchLogcatRecord(self, record, message, thread_id=None, proc_id=None,
                          log_level=None, component=None):
     """Searches the specified logcat output and returns results.
 
     This method searches through the logcat output specified by record for a
@@ skipping 118 matching lines @@
         usage_bytes = int(match.group('usage_bytes'))
         usage_dict['Nvidia'] = int(round(usage_bytes / 1000.0))  # kB
         break
 
     return (usage_dict, smaps)
 
   def GetMemoryUsageForPackage(self, package):
     """Returns the memory usage for all processes whose name contains |pacakge|.
 
     Args:
-      name: A string holding process name to lookup pid list for.
+      package: A string holding process name to lookup pid list for.
 
     Returns:
       A tuple containg:
       [0]: Dict of {metric:usage_kb}, summed over all pids associated with
            |name|.
       The metric keys which may be included are: Size, Rss, Pss, Shared_Clean,
       Shared_Dirty, Private_Clean, Private_Dirty, Referenced, Swap,
       KernelPageSize, MMUPageSize, Nvidia (tablet only).
       [1]: a list with detailed /proc/[PID]/smaps information.
     """
     usage_dict = collections.defaultdict(int)
     pid_list = self.ExtractPid(package)
     smaps = collections.defaultdict(dict)
 
     for pid in pid_list:
       usage_dict_per_pid, smaps_per_pid = self.GetMemoryUsageForPid(pid)
       smaps[pid] = smaps_per_pid
       for (key, value) in usage_dict_per_pid.items():
         usage_dict[key] += value
 
     return usage_dict, smaps
 
   def ProcessesUsingDevicePort(self, device_port):
-    """Lists the processes using the specified device port on loopback
-       interface.
+    """Lists processes using the specified device port on loopback interface.
 
     Args:
       device_port: Port on device we want to check.
 
     Returns:
       A list of (pid, process_name) tuples using the specified port.
     """
     tcp_results = self.RunShellCommand('cat /proc/net/tcp', log_result=False)
-    tcp_address = "0100007F:%04X" % device_port
+    tcp_address = '0100007F:%04X' % device_port
     pids = []
     for single_connect in tcp_results:
       connect_results = single_connect.split()
       # Column 1 is the TCP port, and Column 9 is the inode of the socket
       if connect_results[1] == tcp_address:
         socket_inode = connect_results[9]
         socket_name = 'socket:[%s]' % socket_inode
         lsof_results = self.RunShellCommand('lsof', log_result=False)
         for single_process in lsof_results:
           process_results = single_process.split()
           # Ignore the line if it has less than nine columns in it, which may
           # be the case when a process stops while lsof is executing.
           if len(process_results) <= 8:
             continue
           # Column 0 is the executable name
           # Column 1 is the pid
           # Column 8 is the Inode in use
           if process_results[8] == socket_name:
-            pids.append( (int(process_results[1]), process_results[0]) )
+            pids.append((int(process_results[1]), process_results[0]))
         break
     logging.info('PidsUsingDevicePort: %s', pids)
     return pids