gclient_scm.py: Make working with git more reliable

gclient_scm.py

 # Copyright (c) 2009 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 181 matching lines @@
       rev_type = "branch"
     elif revision.startswith('origin/'):
       # For compatability with old naming, translate 'origin' to 'refs/heads'
       revision = revision.replace('origin/', 'refs/heads/')
       rev_type = "branch"
     else:
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
     if not os.path.exists(self.checkout_path):
-      self._Clone(rev_type, revision, url, options.verbose)
+      self._Clone(revision, url, options.verbose)
       files = self._Run(['ls-files']).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
       if not verbose:
         # Make the output a little prettier. It's nice to have some whitespace
         # between projects when cloning.
         print ""
       return
 
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
                                 '\tTo resolve:\n'
                                 '\t\trm -rf %s\n'
                                 '\tAnd run gclient sync again\n'
                                 % (self.relpath, rev_str, self.relpath))
 
     cur_branch = self._GetCurrentBranch()
 
-    # Check if we are in a rebase conflict
-    if cur_branch is None:
-      raise gclient_utils.Error('\n____ %s%s\n'
-                                '\tAlready in a conflict, i.e. (no branch).\n'
-                                '\tFix the conflict and run gclient again.\n'
-                                '\tOr to abort run:\n\t\tgit-rebase --abort\n'
-                                '\tSee man git-rebase for details.\n'
-                                 % (self.relpath, rev_str))
-
     # Cases:
-    # 1) current branch based on a hash (could be git-svn)
-    #   - try to rebase onto the new upstream (hash or branch)
-    # 2) current branch based on a remote branch with local committed changes,
-    #    but the DEPS file switched to point to a hash
+    # 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
     #   - rebase those changes on top of the hash
-    # 3) current branch based on a remote with or without changes, no switch
+    # 3) current branch is tracking a remote branch w/or w/out changes,
+    #    no switch
     #   - see if we can FF, if not, prompt the user for rebase, merge, or stop
-    # 4) current branch based on a remote, switches to a new remote
+    # 4) current branch is tracking a remote branch, switches to a different
+    #    remote branch
     #   - exit
 
     # GetUpstreamBranch returns something like 'refs/remotes/origin/master' for
     # a tracking branch
     # or 'master' if not a tracking branch (it's based on a specific rev/hash)
     # or it returns None if it couldn't find an upstream
-    upstream_branch = scm.GIT.GetUpstreamBranch(self.checkout_path)
-    if not upstream_branch or not upstream_branch.startswith('refs/remotes'):
-      current_type = "hash"
-      logging.debug("Current branch is based off a specific rev and is not "
-                    "tracking an upstream.")
-    elif upstream_branch.startswith('refs/remotes'):
-      current_type = "branch"
+    if cur_branch is None:
+      upstream_branch = None
+      current_type = "detached"
+      logging.debug("Detached HEAD")
     else:
-      raise gclient_utils.Error('Invalid Upstream')
+      upstream_branch = scm.GIT.GetUpstreamBranch(self.checkout_path)
+      if not upstream_branch or not upstream_branch.startswith('refs/remotes'):
+        current_type = "hash"
+        logging.debug("Current branch is not tracking an upstream (remote)"
+                      " branch.")
+      elif upstream_branch.startswith('refs/remotes'):
+        current_type = "branch"
+      else:
+        raise gclient_utils.Error('Invalid Upstream: %s' % upstream_branch)
 
     # Update the remotes first so we have all the refs.
     for _ in range(10):
       try:
         remote_output, remote_err = scm.GIT.Capture(
             ['remote'] + verbose + ['update'],
             self.checkout_path,
             print_error=False)
         break
       except gclient_utils.CheckCallError:
         # Hackish but at that point, git is known to work so just checking for
         # 502 in stderr should be fine.
         if '502' in e.stderr:
           print str(e)
           print "Sleeping 15 seconds and retrying..."
           time.sleep(15)
           continue
         raise
 
     if verbose:
       print remote_output.strip()
       # git remote update prints to stderr when used with --verbose
       print remote_err.strip()
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
       self._Run(['reset', '--hard', 'HEAD'], redirect_stdout=False)
 
