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
@@ skipping 268 matching lines @@
     """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, cmd_logger=logging,

[bulach, 2012/08/10 11:47:07]

nit: remove cmd_logger? also, spaces: 2 * 60

[Isaac (away), 2012/08/17 04:41:49]

removed cmd_logger.

as far as spacing, would rather not create inconstancy and pylint/gyplint isn't
complaining.

+                                 retry_count=0)
+
+  def ManagedInstall(self, apk_path, keep_data, package_name=None,
+                     reboots_on_failure=2):
+    """Installs the specified package to the device.  Reboots the device on
+       package manager 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.  """
     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()
@@ skipping 74 matching lines @@
       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 451 matching lines @@
           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]) )
         break
     logging.info('PidsUsingDevicePort: %s', pids)
     return pids