Restore 103787 (fix git progress message), and update test expectations.

gclient_utils.py

 # Copyright (c) 2011 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 errno
 import logging
 import os
 import Queue
@@ skipping 229 matching lines @@
         new_fileobj.last_flushed_at = time.time()
     finally:
       new_fileobj.lock.release()
     if should_flush:
       new_fileobj.flush()
 
   new_fileobj.write = auto_flush_write
   return new_fileobj
 
 
-def MakeFileAnnotated(fileobj, include_zero=False):
+def MakeFileAnnotated(fileobj):

[M-A Ruel, 2011/10/06 00:57:34]

Please git svn rebase or svn up correctly.

   """Creates a file object clone to automatically prepends every line in worker
   threads with a NN> prefix."""
   if hasattr(fileobj, 'output_buffers'):
     # Already patched.
     return fileobj
 
   # Attribute 'XXX' defined outside __init__
   # pylint: disable=W0201
   new_fileobj = SoftClone(fileobj)
   if not hasattr(new_fileobj, 'lock'):
     new_fileobj.lock = threading.Lock()
   new_fileobj.output_buffers = {}
   new_fileobj.old_annotated_write = new_fileobj.write
 
   def annotated_write(out):
     index = getattr(threading.currentThread(), 'index', None)
     if index is None:
-      if not include_zero:
-        # Unindexed threads aren't buffered.
-        new_fileobj.old_annotated_write(out)
-        return
-      index = 0
+      # Undexed threads aren't buffered.
+      new_fileobj.old_annotated_write(out)
+      return
 
     new_fileobj.lock.acquire()
     try:
       # Use a dummy array to hold the string so the code can be lockless.
       # Strings are immutable, requiring to keep a lock for the whole dictionary
       # otherwise. Using an array is faster than using a dummy object.
       if not index in new_fileobj.output_buffers:
         obj = new_fileobj.output_buffers[index] = ['']
       else:
         obj = new_fileobj.output_buffers[index]
@@ skipping 70 matching lines @@
       in_line = ''
       while in_byte:
         if in_byte != '\r':
           if print_stdout:
             stdout.write(in_byte)
           if in_byte != '\n':
             in_line += in_byte
           else:
             filter_fn(in_line)
             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()
   except KeyboardInterrupt:
     print >> sys.stderr, 'Failed while running "%s"' % ' '.join(args)
     raise
 
@@ skipping 117 matching lines @@
 
   @property
   def name(self):
     return self._name
 
   @property
   @lockedmethod
   def requirements(self):
     return tuple(self._requirements)
 
-  @lockedmethod
-  def add_requirement(self, new):
-    self._requirements.add(new)
-
 
 class ExecutionQueue(object):
   """Runs a set of WorkItem that have interdependencies and were WorkItem are
   added as they are processed.
 
   In gclient's case, Dependencies sometime needs to be run out of order due to
   From() keyword. This class manages that all the required dependencies are run
   before running each one.
 
   Methods of this class are thread safe.
@@ skipping 42 matching lines @@
     try:
       while True:
         # Check for task to run first, then wait.
         while True:
           if not self.exceptions.empty():
             # Systematically flush the queue when an exception logged.
             self.queued = []
           self._flush_terminated_threads()
           if (not self.queued and not self.running or
               self.jobs == len(self.running)):
-            logging.debug('No more worker threads or can\'t queue anything.')
+            # No more worker threads or can't queue anything.
             break
 
           # Check for new tasks to start.
           for i in xrange(len(self.queued)):
             # Verify its requirements.
             for r in self.queued[i].requirements:
               if not r in self.ran:
                 # Requirement not met.
                 break
             else:
@@ skipping 66 matching lines @@
       # exception.
       task_item.run(*args, **kwargs)
       self.ran.append(task_item.name)
       if self.progress:
         self.progress.update(1, ', '.join(t.item.name for t in self.running))
 
   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))
+      logging.info(item.name)
       self.item = item
       self.index = index
       self.args = args
       self.kwargs = kwargs
 
     def run(self):
       """Runs in its own thread."""
-      logging.debug('_Worker.run(%s)' % self.item.name)
+      logging.debug('running(%s)' % self.item.name)
       work_queue = self.kwargs['work_queue']
       try:
         self.item.run(*self.args, **self.kwargs)
       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)
+      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()