-    if current_type == 'hash':
+    if current_type == 'detached':
+      # case 0
+      self._CheckClean(rev_str)
+      self._CheckDetachedHead(rev_str)
+      self._Run(['checkout', '--quiet', '%s^0' % revision])
+      if not printed_path:
+        print("\n_____ %s%s" % (self.relpath, rev_str))
+    elif current_type == 'hash':
       # case 1
       if scm.GIT.IsGitSvn(self.checkout_path) and upstream_branch is not None:
         # Our git-svn branch (upstream_branch) is our upstream
         self._AttemptRebase(upstream_branch, files, verbose=options.verbose,
                             newbase=revision, printed_path=printed_path)
         printed_path = True
       else:
         # Can't find a merge-base since we don't know our upstream. That makes
         # this command VERY likely to produce a rebase failure. For now we
         # assume origin is our upstream since that's what the old behavior was.
@@ skipping 80 matching lines @@
           if merge_err:
             print "Merge produced error output:\n%s" % merge_err.strip()
           if not verbose:
             # Make the output a little prettier. It's nice to have some
             # whitespace between projects when syncing.
             print ""
 
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
     # If the rebase generated a conflict, abort and ask user to fix
-    if self._GetCurrentBranch() is None:
+    if self._IsRebasing():
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\nConflict while rebasing this branch.\n'
                                 'Fix the conflict and run gclient again.\n'
                                 'See man git-rebase for details.\n'
                                 % (self.relpath, rev_str))
 
     if verbose:
       print "Checked out revision %s" % self.revinfo(options, (), None)
 
   def revert(self, options, args, file_list):
