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 197 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.origin.url'],
+                           cwd=cwd or self.checkout_path).rstrip()
+    except (OSError, subprocess2.CalledProcessError):
+      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 140 matching lines @@
     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.origin.url'])
+    current_url = self.GetRemoteURL(options)
     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

[Isaac (away), 2013/12/04 03:29:19]

I'm confused how your logic interacts with this section

[borenet, 2013/12/04 16:58:42]

Ah yes, I can see how this is dangerous.  I guess as-is, my change would cause
checkouts with modified remote urls to be deleted and resynced from the default
remote.  Can the same thing be accomplished with "git config url.xyz.insteadOf
abc" ?  Doing it that way does not alter remote.origin.url.

I'm open to alternatives for how to determine whether a checkout should be
deleted and re-synced, since the current approach seems problematic.

[borenet, 2013/12/05 21:49:24]

Per discussion on chat, removed this section.

         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)
       self._FetchAndReset(revision, file_list, options)
@@ skipping 404 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.origin.url'],
-                                     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 248 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:
+      local_info = scm.SVN.CaptureLocalInfo([os.curdir], self.checkout_path)
+    except (OSError, subprocess2.CalledProcessError):
+      return None
+    return local_info.get('URL')
+
   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 360 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