Add initial support for color output in the build system

lib/naclports/source_package.py

 # Copyright (c) 2014 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import contextlib
 import os
 import re
 import shutil
 import subprocess
 import sys
@@ skipping 16 matching lines @@
 
 
 @contextlib.contextmanager
 def RedirectStdoutStderr(filename):
   """Context manager that replaces stdout and stderr streams."""
   if filename is None:
     yield
     return
 
   with open(filename, 'a') as stream:
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
     sys.stdout = stream
     sys.stderr = stream
+    util.CheckStdoutForColorSupport()
     try:
       yield
     finally:
-      sys.stdout = sys.__stdout__
-      sys.stderr = sys.__stdout__
+      sys.stdout = old_stdout
+      sys.stderr = old_stderr
+      util.CheckStdoutForColorSupport()
 
 
 def FormatTimeDelta(delta):
   """Converts a duration in seconds to a human readable string.
 
   Args:
     delta: the amount of time in seconds.
 
   Returns: A string desribing the ammount of time passed in.
   """
@@ skipping 172 matching lines @@
     except PkgFormatError:
       # If the package is malformed in some way or in some old format
       # then treat it as not built.
       return False
     return pkg.IsInstallable()
 
   def Install(self, build_deps, force=None, from_source=False):
     self.CheckInstallable()
 
     if force is None and self.IsInstalled():
-      Log('Already installed %s' % self.InfoString())
+      self.LogStatus('Already installed')
       return
 
     if build_deps:
       self.InstallDeps(force, from_source)
 
     if force:
       from_source = True
 
     package_file = self.PackageFile()
     if not self.IsBuilt() and not from_source:
       index = package_index.GetCurrentIndex()
       if index.Installable(self.NAME, self.config):
         package_file = index.Download(self.NAME, self.config)
       else:
         from_source = True
 
     if from_source:
       self.Build(build_deps, force)
 
     if self.IsAnyVersionInstalled():
-      Log('Uninstalling existing %s' % self.InfoString())
+      self.LogStatus('Uninstalling existing')
       self.GetInstalledPackage().DoUninstall()
 
     binary_package.BinaryPackage(package_file).Install()
 
   def GetInstalledPackage(self):
     return package.CreateInstalledPackage(self.NAME, self.config)
 
   def Build(self, build_deps, force=None):
     self.CheckBuildable()
 
     if build_deps:
       self.InstallDeps(force)
 
     if not force and self.IsBuilt():
-      Log('Already built %s' % self.InfoString())
+      self.LogStatus('Already built')
       return
 
     log_root = os.path.join(paths.OUT_DIR, 'logs')
     util.Makedirs(log_root)
 
-    if util.verbose:
-      prefix = '*** '
-    else:
-      prefix = ''
-    Log('%sBuilding %s' % (prefix, self.InfoString()))
+    self.LogStatus('Building')
 
     if util.verbose:
       log_filename = None
     else:
       log_filename = os.path.join(log_root, '%s_%s.log' % (self.NAME,
           str(self.config).replace('/', '_')))
       if os.path.exists(log_filename):
         os.remove(log_filename)
 
     start = time.time()
     with util.BuildLock():
       with RedirectStdoutStderr(log_filename):
         old_verbose = util.verbose
         try:
           util.verbose = True
           self.Download()
           self.Extract()
           self.Patch()
           self.RunBuildSh()
         finally:
           util.verbose = old_verbose
 
     duration = FormatTimeDelta(time.time() - start)
