Add git thaw/freeze to depot_tools.

git_common.py

 # Copyright 2013 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.
 
 # Monkeypatch IMapIterator so that Ctrl-C can kill everything properly.
 # Derived from https://gist.github.com/aljungberg/626518
 import multiprocessing.pool
 from multiprocessing.pool import IMapIterator
 def wrapper(func):
   def wrap(self, timeout=None):
     return func(self, timeout=timeout or 1e100)
   return wrap
 IMapIterator.next = wrapper(IMapIterator.next)
 IMapIterator.__next__ = IMapIterator.next
 # TODO(iannucci): Monkeypatch all other 'wait' methods too.
 
 
 import binascii
 import contextlib
 import functools
 import logging
+import os
 import signal
 import sys
 import tempfile
 import threading
 
 import subprocess2
 
 
 GIT_EXE = 'git.bat' if sys.platform.startswith('win') else 'git'
 
@@ skipping 100 matching lines @@
     pool.close()
   except:
     pool.terminate()
     raise
   finally:
     pool.join()
 
 
 class ProgressPrinter(object):
   """Threaded single-stat status message printer."""
-  def __init__(self, fmt, enabled=None, stream=sys.stderr, period=0.5):
+  def __init__(self, fmt, enabled=None, fout=sys.stderr, period=0.5):
     """Create a ProgressPrinter.
 
     Use it as a context manager which produces a simple 'increment' method:
 
       with ProgressPrinter('(%%(count)d/%d)' % 1000) as inc:
         for i in xrange(1000):
           # do stuff
           if i % 10 == 0:
             inc(10)
 
     Args:
       fmt - String format with a single '%(count)d' where the counter value
         should go.
       enabled (bool) - If this is None, will default to True if
         logging.getLogger() is set to INFO or more verbose.
-      stream (file-like) - The stream to print status messages to.
+      fout (file-like) - The stream to print status messages to.
       period (float) - The time in seconds for the printer thread to wait
         between printing.
     """
     self.fmt = fmt
     if enabled is None:  # pragma: no cover
       self.enabled = logging.getLogger().isEnabledFor(logging.INFO)
     else:
       self.enabled = enabled
 
     self._count = 0
     self._dead = False
     self._dead_cond = threading.Condition()
-    self._stream = stream
+    self._stream = fout
     self._thread = threading.Thread(target=self._run)
     self._period = period
 
   def _emit(self, s):
     if self.enabled:
       self._stream.write('\r' + s)
       self._stream.flush()
 
   def _run(self):
     with self._dead_cond:
@@ skipping 50 matching lines @@
     raise BadCommitRefException(commitrefs)
 
 
 def run(*cmd, **kwargs):
   """Runs a git command. Returns stdout as a string.
 
   If logging is DEBUG, we'll print the command before we run it.
 
   kwargs
     autostrip (bool) - Strip the output. Defaults to True.
-  Output string is always strip()'d.
   """
   autostrip = kwargs.pop('autostrip', True)
-  cmd = (GIT_EXE,) + cmd
-  logging.debug('Running %s', ' '.join(repr(tok) for tok in cmd))
-  ret = subprocess2.check_output(cmd, stderr=subprocess2.PIPE, **kwargs)
+
+  retstream, proc = stream_proc(*cmd, **kwargs)
+  ret = retstream.read()
+  retcode = proc.wait()
+  if retcode != 0:
+    raise subprocess2.CalledProcessError(retcode, cmd, os.getcwd(), ret, None)
+
   if autostrip:
     ret = (ret or '').strip()
   return ret
 
 
+def stream_proc(*cmd, **kwargs):
+  """Runs a git command. Returns stdout as a file.
+
+  If logging is DEBUG, we'll print the command before we run it.
+  """
+  cmd = (GIT_EXE,) + cmd
+  logging.debug('Running %s', ' '.join(repr(tok) for tok in cmd))
+  proc = subprocess2.Popen(cmd, stderr=subprocess2.VOID,
+                           stdout=subprocess2.PIPE, **kwargs)
+  return proc.stdout, proc
+
+
+def stream(*cmd, **kwargs):
+  return stream_proc(*cmd, **kwargs)[0]
+
+
 def hash_one(reflike):
   return run('rev-parse', reflike)
 
 
 def hash_multi(*reflike):
   return run('rev-parse', *reflike).splitlines()
 
 
 def intern_f(f, kind='blob'):
   """Interns a file object into the git object store.
@@ skipping 64 matching lines @@
   See |tree()| for the values of mode, type, and ref.
 
   Args:
     treedict - { name: (mode, type, ref) }
   """
   with tempfile.TemporaryFile() as f:
     for name, (mode, typ, ref) in treedict.iteritems():
       f.write('%s %s %s\t%s\0' % (mode, typ, ref, name))
     f.seek(0)
     return run('mktree', '-z', stdin=f)