Make child process errors kill gyp when parallel processing is on.

pylib/gyp/input.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
 from compiler.ast import Stmt
 import compiler
 import copy
 import gyp.common
 import multiprocessing
 import optparse
 import os.path
 import re
 import shlex
+import signal
 import subprocess
 import sys
 import threading
 import time
 from gyp.common import GypError
 
 
 # A list of types that are treated as linkable.
 linkable_types = ['executable', 'shared_library', 'loadable_module']
 
@@ skipping 419 matching lines @@
 def CallLoadTargetBuildFile(global_flags,
                             build_file_path, data,
                             aux_data, variables,
                             includes, depth, check):
   """Wrapper around LoadTargetBuildFile for parallel processing.
 
      This wrapper is used when LoadTargetBuildFile is executed in
      a worker process.
   """
 
+  signal.signal(signal.SIGINT, signal.SIG_IGN)
+
   # Apply globals so that the worker process behaves the same.
   for key, value in global_flags.iteritems():
     globals()[key] = value
 
   # Save the keys so we can return data that changed.
   data_keys = set(data)
   aux_data_keys = set(aux_data)
 
   result = LoadTargetBuildFile(build_file_path, data,
                                aux_data, variables,
@@ skipping 71 matching lines @@
 def LoadTargetBuildFileParallel(build_file_path, data, aux_data,
                                 variables, includes, depth, check):
   parallel_state = ParallelState()
   parallel_state.condition = threading.Condition()
   parallel_state.dependencies = [build_file_path]
   parallel_state.scheduled = set([build_file_path])
   parallel_state.pending = 0
   parallel_state.data = data
   parallel_state.aux_data = aux_data
 
-  parallel_state.condition.acquire()
-  while parallel_state.dependencies or parallel_state.pending:
-    if not parallel_state.dependencies:
-      parallel_state.condition.wait()
-      continue
+  try:
+    parallel_state.condition.acquire()
+    while parallel_state.dependencies or parallel_state.pending:
+      if not parallel_state.dependencies:
+        parallel_state.condition.wait()
+        continue
 
-    dependency = parallel_state.dependencies.pop()
+      dependency = parallel_state.dependencies.pop()
 
-    parallel_state.pending += 1
-    data_in = {}
-    data_in['target_build_files'] = data['target_build_files']
-    aux_data_in = {}
-    global_flags = {
-      'path_sections': globals()['path_sections'],
-      'non_configuration_keys': globals()['non_configuration_keys'],
-      'absolute_build_file_paths': globals()['absolute_build_file_paths'],
-      'multiple_toolsets': globals()['multiple_toolsets']}
+      parallel_state.pending += 1
+      data_in = {}
+      data_in['target_build_files'] = data['target_build_files']
+      aux_data_in = {}
+      global_flags = {
+        'path_sections': globals()['path_sections'],
+        'non_configuration_keys': globals()['non_configuration_keys'],
+        'absolute_build_file_paths': globals()['absolute_build_file_paths'],
+        'multiple_toolsets': globals()['multiple_toolsets']}
 
-    if not parallel_state.pool:
-      parallel_state.pool = multiprocessing.Pool(8)
-    parallel_state.pool.apply_async(
-        CallLoadTargetBuildFile,
-        args = (global_flags, dependency,
-                data_in, aux_data_in,
-                variables, includes, depth, check),
-        callback = parallel_state.LoadTargetBuildFileCallback)
+      if not parallel_state.pool:
+        parallel_state.pool = multiprocessing.Pool(8)
+      parallel_state.pool.apply_async(
+          CallLoadTargetBuildFile,
+          args = (global_flags, dependency,
+                  data_in, aux_data_in,
+                  variables, includes, depth, check),
+          callback = parallel_state.LoadTargetBuildFileCallback)
+  except KeyboardInterrupt, e:
+    parallel_state.pool.terminate()
+    raise e
 
   parallel_state.condition.release()
 
 
 # Look for the bracket that matches the first bracket seen in a
 # string, and return the start and end as a tuple.  For example, if
 # the input is something like "<(foo <(bar)) blah", then it would
 # return (1, 13), indicating the entire string except for the leading
 # "<" and trailing " blah".
 def FindEnclosingBracketGroup(input):
@@ skipping 2042 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]