Make safesync w/ git hash work when lkgr is ahead of 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 15 matching lines @@
 
   def __init__(self, relpath):
     # Note that we always use '/' as the path separator to be
     # consistent with svn's cygwin-style output on Windows
     self._relpath = relpath.replace("\\", "/")
     self._current_file = None
 
   def SetCurrentFile(self, current_file):
     self._current_file = current_file
 
-  @property 
-  def _replacement_file(self): 
+  @property
+  def _replacement_file(self):
     return posixpath.join(self._relpath, self._current_file)
 
   def _Replace(self, line):
     return line.replace(self._current_file, self._replacement_file)
 
   def Filter(self, line):
     if (line.startswith(self.index_string)):
       self.SetCurrentFile(line[len(self.index_string):])
       line = self._Replace(line)
     else:
@@ skipping 512 matching lines @@
       self._Run(['diff', '--name-status', merge_base], options)
       files = self._Capture(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def GetUsableRev(self, rev, options):
     """Finds a useful revision for this repository.
 
     If SCM is git-svn and the head revision is less than |rev|, git svn fetch
     will be called on the source."""
     sha1 = None
-    # 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 rev.isdigit() and len(rev) < 7:
-      # If the content of the safesync_url appears to be an SVN rev and the
-      # URL of the source appears to be git, we can only attempt to find out
-      # if a revision is useful after we've cloned the original URL, so just
-      # ignore for now.
-      if (os.path.isdir(self.checkout_path) and
-          scm.GIT.IsGitSvn(cwd=self.checkout_path)):
+    if not os.path.isdir(self.checkout_path):

[M-A Ruel, 2013/02/19 19:07:44]

Why are you breaking svn users? It's not necessary.

[iannucci, 2013/02/19 19:18:33]

I'm not, this was in the second if statement in the svn code before. I just
moved it earlier, since it's actually common to both. (see my comment in a
previous email on this CL)

[M-A Ruel, 2013/02/19 19:21:42]

Oh right, this is only for git checkouts, ok fine.

+      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):
         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.')
           if options.verbose:
             print('Running git svn fetch. This might take a while.\n')
           scm.GIT.Capture(['svn', 'fetch'], cwd=self.checkout_path)
         try:
           sha1 = scm.GIT.GetBlessedSha1ForSvnRev(
               cwd=self.checkout_path, rev=rev)
         except gclient_utils.Error, e:
           sha1 = e.message
           print('\nWarning: Could not find a git revision with accurate\n'
                  '.DEPS.git that maps to SVN revision %s.  Sync-ing to\n'
                  'the closest sane git revision, which is:\n'
                  '  %s\n' % (rev, e.message))
         if not sha1:
           raise gclient_utils.Error(
               ( 'It appears that either your git-svn remote is incorrectly\n'
                 'configured or the revision in your safesync_url is\n'
                 'higher than git-svn remote\'s HEAD as we couldn\'t find a\n'
                 'corresponding git hash for SVN rev %s.' ) % rev)
-    elif scm.GIT.IsValidRevision(cwd=self.checkout_path, rev=rev):
-      sha1 = rev
+    else:
+      if scm.GIT.IsValidRevision(cwd=self.checkout_path, rev=rev):
+        sha1 = rev
+      else:
+        # May exist in origin, but we don't have it yet, so fetch and look
+        # again.
+        scm.GIT.Capture(['fetch', 'origin'], cwd=self.checkout_path)
+        if scm.GIT.IsValidRevision(cwd=self.checkout_path, rev=rev):
+          sha1 = rev
 
     if not sha1:
       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 a git-svn\n'
             'remote or a safesync_url that provides git sha1s. Please add a\n'
             'git-svn remote or change your safesync_url. For more info, see:\n'
             'http://code.google.com/p/chromium/wiki/UsingNewGit'
             '#Initial_checkout' ) % rev)
 
@@ skipping 596 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