Make git_cache.py import-able.

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."""
 
 from __future__ import print_function
 
 import logging
 import os
 import posixpath
 import re
 import shlex
 import sys
 import tempfile
 import traceback
 import urlparse
 
 import download_from_google_storage
 import gclient_utils
+import git_cache
 import scm
 import subprocess2
 
 
 THIS_FILE_PATH = os.path.abspath(__file__)
 
 GSUTIL_DEFAULT_PATH = os.path.join(
     os.path.dirname(os.path.abspath(__file__)),
     'third_party', 'gsutil', 'gsutil')
 
@@ skipping 121 matching lines @@
     if not command in dir(self):
       raise gclient_utils.Error('Command %s not implemented in %s wrapper' % (
           command, self.__class__.__name__))
 
     return getattr(self, command)(options, args, file_list)
 
   def GetActualRemoteURL(self, options):
     """Attempt to determine the remote URL for this SCMWrapper."""
     # Git
     if os.path.exists(os.path.join(self.checkout_path, '.git')):
-      actual_remote_url = shlex.split(scm.GIT.Capture(
+      actual_remote_url = shlex.split(self._Capture(
           ['config', '--local', '--get-regexp', r'remote.*.url'],
           self.checkout_path))[1]
 
       # If a cache_dir is used, obtain the actual remote URL from the cache.
       if getattr(self, 'cache_dir', None):
-        try:
-          full_cache_dir = self._Run(['cache', 'exists', '--cache-dir',
-                                      self.cache_dir, self.url],
-                                     options, cwd=self._root_dir).strip()
-        except subprocess2.CalledProcessError:
-          full_cache_dir = None
-        if (full_cache_dir.replace('\\', '/') ==
+        mirror = git_cache.Mirror(self.url)
+        if (mirror.exists() and mirror.mirror_path.replace('\\', '/') ==
             actual_remote_url.replace('\\', '/')):
-          actual_remote_url = shlex.split(scm.GIT.Capture(
+          actual_remote_url = shlex.split(self._Capture(
               ['config', '--local', '--get-regexp', r'remote.*.url'],
-              os.path.join(self._root_dir, full_cache_dir)))[1]
+              cwd=mirror.mirror_path))[1]
       return actual_remote_url
 
     # Svn
     if os.path.exists(os.path.join(self.checkout_path, '.svn')):
       return scm.SVN.CaptureLocalInfo([], self.checkout_path)['URL']
     return None
 
   def DoesRemoteURLMatch(self, options):
     """Determine whether the remote URL of this checkout is the expected URL."""
     if not os.path.exists(self.checkout_path):
@@ skipping 10 matching lines @@
       return False
 
 
 class GitWrapper(SCMWrapper):
   """Wrapper for Git"""
   name = 'git'
   remote = 'origin'
 
   cache_dir = None
 
-  def __init__(self, url=None, root_dir=None, relpath=None, out_fh=None,
-               out_cb=None):
+  def __init__(self, url=None, *args):
     """Removes 'git+' fake prefix from git URL."""
     if url.startswith('git+http://') or url.startswith('git+https://'):
       url = url[4:]
-    SCMWrapper.__init__(self, url, root_dir, relpath, out_fh, out_cb)
+    SCMWrapper.__init__(self, url, *args)
 
   @staticmethod
   def BinaryExists():
     """Returns true if the command exists."""
     try:
       # We assume git is newer than 1.7.  See: crbug.com/114483
       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
@@ skipping 510 matching lines @@
     return base_url[:base_url.rfind('/')] + url
 
   def _CreateOrUpdateCache(self, url, options):
     """Make a new git mirror or update existing mirror for |url|, and return the
     mirror URI to clone from.
 
     If no cache-dir is specified, just return |url| unchanged.
     """
     if not self.cache_dir:
       return url
-    v = ['-v'] if options.verbose else []
-    self._Run(['cache', 'populate'] + v + ['--cache-dir', self.cache_dir, url],
-              options, cwd=self._root_dir, retry=True)
-    return self._Run(['cache', 'exists', '--cache-dir', self.cache_dir, url],
-                     options, cwd=self._root_dir, ).strip()
+    mirror = git_cache.Mirror(url)
+    mirror.unlock()

[Ryan Tseng, 2014/04/09 00:39:44]

We actually don't want to do this.  The lock is present to avoid two or more
gclient tasklets from calling populate() at the same time.

Moreover, bot_update takes care of all unlocking(), so if the repo is locked at
this point, then something is probably wrong.

[szager1, 2014/04/09 05:22:29]

OK.  I may have gone a bit overboard in adding calls to unlock().  However, I
have seen the locking code fail sporadically on Windows.

+    mirror.populate(noisy=options.verbose)

[Ryan Tseng, 2014/04/09 00:39:44]

bootstrap=True?

[szager1, 2014/04/09 05:22:29]

Done.

+    mirror.unlock()
+    return mirror.mirror_path if mirror.exists() else None
 
   def _Clone(self, revision, url, options):
     """Clone a git repository from the given URL.
 
     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 options.verbose:
@@ skipping 705 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