Update pylockfile to 4a7a20d91c44d2be6396be5fc64d27b0b5afa4e2

lib/lockfile/__init__.py

+# -*- coding: utf-8 -*-
+
 """
 lockfile.py - Platform-independent advisory file locks.
 
@@ -68,7 +70,7 @@ if not hasattr(threading.Thread, "get_name"):
 
 __all__ = ['Error', 'LockError', 'LockTimeout', 'AlreadyLocked',
            'LockFailed', 'UnlockError', 'NotLocked', 'NotMyLock',
-           'LinkLockFile', 'MkdirLockFile', 'SQLiteLockFile',
+           'LinkFileLock', 'MkdirFileLock', 'SQLiteFileLock',
            'LockBase', 'locked']
 
 class Error(Exception):
@@ -154,14 +156,58 @@ class NotMyLock(UnlockError):
     """
     pass
 
-class LockBase:
+class _SharedBase(object):
+    def __init__(self, path):
+        self.path = path
+
+    def acquire(self, timeout=None):
+        """
+        Acquire the lock.
+
+        * If timeout is omitted (or None), wait forever trying to lock the
+          file.
+
+        * If timeout > 0, try to acquire the lock for that many seconds.  If
+          the lock period expires and the file is still locked, raise
+          LockTimeout.
+
+        * If timeout <= 0, raise AlreadyLocked immediately if the file is
+          already locked.
+        """
+        raise NotImplemented("implement in subclass")
+
+    def release(self):
+        """
+        Release the lock.
+
+        If the file is not locked, raise NotLocked.
+        """
+        raise NotImplemented("implement in subclass")
+
+    def __enter__(self):
+        """
+        Context manager support.
+        """
+        self.acquire()
+        return self
+
+    def __exit__(self, *_exc):
+        """
+        Context manager support.
+        """
+        self.release()
+
+    def __repr__(self):
+        return "<%s: %r>" % (self.__class__.__name__, self.path)
+
+class LockBase(_SharedBase):
     """Base class for platform-specific lock classes."""
     def __init__(self, path, threaded=True, timeout=None):
         """
         >>> lock = LockBase('somefile')
         >>> lock = LockBase('somefile', threaded=False)
         """
-        self.path = path
+        super(LockBase, self).__init__(path)
         self.lock_file = os.path.abspath(path) + ".lock"
         self.hostname = socket.gethostname()
         self.pid = os.getpid()
@@ -189,30 +235,6 @@ class LockBase:
                                                        hash(self.path)))
         self.timeout = timeout
 
-    def acquire(self, timeout=None):
-        """
-        Acquire the lock.
-
-        * If timeout is omitted (or None), wait forever trying to lock the
-          file.
-
-        * If timeout > 0, try to acquire the lock for that many seconds.  If
-          the lock period expires and the file is still locked, raise
-          LockTimeout.
-
-        * If timeout <= 0, raise AlreadyLocked immediately if the file is
-          already locked.
-        """
-        raise NotImplemented("implement in subclass")
-
-    def release(self):
-        """
-        Release the lock.
-
-        If the file is not locked, raise NotLocked.
-        """
-        raise NotImplemented("implement in subclass")
-
     def is_locked(self):
         """
         Tell whether or not the file is locked.
@@ -231,19 +253,6 @@ class LockBase:
         """
         raise NotImplemented("implement in subclass")
 
-    def __enter__(self):
-        """
-        Context manager support.
-        """
-        self.acquire()
-        return self
-
-    def __exit__(self, *_exc):
-        """
-        Context manager support.
-        """
-        self.release()
-
     def __repr__(self):
         return "<%s: %r -- %r>" % (self.__class__.__name__, self.unique_name,
                                    self.path)

lib/lockfile/linklockfile.py

@@ -5,7 +5,6 @@ import os
 
 from . import (LockBase, LockFailed, NotLocked, NotMyLock, LockTimeout,
                AlreadyLocked)
-import errno
 
 class LinkLockFile(LockBase):
     """Lock access to a file using atomic property of link(2).
@@ -20,7 +19,7 @@ class LinkLockFile(LockBase):
         except IOError:
             raise LockFailed("failed to create %s" % self.unique_name)
 
-        timeout = timeout is not None and timeout or self.timeout
+        timeout = timeout if timeout is not None else self.timeout
         end_time = time.time()
         if timeout is not None and timeout > 0:
             end_time += timeout
@@ -29,9 +28,7 @@ class LinkLockFile(LockBase):
             # Try and create a hard link to it.
             try:
                 os.link(self.unique_name, self.lock_file)
-            except OSError as e:
-                if e.errno == errno.ENOSYS:
-                    raise LockFailed("%s" % e.strerror)
+            except OSError:
                 # Link creation failed.  Maybe we've double-locked?
                 nlinks = os.stat(self.unique_name).st_nlink
                 if nlinks == 2:

lib/lockfile/mkdirlockfile.py

@@ -24,7 +24,7 @@ class MkdirLockFile(LockBase):
                                                       self.pid))
 
     def acquire(self, timeout=None):
-        timeout = timeout is not None and timeout or self.timeout
+        timeout = timeout if timeout is not None else self.timeout
         end_time = time.time()
         if timeout is not None and timeout > 0:
             end_time += timeout

lib/lockfile/pidlockfile.py

@@ -70,7 +70,7 @@ class PIDLockFile(LockBase):
         the lock could not be acquired.
         """
 
-        timeout = timeout is not None and timeout or self.timeout
+        timeout = timeout if timeout is not None else self.timeout
         end_time = time.time()
         if timeout is not None and timeout > 0:
             end_time += timeout
@@ -81,8 +81,8 @@ class PIDLockFile(LockBase):
             except OSError as exc:
                 if exc.errno == errno.EEXIST:
                     # The lock creation failed.  Maybe sleep a bit.
-                    if timeout is not None and time.time() > end_time:
-                        if timeout > 0:
+                    if time.time() > end_time:
+                        if timeout is not None and timeout > 0:
                             raise LockTimeout("Timeout waiting to acquire"
                                               " lock for %s" %
                                               self.path)

lib/lockfile/sqlitelockfile.py

@@ -50,7 +50,7 @@ class SQLiteLockFile(LockBase):
             atexit.register(os.unlink, SQLiteLockFile.testdb)
 
     def acquire(self, timeout=None):
-        timeout = timeout is not None and timeout or self.timeout
+        timeout = timeout if timeout is not None else self.timeout
         end_time = time.time()
         if timeout is not None and timeout > 0:
             end_time += timeout

lib/lockfile/symlinklockfile.py

@@ -21,7 +21,7 @@ class SymlinkLockFile(LockBase):
         #    open(self.unique_name, "wb").close()
         #except IOError:
         #    raise LockFailed("failed to create %s" % self.unique_name)
-        timeout = timeout is not None and timeout or self.timeout
+        timeout = timeout if timeout is not None else self.timeout
         end_time = time.time()
         if timeout is not None and timeout > 0:
             end_time += timeout