@@ skipping 40 matching lines @@
       self._Run(['diff', '--name-status', merge_base], redirect_stdout=False)
       files = self._Run(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def FullUrlForRelativeUrl(self, url):
     # Strip from last '/'
     # Equivalent to unix basename
     base_url = self.url
     return base_url[:base_url.rfind('/')] + url
 
-  def _Clone(self, rev_type, revision, url, verbose=False):
+  def _Clone(self, revision, url, verbose=False):
     """Clone a git repository from the given URL.
 
-    Once we've cloned the repo, we checkout a working branch based off the
-    specified revision."""
+    Once we've cloned the repo, we checkout a working branch if the specified
+    revision is a branch head. If it is a tag or a specific commit, then we
+    leave HEAD detached as it makes future updates simpler -- in this case the
+    user should first create a new branch or switch to an existing branch before
+    making changes in the repo."""
     if not verbose:
       # git clone doesn't seem to insert a newline properly before printing
       # to stdout
       print ""
 
     clone_cmd = ['clone']
+    if revision.startswith('refs/heads/'):
+      clone_cmd.extend(['-b', revision.replace('refs/heads/', '')])
+      detach_head = False
+    else:
+      clone_cmd.append('--no-checkout')
+      detach_head = True
     if verbose:
       clone_cmd.append('--verbose')
     clone_cmd.extend([url, self.checkout_path])
 
     for _ in range(3):
       try:
         self._Run(clone_cmd, cwd=self._root_dir, redirect_stdout=False)
         break
       except gclient_utils.Error, e:
         # TODO(maruel): Hackish, should be fixed by moving _Run() to
         # CheckCall().
         # Too bad we don't have access to the actual output.
         # We should check for "transfer closed with NNN bytes remaining to
         # read". In the meantime, just make sure .git exists.
         if (e.args[0] == 'git command clone returned 128' and
             os.path.exists(os.path.join(self.checkout_path, '.git'))):
           print str(e)
           print "Retrying..."
           continue
         raise e
 
-    if rev_type == "branch":
-      short_rev = revision.replace('refs/heads/', '')
-      new_branch = revision.replace('heads', 'remotes/origin')
-    elif revision.startswith('refs/tags/'):
-      short_rev = revision.replace('refs/tags/', '')
-      new_branch = revision
-    else:
-      # revision is a specific sha1 hash
-      short_rev = revision
-      new_branch = revision
-
-    cur_branch = self._GetCurrentBranch()
-    if cur_branch != short_rev:
-      self._Run(['checkout', '-b', short_rev, new_branch],
-                redirect_stdout=False)
+    if detach_head:
+      # Squelch git's very verbose detached HEAD warning and use our own
+      self._Run(['checkout', '--quiet', '%s^0' % revision])
+      print \
+        "Checked out %s to a detached HEAD. Before making any commits\n" \
+        "in this repo, you should use 'git checkout <branch>' to switch to\n" \
+        "an existing branch or use 'git checkout origin -b <branch>' to\n" \
+        "create a new branch for your work." % revision
 
   def _AttemptRebase(self, upstream, files, verbose=False, newbase=None,
                      branch=None, printed_path=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
     files.extend(self._Run(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
     if not printed_path:
       print "\n_____ %s : Attempting rebase onto %s..." % (self.relpath,
@@ skipping 62 matching lines @@
       # Make the output a little prettier. It's nice to have some
       # whitespace between projects when syncing.
       print ""
 
   def _CheckMinVersion(self, 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
+    # for now emualate (more-or-less) git-rebase.sh / git-completion.bash
+    g = os.path.join(self.checkout_path, '.git')
+    return (
+      os.path.isdir(os.path.join(g, "rebase-merge")) or
+      os.path.isdir(os.path.join(g, "rebase-apply")))
+
+  def _CheckClean(self, rev_str):
+    # Make sure the tree is clean; see git-rebase.sh for reference
+    try:
+      scm.GIT.Capture(['update-index', '--ignore-submodules', '--refresh'],
+                      self.checkout_path, print_error=False)
+    except gclient_utils.CheckCallError, e:
+        raise gclient_utils.Error('\n____ %s%s\n'
+                                  '\tYou have unstaged changes.\n'
+                                  '\tPlease commit, stash, or reset.\n'
+                                   % (self.relpath, rev_str))
+    try:
+      scm.GIT.Capture(['diff-index', '--cached', '--name-status', '-r',
+                       '--ignore-submodules', 'HEAD', '--'], self.checkout_path,
+                       print_error=False)
+    except gclient_utils.CheckCallError, e:
+        raise gclient_utils.Error('\n____ %s%s\n'
+                                  '\tYour index contains uncommitted changes\n'
+                                  '\tPlease commit, stash, or reset.\n'
+                                   % (self.relpath, rev_str))
+
+  def _CheckDetachedHead(self, rev_str):
+    # HEAD is detached. Make sure it is safe to move away from (i.e., it is
+    # reference by a commit). If not, error out -- most likely a rebase is
+    # in progress, try to detect so we can give a better error.
+    try:
+      out, err = scm.GIT.Capture(
+        ['name-rev', '--no-undefined', 'HEAD'],
+        self.checkout_path,
+        print_error=False)
+    except gclient_utils.CheckCallError, e:
+      # Commit is not contained by any rev. See if the user is rebasing:
+      if self._IsRebasing():
+        # Punt to the user
+        raise gclient_utils.Error('\n____ %s%s\n'
+                                  '\tAlready in a conflict, i.e. (no branch).\n'
+                                  '\tFix the conflict and run gclient again.\n'
+                                  '\tOr to abort run:\n\t\tgit-rebase --abort\n'
+                                  '\tSee man git-rebase for details.\n'
+                                   % (self.relpath, rev_str))
+      # Let's just save off the commit so we can proceed.
+      name = "saved-by-gclient-" + self._Run(["rev-parse", "--short", "HEAD"])
+      self._Run(["branch", name])
+      print ("\n_____ found an unreferenced commit and saved it as '%s'" % name)
+
   def _GetCurrentBranch(self):
-    # Returns name of current branch
-    # Returns None if inside a (no branch)
-    tokens = self._Run(['branch']).split()
-    branch = tokens[tokens.index('*') + 1]
-    if branch == '(no':
+    # Returns name of current branch or None for detached HEAD
+    branch = self._Run(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
+    if branch == 'HEAD':
       return None
     return branch
 
   def _Run(self, args, cwd=None, redirect_stdout=True):
     # TODO(maruel): Merge with Capture or better gclient_utils.CheckCall().
     if cwd is None:
         cwd = self.checkout_path
     stdout = None
     if redirect_stdout:
       stdout = subprocess.PIPE
@@ skipping 270 matching lines @@
       print("\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
             "does not exist."
             % (' '.join(command), path))
       # There's no file list to retrieve.
     else:
       scm.SVN.RunAndGetFileList(options, command, path, file_list)
 
   def FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url