Allow gclient clone in non-empty directories

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 collections
 import logging
 import os
 import posixpath
 import re
 import sys
+import tempfile
 import threading
 import time
 
 import gclient_utils
 import scm
 import subprocess2
 
 
 THIS_FILE_PATH = os.path.abspath(__file__)
 
@@ skipping 309 matching lines @@
     files = [] if file_list is not None else None
 
     printed_path = False
     verbose = []
     if options.verbose:
       print('\n_____ %s%s' % (self.relpath, rev_str))
       verbose = ['--verbose']
       printed_path = True
 
     url = self._CreateOrUpdateCache(url, options)
-
-    if revision.startswith('refs/'):
-      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) or (
-        os.path.isdir(self.checkout_path) and
-        not os.listdir(self.checkout_path)):
-      gclient_utils.safe_makedirs(os.path.dirname(self.checkout_path))
+    if (not os.path.exists(self.checkout_path) or
+        (os.path.isdir(self.checkout_path) and
+         not os.path.exists(os.path.join(self.checkout_path, '.git')))):
       self._Clone(revision, url, options)
       self.UpdateSubmoduleConfig()
       if file_list is not None:
         files = self._Capture(['ls-files']).splitlines()
         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
@@ skipping 26 matching lines @@
             ['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)
       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(['init'], options)
+      self._Run(['remote', 'set-url', 'origin', url], options)
       self._Run(['-c', 'core.deltaBaseCacheLimit=2g', '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
     #   - rebase those changes on top of the hash
     # 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 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
+    if revision.startswith('refs/'):
+      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 cur_branch is None:
       upstream_branch = None
       current_type = "detached"
       logging.debug("Detached HEAD")
     else:
       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.")
@@ skipping 333 matching lines @@
     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 options.verbose:
       # git clone doesn't seem to insert a newline properly before printing
       # to stdout
       print('')
     template_path = os.path.join(
         os.path.dirname(THIS_FILE_PATH), 'git-templates')
-    clone_cmd = ['-c', 'core.deltaBaseCacheLimit=2g', 'clone', '--progress',
-                 '--template=%s' % template_path]
+    clone_cmd = ['-c', 'core.deltaBaseCacheLimit=2g', 'clone', '--no-checkout',
+                 '--progress', '--template=%s' % template_path]
     if self.cache_dir:
       clone_cmd.append('--shared')
-    if revision.startswith('refs/heads/'):
-      clone_cmd.extend(['-b', revision.replace('refs/heads/', '')])
-      detach_head = False
-    else:
-      detach_head = True
     if options.verbose:
       clone_cmd.append('--verbose')
-    clone_cmd.extend([url, self.checkout_path])
-
+    clone_cmd.append(url)
     # If the parent directory does not exist, Git clone on Windows will not
     # create it, so we need to do it manually.
     parent_dir = os.path.dirname(self.checkout_path)
-    if not os.path.exists(parent_dir):
-      gclient_utils.safe_makedirs(parent_dir)
-
-    for _ in range(3):
-      try:
-        self._Run(clone_cmd, options, cwd=self._root_dir, git_filter=True)
-        break
-      except subprocess2.CalledProcessError, e:
-        # Too bad we don't have access to the actual output yet.
-        # We should check for "transfer closed with NNN bytes remaining to
-        # read". In the meantime, just make sure .git exists.
-        if (e.returncode == 128 and
-            os.path.exists(os.path.join(self.checkout_path, '.git'))):
-          print(str(e))
-          print('Retrying...')
-          continue
-        raise e
-
-    # Update the "branch-heads" remote-tracking branches, since we might need it
-    # to checkout a specific revision below.
-    self._UpdateBranchHeads(options, fetch=True)
-
-    if detach_head:
+    if not os.path.exists(self.checkout_path):

[M-A Ruel, 2013/07/19 20:42:40]

While at it, replace with isdir()

[Isaac (away), 2013/07/19 21:50:28]

Done.

+      gclient_utils.safe_makedirs(self.checkout_path)
+    tmp_dir = tempfile.mkdtemp(
+        prefix='_gclient_%s_' % os.path.basename(self.checkout_path),
+        dir=parent_dir)
+    try:
+      clone_cmd.append(tmp_dir)
+      for _ in range(3):
+        try:
+          self._Run(clone_cmd, options, cwd=None, git_filter=True)
+          break
+        except subprocess2.CalledProcessError, e:
+          # Too bad we don't have access to the actual output yet.
+          # We should check for "transfer closed with NNN bytes remaining to
+          # read". In the meantime, just make sure .git exists.
+          if (e.returncode == 128 and
+              os.path.exists(os.path.join(tmp_dir, '.git'))):
+            print(str(e))
+            print('Retrying...')
+            continue
+          raise e
+      os.rename(os.path.join(tmp_dir, '.git'),
+                os.path.join(self.checkout_path, '.git'))
+    finally:
+      if os.listdir(tmp_dir):
+        print('\n_____ removing non-empty tmp dir %s' % tmp_dir)
+      gclient_utils.rmtree(tmp_dir)
+    if revision.startswith('refs/heads/'):
+      self._Run(['checkout', revision.replace('refs/heads/', '')], options)
+    else:
       # Squelch git's very verbose detached HEAD warning and use our own
-      self._Capture(['checkout', '--quiet', '%s' % revision])
+      self._Run(['checkout', '--quiet', revision], options)
       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, options, newbase=None,
                      branch=None, printed_path=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
     if files is not None:
@@ skipping 57 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'])
-      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
@@ skipping 505 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