WIP Chromite supporting "LEGACY" mode, as requested by Anush.

chromite/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 os
 import re
+import signal
 import subprocess
 import sys
 
 _STDOUT_IS_TTY = hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
 
 
 class CommandResult(object):
   """An object to store various attributes of a child process."""
 
   def __init__(self):
     self.cmd = None
     self.error = None
     self.output = None
     self.returncode = None
 
 
 class RunCommandError(Exception):
   """Error caught in RunCommand() method."""
   pass
 
 
 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, shell=False):
+               cwd=None, input=None, enter_chroot=False, shell=False,
+               env=None, ignore_sigint=False):
   """Runs a command.
 
   Args:
     cmd: cmd to run.  Should be input to subprocess.Popen.
     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.
     shell: If shell is True, the specified command will be executed through
       the shell.
+    env: If non-None, this is the environment for the new process.
+    ignore_sigint: If True, we'll ignore signal.SIGINT before calling the
+      child.  This is the desired behavior if we know our child will handle
+      Ctrl-C.  If we don't do this, I think we and the child will both get
+      Ctrl-C at the same time, which means we'll forcefully kill the child.
 
   Returns:
     A CommandResult object.
 
   Raises:
     Exception:  Raises generic exception on error with optional error_message.
   """
   # Set default for variables.
   stdout = None
   stderr = None
@@ skipping 13 matching lines @@
     if enter_chroot: cmd = ['./enter_chroot.sh', '--'] + cmd
     cmd_str = ' '.join(cmd)
 
   # Print out the command before running.
   if print_cmd:
     Info('RunCommand: %s' % cmd_str)
   cmd_result.cmd = cmd_str
 
   try:
     proc = subprocess.Popen(cmd, cwd=cwd, stdin=stdin, stdout=stdout,
-                            stderr=stderr, shell=shell)
-    (cmd_result.output, cmd_result.error) = proc.communicate(input)
+                            stderr=stderr, shell=shell, env=env)
+    if ignore_sigint:
+      old_sigint = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    try:
+      (cmd_result.output, cmd_result.error) = proc.communicate(input)
+    finally:
+      if ignore_sigint:
+        signal.signal(signal.SIGINT, old_sigint)
+
     if exit_code:
       cmd_result.returncode = proc.returncode
 
     if not error_ok and proc.returncode:
       msg = ('Command "%s" failed.\n' % cmd_str +
              (error_message or cmd_result.error or cmd_result.output or ''))
       raise RunCommandError(msg)
   # TODO(sosa): is it possible not to use the catch-all Exception here?
   except Exception, e:
     if not error_ok:
@@ skipping 148 matching lines @@
   Returns:
     a string: absolute path to output directory.
   """
   src_root = GetSrcRoot()
   rel_path = 'build/images/%s' % board
   # ASSUME: --build_attempt always sets to 1
   version_str = '-'.join([cros_version, 'a1'])
   output_dir = os.path.join(os.path.dirname(src_root), rel_path, version_str)
   Info ('output_dir = %s' % output_dir)
   return output_dir