Repair broken git checkouts caused by aborting git clone.

gclient_scm.py

 # 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import logging
 import os
 import posixpath
 import re
@@ skipping 219 matching lines @@
       # Not a fatal error, or even very interesting in a non-git-submodule
       # world.  So just keep it quiet.
       pass
     try:
       gclient_utils.CheckCallAndFilter(cmd3, **kwargs)
     except subprocess2.CalledProcessError:
       gclient_utils.CheckCallAndFilter(cmd3 + ['always'], **kwargs)
 
     gclient_utils.CheckCallAndFilter(cmd4, **kwargs)
 
+  def _FetchAndReset(self, revision, file_list, options):
+    """Equivalent to git fetch; git reset."""
+    quiet = []
+    if not options.verbose:
+      quiet = ['--quiet']
+    self._UpdateBranchHeads(options, fetch=False)
+    self._Run(['fetch', 'origin', '--prune'] + quiet, options)
+    self._Run(['reset', '--hard', revision] + quiet, options)
+    self.UpdateSubmoduleConfig()
+    files = self._Capture(['ls-files']).splitlines()
+    file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
@@ skipping 81 matching lines @@
     if (current_url != url and
         url != 'git://foo' and
         subprocess2.capture(
             ['git', 'config', 'remote.origin.gclient-auto-fix-url'],
             cwd=self.checkout_path).strip() != 'False'):
       print('_____ switching %s to a new upstream' % self.relpath)
       # Make sure it's clean
       self._CheckClean(rev_str)
       # Switch over to the new upstream
       self._Run(['remote', 'set-url', 'origin', url], options)
-      quiet = []
-      if not options.verbose:
-        quiet = ['--quiet']
-      self._UpdateBranchHeads(options, fetch=False)
-      self._Run(['fetch', 'origin', '--prune'] + quiet, options)
-      self._Run(['reset', '--hard', revision] + quiet, options)
-      self.UpdateSubmoduleConfig()
-      files = self._Capture(['ls-files']).splitlines()
-      file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+      self._FetchAndReset(revision, file_list, options)
       return
 
+    if not self._IsValidGitRepo():
+      # .git directory is hosed for some reason, set it back up.
+      print('_____ %s/.git is corrupted, rebuilding' % self.relpath)
+      self._Run(['init'], options)
+      self._Run(['remote', 'set-url', 'origin', url], options)
+
+    if not self._HasHead():
+      # Previous checkout was aborted before branches could be created in repo,
+      # so we need to reconstruct them here.
+      self._Run(['pull', 'origin', 'master'], options)
+      self._FetchAndReset(revision, file_list, options)
+
     cur_branch = self._GetCurrentBranch()
 
     # Cases:
     # 0) HEAD is detached. Probably from our initial clone.
     #   - make sure HEAD is contained by a named ref, then update.
     # Cases 1-4. HEAD is a branch.
     # 1) current branch is not tracking a remote branch (could be git-svn)
     #   - try to rebase onto the new hash or branch
     # 2) current branch is tracking a remote branch with local committed
     #    changes, but the DEPS file switched to point to a hash
@@ skipping 432 matching lines @@
                                   "manually.\ncd %s && git " %
                                   self.checkout_path
                                   + "%s" % ' '.join(rebase_cmd))
 
     print(rebase_output.strip())
     if not options.verbose:
       # Make the output a little prettier. It's nice to have some
       # whitespace between projects when syncing.
       print('')
 
+  def _IsValidGitRepo(self):
+    """Returns if the directory is a valid git repository.
+
+    Checks if git status works.
+    """
+    try:
+      self._Capture(['status'])

[Isaac (away), 2013/07/16 10:06:21]

status is a expensive command on some projects (like blink) -- could we change
this to rev-parse HEAD?

+      return True
+    except subprocess2.CalledProcessError:
+      return False
+
+  def _HasHead(self):
+    """Returns True if any commit is checked out.
+
+    This is done by checking if rev-parse HEAD works in the current repository.
+    """
+    try:
+      self._GetCurrentBranch()
+      return True
+    except subprocess2.CalledProcessError:
+      return False
+
   @staticmethod
   def _CheckMinVersion(min_version):
     (ok, current_version) = scm.GIT.AssertVersion(min_version)
     if not ok:
       raise gclient_utils.Error('git version %s < minimum required %s' %
                                 (current_version, min_version))
 
   def _IsRebasing(self):
     # Check for any of REBASE-i/REBASE-m/REBASE/AM. Unfortunately git doesn't
     # have a plumbing command to determine whether a rebase is in progress, so
@@ skipping 477 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command