Add 'git cache fetch' subcommand.

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 546 matching lines @@
       'verbose': options.verbose,
       'shallow': options.shallow,
       'bootstrap': not options.no_bootstrap,
       'ignore_lock': options.ignore_locks,
   }
   if options.depth:
     kwargs['depth'] = options.depth
   mirror.populate(**kwargs)
 
 
+@subcommand.usage('Fetch new commits into cache and current checkout')
+def CMDfetch(parser, args):
+  """Update mirror, and fetch in cwd."""
+  parser.add_option('--all', action='store_true', help='Fetch all remotes')
+  options, args = parser.parse_args(args)
+
+  # Figure out which remotes to fetch.  This mimics the behavior of regular
+  # 'git fetch'.
+  remotes = []
+  if options.all:
+    assert not args, 'fatal: fetch --all does not take a repository argument'
+    remotes = subprocess.check_output([Mirror.git_exe, 'remote']).splitlines()
+  elif args:
+    remotes = args
+  else:
+    current_branch = subprocess.check_output(

[iannucci, 2014/08/07 18:29:53]

won't this need to go up all the way to the rootmost branch, if you have local
tracking branches?

[szager1, 2014/08/07 18:32:53]

git doesn't behave that way; it only looks at the currently-checked-out-branch. 
I think.

[szager1, 2014/08/07 18:38:48]

Also, I think the degenerate base case will work fine for pretty much everyone:
no remote is specified, it fetches 'origin'.

+        [Mirror.git_exe, 'rev-parse', '--abbrev-ref', 'HEAD']).strip()
+    if current_branch != 'HEAD':
+      upstream = subprocess.check_output(
+          [Mirror.git_exe, 'config', 'branch.%s.remote' % current_branch]
+      ).strip()
+      if upstream:

[iannucci, 2014/08/07 18:29:53]

local branches will have an upstream of '.'

[szager1, 2014/08/07 18:32:53]

Fixed.

+        remotes = [upstream]
+  if not remotes:
+    remotes = ['origin']
+
+  cachepath = Mirror.GetCachePath()
+  git_dir = os.path.abspath(subprocess.check_output(
+      [Mirror.git_exe, 'rev-parse', '--git-dir']))
+  git_dir = os.path.abspath(git_dir)
+  if git_dir.startswith(cachepath):
+    mirror = Mirror.FromPath(git_dir)
+    mirror.populate()
+    return 0
+  for remote in remotes:
+    remote_url = subprocess.check_output(
+        [Mirror.git_exe, 'config', 'remote.%s.url' % remote]).strip()
+    if remote_url.startswith(cachepath):
+      mirror = Mirror.FromPath(remote_url)
+      mirror.print = lambda *args: None
+      print('Updating git cache...')
+      mirror.populate()
+    subprocess.check_call([Mirror.git_exe, 'fetch', remote])
+  return 0
+
+
 @subcommand.usage('[url of repo to unlock, or -a|--all]')
 def CMDunlock(parser, args):
   """Unlock one or all repos if their lock files are still around."""
   parser.add_option('--force', '-f', action='store_true',
                     help='Actually perform the action')
   parser.add_option('--all', '-a', action='store_true',
                     help='Unlock all repository caches')
   options, args = parser.parse_args(args)
   if len(args) > 1 or (len(args) == 0 and not options.all):
     parser.error('git cache unlock takes exactly one repo url, or --all')
@@ skipping 54 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:]))