[Android] Reduce test logging verbosity.

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 91 matching lines @@
     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')
   if preferred_device in devices:
     devices.remove(preferred_device)
     devices.insert(0, preferred_device)
   return devices
 
+
 def IsDeviceAttached(device):
   return device in GetAttachedDevices()
 
+
 def _GetFilesFromRecursiveLsOutput(path, ls_output, re_file, utc_offset=None):
   """Gets a list of files from `ls` command output.
 
   Python's os.walk isn't used because it doesn't work over adb shell.
 
   Args:
     path: The path to list.
     ls_output: A list of lines returned by an `ls -lR` command.
     re_file: A compiled regular expression which parses a line into named groups
         consisting of at minimum "filename", "date", "time", "size" and
@@ skipping 32 matching lines @@
         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
         lastmod -= utc_delta
       files[filename] = (int(file_match.group('size')), lastmod)
   return files
 
+
 def _ComputeFileListHash(md5sum_output):
   """Returns a list of MD5 strings from the provided md5sum output."""
   return [line.split('  ')[0] for line in md5sum_output]
 
+
 def _HasAdbPushSucceeded(command_output):
   """Returns whether adb push has succeeded from the provided output."""
   if not command_output:
     return False
   # 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]', command_output.splitlines()[-1]):
     logging.critical('PUSH FAILED: ' + command_output)
     return False
   return True
 
+
 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')
   except (ValueError, IndexError):
     logging.critical('Error reading timestamp from ' + log_line)
     return None
 
 
@@ skipping 12 matching lines @@
     self._device = device
     self._logcat = None
     self.logcat_process = None
     self._logcat_tmpoutfile = None
     self._pushed_files = []
     self._device_utc_offset = self.RunShellCommand('date +%z')[0]
     self._md5sum_path = ''
     self._external_storage = ''
     self._util_wrapper = ''
 
+  def _LogShell(self, cmd):
+    """Logs the adb shell command."""
+    if self._device:
+      device_repr = self._device[-4:]
+    else:
+      device_repr = '????'
+    logging.info('[%s]> %s', device_repr, cmd)
+
   def Adb(self):
     """Returns our AdbInterface to avoid us wrapping all its methods."""
     return self._adb
 
   def IsOnline(self):
     """Checks whether the device is online.
 
     Returns:
       True if device is in 'device' mode, False otherwise.
     """
@@ skipping 86 matching lines @@
     """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)
+    self._LogShell(uninstall_command)
     return self._adb.SendCommand(uninstall_command, timeout_time=60)
 
   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: Reinstall an existing apk, keeping the data.
 
     Returns:
       A status string returned by adb install
     """
     assert os.path.isfile(package_file_path), ('<%s> is not file' %
                                                package_file_path)
 
     install_cmd = ['install']
 
     if reinstall:
       install_cmd.append('-r')
 
     install_cmd.append(package_file_path)
     install_cmd = ' '.join(install_cmd)
 
-    logging.info('>>> $' + install_cmd)
+    self._LogShell(install_cmd)
     return self._adb.SendCommand(install_cmd,
                                  timeout_time=2 * 60,
                                  retry_count=0)
 
   def ManagedInstall(self, apk_path, keep_data=False, package_name=None,
                      reboots_on_failure=2):
     """Installs specified package and reboots device on timeouts.
 
     Args:
       apk_path: Path to .apk file to install.
@@ skipping 110 matching lines @@
       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)
+    self._LogShell(command)
     if "'" in command: logging.warning(command + " contains ' quotes")
     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))
+      self._LogShell('\n'.join(result))
     return result
 
   def GetShellCommandStatusAndOutput(self, command, timeout_time=20,
                                      log_result=False):
     """See RunShellCommand() above.
 
     Returns:
       The tuple (exit code, list of output lines).
     """
     lines = self.RunShellCommand(
@@ skipping 197 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)
+    self._LogShell(push_command)
     output = self._adb.SendCommand(push_command, timeout_time=30 * 60)
     assert _HasAdbPushSucceeded(output)
 
 
   def GetFileContents(self, filename, log_result=False):
     """Gets contents from the file specified by |filename|."""
     return self.RunShellCommand('cat "%s" 2>/dev/null' % filename,
                                 log_result=log_result)
 
   def SetFileContents(self, filename, contents):
@@ skipping 535 matching lines @@
 
     Args:
       test: Test class/method.
       test_package: Name of the test jar.
       timeout: Timeout time in seconds.
 
     Returns:
       An instance of am_instrument_parser.TestResult object.
     """
     cmd = 'uiautomator runtest %s -e class %s' % (test_package, test)
-    logging.info('>>> $' + cmd)
+    self._LogShell(cmd)
     output = self._adb.SendShellCommand(cmd, timeout_time=timeout)
     # uiautomator doesn't fully conform to the instrumenation test runner
     # convention and doesn't terminate with INSTRUMENTATION_CODE.
     # Just assume the first result is valid.
     (test_results, _) = am_instrument_parser.ParseAmInstrumentOutput(output)
     return test_results[0]
 
 
 class NewLineNormalizer(object):
   """A file-like object to normalize EOLs to '\n'.
 
   Pexpect runs adb within a pseudo-tty device (see
   http://www.noah.org/wiki/pexpect), so any '\n' printed by adb is written
   as '\r\n' to the logfile. Since adb already uses '\r\n' to terminate
   lines, the log ends up having '\r\r\n' at the end of each line. This
   filter replaces the above with a single '\n' in the data stream.
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()