[Android] Don't use zip pushing if not built or on user builds.

build/android/pylib/device/device_utils.py

 # Copyright 2014 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 a variety of device interactions based on adb.
 
 Eventually, this will be based on adb_wrapper.
 """
 # pylint: disable=W0613
 
+import logging
 import multiprocessing
 import os
 import pipes
 import sys
 import tempfile
 import time
 import zipfile
 
 import pylib.android_commands
 from pylib.device import adb_wrapper
@@ skipping 55 matching lines @@
       self.adb = device
       self.old_interface = pylib.android_commands.AndroidCommands(str(device))
     elif isinstance(device, pylib.android_commands.AndroidCommands):
       self.adb = adb_wrapper.AdbWrapper(device.GetDevice())
       self.old_interface = device
     elif not device:
       self.adb = adb_wrapper.AdbWrapper('')
       self.old_interface = pylib.android_commands.AndroidCommands()
     else:
       raise ValueError('Unsupported type passed for argument "device"')
-    self._commands_installed = False
+    self._commands_installed = None
     self._default_timeout = default_timeout
     self._default_retries = default_retries
     assert(hasattr(self, decorators.DEFAULT_TIMEOUT_ATTR))
     assert(hasattr(self, decorators.DEFAULT_RETRIES_ATTR))
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def IsOnline(self, timeout=None, retries=None):
     """Checks whether the device is online.
 
     Args:
