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')
 
-
+CHROMIUM_SRC_URL = 'https://chromium.googlesource.com/chromium/src.git'
 class DiffFiltererWrapper(object):
   """Simple base class which tracks which file is being diffed and
   replaces instances of its file name in the original and
   working copy lines of the svn/git diff output."""
   index_string = None
   original_prefix = "--- "
   working_prefix = "+++ "
 
   def __init__(self, relpath, print_func):
     # Note that we always use '/' as the path separator to be
@@ skipping 110 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(

[kustermann, 2014/05/01 23:35:15]

This line raises an exception on a "gclient sync" on my machine:

~/mycheckout $ gclient sync
Traceback (most recent call last):
  File "/..../bin/depot_tools/gclient.py", line 1974, in <module>
    sys.exit(Main(sys.argv[1:]))
  File "/..../bin/depot_tools/gclient.py", line 1962, in Main
    return dispatcher.execute(OptionParser(), argv)
  File "/..../bin/depot_tools/subcommand.py", line 245, in execute
    return command(parser, args[1:])
  File "/..../bin/depot_tools/gclient.py", line 1741, in CMDsync
    ret = client.RunOnDeps('update', args)
  File "/..../bin/depot_tools/gclient.py", line 1261, in RunOnDeps
    self._CheckConfig()
  File "/..../bin/depot_tools/gclient.py", line 1060, in _CheckConfig
    actual_url = scm.GetActualRemoteURL(self._options)
  File "/..../bin/depot_tools/gclient_scm.py", line 164, in GetActualRemoteURL
    actual_remote_url = shlex.split(self._Capture(
AttributeError: 'SVNWrapper' object has no attribute '_Capture'
Sending crash report ...
  args: ['/..../bin/depot_tools/gclient.py', 'sync']
  cwd: /..../mycheckout
  exception: 'SVNWrapper' object has no attribute '_Capture'
  host: kustermann
  stack:   File "/..../bin/depo
  user: kustermann
  version: 2.7.3 (default, Feb 27 2014, 19:58:35) 
[GCC 4.6.3
A stack trace has been sent to the maintainers.


Git blame says that this CL was the last one touching this line.

Could you take a look?
Let me know if you need more information.

           ['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)
+    filter_kwargs = { 'time_throttle': 1, 'out_fh': self.out_fh }
+    if self.out_cb:
+      filter_kwargs['predicate'] = self.out_cb
+    self.filter = gclient_utils.GitFilter(**filter_kwargs)
 
   @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 235 matching lines @@
     if options.force or options.reset:
       target = 'HEAD'
       if options.upstream and upstream_branch:
         target = upstream_branch
       self._Run(['reset', '--hard', target], options)
 
     if current_type == 'detached':
       # case 0
       self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
-      self._Capture(['checkout', '--quiet', '%s' % revision])
+      if self._Capture(['rev-list', '-n', '1', 'HEAD']) == revision:
+        self.Print('Up-to-date; skipping checkout.')
+      else:
+        self._Capture(['checkout', '--quiet', '%s' % revision])
       if not printed_path:
         self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
     elif current_type == 'hash':
       # case 1
       if scm.GIT.IsGitSvn(self.checkout_path) and upstream_branch is not None:
         # Our git-svn branch (upstream_branch) is our upstream
         self._AttemptRebase(upstream_branch, files, options,
                             newbase=revision, printed_path=printed_path,
                             merge=options.merge)
         printed_path = True
@@ skipping 254 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_kwargs = { 'print_func': self.filter }
+    if url == CHROMIUM_SRC_URL or url + '.git' == CHROMIUM_SRC_URL:
+      mirror_kwargs['refs'] = ['refs/tags/lkgr', 'refs/tags/lkcr']
+    mirror = git_cache.Mirror(url, **mirror_kwargs)
+    mirror.populate(verbose=options.verbose, bootstrap=True)
+    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 215 matching lines @@
       if fetch:
         cfg = gclient_utils.DefaultIndexPackConfig(self.url)
         fetch_cmd =  cfg + ['fetch', self.remote]
         if options.verbose:
           fetch_cmd.append('--verbose')
         self._Run(fetch_cmd, options, retry=True)
 
   def _Run(self, args, options, **kwargs):
     cwd = kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('stdout', self.out_fh)
-    filter_kwargs = { 'time_throttle': 10, 'out_fh': self.out_fh }
-    if self.out_cb:
-      filter_kwargs['predicate'] = self.out_cb
-    kwargs['filter_fn'] = git_filter = gclient_utils.GitFilter(**filter_kwargs)
+    kwargs['filter_fn'] = self.filter
     kwargs.setdefault('print_stdout', False)
     # Don't prompt for passwords; just fail quickly and noisily.
     # By default, git will use an interactive terminal prompt when a username/
     # password is needed.  That shouldn't happen in the chromium workflow,
     # and if it does, then gclient may hide the prompt in the midst of a flood
     # of terminal spew.  The only indication that something has gone wrong
     # will be when gclient hangs unresponsively.  Instead, we disable the
     # password prompt and simply allow git to fail noisily.  The error
     # message produced by git will be copied to gclient's output.
     env = kwargs.get('env') or kwargs.setdefault('env', os.environ.copy())
     env.setdefault('GIT_ASKPASS', 'true')
     env.setdefault('SSH_ASKPASS', 'true')
 
     cmd = ['git'] + args
     header = "running '%s' in '%s'" % (' '.join(cmd), cwd)
-    git_filter(header)
+    self.filter(header)
     return gclient_utils.CheckCallAndFilter(cmd, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
   name = 'svn'
 
   @staticmethod
   def BinaryExists():
     """Returns true if the command exists."""
@@ skipping 450 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