toolchain_build: Avoid python tracebacks for package build errors

toolchain_build/toolchain_main.py

 #!/usr/bin/python
 # Copyright (c) 2012 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.
 
 """Build NativeClient toolchain packages."""
 
 import logging
 import optparse
 import os
+import subprocess
 import sys
 import textwrap
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 import pynacl.file_tools
 import pynacl.gsd_storage
 import pynacl.log_tools
 import pynacl.local_storage_cache
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
@@ skipping 22 matching lines @@
   """
   if cloud_item.dir_item:
     url = cloud_item.dir_item.url
     pynacl.log_tools.WriteAnnotatorLine('@@@STEP_LINK@download@%s@@@' % url)
 
     if cloud_item.log_url:
       log_url = cloud_item.log_url
       pynacl.log_tools.WriteAnnotatorLine('@@@STEP_LINK@log@%s@@@' % log_url)
 
 
+class BuildError(Exception):
+    pass
+
 class PackageBuilder(object):
   """Module to build a setup of packages."""
 
   def __init__(self, packages, package_targets, args):
     """Constructor.
 
     Args:
       packages: A dictionary with the following format. There are two types of
                 packages: source and build (described below).
         {
@@ skipping 89 matching lines @@
   def Main(self):
     """Main entry point."""
     pynacl.file_tools.MakeDirectoryIfAbsent(self._options.source)
     pynacl.file_tools.MakeDirectoryIfAbsent(self._options.output)
 
     pynacl.log_tools.SetupLogging(
         verbose=self._options.verbose,
         log_file=self._options.log_file,
         quiet=self._options.quiet,
         no_annotator=self._options.no_annotator)
-    self.BuildAll()
-    self.OutputPackagesInformation()
+    try:
+      self.BuildAll()
+      self.OutputPackagesInformation()
+    except BuildError as e:
+      print e
+      return 1
+    return 0
 
   def GetOutputDir(self, package, use_subdir):
     # The output dir of source packages is in the source directory, and can be
     # overridden.
     if self._packages[package]['type'] == 'source':
       dirname = self._packages[package].get('output_dirname', package)
       return os.path.join(self._options.source, dirname)
     else:
       root = os.path.join(self._options.output, package + '_install')
       if use_subdir and 'output_subdir' in self._packages[package]:
         return os.path.join(root, self._packages[package]['output_subdir'])
       return root
 
   def BuildPackage(self, package):
     """Build a single package.
 
     Assumes dependencies of the package have been built.
     Args:
       package: Package to build.
     """
 
     package_info = self._packages[package]
 
     # Validate the package description.
     if 'type' not in package_info:
-      raise Exception('package %s does not have a type' % package)
+      raise BuildError('package %s does not have a type' % package)
     type_text = package_info['type']
     if type_text not in ('source', 'build', 'build_noncanonical', 'work'):
-      raise Exception('package %s has unrecognized type: %s' %
+      raise BuildError('package %s has unrecognized type: %s' %
                       (package, type_text))
     is_source_target = type_text == 'source'
     is_build_target = type_text in ('build', 'build_noncanonical')
     build_signature_key_extra = ''
     if type_text == 'build_noncanonical':
       build_signature_key_extra = '_' + pynacl.gsd_storage.LegalizeName(
           pynacl.platform.PlatformTriple())
 
     if 'commands' not in package_info:
-      raise Exception('package %s does not have any commands' % package)
+      raise BuildError('package %s does not have any commands' % package)
 
     # Source targets are the only ones to run when doing sync-only.
     if not is_source_target and self._options.sync_sources_only:
       logging.debug('Build skipped: not running commands for %s' % package)
       return
 
     # Source targets do not run when skipping sync.
     if is_source_target and not (
         self._options.sync_sources or self._options.sync_sources_only):
       logging.debug('Sync skipped: not running commands for %s' % package)
       return
 
     if type_text == 'build_noncanonical' and self._options.canonical_only:
       logging.debug('Non-canonical build of %s skipped' % package)
       return
 
     pynacl.log_tools.WriteAnnotatorLine(
         '@@@BUILD_STEP %s (%s)@@@' % (package, type_text))
     logging.debug('Building %s package %s' % (type_text, package))
 
     dependencies = package_info.get('dependencies', [])
 
     # Collect a dict of all the inputs.
     inputs = {}
     # Add in explicit inputs.
     if 'inputs' in package_info:
       for key, value in package_info['inputs'].iteritems():
         if key in dependencies:
-          raise Exception('key "%s" found in both dependencies and inputs of '
+          raise BuildError('key "%s" found in both dependencies and inputs of '
                           'package "%s"' % (key, package))
         inputs[key] = value
     elif type_text != 'source':
       # Non-source packages default to a particular input directory.
       inputs['src'] = os.path.join(self._options.source, package)
     # Add in each dependency by package name.
     for dependency in dependencies:
       inputs[dependency] = self.GetOutputDir(dependency, True)
 
     # Each package generates intermediate into output/<PACKAGE>_work.
@@ skipping 16 matching lines @@
 
     # Create a command option object specifying current build.
     cmd_options = command_options.CommandOptions(
         work_dir=work_dir,
         clobber_working=self._options.clobber,
         clobber_source=self._options.clobber_source,
         trybot=self._options.trybot,
         buildbot=self._options.buildbot)
 
     # Do it.
-    self._build_once.Run(
+    try:
+      self._build_once.Run(
         package, inputs, output,
         commands=commands,
         cmd_options=cmd_options,
         working_dir=work_dir,
         memoize=is_build_target,
         signature_file=self._signature_file,
         subdir=output_subdir,
         bskey_extra = build_signature_key_extra)
+    except subprocess.CalledProcessError as e:
+      raise BuildError(
+        'Error building %s: %s' % (package, str(e)))
 
     if not is_source_target and self._options.install:
       install = pynacl.platform.CygPath(self._options.install)
       logging.debug('Installing output to %s' % install)
       pynacl.file_tools.CopyTree(output, install)
 
   def BuildOrder(self, targets):
     """Find what needs to be built in what order to build all targets.
 
     Args:
@@ skipping 230 matching lines @@
     """Returns a dictionary of extra substitution paths allowed for commands."""
     if self._options.disable_git_cache:
       git_cache_dir = ''
     else:
       git_cache_dir = self._options.git_cache
 
     return {
         'top_srcdir': NACL_DIR,
         'git_cache_dir': git_cache_dir,
         }