-    Log('Build complete %s [took %s]' % (self.InfoString(), duration))
+    util.LogHeading('Build complete', ' [took %s]' % duration)
 
   def RunBuildSh(self):
     build_port = os.path.join(paths.TOOLS_DIR, 'build_port.sh')
     cmd = [build_port]
 
     env = os.environ.copy()
     env['TOOLCHAIN'] = self.config.toolchain
     env['NACL_ARCH'] = self.config.arch
     env['NACL_DEBUG'] = self.config.debug and '1' or '0'
     rtn = subprocess.call(cmd,
@@ skipping 57 matching lines @@
     stamp_file = self.GetExtractStamp()
     stamp_contents = self.GetExtractStampContent()
     if os.path.exists(dest):
       if StampContentsMatch(stamp_file, stamp_contents):
         Log('Already up-to-date: %s' % util.RelPath(dest))
         return
 
       raise Error("Upstream archive or patch has changed.\n" +
                   "Please remove existing checkout and try again: '%s'" % dest)
 
-    self.Banner('Extracting')
+    util.LogHeading('Extracting')
     util.Makedirs(paths.OUT_DIR)
     tmp_output_path = tempfile.mkdtemp(dir=paths.OUT_DIR)
     try:
       ExtractArchive(archive, tmp_output_path)
       src = os.path.join(tmp_output_path, new_foldername)
       if not os.path.isdir(src):
         raise Error('Archive contents not found: %s' % src)
       Trace("renaming '%s' -> '%s'" % (src, dest))
       os.rename(src, dest)
     finally:
       shutil.rmtree(tmp_output_path)
 
     self.RemoveStamps()
     WriteStamp(stamp_file, stamp_contents)
 
   def RunCmd(self, cmd, **args):
     try:
       subprocess.check_call(cmd,
                             stdout=sys.stdout,
                             stderr=sys.stderr,
                             cwd=self.GetBuildLocation(),
                             **args)
     except subprocess.CalledProcessError as e:
       raise Error(e)
 
   def Log(self, message):
     Log('%s: %s' % (message, self.InfoString()))
 
-  def Banner(self, message):
-    Log("#####################################################################")
-    self.Log(message)
-    Log("#####################################################################")
-
   def GetStampDir(self):
     return os.path.join(paths.STAMP_DIR, self.NAME)
 
   def RemoveStamps(self):
     util.RemoveTree(self.GetStampDir())
 
   def Patch(self):
     stamp_file = os.path.join(self.GetStampDir(), 'nacl_patch')
     src_dir = self.GetBuildLocation()
     if self.URL is None:
       return
 
     if os.path.exists(stamp_file):
       self.Log('Skipping patch step (cleaning source tree)')
       cmd = ['git', 'clean', '-f', '-d']
       if not util.verbose:
         cmd.append('-q')
       self.RunCmd(cmd)
       return
 
-    self.Banner('Patching')
+    util.LogHeading('Patching')
     Log('Init git repo: %s' % src_dir)
     try:
       InitGitRepo(src_dir)
     except subprocess.CalledProcessError as e:
       raise Error(e)
     if os.path.exists(self.GetPatchFile()):
       Trace('applying patch to: %s' % src_dir)
       cmd = ['patch', '-p1', '-g0', '--no-backup-if-mismatch']
       with open(self.GetPatchFile()) as f:
         self.RunCmd(cmd, stdin=f)
@@ skipping 115 matching lines @@
     stamp_content += '\n'
 
     dest = self.GetBuildLocation()
     if os.path.exists(self.GetBuildLocation()):
       if StampContentsMatch(stamp_file, stamp_content):
         return
 
       raise Error('Upstream archive or patch has changed.\n' +
                   "Please remove existing checkout and try again: '%s'" % dest)
 
-    self.Banner('Cloning')
+    util.LogHeading('Cloning')
     # Ensure local mirror is up-to-date
     git_mirror, git_commit = self.GitCloneToMirror()
     # Clone from the local mirror.
     RunGitCmd(None, ['clone', git_mirror, dest])
     RunGitCmd(dest, ['reset', '--hard', git_commit])
 
     # Set the origing to the original URL so it is possible to push directly
     # from the build tree.
     RunGitCmd(dest, ['remote', 'set-url', 'origin', '${GIT_URL}'])
 
@@ skipping 107 matching lines @@
   if os.path.isdir(package_name):
     return SourcePackage(package_name, config)
 
   for subdir in DEFAULT_LOCATIONS:
     pkg_root = os.path.join(paths.NACLPORTS_ROOT, subdir, package_name)
     info = os.path.join(pkg_root, 'pkg_info')
     if os.path.exists(info):
       return SourcePackage(pkg_root, config)
 
   raise Error("Package not found: %s" % package_name)