Allow blocking git-cache update with a timeout.

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 26 matching lines @@
 
 class LockError(Exception):
   pass
 
 class RefsHeadsFailedToFetch(Exception):
   pass
 
 class Lockfile(object):
   """Class to represent a cross-platform process-specific lockfile."""
 
-  def __init__(self, path):
+  def __init__(self, path, timeout=0):
     self.path = os.path.abspath(path)
+    self.timeout = timeout
     self.lockfile = self.path + ".lock"
     self.pid = os.getpid()
 
   def _read_pid(self):
     """Read the pid stored in the lockfile.
 
     Note: This method is potentially racy. By the time it returns the lockfile
     may have been unlocked, removed, or stolen by some other process.
     """
     try:
@@ skipping 25 matching lines @@
         if exitcode == 0:
           return
         time.sleep(3)
       raise LockError('Failed to remove lock: %s' % lockfile)
     else:
       os.remove(self.lockfile)
 
   def lock(self):
     """Acquire the lock.
 
-    Note: This is a NON-BLOCKING FAIL-FAST operation.
-    Do. Or do not. There is no try.
+    This will block with a deadline of self.timeout seconds.
+    If self.timeout is zero, a NON-BLOCKING FAIL-FAST operation.
     """
-    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))
+    elapsed = 0
+    while True:
+      try:
+        self._make_lockfile()
+        return
+      except OSError as e:
+        if elapsed < self.timeout:
+          sleep_time = min(3, self.timeout - elapsed)
+          elapsed += sleep_time

[tandrii(chromium), 2016/02/02 22:01:00]

maybe also print here that it's waiting on a lock?

[szager1, 2016/02/02 22:33:11]

Done.

+          time.sleep(sleep_time)
+          continue
+        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."""
     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:
@@ skipping 280 matching lines @@
     for spec in fetch_specs:
       try:
         self.print('Fetching %s' % spec)
         self.RunGit(fetch_cmd + [spec], cwd=rundir, retry=True)
       except subprocess.CalledProcessError:
         if spec == '+refs/heads/*:refs/heads/*':
           raise RefsHeadsFailedToFetch
         logging.warn('Fetch of %s failed' % spec)
 
   def populate(self, depth=None, shallow=False, bootstrap=False,
-               verbose=False, ignore_lock=False):
+               verbose=False, ignore_lock=False, lock_timeout=0):
     assert self.GetCachePath()
     if shallow and not depth:
       depth = 10000
     gclient_utils.safe_makedirs(self.GetCachePath())
 
-    lockfile = Lockfile(self.mirror_path)
+    lockfile = Lockfile(self.mirror_path, lock_timeout)
     if not ignore_lock:
       lockfile.lock()
 
     tempdir = None
     try:
       tempdir = self._ensure_bootstrapped(depth, bootstrap)
       rundir = tempdir or self.mirror_path
       self._fetch(rundir, verbose, depth)
     except RefsHeadsFailedToFetch:
       # This is a major failure, we need to clean and force a bootstrap.
@@ skipping 154 matching lines @@
   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,
+      'lock_timeout': options.timeout,
   }
   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')
@@ skipping 23 matching lines @@
         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(bootstrap=not options.no_bootstrap)
+    mirror.populate(
+        bootstrap=not options.no_bootstrap, lock_timeout=options.timeout)
     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(bootstrap=not options.no_bootstrap)
+      mirror.populate(
+          bootstrap=not options.no_bootstrap, lock_timeout=options.timeout)
     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',
@@ skipping 28 matching lines @@
   """Wrapper class for OptionParser to handle global options."""
 
   def __init__(self, *args, **kwargs):
     optparse.OptionParser.__init__(self, *args, prog='git cache', **kwargs)
     self.add_option('-c', '--cache-dir',
                     help='Path to the directory containing the cache')
     self.add_option('-v', '--verbose', action='count', default=1,
                     help='Increase verbosity (can be passed multiple times)')
     self.add_option('-q', '--quiet', action='store_true',
                     help='Suppress all extraneous output')
+    self.add_option('--timeout', type='int', default=0,
+                    help='Timeout for acquiring cache lock, in seconds')
 
   def parse_args(self, args=None, values=None):
     options, args = optparse.OptionParser.parse_args(self, args, values)
     if options.quiet:
       options.verbose = 0
 
     levels = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
     logging.basicConfig(level=levels[min(options.verbose, len(levels) - 1)])
 
     try:
@@ skipping 14 matching lines @@
   dispatcher = subcommand.CommandDispatcher(__name__)
   return dispatcher.execute(OptionParser(), argv)
 
 
 if __name__ == '__main__':
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)