| """Async wrapper around :class:`ReadWriteLock` for use with ``asyncio``.""" |
|
|
| from __future__ import annotations |
|
|
| import asyncio |
| import functools |
| import os |
| import sqlite3 |
| import threading |
| from concurrent.futures import ThreadPoolExecutor |
| from contextlib import asynccontextmanager |
| from typing import TYPE_CHECKING, Literal, ParamSpec, TypeVar, cast |
|
|
| from ._api import ( |
| _append_exception_context, |
| _ensure_current_process, |
| _fork_transition, |
| _register_fork_object, |
| ) |
| from ._async import ( |
| _BackendOutcome, |
| _capture_call, |
| _drain_future, |
| _future_result, |
| _raise_cancelled_error, |
| _task_owners_for, |
| _wait_until_done, |
| ) |
| from ._read_write import ReadWriteLock |
|
|
| if TYPE_CHECKING: |
| from collections.abc import AsyncGenerator, Callable |
| from concurrent import futures |
| from types import TracebackType |
|
|
|
|
| _P = ParamSpec("_P") |
| _R = TypeVar("_R") |
|
|
|
|
| class AsyncReadWriteLock: |
| """ |
| Async wrapper around :class:`ReadWriteLock` for use in ``asyncio`` applications. |
| |
| This wrapper dispatches every blocking SQLite operation to a thread pool via ``loop.run_in_executor()`` because |
| Python's :mod:`sqlite3` module has no async API. Each ``asyncio`` task owns its own hold. Tasks share a read lock, |
| and a task asking for the write lock waits until the other holders release, with waiting writers ahead of new |
| readers. As with :class:`ReadWriteLock`, upgrading or downgrading a held lock raises :class:`RuntimeError`. |
| Singleton wrappers over one path share their task holds. |
| |
| :param lock_file: path to the SQLite database file used as the lock |
| :param timeout: maximum wait time in seconds; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days |
| :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable |
| :param is_singleton: if ``True``, reuse existing :class:`ReadWriteLock` instances for the same resolved path |
| :param loop: event loop for ``run_in_executor``; ``None`` uses the running loop |
| :param executor: executor for ``run_in_executor``. When ``None`` this lock creates and owns a dedicated |
| single-thread executor so every operation runs on the same thread (SQLite affinity requires this) and shuts it |
| down in :meth:`close`. This lock uses a caller-supplied executor as-is and never shuts it down, so after passing |
| no executor call :meth:`close` to release the owned one. |
| |
| .. versionadded:: 3.21.0 |
| |
| """ |
|
|
| def __init__( |
| self, |
| lock_file: str | os.PathLike[str], |
| timeout: float = -1, |
| *, |
| blocking: bool = True, |
| is_singleton: bool = True, |
| loop: asyncio.AbstractEventLoop | None = None, |
| executor: futures.Executor | None = None, |
| ) -> None: |
| creator_pid = os.getpid() |
| self._creator_pid = creator_pid |
| self._fork_invalidated = False |
| self._closed = False |
| _register_fork_object(self) |
| with _fork_transition(): |
| self._lock = ReadWriteLock(lock_file, timeout, blocking=blocking, is_singleton=is_singleton) |
| self._owners = _task_owners_for(self._lock) |
| self._loop = loop |
| self._owns_executor = executor is None |
| self._executor = executor or ThreadPoolExecutor(max_workers=1) |
| if os.getpid() != creator_pid: |
| msg = "AsyncReadWriteLock construction cannot continue after fork" |
| raise RuntimeError(msg) |
|
|
| @property |
| def lock_file(self) -> str: |
| """The path to the lock file.""" |
| return self._lock.lock_file |
|
|
| @property |
| def timeout(self) -> float: |
| """The default timeout.""" |
| return self._lock.timeout |
|
|
| @property |
| def blocking(self) -> bool: |
| """Whether blocking is enabled by default.""" |
| return self._lock.blocking |
|
|
| @property |
| def loop(self) -> asyncio.AbstractEventLoop | None: |
| """The event loop (or ``None`` for the running loop).""" |
| return self._loop |
|
|
| @property |
| def executor(self) -> futures.Executor: |
| """The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied).""" |
| return self._executor |
|
|
| @asynccontextmanager |
| async def read_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]: |
| """ |
| Async context manager that acquires and releases a shared read lock. |
| |
| Falls back to instance defaults for *timeout* and *blocking* when ``None``. |
| |
| :param timeout: maximum wait time in seconds, or ``None`` to use the instance default |
| :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default |
| |
| """ |
| await self.acquire_read(timeout, blocking=blocking) |
| body_error: BaseException | None = None |
| try: |
| yield |
| except BaseException as error: |
| body_error = error |
| raise |
| finally: |
| await self._release_in_context(body_error) |
|
|
| @asynccontextmanager |
| async def write_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]: |
| """ |
| Async context manager that acquires and releases an exclusive write lock. |
| |
| Falls back to instance defaults for *timeout* and *blocking* when ``None``. |
| |
| :param timeout: maximum wait time in seconds, or ``None`` to use the instance default |
| :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default |
| |
| """ |
| await self.acquire_write(timeout, blocking=blocking) |
| body_error: BaseException | None = None |
| try: |
| yield |
| except BaseException as error: |
| body_error = error |
| raise |
| finally: |
| await self._release_in_context(body_error) |
|
|
| async def _release_in_context(self, body_error: BaseException | None) -> None: |
| try: |
| await self.release() |
| except BaseException as release_error: |
| if body_error is not None: |
| _append_exception_context(release_error, body_error) |
| raise |
|
|
| async def acquire_read( |
| self, timeout: float | None = None, *, blocking: bool | None = None |
| ) -> AsyncAcquireReadWriteReturnProxy: |
| """ |
| Acquire a shared read lock. |
| |
| See :meth:`ReadWriteLock.acquire_read` for full semantics. |
| |
| :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's |
| busy-timeout cap of about 23 days |
| :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention; |
| ``None`` uses the instance setting |
| |
| :returns: a proxy that can be used as an async context manager to release the lock |
| |
| :raises RuntimeError: if the calling task already holds the write lock |
| :raises Timeout: if the lock cannot be acquired within *timeout* seconds |
| :raises TypeError: if *timeout* is a :class:`bool` or not a real number |
| :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` |
| |
| """ |
| self._raise_if_unusable() |
| await self._acquire("read", timeout, blocking=blocking) |
| return AsyncAcquireReadWriteReturnProxy(lock=self) |
|
|
| async def acquire_write( |
| self, timeout: float | None = None, *, blocking: bool | None = None |
| ) -> AsyncAcquireReadWriteReturnProxy: |
| """ |
| Acquire an exclusive write lock. |
| |
| See :meth:`ReadWriteLock.acquire_write` for full semantics. |
| |
| :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's |
| busy-timeout cap of about 23 days |
| :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention; |
| ``None`` uses the instance setting |
| |
| :returns: a proxy that can be used as an async context manager to release the lock |
| |
| :raises RuntimeError: if the calling task already holds the read lock |
| :raises Timeout: if the lock cannot be acquired within *timeout* seconds |
| :raises TypeError: if *timeout* is a :class:`bool` or not a real number |
| :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1`` |
| |
| """ |
| self._raise_if_unusable() |
| await self._acquire("write", timeout, blocking=blocking) |
| return AsyncAcquireReadWriteReturnProxy(lock=self) |
|
|
| async def _acquire(self, mode: Literal["read", "write"], timeout: float | None, *, blocking: bool | None) -> None: |
| timeout = self.timeout if timeout is None else timeout |
| blocking = self.blocking if blocking is None else blocking |
| sync_acquire = self._lock.acquire_read if mode == "read" else self._lock.acquire_write |
|
|
| def enter_backend(remaining: float) -> None: |
| sync_acquire(remaining, blocking=blocking) |
| self._owners.backend_thread = threading.get_ident() |
|
|
| async def enter(remaining: float) -> None: |
| await self._run_acquire(functools.partial(enter_backend, remaining)) |
|
|
| await self._owners.acquire(mode, timeout=timeout, blocking=blocking, lock_file=self.lock_file, enter=enter) |
|
|
| async def release(self, *, force: bool = False) -> None: |
| """ |
| Release one level of the calling task's hold. |
| |
| The wrapper releases the database lock once no task holds it. |
| |
| :param force: if ``True``, drop the calling task's whole hold at any nesting level |
| |
| :raises RuntimeError: if the calling task holds no lock and *force* is ``False`` |
| |
| """ |
| _ensure_current_process() |
| if self._inherited: |
| return |
| await self._owners.release( |
| force=force, lock_file=self.lock_file, leave=functools.partial(self._submit, self._leave_backend) |
| ) |
|
|
| async def close(self) -> None: |
| """ |
| Release the lock (if held) and close the underlying SQLite connection. |
| |
| After calling this method, the lock instance is no longer usable. |
| |
| """ |
| _ensure_current_process() |
| if self._inherited: |
| return |
| if self._closed: |
| return |
| close_future = self._submit(self._lock.close) |
| try: |
| await _wait_until_done(close_future) |
| except asyncio.CancelledError as cancellation: |
| try: |
| await _drain_future(close_future) |
| except BaseException as error: |
| _raise_cancelled_error(cancellation, error) |
| self._closed = True |
| self._owners.reset() |
| self._shutdown_owned_executor() |
| raise |
| _future_result(close_future) |
| self._closed = True |
| self._owners.reset() |
| |
| |
| if self._owns_executor: |
| await asyncio.to_thread(functools.partial(self._executor.shutdown, wait=True)) |
|
|
| async def _run_acquire(self, acquire: Callable[[], None]) -> None: |
| acquire_future = self._submit(acquire) |
| try: |
| await _wait_until_done(acquire_future) |
| except asyncio.CancelledError as cancellation: |
| try: |
| await _drain_future(acquire_future) |
| except BaseException as error: |
| _raise_cancelled_error(cancellation, error) |
| try: |
| await _drain_future(self._submit(self._leave_backend)) |
| except BaseException as error: |
| _raise_cancelled_error(cancellation, error) |
| raise |
| _future_result(acquire_future) |
|
|
| def _leave_backend(self) -> None: |
| |
| self._lock._release_level_of( |
| cast("int", self._owners.backend_thread) |
| ) |
|
|
| def _submit( |
| self, func: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs |
| ) -> asyncio.Future[_BackendOutcome[_R]]: |
| return (self._loop or asyncio.get_running_loop()).run_in_executor( |
| self._executor, |
| _capture_call, |
| functools.partial(func, *args, **kwargs), |
| ) |
|
|
| def _shutdown_owned_executor(self) -> None: |
| if self._owns_executor: |
| self._executor.shutdown(wait=False) |
|
|
| @property |
| def _inherited(self) -> bool: |
| return self._fork_invalidated or os.getpid() != self._creator_pid |
|
|
| def _raise_if_unusable(self) -> None: |
| _ensure_current_process() |
| if self._inherited: |
| msg = f"AsyncReadWriteLock on {self.lock_file} was invalidated by fork(); construct a new instance" |
| raise RuntimeError(msg) |
| if self._closed: |
| msg = "Cannot operate on a closed database." |
| raise sqlite3.ProgrammingError(msg) |
|
|
| def _reset_after_fork_in_child(self) -> None: |
| self._fork_invalidated = True |
|
|
| def __del__(self) -> None: |
| |
| |
| if os.getpid() == getattr(self, "_creator_pid", None) and getattr(self, "_owns_executor", False): |
| self._executor.shutdown(wait=False) |
|
|
|
|
| class AsyncAcquireReadWriteReturnProxy: |
| """Context-aware object that releases the async read/write lock on exit.""" |
|
|
| def __init__(self, lock: AsyncReadWriteLock) -> None: |
| self.lock = lock |
|
|
| async def __aenter__(self) -> AsyncReadWriteLock: |
| return self.lock |
|
|
| async def __aexit__( |
| self, |
| exc_type: type[BaseException] | None, |
| exc_value: BaseException | None, |
| traceback: TracebackType | None, |
| ) -> None: |
| await self.lock.release() |
|
|
|
|
| __all__ = [ |
| "AsyncAcquireReadWriteReturnProxy", |
| "AsyncReadWriteLock", |
| ] |
|
|
