Add automatic auto-flushing stdout.

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 267 matching lines @@
             % (' '.join(args), kwargs.get('cwd', '.')))
       elif filter_fn:
         filter_fn(line)
     kwargs['filter_fn'] = filter_msg
     kwargs['call_filter_on_first_line'] = True
   # Obviously.
   kwargs['print_stdout'] = True
   return CheckCallAndFilter(args, **kwargs)
 
 
+class StdoutAutoFlush(object):
+  """Automatically flush after N seconds."""
+  def __init__(self, stdout, delay=10):
+    self.lock = threading.Lock()
+    self.stdout = stdout
+    self.delay = delay
+    self.last_flushed_at = time.time()
+    self.stdout.flush()
+
+  def write(self, out):
+    """Thread-safe."""
+    self.stdout.write(out)
+    should_flush = False
+    with self.lock:
+      if (time.time() - self.last_flushed_at) > self.delay:
+        should_flush = True
+        self.last_flushed_at = time.time()
+    if should_flush:
+      self.stdout.flush()
+
+  def flush(self):
+    self.stdout.flush()
+
+
 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.
     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)
   assert not 'stderr' in kwargs
   kid = Popen(args, bufsize=0,
               stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
               **kwargs)
 
   # Do a flush of stdout before we begin reading from the subprocess's stdout
-  last_flushed_at = time.time()
   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.
   in_byte = kid.stdout.read(1)
   if in_byte:
     if call_filter_on_first_line:
       filter_fn(None)
     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 = ''
-          # Flush at least 10 seconds between line writes.  We wait at least 10
-          # seconds to avoid overloading the reader that called us with output,
-          # which can slow busy readers down.
-          if (time.time() - last_flushed_at) > 10:
-            last_flushed_at = time.time()
-            stdout.flush()
       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()
   if rv:
     raise CheckCallError(args, kwargs.get('cwd', None), rv, None)
   return 0
 
@@ skipping 216 matching lines @@
         if exception:
           self.parent.exceptions.append(exception)
         if self.parent.progress:
           self.parent.progress.update(1)
         assert not self.item.name in self.parent.ran
         if not self.item.name in self.parent.ran:
           self.parent.ran.append(self.item.name)
       finally:
         self.parent.ready_cond.notifyAll()
         self.parent.ready_cond.release()