Re-reland r245404 ("If the destination directory doesn't contain the desired repo, delete it")

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
@@ skipping 192 matching lines @@
       result, version = scm.GIT.AssertVersion('1.7')
       if not result:
         raise gclient_utils.Error('Git version is older than 1.7: %s' % version)
       return result
     except OSError:
       return False
 
   def GetCheckoutRoot(self):
     return scm.GIT.GetCheckoutRoot(self.checkout_path)
 
+  def GetRemoteURL(self, options, cwd=None):
+    try:
+      return self._Capture(['config', 'remote.%s.url' % self.remote],
+                           cwd=cwd or self.checkout_path).rstrip()
+    except (OSError, subprocess2.CalledProcessError):
+      pass
+    try:
+      # This may occur if we have a git-svn checkout.
+      if scm.GIT.IsGitSvn(cwd or self.checkout_path):
+        return scm.GIT.Capture(['config', '--local', '--get',
+                                'svn-remote.svn.url'], os.curdir).rstrip()
+    except (OSError, subprocess2.CalledProcessError):
+      pass
+    return None
+
   def GetRevisionDate(self, _revision):
     """Returns the given revision's date in ISO-8601 format (which contains the
     time zone)."""
     # TODO(floitsch): get the time-stamp of the given revision and not just the
     # time-stamp of the currently checked out revision.
     return self._Capture(['log', '-n', '1', '--format=%ai'])
 
   @staticmethod
   def cleanup(options, args, file_list):
     """'Cleanup' the repo.
@@ skipping 35 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)
-
-    fetch_cmd = [
-      '-c', 'core.deltaBaseCacheLimit=2g', 'fetch', self.remote, '--prune']
-    self._Run(fetch_cmd + quiet, options, retry=True)
-    self._Run(['reset', '--hard', revision] + quiet, 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])
-
   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 66 matching lines @@
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     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))
 
-    # See if the url has changed (the unittests use git://foo for the url, let
-    # that through).
-    current_url = self._Capture(['config', 'remote.%s.url' % self.remote])
-    return_early = False
-    # TODO(maruel): Delete url != 'git://foo' since it's just to make the
-    # unit test pass. (and update the comment above)
-    # Skip url auto-correction if remote.origin.gclient-auto-fix-url is set.
-    # This allows devs to use experimental repos which have a different url
-    # but whose branch(s) are the same as official repos.
-    if (current_url != url and
-        url != 'git://foo' and
-        subprocess2.capture(
-            ['git', 'config', 'remote.%s.gclient-auto-fix-url' % self.remote],
-            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', self.remote, url], options)
-      self._FetchAndReset(revision, file_list, options)
-      return_early = True
-
     # Need to do this in the normal path as well as in the post-remote-switch
     # path.
     self._PossiblySwitchCache(url, options)
 
-    if return_early:
-      return self._Capture(['rev-parse', '--verify', 'HEAD'])
-
     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 245 matching lines @@
       raise gclient_utils.Error(
           ( 'We could not find a valid hash for safesync_url response "%s".\n'
             'Safesync URLs with a git checkout currently require the repo to\n'
             'be cloned without a safesync_url before adding the safesync_url.\n'
             'For more info, see: '
             'http://code.google.com/p/chromium/wiki/UsingNewGit'
             '#Initial_checkout' ) % rev)
     elif rev.isdigit() and len(rev) < 7:
       # Handles an SVN rev.  As an optimization, only verify an SVN revision as
       # [0-9]{1,6} for now to avoid making a network request.
-      if scm.GIT.IsGitSvn(cwd=self.checkout_path):
+      if scm.GIT.IsGitSvn(checkout_root=self.checkout_path):
         local_head = scm.GIT.GetGitSvnHeadRev(cwd=self.checkout_path)
         if not local_head or local_head < int(rev):
           try:
             logging.debug('Looking for git-svn configuration optimizations.')
             if scm.GIT.Capture(['config', '--get', 'svn-remote.svn.fetch'],
                              cwd=self.checkout_path):
               scm.GIT.Capture(['fetch'], cwd=self.checkout_path)
           except subprocess2.CalledProcessError:
             logging.debug('git config --get svn-remote.svn.fetch failed, '
                           'ignoring possible optimization.')
@@ skipping 126 matching lines @@
         if use_reference:
           cmd += ['--reference', os.path.abspath(self.checkout_path)]
 
         self._Run(cmd + [url, folder],
                   options, filter_fn=filter_fn, cwd=self.cache_dir, retry=True)
       else:
         # For now, assert that host/path/to/repo.git is identical. We may want
         # to relax this restriction in the future to allow for smarter cache
         # repo update schemes (such as pulling the same repo, but from a
         # different host).
-        existing_url = self._Capture(['config', 'remote.%s.url' % self.remote],
-                                     cwd=folder)
+        existing_url = self.GetRemoteURL(options, cwd=folder)
         assert self._NormalizeGitURL(existing_url) == self._NormalizeGitURL(url)
 
         if use_reference:
           with open(altfile, 'w') as f:
             f.write(os.path.abspath(checkout_objects))
 
         # Would normally use `git remote update`, but it doesn't support
         # --progress, so use fetch instead.
         self._Run(['fetch'] + v + ['--multiple', '--progress', '--all'],
                   options, filter_fn=filter_fn, cwd=folder, retry=True)
@@ skipping 268 matching lines @@
       result, version = scm.SVN.AssertVersion('1.4')
       if not result:
         raise gclient_utils.Error('SVN version is older than 1.4: %s' % version)
       return result
     except OSError:
       return False
 
   def GetCheckoutRoot(self):
     return scm.SVN.GetCheckoutRoot(self.checkout_path)
 
+  def GetRemoteURL(self, options):
+    try:
+      return scm.SVN.CaptureLocalInfo([os.curdir],
+                                      self.checkout_path).get('URL')
+    except (OSError, subprocess2.CalledProcessError):
+      pass
+    try:
+      # This may occur if we have a git-svn checkout.
+      if scm.GIT.IsGitSvn(os.curdir):
+        return scm.GIT.Capture(['config', '--local', '--get',
+                                'svn-remote.svn.url'], os.curdir).rstrip()
+    except (OSError, subprocess2.CalledProcessError):
+      pass
+    return None
+
+
   def GetRevisionDate(self, revision):
     """Returns the given revision's date in ISO-8601 format (which contains the
     time zone)."""
     date = scm.SVN.Capture(
         ['propget', '--revprop', 'svn:date', '-r', revision],
         os.path.join(self.checkout_path, '.'))
     return date.strip()
 
   def cleanup(self, options, args, _file_list):
     """Cleanup working copy."""
@@ skipping 19 matching lines @@
         filter_fn=SvnDiffFilterer(self.relpath).Filter)
 
   def update(self, options, args, file_list):
     """Runs svn 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.
     """
-    # Only update if git or hg is not controlling the directory.
-    git_path = os.path.join(self.checkout_path, '.git')
-    if os.path.exists(git_path):
-      print('________ found .git directory; skipping %s' % self.relpath)
-      return
+    exists = os.path.exists(self.checkout_path)
 
-    hg_path = os.path.join(self.checkout_path, '.hg')
-    if os.path.exists(hg_path):
-      print('________ found .hg directory; skipping %s' % self.relpath)
+    if exists and scm.GIT.IsGitSvn(checkout_root=self.checkout_path):
+      print '________ %s looks like git-svn; skipping.' % self.relpath
       return
 
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     # revision is the revision to match. It is None if no revision is specified,
     # i.e. the 'deps ain't pinned'.
     url, revision = gclient_utils.SplitUrlRevision(self.url)
-    # Keep the original unpinned url for reference in case the repo is switched.
-    base_url = url
     managed = True
     if options.revision:
       # Override the revision number.
       revision = str(options.revision)
     if revision:
       if revision != 'unmanaged':
         forced_revision = True
         # Reconstruct the url.
         url = '%s@%s' % (url, revision)
         rev_str = ' at %s' % revision
       else:
         managed = False
         revision = None
     else:
       forced_revision = False
       rev_str = ''
 
     # Get the existing scm url and the revision number of the current checkout.
-    exists = os.path.exists(self.checkout_path)
     if exists and managed:
       try:
         from_info = scm.SVN.CaptureLocalInfo(
             [], os.path.join(self.checkout_path, '.'))
       except (gclient_utils.Error, subprocess2.CalledProcessError):
         if options.reset and options.delete_unversioned_trees:
           print 'Removing troublesome path %s' % self.checkout_path
           gclient_utils.rmtree(self.checkout_path)
           exists = False
         else:
@@ skipping 115 matching lines @@
               if d[0][0] == '!':
                 print 'You can pass --force to enable automatic removal.'
               raise e
 
     # Retrieve the current HEAD version because svn is slow at null updates.
     if options.manually_grab_svn_rev and not revision:
       from_info_live = scm.SVN.CaptureRemoteInfo(from_info['URL'])
       revision = str(from_info_live['Revision'])
       rev_str = ' at %s' % revision
 
-    if from_info['URL'] != base_url:
-      # The repository url changed, need to switch.
-      try:
-        to_info = scm.SVN.CaptureRemoteInfo(url)
-      except (gclient_utils.Error, subprocess2.CalledProcessError):
-        # The url is invalid or the server is not accessible, it's safer to bail
-        # out right now.
-        raise gclient_utils.Error('This url is unreachable: %s' % url)
-      can_switch = ((from_info['Repository Root'] != to_info['Repository Root'])
-                    and (from_info['UUID'] == to_info['UUID']))
-      if can_switch:
-        print('\n_____ relocating %s to a new checkout' % self.relpath)
-        # We have different roots, so check if we can switch --relocate.
-        # Subversion only permits this if the repository UUIDs match.
-        # Perform the switch --relocate, then rewrite the from_url
-        # to reflect where we "are now."  (This is the same way that
-        # Subversion itself handles the metadata when switch --relocate
-        # is used.)  This makes the checks below for whether we
-        # can update to a revision or have to switch to a different
-        # branch work as expected.
-        # TODO(maruel):  TEST ME !
-        command = ['switch', '--relocate',
-                   from_info['Repository Root'],
-                   to_info['Repository Root'],
-                   self.relpath]
-        self._Run(command, options, cwd=self._root_dir)
-        from_info['URL'] = from_info['URL'].replace(
-            from_info['Repository Root'],
-            to_info['Repository Root'])
-      else:
-        if not options.force and not options.reset:
-          # Look for local modifications but ignore unversioned files.
-          for status in scm.SVN.CaptureStatus(None, self.checkout_path):
-            if status[0][0] != '?':
-              raise gclient_utils.Error(
-                  ('Can\'t switch the checkout to %s; UUID don\'t match and '
-                   'there is local changes in %s. Delete the directory and '
-                   'try again.') % (url, self.checkout_path))
-        # Ok delete it.
-        print('\n_____ switching %s to a new checkout' % self.relpath)
-        gclient_utils.rmtree(self.checkout_path)
-        # We need to checkout.
-        command = ['checkout', url, self.checkout_path]
-        command = self._AddAdditionalUpdateFlags(command, options, revision)
-        self._RunAndGetFileList(command, options, file_list, self._root_dir)
-        return self.Svnversion()
-
     # If the provided url has a revision number that matches the revision
     # number of the existing directory, then we don't need to bother updating.
     if not options.force and str(from_info['Revision']) == revision:
       if options.verbose or not forced_revision:
         print('\n_____ %s%s' % (self.relpath, rev_str))
     else:
       command = ['update', self.checkout_path]
       command = self._AddAdditionalUpdateFlags(command, options, revision)
       self._RunAndGetFileList(command, options, file_list, self._root_dir)
 
@@ skipping 46 matching lines @@
     if not os.path.isdir(self.checkout_path):
       if os.path.exists(self.checkout_path):
         gclient_utils.rmtree(self.checkout_path)
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
       print('\n_____ %s is missing, synching instead' % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     if not os.path.isdir(os.path.join(self.checkout_path, '.svn')):
-      if os.path.isdir(os.path.join(self.checkout_path, '.git')):
-        print('________ found .git directory; skipping %s' % self.relpath)
-        return
-      if os.path.isdir(os.path.join(self.checkout_path, '.hg')):
-        print('________ found .hg directory; skipping %s' % self.relpath)
+      if scm.GIT.IsGitSvn(checkout_root=self.checkout_path):

[iannucci, 2014/02/06 23:05:11]

antipattern. don't use named args to fill in positional values. It leads to pain
when someone decides to rename the parameter on the function later :D

[borenet, 2014/02/07 14:32:21]

Removed.  I wanted to be very explicit that the function only works if the
provided parameter is the root of the checkout (which would contain a .git
directory).

+        print '________ %s looks like git-svn; skipping.' % self.relpath
         return
       if not options.force:
         raise gclient_utils.Error('Invalid checkout path, aborting')
       print(
           '\n_____ %s is not a valid svn checkout, synching instead' %
           self.relpath)
       gclient_utils.rmtree(self.checkout_path)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
@@ skipping 98 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