Make git-freeze bail out if the user has too much untracked data.

git_common.py

 # Copyright 2014 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):
@@ skipping 14 matching lines @@
 import setup_color
 import shutil
 import signal
 import sys
 import tempfile
 import textwrap
 import threading
 
 import subprocess2
 
+from StringIO import StringIO
+
+
 ROOT = os.path.abspath(os.path.dirname(__file__))
-
 IS_WIN = sys.platform == 'win32'
 GIT_EXE = ROOT+'\\git.bat' if IS_WIN else 'git'
 TEST_MODE = False
 
 FREEZE = 'FREEZE'
 FREEZE_SECTIONS = {
   'indexed': 'soft',
   'unindexed': 'mixed'
 }
 FREEZE_MATCHER = re.compile(r'%s.(%s)' % (FREEZE, '|'.join(FREEZE_SECTIONS)))
@@ skipping 338 matching lines @@
   except subprocess2.CalledProcessError:
     pass
 
 
 def diff(oldrev, newrev, *args):
   return run('diff', oldrev, newrev, *args)
 
 
 def freeze():
   took_action = False
+  key = 'depot-tools.freeze-size-limit'
+  MB = 2**20
+  limit_mb = get_config_int(key, 100)
+  untracked_bytes = 0
+
+  for f, s in status():
+    if is_unmerged(s):
+      die("Cannot freeze unmerged changes!")
+    if limit_mb > 0:
+      if s.lstat == '?':
+        untracked_bytes += os.stat(f).st_size
+      if untracked_bytes > limit_mb * MB:
+        die("""\
+          You appear to have too much untracked+unignored data in your git
+          checkout: %.1f / %d MB.
+
+          Run `git status` to see what it is.
+
+          In addition to making many git commands slower, this will prevent
+          depot_tools from freezing your in-progress changes.
+
+          You should add untracked data that you want to ignore to your repo's
+            .git/info/excludes
+          file. See `git help ignore` for the format of this file.
+
+          If this data is indended as part of your commit, you may adjust the
+          freeze limit by running:
+            git config %s <new_limit>
+          Where <new_limit> is an integer threshold in megabytes.""",
+          untracked_bytes / (MB * 1.0), limit_mb, key)
 
   try:
     run('commit', '--no-verify', '-m', FREEZE + '.indexed')
     took_action = True
   except subprocess2.CalledProcessError:
     pass
 
   try:
     run('add', '-A')
     run('commit', '--no-verify', '-m', FREEZE + '.unindexed')
@@ skipping 90 matching lines @@
   ret = run('hash-object', '-t', kind, '-w', '--stdin', stdin=f)
   f.close()
   return ret
 
 
 def is_dormant(branch):
   # TODO(iannucci): Do an oldness check?
   return branch_config(branch, 'dormant', 'false') != 'false'
 
 
+def is_unmerged(stat_value):
+  return (
+      'U' in (stat_value.lstat, stat_value.rstat) or
+      ((stat_value.lstat == stat_value.rstat) and stat_value.lstat in 'AD')
+  )
+
+
 def manual_merge_base(branch, base, parent):
   set_branch_config(branch, 'base', base)
   set_branch_config(branch, 'base-upstream', parent)
 
 
 def mktree(treedict):
   """Makes a git tree object and returns its hash.
 
   See |tree()| for the values of mode, type, and ref.
 
@@ skipping 189 matching lines @@
   if dirty:
     print 'Cannot %s with a dirty tree. You must commit locally first.' % cmd
     print 'Uncommitted files: (git diff-index --name-status HEAD)'
     print dirty[:4096]
     if len(dirty) > 4096: # pragma: no cover
       print '... (run "git diff-index --name-status HEAD" to see full output).'
     return True
   return False
 
 
+def status():
+  """Returns a parsed version of git-status.
+
+  Returns a generator of (current_name, (lstat, rstat, src)) pairs where:
+    * current_name is the name of the file
+    * lstat is the left status code letter from git-status
+    * rstat is the left status code letter from git-status
+    * src is the current name of the file, or the original name of the file
+      if lstat == 'R'
+  """
+  stat_entry = collections.namedtuple('stat_entry', 'lstat rstat src')
+
+  def tokenizer(stream):
+    acc = StringIO()
+    c = None
+    while c != '':
+      c = stream.read(1)
+      if c in (None, '', '\0'):
+        if acc.len:
+          yield acc.getvalue()
+          acc = StringIO()
+      else:
+        acc.write(c)
+
+  def parser(tokens):
+    while True:
+      # Raises StopIteration if it runs out of tokens.
+      status_dest = next(tokens)
+      stat, dest = status_dest[:2], status_dest[3:]
+      lstat, rstat = stat
+      if lstat == 'R':
+        src = next(tokens)
+      else:
+        src = dest
+      yield (dest, stat_entry(lstat, rstat, src))
+
+  return parser(tokenizer(run_stream('status', '-z', bufsize=-1)))
+
+
 def squash_current_branch(header=None, merge_base=None):
   header = header or 'git squash commit.'
   merge_base = merge_base or get_or_create_merge_base(current_branch())
   log_msg = header + '\n'
   if log_msg:
     log_msg += '\n'
   log_msg += run('log', '--reverse', '--format=%H%n%B', '%s..HEAD' % merge_base)
   run('reset', '--soft', merge_base)
 
   if not get_dirty_files():
@@ skipping 191 matching lines @@
                       ['HEAD'])
 
 
 def clone_file(repository, new_workdir, link, operation):
   if not os.path.exists(os.path.join(repository, link)):
     return
   link_dir = os.path.dirname(os.path.join(new_workdir, link))
   if not os.path.exists(link_dir):
     os.makedirs(link_dir)
   operation(os.path.join(repository, link), os.path.join(new_workdir, link))