@@ skipping 41 matching lines @@
 
     Raises:
       CommandFailedError if root could not be enabled.
       CommandTimeoutError on timeout.
     """
     if not self.old_interface.EnableAdbRoot():
       raise device_errors.CommandFailedError(
           'Could not enable root.', device=str(self))
 
   @decorators.WithTimeoutAndRetriesFromInstance()
+  def IsUserBuild(self, timeout=None, retries=None):
+    """Checks whether or not the device is running a user build.
+
+    Args:
+      timeout: timeout in seconds
+      retries: number of retries
+
+    Returns:
+      True if the device is running a user build, False otherwise (i.e. if
+        it's running a userdebug build).
+
+    Raises:
+      CommandTimeoutError on timeout.
+      DeviceUnreachableError on missing device.
+    """
+    return self._GetPropImpl('ro.build.type') == 'user'
+
+  @decorators.WithTimeoutAndRetriesFromInstance()
   def GetExternalStoragePath(self, timeout=None, retries=None):
     """Get the device's path to its SD card.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       The device's path to its SD card.
 
@@ skipping 363 matching lines @@
         dir_file_count += sum(len(f) for _r, _d, f in os.walk(h))
       else:
         dir_file_count += 1
 
     push_duration = self._ApproximateDuration(
         file_count, file_count, size, False)
     dir_push_duration = self._ApproximateDuration(
         len(host_device_tuples), dir_file_count, dir_size, False)
     zip_duration = self._ApproximateDuration(1, 1, size, True)
 
-    if dir_push_duration < push_duration and dir_push_duration < zip_duration:
+    self._InstallCommands()
+
+    if dir_push_duration < push_duration and (
+        dir_push_duration < zip_duration or not self._commands_installed):
       self._PushChangedFilesIndividually(host_device_tuples)
-    elif push_duration < zip_duration:
+    elif push_duration < zip_duration or not self._commands_installed:
       self._PushChangedFilesIndividually(files)
     else:
       self._PushChangedFilesZipped(files)
       self._RunShellCommandImpl(
           ['chmod', '-R', '777'] + [d for _, d in host_device_tuples],
           as_root=True)
 
   def _GetChangedFilesImpl(self, host_path, device_path):
     real_host_path = os.path.realpath(host_path)
     try:
@@ skipping 21 matching lines @@
       to_push = []
       for host_hash, host_abs_path in (
           (h.hash, h.path) for h in host_hash_tuples):
         device_abs_path = '%s/%s' % (
             real_device_path, os.path.relpath(host_abs_path, real_host_path))
         if (device_abs_path not in device_tuple_dict
             or device_tuple_dict[device_abs_path] != host_hash):
           to_push.append((host_abs_path, device_abs_path))
       return to_push
 
+  def _InstallCommands(self):
+    if self._commands_installed is None:
+      try:
+        if not install_commands.Installed(self):
+          install_commands.InstallCommands(self)
+        self._commands_installed = True
+      except Exception as e:
+        logging.warning('unzip not available: %s' % str(e))
+        self._commands_installed = False
+
   @staticmethod
   def _ApproximateDuration(adb_calls, file_count, byte_count, is_zipping):
     # We approximate the time to push a set of files to a device as:
     #   t = c1 * a + c2 * f + c3 + b / c4 + b / (c5 * c6), where
     #     t: total time (sec)
     #     c1: adb call time delay (sec)
     #     a: number of times adb is called (unitless)
     #     c2: push time delay (sec)
     #     f: number of files pushed via adb (unitless)
     #     c3: zip time delay (sec)
@@ skipping 21 matching lines @@
     return (adb_call_time + adb_push_setup_time + zip_time + transfer_time)
 
   def _PushChangedFilesIndividually(self, files):
     for h, d in files:
       self.adb.Push(h, d)
 
   def _PushChangedFilesZipped(self, files):
     if not files:
       return
 
-    self._InstallCommands()
-
     with tempfile.NamedTemporaryFile(suffix='.zip') as zip_file:
       zip_proc = multiprocessing.Process(
           target=DeviceUtils._CreateDeviceZip,
           args=(zip_file.name, files))
       zip_proc.start()
       zip_proc.join()
 
       zip_on_device = '%s/tmp.zip' % self._GetExternalStoragePathImpl()
       try:
         self.adb.Push(zip_file.name, zip_on_device)
         self._RunShellCommandImpl(
             ['unzip', zip_on_device],
             as_root=True, check_return=True,
             env={'PATH': '$PATH:%s' % install_commands.BIN_DIR})
       finally:
         if zip_proc.is_alive():
           zip_proc.terminate()
         if self._IsOnlineImpl():
           self._RunShellCommandImpl(['rm', zip_on_device])
 
-  def _InstallCommands(self):
-    if not self._commands_installed and not install_commands.Installed(self):
-      install_commands.InstallCommands(self)
-      self._commands_installed = True
-
   @staticmethod
   def _CreateDeviceZip(zip_path, host_device_tuples):
     with zipfile.ZipFile(zip_path, 'w') as zip_file:
       for host_path, device_path in host_device_tuples:
         if os.path.isfile(host_path):
           zip_file.write(host_path, device_path, zipfile.ZIP_DEFLATED)
         else:
           for hd, _, files in os.walk(host_path):
             dd = '%s/%s' % (device_path, os.path.relpath(host_path, hd))
             zip_file.write(hd, dd, zipfile.ZIP_STORED)
@@ skipping 171 matching lines @@
                      the device.
       timeout: timeout in seconds
       retries: number of retries
 
     Returns:
       The value of the device's |property_name| property.
 
     Raises:
       CommandTimeoutError on timeout.
     """
+    return self._GetPropImpl(property_name)
+
+  def _GetPropImpl(self, property_name):
     return self.old_interface.system_properties[property_name]
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def SetProp(self, property_name, value, timeout=None, retries=None):
     """Sets a property on the device.
 
     Args:
       property_name: A string containing the name of the property to set on
                      the device.
       value: A string containing the value to set to the property on the
@@ skipping 121 matching lines @@
       A Parallelizer operating over |devices|.
     """
     if not devices or len(devices) == 0:
       devices = pylib.android_commands.GetAttachedDevices()
     parallelizer_type = (parallelizer.Parallelizer if async
                          else parallelizer.SyncParallelizer)
     return parallelizer_type([
         d if isinstance(d, DeviceUtils) else DeviceUtils(d)
         for d in devices])