Fixed missing or inconsistent error when acquiring already owned Lock (#799)

Fixes #798.

---------

Co-authored-by: Thomas Grainger <[email protected]>

(cherry picked from commit 5c60291)

Author: agronholm

docs/versionhistory.rst

@@ -3,6 +3,27 @@ Version history
 
 This library adheres to `Semantic Versioning 2.0 <http://semver.org/>`_.
 
+**UNRELEASED**
+
+- Fixed acquring a lock twice in the same task on asyncio hanging instead of raising a
+  ``RuntimeError`` (`#798 <https://github.com/agronholm/anyio/issues/798>`_)
+
+**4.6.0**
+
+- Dropped support for Python 3.8
+  (as `#698 <https://github.com/agronholm/anyio/issues/698>`_ cannot be resolved
+  without cancel message support)
+- Fixed 100% CPU use on asyncio while waiting for an exiting task group to finish while
+  said task group is within a cancelled cancel scope
+  (`#695 <https://github.com/agronholm/anyio/issues/695>`_)
+- Fixed cancel scopes on asyncio not propagating ``CancelledError`` on exit when the
+  enclosing cancel scope has been effectively cancelled
+  (`#698 <https://github.com/agronholm/anyio/issues/698>`_)
+- Fixed asyncio task groups not yielding control to the event loop at exit if there were
+  no child tasks to wait on
+- Fixed inconsistent task uncancellation with asyncio cancel scopes belonging to a
+  task group when said task group has child tasks running
+
 **4.5.0**
 
 - Improved the performance of ``anyio.Lock`` and ``anyio.Semaphore`` on asyncio (even up

src/anyio/_backends/_asyncio.py

@@ -1681,9 +1681,10 @@ def __init__(self, *, fast_acquire: bool = False) -> None:
         self._waiters: deque[tuple[asyncio.Task, asyncio.Future]] = deque()
 
     async def acquire(self) -> None:
+        task = cast(asyncio.Task, current_task())
         if self._owner_task is None and not self._waiters:
             await AsyncIOBackend.checkpoint_if_cancelled()
-            self._owner_task = current_task()
+            self._owner_task = task
 
             # Unless on the "fast path", yield control of the event loop so that other
             # tasks can run too
@@ -1696,7 +1697,9 @@ async def acquire(self) -> None:
 
             return
 
-        task = cast(asyncio.Task, current_task())
+        if self._owner_task == task:
+            raise RuntimeError("Attempted to acquire an already held Lock")
+
         fut: asyncio.Future[None] = asyncio.Future()
         item = task, fut
         self._waiters.append(item)
@@ -1712,10 +1715,14 @@ async def acquire(self) -> None:
         self._waiters.remove(item)
 
     def acquire_nowait(self) -> None:
+        task = cast(asyncio.Task, current_task())
         if self._owner_task is None and not self._waiters:
-            self._owner_task = current_task()
+            self._owner_task = task
             return
 
+        if self._owner_task is task:
+            raise RuntimeError("Attempted to acquire an already held Lock")
+
         raise WouldBlock
 
     def locked(self) -> bool:

src/anyio/_backends/_trio.py

@@ -659,9 +659,19 @@ def __init__(self, *, fast_acquire: bool = False) -> None:
         self._fast_acquire = fast_acquire
         self.__original = trio.Lock()
 
+    @staticmethod
+    def _convert_runtime_error_msg(exc: RuntimeError) -> None:
+        if exc.args == ("attempt to re-acquire an already held Lock",):
+            exc.args = ("Attempted to acquire an already held Lock",)
+
     async def acquire(self) -> None:
         if not self._fast_acquire:
-            await self.__original.acquire()
+            try:
+                await self.__original.acquire()
+            except RuntimeError as exc:
+                self._convert_runtime_error_msg(exc)
+                raise
+
             return
 
         # This is the "fast path" where we don't let other tasks run
@@ -670,12 +680,18 @@ async def acquire(self) -> None:
             self.__original.acquire_nowait()
         except trio.WouldBlock:
             await self.__original._lot.park()
+        except RuntimeError as exc:
+            self._convert_runtime_error_msg(exc)
+            raise
 
     def acquire_nowait(self) -> None:
         try:
             self.__original.acquire_nowait()
         except trio.WouldBlock:
             raise WouldBlock from None
+        except RuntimeError as exc:
+            self._convert_runtime_error_msg(exc)
+            raise
 
     def locked(self) -> bool:
         return self.__original.locked()

tests/test_synchronization.py

@@ -96,6 +96,23 @@ async def try_lock() -> None:
             assert lock.locked()
             tg.start_soon(try_lock)
 
+    @pytest.mark.parametrize("fast_acquire", [True, False])
+    async def test_acquire_twice_async(self, fast_acquire: bool) -> None:
+        lock = Lock(fast_acquire=fast_acquire)
+        await lock.acquire()
+        with pytest.raises(
+            RuntimeError, match="Attempted to acquire an already held Lock"
+        ):
+            await lock.acquire()
+
+    async def test_acquire_twice_sync(self) -> None:
+        lock = Lock()
+        lock.acquire_nowait()
+        with pytest.raises(
+            RuntimeError, match="Attempted to acquire an already held Lock"
+        ):
+            lock.acquire_nowait()
+
     @pytest.mark.parametrize(
         "release_first",
         [pytest.param(False, id="releaselast"), pytest.param(True, id="releasefirst")],