File: //opt/saltstack/salt/lib/python3.10/site-packages/filelock/__pycache__/_read_write.cpython-310.pyc
o
;jM= � @ s U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl m
Z
m Z d dl m
Z
mZ d dlmZ ddlmZ ddlmZ e
rMd d lmZ e�d
�Ze� Zd ed < e� � Z d dd�Z e� e � dZ d dd�Z!G dd� de"�Z#G d d � d e#d �Z$dS )!� )� annotationsN)�contextmanager�suppress)�
TYPE_CHECKING�Literal)�WeakValueDictionary� )�AcquireReturnProxy)�Timeout)� GeneratorZfilelockzset[sqlite3.Connection]�_all_connections�return�Nonec
C sp t �, tt�D ]} tt�� | �� W d � n1 s w Y qt�� W d � d S 1 s1w Y d S �N)�_all_connections_lock�listr r � Exception�close�clear)Zcon� r �H/opt/saltstack/salt/lib/python3.10/site-packages/filelock/_read_write.py�_cleanup_connections s
��
"�r i��5w�timeout�float�blocking�bool�already_waited�intc C sx |du rdS | dkr t S | dk rd}t|��| dkr!t| | d�n| }t|d �}|t ks1|dk r:t�d| t � t S |S )NFr ���z+timeout must be a non-negative number or -1i� z7timeout %s is too large for SQLite, using %s ms instead)�_MAX_SQLITE_TIMEOUT_MS�
ValueError�maxr �_LOGGER�warning)r r r �msg� remaining�
timeout_msr r r �timeout_for_sqlite( s r' c s@ e Zd ZU dZded< ded< dddd�d� fdd�Z� ZS )�_ReadWriteLockMetaa"
Metaclass that handles singleton resolution when is_singleton=True.
Singleton logic lives here rather than in ReadWriteLock.get_lock so that ``ReadWriteLock(path)`` transparently
returns cached instances without a 2-arg ``super()`` call that type checkers cannot verify.
�0WeakValueDictionary[pathlib.Path, ReadWriteLock]�
_instanceszthreading.Lock�_instances_lockr T�r � is_singleton� lock_file�str | os.PathLike[str]r r r r r- r
�
ReadWriteLockc s� |s t � j||||d�S t�|��� }| j�B || jvr,t � j||||d�}|| j|< n| j| }|j|ks;|j|krOd|j� d|j� d|� d|� �}t |��|W d � S 1 s[w Y d S )Nr, z$Singleton lock created with timeout=z , blocking=z , cannot be changed to timeout=)
�super�__call__�pathlib�Path�resolver+ r* r r r )�clsr. r r r- �
normalized�instancer$ �� __class__r r r2 G s$
���$�z_ReadWriteLockMeta.__call__�r )
r. r/ r r r r r- r r
r0 )�__name__�
__module__� __qualname__�__doc__�__annotations__r2 �
__classcell__r r r9 r r( ; s
��r( c @ s� e Zd ZU dZe� Zded< e�� Z e
d9dd�d:dd��Z d9ddd�d;dd�Z d<dd�Z
d=d d �Zd>d d!�Zd?d"d#�Zd@d$d%�Zd9dd�dAd&d'�Zd9dd�dAd(d)�Zd*d+�dBd-d.�ZedCd/d�dDd3d4��ZedCd/d�dDd5d6��ZdEd7d8�Zd/S )Fr0 a�
Cross-process read-write lock backed by SQLite.
Allows concurrent shared readers or a single exclusive writer. The lock is reentrant within the same mode (multiple
``acquire_read`` calls nest, as do multiple ``acquire_write`` calls from the same thread), but upgrading from read
to write or downgrading from write to read raises :class:`RuntimeError`. Write locks are pinned to the thread that
acquired them.
By default, ``is_singleton=True``: calling ``ReadWriteLock(path)`` with the same resolved path returns the same
instance. The lock file must use a ``.db`` extension (SQLite database).
:param lock_file: path to the SQLite database file used as the lock
:param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
:param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
:param is_singleton: if ``True``, reuse existing instances for the same resolved path
.. versionadded:: 3.21.0
r) r* r T�r r. r/ r r r r r
c C s | |||d�S )a
Return the singleton :class:`ReadWriteLock` for *lock_file*.
:param lock_file: path to the SQLite database file used as the lock
:param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
:param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
:returns: the singleton lock instance
:raises ValueError: if an instance already exists for this path with different *timeout* or *blocking* values
rB r )r6 r. r r r r r �get_lock{ s zReadWriteLock.get_lockr, r- r c C s� t �|�| _|| _|| _t�� | _t�� | _d| _ d | _
d | _ t j
| jdd�| _t� t�| j� W d � d S 1 s<w Y d S )Nr F)Zcheck_same_thread)�os�fspathr. r r � threading�Lock�_transaction_lock�_internal_lock� _lock_level�
_current_mode�_write_thread_id�sqlite3�connect�_conr r �add)�selfr. r r r- r r r �__init__� s
"�zReadWriteLock.__init__c C sP |s
| j jdd�}n|dkr| j jdd�}n| j jd|d�}|s&t| j�d �d S )NFrB r T�r r )rH �acquirer
r. )rQ r r Zacquiredr r r �_acquire_transaction_lock� s �z'ReadWriteLock._acquire_transaction_lock�mode�Literal['read', 'write']�opposite�str� directionr c C s� | j |kr d|� d| j� dt| �� d|� d|� d� }t|��|dkrAt�� }| jkrAd| j� dt| �� d |� d
| j� �}t|��| jd 7 _t| d �S )
NzCannot acquire z lock on � (lock id: z): already holding a z lock (z
not allowed)�writez Cannot acquire write lock on z) from thread z while it is held by thread r ��lock) rK r. �id� RuntimeErrorrF � get_identrL rJ r )rQ rV rX rZ r$ Zcurr r r �_validate_reentrant� s$
������
z!ReadWriteLock._validate_reentrant�
start_timec C s� t �� | }t|||d�}| j�d|� d���� | j�d��� t �� | }t|||d� }|kr>| j�d|� d���� |dkrDdnd}| j�|��� |dkr\| j�d ��� d S d S )
N)r r zPRAGMA busy_timeout=�;zPRAGMA journal_mode=MEMORY;r\ z BEGIN EXCLUSIVE TRANSACTION;zBEGIN TRANSACTION;�readz'SELECT name FROM sqlite_schema LIMIT 1;)�time� perf_counterr' rO Zexecuter ) rQ rV r r rc Zwaitedr& Z
recomputedZstmtr r r �_configure_and_begin� s �z"ReadWriteLock._configure_and_beginc
C s� |dkrdnd}|dkrdnd}| j � | jdkr'| �|||�W d � S W d � n1 s1w Y t�� }| j||d� z+z| j||||d�W W | j�� S t j
yl } z
dt |�vrb� t | j
�d �d }~ww | j�� w ) Nre r\ � downgrade�upgrader rS �r rc zdatabase is locked)rI rJ rb rf rg rU �_do_acquire_innerrH �releaserM ZOperationalErrorrY r
r. )rQ rV r r rX rZ rc �excr r r �_acquire� s(
� � � �� zReadWriteLock._acquirec C s� |dkrdnd}|dkrdnd}| j � | jdkr'| �|||�W d � S W d � n1 s1w Y | j||||d� | j � || _d| _|dkrRt�� | _W d � n1 s\w Y t| d�S ) Nre r\ ri rj r rk r r] ) rI rJ rb rh rK rF ra rL r )rQ rV r r rc rX rZ r r r rl � s"
� �
� �
z ReadWriteLock._do_acquire_innerc C � | j d||d�S )a�
Acquire a shared read lock.
If this instance already holds a read lock, the lock level is incremented (reentrant). Attempting to acquire a
read lock while holding a write lock raises :class:`RuntimeError` (downgrade not allowed).
:param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
:param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
:returns: a proxy that can be used as a context manager to release the lock
:raises RuntimeError: if a write lock is already held on this instance
:raises Timeout: if the lock cannot be acquired within *timeout* seconds
re rB �ro �rQ r r r r r � acquire_read� s zReadWriteLock.acquire_readc C rp )a�
Acquire an exclusive write lock.
If this instance already holds a write lock from the same thread, the lock level is incremented (reentrant).
Attempting to acquire a write lock while holding a read lock raises :class:`RuntimeError` (upgrade not allowed).
Write locks are pinned to the acquiring thread: a different thread trying to re-enter also raises
:class:`RuntimeError`.
:param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
:param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
:returns: a proxy that can be used as a context manager to release the lock
:raises RuntimeError: if a read lock is already held, or a write lock is held by a different thread
:raises Timeout: if the lock cannot be acquired within *timeout* seconds
r\ rB rq rr r r r �
acquire_write s zReadWriteLock.acquire_writeF��forcerv c C s� d}| j �B | jdkr&|r W d � dS d| j� dt| �� d�}t|��|r,d| _n| jd8 _| jdkr@d| _d| _d}W d � n1 sJw Y |rX| j�� dS dS ) al
Release one level of the current lock.
When the lock level reaches zero the underlying SQLite transaction is rolled back, releasing the database lock.
:param force: if ``True``, release the lock completely regardless of the current lock level
:raises RuntimeError: if no lock is currently held and *force* is ``False``
Fr NzCannot release a lock on r[ z) that is not heldr T) rI rJ r. r_ r` rK rL rO Zrollback)rQ rv Zshould_rollbackr$ r r r rm # s(
�
� ��zReadWriteLock.releaseN� float | None� bool | None�Generator[None]c c �L � |du r| j }|du r| j}| j||d� z
dV W | �� dS | �� w )a}
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
NrB )r r rs rm rr r r r � read_lock@ � � zReadWriteLock.read_lockc c rz )a�
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
NrB )r r rt rm rr r r r �
write_lockU r| zReadWriteLock.write_lockc C sL | j dd� | j�� t� t�| j� W d � dS 1 s w Y dS )z�
Release the lock (if held) and close the underlying SQLite connection.
After calling this method, the lock instance is no longer usable.
Tru N)rm rO r r r �discard)rQ r r r r j s
"�zReadWriteLock.closer; )r. r/ r r r r r
r0 )
r. r/ r r r r r- r r
r )r r r r r
r )rV rW rX rY rZ rY r
r )
rV rW r r r r rc r r
r )rV rW r r r r r
r )
rV rW r r r r rc r r
r )r r r r r
r )rv r r
r r )r rw r rx r
ry �r
r )r< r= r> r? r r* r@ rF rG r+ � classmethodrC rR rU rb rh ro rl rs rt rm r r{ r} r r r r r r0 c s6
����
r0 )� metaclassr )r r r r r r r
r )%�
__future__r �atexit�loggingrD r3 rM rF rf �
contextlibr r �typingr r �weakrefr Z_apir �_errorr
�collections.abcr � getLoggerr" �setr r@ rG r r �registerr r' �typer( r0 r r r r �<module> s0
(