feat(recipe): allow non ephemeral locking

Right now if the program taking the lock exits, the lock is also
released implicitly as the zk node is ephemeral. In some usecases
its desirable to make the lock release explicit. For example, in
scripting multiple programs that contend for a lock, or purposeful
failing lock acquirers to detect issues.

The ephemeral flag in acquire() allows for this behavior.

Author: raags

kazoo/recipe/lock.py

@@ -126,23 +126,33 @@ def cancel(self):
         self.cancelled = True
         self.wake_event.set()
 
-    def acquire(self, blocking=True, timeout=None):
+    def acquire(self, blocking=True, timeout=None, ephemeral=True):
         """
         Acquire the lock. By defaults blocks and waits forever.
 
         :param blocking: Block until lock is obtained or return immediately.
         :type blocking: bool
         :param timeout: Don't wait forever to acquire the lock.
         :type timeout: float or None
+        :param ephemeral: Don't use ephemeral znode for the lock.
+        :type ephemeral: bool
 
         :returns: Was the lock acquired?
         :rtype: bool
 
         :raises: :exc:`~kazoo.exceptions.LockTimeout` if the lock
                  wasn't acquired within `timeout` seconds.
 
+        .. warning::
+
+            When :attr:`ephemeral` is set to False session expiration
+            will not release the lock and must be handled separately.
+
         .. versionadded:: 1.1
             The timeout option.
+
+        .. versionadded:: 2.4.1
+            The ephemeral option.
         """
 
         def _acquire_lock():
@@ -170,7 +180,8 @@ def _acquire_lock():
             gotten = False
             try:
                 gotten = retry(self._inner_acquire,
-                               blocking=blocking, timeout=timeout)
+                               blocking=blocking, timeout=timeout,
+                               ephemeral=ephemeral)
             except RetryFailedError:
                 pass
             except KazooException:
@@ -192,7 +203,7 @@ def _watch_session(self, state):
         self.wake_event.set()
         return True
 
-    def _inner_acquire(self, blocking, timeout):
+    def _inner_acquire(self, blocking, timeout, ephemeral=True):
 
         # wait until it's our chance to get it..
         if self.is_acquired:
@@ -212,7 +223,7 @@ def _inner_acquire(self, blocking, timeout):
 
         if not node:
             node = self.client.create(self.create_path, self.data,
-                                      ephemeral=True, sequence=True)
+                                      ephemeral=ephemeral, sequence=True)
             # strip off path to node
             node = node[len(self.path) + 1:]
 

kazoo/tests/test_lock.py

@@ -6,6 +6,7 @@
 
 from kazoo.exceptions import CancelledError
 from kazoo.exceptions import LockTimeout
+from kazoo.exceptions import NoNodeError
 from kazoo.testing import KazooTestCase
 from kazoo.tests import util as test_util
 
@@ -355,6 +356,18 @@ def test_lock_reacquire(self):
         lock.acquire()
         lock.release()
 
+    def test_lock_ephemeral(self):
+        client1 = self._get_client()
+        client1.start()
+        lock = client1.Lock(self.lockpath, "ephemeral")
+        lock.acquire(ephemeral=False)
+        znode = self.lockpath + '/' + lock.node
+        client1.stop()
+        try:
+            self.client.get(znode)
+        except NoNodeError:
+            self.fail("NoNodeError raised unexpectedly!")
+
     def test_lock_timeout(self):
         timeout = 3
         e = self.make_event()