Add logs for update_engine and image_to_live to test artifacts.

lib/cros_build_lib.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Common python commands used by various build scripts."""
 
 import inspect
 import os
 import re
 import subprocess
 import sys
 
 _STDOUT_IS_TTY = hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
 
 # TODO(sosa):  Move logging to logging module.
 
 class RunCommandException(Exception):
   """Raised when there is an error in RunCommand."""
   pass
 
 
 def GetCallerName():
   """Returns the name of the calling module with __main__."""
   top_frame = inspect.stack()[-1][0]
   return os.path.basename(top_frame.f_code.co_filename)
 
 
 def RunCommand(cmd, print_cmd=True, error_ok=False, error_message=None,
                exit_code=False, redirect_stdout=False, redirect_stderr=False,
-               cwd=None, input=None, enter_chroot=False, num_retries=0):
+               cwd=None, input=None, enter_chroot=False, num_retries=0,
+               log_to_file=None):
   """Runs a shell command.
 
   Arguments:
     cmd: cmd to run.  Should be input to subprocess.POpen.  If a string,
       converted to an array using split().
     print_cmd: prints the command before running it.
     error_ok: does not raise an exception on error.
     error_message: prints out this message when an error occurrs.
     exit_code: returns the return code of the shell command.
     redirect_stdout: returns the stdout.
     redirect_stderr: holds stderr output until input is communicated.
     cwd: the working directory to run this cmd.
     input: input to pipe into this command through stdin.
     enter_chroot: this command should be run from within the chroot.  If set,
       cwd must point to the scripts directory.
     num_retries: the number of retries to perform before dying
+    log_to_file: Redirects all stderr and stdout to file specified by this path.
 
   Returns:
     If exit_code is True, returns the return code of the shell command.
     Else returns the output of the shell command.
 
   Raises:
     Exception:  Raises RunCommandException on error with optional error_message,
+
                 but only if exit_code, and error_ok are both False. 
   """
   # Set default for variables.
   stdout = None
   stderr = None
   stdin = None
+  file_handle = None
   output = ''
 
   # Modify defaults based on parameters.
-  if redirect_stdout:  stdout = subprocess.PIPE
-  if redirect_stderr:  stderr = subprocess.PIPE
+  if log_to_file:
+    file_handle = open(log_to_file, 'w+')
+    stdout = file_handle
+    stderr = file_handle
+  else:
+    if redirect_stdout:  stdout = subprocess.PIPE
+    if redirect_stderr:  stderr = subprocess.PIPE
+
   if input:  stdin = subprocess.PIPE
   if enter_chroot:  cmd = ['./enter_chroot.sh', '--'] + cmd
 
   # Print out the command before running.
+  cmd_string = 'PROGRAM(%s) -> RunCommand: %r in dir %s' % (GetCallerName(),
+                                                            cmd, cwd)
   if print_cmd:
-    Info('PROGRAM(%s) -> RunCommand: %r in dir %s' %
-         (GetCallerName(), cmd, cwd))
+    if not log_to_file:
+      Info(cmd_string)
+    else:
+      Info('%s -- Logging to %s' % (cmd_string, log_to_file))
 
   for retry_count in range(num_retries + 1):
 
     # If it's not the first attempt, it's a retry
     if retry_count > 0 and print_cmd:
       Info('PROGRAM(%s) -> RunCommand: retrying %r in dir %s' %
            (GetCallerName(), cmd, cwd))
 
     proc = subprocess.Popen(cmd, cwd=cwd, stdin=stdin,
                             stdout=stdout, stderr=stderr)
     (output, error) = proc.communicate(input)
 
     # if the command worked, don't retry any more.
     if proc.returncode == 0:
       break
 
+  if file_handle: file_handle.close()
+
   # If they asked for an exit_code, give it to them on success or failure
   if exit_code:
     return proc.returncode
 
   # If the command (and all retries) failed, handle error result
   if proc.returncode != 0:
     if error_ok:
       Warning('Command "%r" failed.\n' % (cmd) +
               (error_message or error or output or ''))
     else:
@@ skipping 151 matching lines @@
   # Strip the repository root from the path and strip first /.
   relative_path = path_abs_path.replace(root_abs_path, '')[1:]
 
   if relative_path == path_abs_path:
     raise Exception('Error: path is outside your src tree, cannot reinterpret.')
 
   new_path = os.path.join('/home', os.getenv('USER'), 'trunk', relative_path)
   return new_path
 
 
+def PrependChrootPath(path):
+  """Assumes path is a chroot path and prepends chroot to create full path."""
+  chroot_path = os.path.join(FindRepoDir(), '..', 'chroot')
+  if path.startswith('/'):
+    return os.path.realpath(os.path.join(chroot_path, path[1:]))
+  else:
+    return os.path.realpath(os.path.join(chroot_path, path))
+
+
 def GetIPAddress(device='eth0'):
   """Returns the IP Address for a given device using ifconfig.
 
   socket.gethostname() is insufficient for machines where the host files are
   not set up "correctly."  Since some of our builders may have this issue,
   this method gives you a generic way to get the address so you are reachable
   either via a VM or remote machine on the same network.
   """
   ifconfig_output = RunCommand(['/sbin/ifconfig', device],
                                redirect_stdout=True, print_cmd=False)
   match = re.search('.*inet addr:(\d+\.\d+\.\d+\.\d+).*', ifconfig_output)
   if match:
     return match.group(1)
   else:
     Warning('Failed to find ip address in %s' % ifconfig_output)
     return None