Kill subprocesses on KeyboardInterrupt.

gclient_utils.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Generic utils."""
 
 import codecs
 import logging
 import os
 import Queue
@@ skipping 305 matching lines @@
     return fileobj
   return AutoFlush(fileobj, delay)
 
 
 def MakeFileAnnotated(fileobj, include_zero=False):
   if getattr(fileobj, 'annotated', None):
     return fileobj
   return Annotated(fileobj)
 
 
+class GClientChildrenSingleton(object):
+  _instance = None
+  children = {}
+  children_lock = threading.Lock()
+
+  def __new__(cls, *args, **kwargs):
+    if not isinstance(cls._instance, cls):
+      cls._instance = object.__new__(cls, *args, **kwargs)

[M-A Ruel, 2013/05/03 16:39:01]

I don't think it's a good idea. Just create a global variable, it's cleaner and
way more logical.

+    return cls._instance
+
+  def add(self, popen_obj):
+    with self.children_lock:
+      self.children[popen_obj.pid] = popen_obj
+
+  def remove(self, popen_obj):
+    with self.children_lock:
+      del self.children[popen_obj.pid]
+
+
+def KillAllRemainingChildren():
+  children = GClientChildrenSingleton()
+  dead_objs = []
+
+  for pid, child in children.children.iteritems():
+    if child.poll():
+      dead_objs.append(child)
+      continue
+
+    try:
+      child.kill()
+      dead_objs.append(child)
+    except OSError:
+      pass
+
+  for obj in dead_objs:
+    children.remove(obj)
+
+  if children.children:
+    print >> sys.stderr, 'Could not kill the folling subprocesses:'
+    for pid in children.children:
+      print >> sys.stderr, '  ', pid
+
+
 def CheckCallAndFilter(args, stdout=None, filter_fn=None,
                        print_stdout=None, call_filter_on_first_line=False,
                        **kwargs):
   """Runs a command and calls back a filter function if needed.
 
   Accepts all subprocess2.Popen() parameters plus:
     print_stdout: If True, the command's stdout is forwarded to stdout.
     filter_fn: A function taking a single string argument called with each line
                of the subprocess2's output. Each line has the trailing newline
                character trimmed.
     stdout: Can be any bufferable output.
 
   stderr is always redirected to stdout.
   """
   assert print_stdout or filter_fn
   stdout = stdout or sys.stdout
   filter_fn = filter_fn or (lambda x: None)
   kid = subprocess2.Popen(
       args, bufsize=0, stdout=subprocess2.PIPE, stderr=subprocess2.STDOUT,
       **kwargs)
 
+  children = GClientChildrenSingleton()
+  children.add(kid)
+
   # Do a flush of stdout before we begin reading from the subprocess2's stdout
   stdout.flush()
 
   # Also, we need to forward stdout to prevent weird re-ordering of output.
   # This has to be done on a per byte basis to make sure it is not buffered:
   # normally buffering is done for each line, but if svn requests input, no
   # end-of-line character is output after the prompt and it would not show up.
   try:
     in_byte = kid.stdout.read(1)
     if in_byte:
@@ skipping 11 matching lines @@
             in_line = ''
         else:
           filter_fn(in_line)
           in_line = ''
         in_byte = kid.stdout.read(1)
       # Flush the rest of buffered output. This is only an issue with
       # stdout/stderr not ending with a \n.
       if len(in_line):
         filter_fn(in_line)
     rv = kid.wait()
+
+    # Don't put this in a 'finally,' since the child may still run if we get an
+    # exception.
+    children.remove(kid)
+
   except KeyboardInterrupt:
     print >> sys.stderr, 'Failed while running "%s"' % ' '.join(args)
     raise
 
   if rv:
     raise subprocess2.CalledProcessError(
         rv, args, kwargs.get('cwd', None), None, None)
   return 0
 
 
@@ skipping 262 matching lines @@
 
   class _Worker(threading.Thread):
     """One thread to execute one WorkItem."""
     def __init__(self, item, index, args, kwargs):
       threading.Thread.__init__(self, name=item.name or 'Worker')
       logging.info('_Worker(%s) reqs:%s' % (item.name, item.requirements))
       self.item = item
       self.index = index
       self.args = args
       self.kwargs = kwargs
+      self.daemon = True
 
     def run(self):
       """Runs in its own thread."""
       logging.debug('_Worker.run(%s)' % self.item.name)
       work_queue = self.kwargs['work_queue']
       try:
         self.item.run(*self.args, **self.kwargs)
+      except KeyboardInterrupt:
+        logging.info('Caught KeyboardInterrupt in thread %s' % self.item.name)
+        logging.info(str(sys.exc_info()))
+        work_queue.exceptions.put(sys.exc_info())
+        raise

[M-A Ruel, 2013/05/03 16:39:01]

Then the lines 731-735 should be in a finally

       except Exception:
         # Catch exception location.
         logging.info('Caught exception in thread %s' % self.item.name)
         logging.info(str(sys.exc_info()))
         work_queue.exceptions.put(sys.exc_info())
       logging.info('_Worker.run(%s) done' % self.item.name)
 
       work_queue.ready_cond.acquire()
       try:
         work_queue.ready_cond.notifyAll()
@@ skipping 87 matching lines @@
 
   Python on OSX 10.6 raises a NotImplementedError exception.
   """
   try:
     import multiprocessing
     return multiprocessing.cpu_count()
   except:  # pylint: disable=W0702
     # Mac OS 10.6 only
     # pylint: disable=E1101
     return int(os.sysconf('SC_NPROCESSORS_ONLN'))