Lock bug fixes

Author: Joel Collins

labthings/core/lock.py

@@ -31,6 +31,9 @@ def __repr__(self):
             self._owner,
         )
 
+    def locked(self):
+        return self._block.locked()
+
     def acquire(self, blocking=True, timeout=None):
         """
         Acquire the mutex, blocking if *blocking* is true, for up to
@@ -68,22 +71,6 @@ def release(self):
     def __exit__(self, typ, value, tb):
         self.release()
 
-    # Internal methods used by condition variables
-
-    def _acquire_restore(self, count_owner):
-        count, owner = count_owner
-        self._block.acquire()
-        self._count = count
-        self._owner = owner
-
-    def _release_save(self):
-        count = self._count
-        self._count = 0
-        owner = self._owner
-        self._owner = None
-        self._block.release()
-        return (count, owner)
-
     def _is_owned(self):
         return self._owner is getcurrent()
 
@@ -109,8 +96,10 @@ def __init__(self, timeout=1, name=None):
     def locked(self):
         return self._lock.locked()
 
-    def acquire(self, blocking=True):
-        return self._lock.acquire(blocking, timeout=self.timeout)
+    def acquire(self, blocking=True, timeout=None):
+        if not timeout:
+            timeout = self.timeout
+        return self._lock.acquire(blocking, timeout=timeout)
 
     def __enter__(self):
         result = self._lock.acquire(blocking=True, timeout=self.timeout)
@@ -125,6 +114,17 @@ def __exit__(self, *args):
     def release(self):
         self._lock.release()
 
+    @property
+    def _owner(self):
+        return self._lock._owner
+
+    @_owner.setter
+    def _owner(self, new_owner):
+        self._lock._owner = new_owner
+
+    def _is_owned(self):
+        return self._lock._is_owned()
+
 
 class CompositeLock:
     """
@@ -144,8 +144,19 @@ def __init__(self, locks, timeout=1):
         self.locks = locks
         self.timeout = timeout
 
-    def acquire(self, blocking=True):
-        return (lock.acquire(blocking=blocking) for lock in self.locks)
+    def acquire(self, blocking=True, timeout=None):
+        if not timeout:
+            timeout = self.timeout
+
+        lock_all = all(
+            [lock.acquire(blocking=blocking, timeout=timeout) for lock in self.locks]
+        )
+
+        if not lock_all:
+            self._emergency_release()
+            return False
+
+        return True
 
     def __enter__(self):
         result = (lock.acquire(blocking=True) for lock in self.locks)
@@ -159,5 +170,29 @@ def __exit__(self, *args):
             lock.release()
 
     def release(self):
+        # If not all child locks are owner by caller
+        if not all([owner is getcurrent() for owner in self._owner]):
+            raise RuntimeError("cannot release un-acquired lock")
         for lock in self.locks:
-            lock.release()
+            if lock.locked():
+                lock.release()
+
+    def _emergency_release(self):
+        for lock in self.locks:
+            if lock.locked() and lock._is_owned():
+                lock.release()
+
+    def locked(self):
+        return any([lock.locked() for lock in self.locks])
+
+    @property
+    def _owner(self):
+        return [lock._owner for lock in self.locks]
+
+    @_owner.setter
+    def _owner(self, new_owner):
+        for lock in self.locks:
+            lock._owner = new_owner
+
+    def _is_owned(self):
+        return all([lock._is_owned() for lock in self.locks])