Implement git-drover.

git_cache.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """A git command for managing a local cache of git repositories."""
 
 from __future__ import print_function
 import errno
 import logging
@@ skipping 10 matching lines @@
 import gclient_utils
 import subcommand
 
 try:
   # pylint: disable=E0602
   WinErr = WindowsError
 except NameError:
   class WinErr(Exception):
     pass
 
+
 class LockError(Exception):
   pass
 
 
 class Lockfile(object):
   """Class to represent a cross-platform process-specific lockfile."""
 
   def __init__(self, path):
     self.path = os.path.abspath(path)
     self.lockfile = self.path + ".lock"
@@ skipping 103 matching lines @@
     'third_party', 'gsutil', 'gsutil')
   bootstrap_bucket = 'chromium-git-cache'
 
   def __init__(self, url, refs=None, print_func=None):
     self.url = url
     self.refs = refs or []
     self.basedir = self.UrlToCacheDir(url)
     self.mirror_path = os.path.join(self.GetCachePath(), self.basedir)
     self.print = print_func or print
 
+  @classmethod
+  def from_repo(cls, path=None):
+    """Returns Mirror if path is in a cached repo, else None."""
+    args = ['-C', path] if path else []
+    args = [cls.git_exe] + args + ['rev-parse', '--git-dir']
+    git_path = subprocess.check_output(args).strip()
+    alt_path = os.path.join(git_path, 'objects', 'info', 'alternates')
+
+    if os.path.exists(alt_path):
+      with open(alt_path, 'rb') as alt:
+        mirror_path = alt.read().strip()
+      mirror_path = os.path.dirname(mirror_path)
+      cache_path = os.path.dirname(mirror_path)
+      if os.path.exists(mirror_path):
+        url = subprocess.check_output(
+            [cls.git_exe, '-C', mirror_path, 'config', 'remote.origin.url']
+        ).strip()
+
+        # TODO(iannucci): cache_path should NOT be a class attribute. Maybe
+        # a `default_cache_path`, but not the actual path.
+        cls.SetCachePath(cache_path)
+
+        return cls(url)
+
   @staticmethod
   def UrlToCacheDir(url):
     """Convert a git url to a normalized form for the cache dir path."""
     parsed = urlparse.urlparse(url)
     norm_url = parsed.netloc + parsed.path
     if norm_url.endswith('.git'):
       norm_url = norm_url[:-len('.git')]
     return norm_url.replace('-', '--').replace('/', '-').lower()
 
   @staticmethod
@@ skipping 51 matching lines @@
     self.RunGit(['config', '--replace-all', 'remote.origin.fetch',
                  '+refs/heads/*:refs/heads/*'], cwd=cwd)
     for ref in self.refs:
       ref = ref.lstrip('+').rstrip('/')
       if ref.startswith('refs/'):
         refspec = '+%s:%s' % (ref, ref)
       else:
         refspec = '+refs/%s/*:refs/%s/*' % (ref, ref)
       self.RunGit(['config', '--add', 'remote.origin.fetch', refspec], cwd=cwd)
 
-  def bootstrap_repo(self, directory):
+  def bootstrap_repo(self, directory, verbose):
     """Bootstrap the repo from Google Stroage if possible."""
 
     python_fallback = False
     if sys.platform.startswith('win') and not self.FindExecutable('7z'):
       python_fallback = True
     elif sys.platform.startswith('darwin'):
       # The OSX version of unzip doesn't support zip64.
       python_fallback = True
     elif not self.FindExecutable('unzip'):
       python_fallback = True
 
     gs_folder = 'gs://%s/%s' % (self.bootstrap_bucket, self.basedir)
     gsutil = Gsutil(
         self.gsutil_exe, boto_path=os.devnull, bypass_prodaccess=True)
     # Get the most recent version of the zipfile.
     _, ls_out, _ = gsutil.check_call('ls', gs_folder)
     ls_out_sorted = sorted(ls_out.splitlines())
     if not ls_out_sorted:
       # This repo is not on Google Storage.
       return False
     latest_checkout = ls_out_sorted[-1]
 
     # Download zip file to a temporary directory.
     try:
       tempdir = tempfile.mkdtemp()
-      self.print('Downloading %s' % latest_checkout)
-      code, out, err = gsutil.check_call('cp', latest_checkout, tempdir)
+      if not verbose:
+        self.print('Downloading %s' % latest_checkout)
+      code, out, err = gsutil.check_call('cp', latest_checkout, tempdir,
+                                         verbose=verbose)
       if code:
         self.print('%s\n%s' % (out, err))
         return False
       filename = os.path.join(tempdir, latest_checkout.split('/')[-1])
 
       # Unpack the file with 7z on Windows, unzip on linux, or fallback.
       if not python_fallback:
         if sys.platform.startswith('win'):
           cmd = ['7z', 'x', '-o%s' % directory, '-tzip', filename]
         else:
@@ skipping 17 matching lines @@
       self.print(
           'Extracting bootstrap zipfile %s failed.\n'
           'Resuming normal operations.' % filename)
       return False
     return True
 
   def exists(self):
     return os.path.isfile(os.path.join(self.mirror_path, 'config'))
 
   def populate(self, depth=None, shallow=False, bootstrap=False,
-               verbose=False):
+               verbose=False, fetch_specs=()):
     if shallow and not depth:
       depth = 10000
     gclient_utils.safe_makedirs(self.GetCachePath())
 
     v = []
     if verbose:
       v = ['-v', '--progress']
 
     d = []
     if depth:
       d = ['--depth', str(depth)]
 
 
     with Lockfile(self.mirror_path):
       # Setup from scratch if the repo is new or is in a bad state.
       tempdir = None
       if not os.path.exists(os.path.join(self.mirror_path, 'config')):
         gclient_utils.rmtree(self.mirror_path)
         tempdir = tempfile.mkdtemp(
             suffix=self.basedir, dir=self.GetCachePath())
-        bootstrapped = not depth and bootstrap and self.bootstrap_repo(tempdir)
+        bootstrapped = (not depth and bootstrap and
+                        self.bootstrap_repo(tempdir, verbose))
         if not bootstrapped:
           self.RunGit(['init', '--bare'], cwd=tempdir)
       else:
         if depth and os.path.exists(os.path.join(self.mirror_path, 'shallow')):
           logging.warn(
               'Shallow fetch requested, but repo cache already exists.')
         d = []
 
       rundir = tempdir or self.mirror_path
       self.config(rundir)
       fetch_cmd = ['fetch'] + v + d + ['origin']
-      fetch_specs = subprocess.check_output(
+      fetch_specs = fetch_specs or subprocess.check_output(
           [self.git_exe, 'config', '--get-all', 'remote.origin.fetch'],
           cwd=rundir).strip().splitlines()
       for spec in fetch_specs:
         try:
           self.RunGit(fetch_cmd + [spec], cwd=rundir, retry=True)
         except subprocess.CalledProcessError:
           logging.warn('Fetch of %s failed' % spec)
       if tempdir:
         os.rename(tempdir, self.mirror_path)
 
@@ skipping 173 matching lines @@
     return options, args
 
 
 def main(argv):
   dispatcher = subcommand.CommandDispatcher(__name__)
   return dispatcher.execute(OptionParser(), argv)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))