ABANDONED. Use gclient_utils instead.

subprocess2.py

 # coding=utf8
 # 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.
 """Collection of subprocess wrapper functions.
 
 In theory you shouldn't need anything else in subprocess, or this module failed.
 """
 
 import cStringIO
@@ skipping 444 matching lines @@
       kwargs['stdin'] = stdin
       stdin = None
 
   proc = Popen(args, **kwargs)
   if stdin:
     return proc.communicate(stdin, timeout, nag_timer), proc.returncode
   else:
     return proc.communicate(None, timeout, nag_timer), proc.returncode
 
 
+def communicate_and_stream(args, **kwargs):

[M-A Ruel, 2016/03/08 23:54:08]

There's a function to do something similar in gclient_utils.py. In practice,
subprocess42 does it much better with a for loop.

+  """Same as communicate, but will not just capture, but also stream output
+  streams while command is running.
+
+  Returns ((stdout, stderr), returncode).
+
+  By default, streams and captures both stdout and stderr. You can silence any
+  of the streams, but passing std{err,out} special PIPE or VOID, depending on
+  whether you want it captured or completely ignored.
+
+  This useful for commands that take time to run, such that it's useful to both
+  capture output but also steram as parent process std{out,err}.
+  """
+  # communicate method above won't capture anything if std{err,out} is callable.
+  # So, capture it ourselves essentially the same way.
+  # Aslo, because callbacks are called in asynchroneous thread, we can stream

[Paweł Hajdan Jr., 2016/03/08 23:52:24]

nit: Aslo -> Also ; asynchroneous -> asynchronous

+  # output directly with simple labmbda, no need for yet another thread.
+  def combine_funcs(f1, f2):
+    def f(x):
+      f1(x)
+      f2(x)
+    return f
+
+  result = {}
+  for stream in ('stderr', 'stdout'):
+    if stream in kwargs:
+      # Don't stream/capture streams that user specified explicitely.

[Paweł Hajdan Jr., 2016/03/08 23:52:24]

nit: explicitely -> explicitly

+      continue
+    result[stream] = []  # Container to hold results data chunks.
+    kwargs[stream] = combine_funcs(
+        result[stream].append,
+        getattr(sys, stream).write)
+
+  (out, err), returncode = communicate(args, **kwargs)
+  if 'stderr' in result:
+    assert not err
+    err = ''.join(result['stderr'])
+  if 'stdout' in result:
+    assert not out
+    out = ''.join(result['stdout'])
+  return (out, err), returncode
+
+
 def call(args, **kwargs):
   """Emulates subprocess.call().
 
   Automatically convert stdout=PIPE or stderr=PIPE to VOID.
   In no case they can be returned since no code path raises
   subprocess2.CalledProcessError.
   """
   if kwargs.get('stdout') == PIPE:
     kwargs['stdout'] = VOID
   if kwargs.get('stderr') == PIPE:
@@ skipping 40 matching lines @@
 
   - Throws if return code is not 0.
   - Works even prior to python 2.7.
   - Blocks stdin by default if not specified since no output will be visible.
   - As per doc, "The stdout argument is not allowed as it is used internally."
   """
   kwargs.setdefault('stdin', VOID)
   if 'stdout' in kwargs:
     raise ValueError('stdout argument not allowed, it would be overridden.')
   return check_call_out(args, stdout=PIPE, **kwargs)[0]