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)
+    return self._adb.SendCommand(uninstall_command, timeout_time=60,
+                                 cmd_logger=logging)
 
-  def Install(self, package_file_path):
+  def Install(self, package_file_path, reinstall=False, retry_count=3):
     """Installs the specified package to the device.
 
     Args:
       package_file_path: Path to .apk file to install.
+      reinstall: Whether to reinstall over existing package

[bulach, 2012/08/09 12:36:52]

nit: remove retry_count from 313, since it's undocumented and unused?

 
     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/09 12:36:52]

nit: I think it needs space around *, timeout_time=2 * 60

[Isaac (away), 2012/08/10 04:44:35]

It's like this a couple other places in this file.  You sure I should change?

On 2012/08/09 12:36:52, bulach wrote:

+                                 retry_count=3)
+
+  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

[bulach, 2012/08/09 12:36:52]

nit: )

+      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, retry_count=0)
+        if 'Success' in install_status:
+          return install_status
+      except errors.WaitForResponseTimedOutError:
+        if reboots_left < 0:

[bulach, 2012/08/09 12:36:52]

nit: seems that this should be <= 0, that is, passing reboots_on_failure=0
should never reboot.. also, 360 would need to be == 1

+          raise
+      # Force a hard reboot on last attempt
+      self.Reboot(full_reboot=(reboots_left==0))

[bulach, 2012/08/09 12:36:52]

nit: space around ==

+      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 42 matching lines @@
         attempts += 1
     if not boot_completed:
       raise errors.WaitForResponseTimedOutError(
           '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:
         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,
+                                        cmd_logger=logging).splitlines()
     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 39 matching lines @@
       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)
-    logging.info('>>> $' + push_command)
-    output = self._adb.SendCommand(push_command, timeout_time=30*60)
+    output = self._adb.SendCommand(push_command, timeout_time=30*60,
+                                   cmd_logger=logging)
     assert output
     # Success looks like this: "3035 KB/s (12512056 bytes in 4.025s)"
     # Errors look like this: "failed to copy  ... "
     if not re.search('^[0-9]', output.splitlines()[-1]):
       logging.critical('PUSH FAILED: ' + output)
 
   def GetFileContents(self, filename, log_result=True):
     """Gets contents from the file specified by |filename|."""
     return self.RunShellCommand('if [ -f "' + filename + '" ]; then cat "' +
                                 filename + '"; fi', log_result=log_result)
@@ skipping 390 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