Add --ignore-lock option.

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 81 matching lines @@
     try:
       self._make_lockfile()
     except OSError as e:
       if e.errno == errno.EEXIST:
         raise LockError("%s is already locked" % self.path)
       else:
         raise LockError("Failed to create %s (err %s)" % (self.path, e.errno))
 
   def unlock(self):
     """Release the lock."""
-    if not self.is_locked():
-      raise LockError("%s is not locked" % self.path)
-    if not self.i_am_locking():
-      raise LockError("%s is locked, but not by me" % self.path)
-    self._remove_lockfile()
+    try:
+      if not self.is_locked():
+        raise LockError("%s is not locked" % self.path)
+      if not self.i_am_locking():
+        raise LockError("%s is locked, but not by me" % self.path)
+      self._remove_lockfile()
+    except WinErr:
+      # Windows is unreliable when it comes to file locking.  YMMV.
+      pass
 
   def break_lock(self):
     """Remove the lock, even if it was created by someone else."""
     try:
       self._remove_lockfile()
       return True
     except OSError as exc:
       if exc.errno == errno.ENOENT:
         return False
       else:
         raise
 
   def is_locked(self):
     """Test if the file is locked by anyone.
 
     Note: This method is potentially racy. By the time it returns the lockfile
     may have been unlocked, removed, or stolen by some other process.
     """
     return os.path.exists(self.lockfile)
 
   def i_am_locking(self):
     """Test if the file is locked by this process."""
     return self.is_locked() and self.pid == self._read_pid()
 
-  def __enter__(self):
-    self.lock()
-    return self
-
-  def __exit__(self, *_exc):
-    # Windows is unreliable when it comes to file locking.  YMMV.
-    try:
-      self.unlock()
-    except WinErr:
-      pass
-
 
 class Mirror(object):
 
   git_exe = 'git.bat' if sys.platform.startswith('win') else 'git'
   gsutil_exe = os.path.join(
     os.path.dirname(os.path.abspath(__file__)),
     'third_party', 'gsutil', 'gsutil')
 
   def __init__(self, url, refs=None, print_func=None):
     self.url = url
@@ skipping 158 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, ignore_lock=False):
     assert self.GetCachePath()
     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):
+    lockfile = Lockfile(self.mirror_path)
+    if not ignore_lock:
+      lockfile.lock()
+
+    try:
       # Setup from scratch if the repo is new or is in a bad state.
       tempdir = None
       config_file = os.path.join(self.mirror_path, 'config')
       pack_dir = os.path.join(self.mirror_path, 'objects', 'pack')
       pack_files = []
       if os.path.isdir(pack_dir):
         pack_files = [f for f in os.listdir(pack_dir) if f.endswith('.pack')]
 
       should_bootstrap = (not os.path.exists(config_file) or
                           len(pack_files) > GC_AUTOPACKLIMIT)
@@ skipping 27 matching lines @@
       fetch_specs = 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)
+    finally:
+      if not ignore_lock:
+        lockfile.unlock()
 
   def update_bootstrap(self):
     # The files are named <git number>.zip
     gen_number = subprocess.check_output(
         [self.git_exe, 'number', 'master'], cwd=self.mirror_path).strip()
     self.RunGit(['gc'])  # Run Garbage Collect to compress packfile.
     # Creating a temp file and then deleting it ensures we can use this name.
     _, tmp_zipfile = tempfile.mkstemp(suffix='.zip')
     os.remove(tmp_zipfile)
     subprocess.call(['zip', '-r', tmp_zipfile, '.'], cwd=self.mirror_path)
@@ skipping 97 matching lines @@
 def CMDpopulate(parser, args):
   """Ensure that the cache has all up-to-date objects for the given repo."""
   parser.add_option('--depth', type='int',
                     help='Only cache DEPTH commits of history')
   parser.add_option('--shallow', '-s', action='store_true',
                     help='Only cache 10000 commits of history')
   parser.add_option('--ref', action='append',
                     help='Specify additional refs to be fetched')
   parser.add_option('--no_bootstrap', action='store_true',
                     help='Don\'t bootstrap from Google Storage')
+  parser.add_option('--ignore_locks', action='store_true',
+                    help='Don\'t try to lock repository')
 
   options, args = parser.parse_args(args)
   if not len(args) == 1:
     parser.error('git cache populate only takes exactly one repo url.')
   url = args[0]
 
   mirror = Mirror(url, refs=options.ref)
   kwargs = {
       '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('[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',
@@ skipping 60 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:]))