Enable annotated output for --jobs N!=1.

gclient_utils.py

 # Copyright 2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 296 matching lines @@
         self.last_flushed_at = time.time()
     finally:
       self.lock.release()
     if should_flush:
       self.stdout.flush()
 
   def flush(self):
     self.stdout.flush()
 
 
+class StdoutAnnotated(object):
+  """Prepends every line with a string."""
+  def __init__(self, prepend, stdout):
+    self.prepend = prepend
+    self.buf = ''
+    self.stdout = stdout
+
+  def write(self, out):
+    self.buf += out
+    while '\n' in self.buf:
+      line, self.buf = self.buf.split('\n', 1)
+      self.stdout.write(self.prepend + line + '\n')
+
+  def flush(self):
+    pass
+
+  def full_flush(self):
+    if self.buf:
+      self.stdout.write(self.prepend + self.buf)
+      self.stdout.flush()
+      self.buf = ''
+
+
 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 subprocess.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 subprocess's output. Each line has the trailing newline
                character trimmed.
@@ skipping 235 matching lines @@
 
   def _flush_terminated_threads(self):
     """Flush threads that have terminated."""
     running = self.running
     self.running = []
     for t in running:
       if t.isAlive():
         self.running.append(t)
       else:
         t.join()
-        t.kwargs['options'].stdout.flush()
+        t.kwargs['options'].stdout.full_flush()
         if self.progress:
           self.progress.update(1)
         assert not t.name in self.ran
         if not t.name in self.ran:
           self.ran.append(t.name)
 
   def _run_one_task(self, task_item, args, kwargs):
     if self.jobs > 1:
       # Start the thread.
       index = len(self.ran) + len(self.running) + 1
-      # Copy 'options' just to be safe.
+      # Copy 'options' and add annotated stdout.
       task_kwargs = kwargs.copy()
       task_kwargs['options'] = copy.copy(task_kwargs['options'])
+      task_kwargs['options'].stdout = StdoutAnnotated(
+          '%d>' % index, task_kwargs['options'].stdout)
       new_thread = self._Worker(task_item, args, task_kwargs)
       self.running.append(new_thread)
       new_thread.start()
     else:
       # Run the 'thread' inside the main thread. Don't try to catch any
       # exception.
       task_item.run(*args, **kwargs)
       self.ran.append(task_item.name)
 
   class _Worker(threading.Thread):
@@ skipping 16 matching lines @@
         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('Task %s done' % self.item.name)
 
       work_queue.ready_cond.acquire()
       try:
         work_queue.ready_cond.notifyAll()
       finally:
         work_queue.ready_cond.release()