| Current File : //proc/self/root/lib/python3/dist-packages/certbot/_internal/__pycache__/lock.cpython-312.pyc |
�
M/�e�' � � � d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddl
Z
dZ ej e� Z G d � d
� Z G d � d � Z G d
� de� Z G d� de� Zdedefd�Zy# e $ r ddl
Z
dZ Y �Rw xY w)zZImplements file locks compatible with Linux and Windows for locking files and directories.� N)�Optional)�errors)�
filesystem)�osTFc �H � e Zd ZdZdeddfd�Zdefd�Zd
d�Zd
d�Zde fd �Z
y) �LockFilea�
Platform independent file lock system.
LockFile accepts a parameter, the path to a file acting as a lock. Once the LockFile,
instance is created, the associated file is 'locked from the point of view of the OS,
meaning that if another instance of Certbot try at the same time to acquire the same lock,
it will raise an Exception. Calling release method will release the lock, and make it
available to every other instance.
Upon exit, Certbot will also release all the locks.
This allows us to protect a file or directory from being concurrently accessed
or modified by two Certbot instances.
LockFile is platform independent: it will proceed to the appropriate OS lock mechanism
depending on Linux or Windows.
�path�returnNc �p � || _ t rt nt } ||� | _ | j � y)z�
Create a LockFile instance on the given file path, and acquire lock.
:param str path: the path to the file that will hold a lock
N)�_path�
POSIX_MODE�_UnixLockMechanism�_WindowsLockMechanism�_lock_mechanism�acquire)�selfr � mechanisms �8/usr/lib/python3/dist-packages/certbot/_internal/lock.py�__init__zLockFile.__init__$ s+ � �
��
�*4�&�:O� � (���� � � � �� c � � dj | j j | j � }| j � r|dz
}|S |dz
}|S )Nz
{0}({1}) <z acquired>z released>)�format� __class__�__name__r � is_locked)r �repr_strs r �__repr__zLockFile.__repr__/ sN � � �&�&�t�~�~�'>�'>��
�
�K�� �>�>� � � � #�H� ��
� � #�H��r c �8 � | j j � y)z�
Acquire the lock on the file, forbidding any other Certbot instance to acquire it.
:raises errors.LockError: if unable to acquire the lock
N)r r �r s r r zLockFile.acquire7 s � �
� � �$�$�&r c �8 � | j j � y)zb
Release the lock on the file, allowing any other Certbot instance to acquire it.
N)r �releaser s r r! zLockFile.release> s � �
� � �$�$�&r c �6 � | j j � S )zu
Check if the file is currently locked.
:return: True if the file is locked, False otherwise
)r r r s r r zLockFile.is_lockedD s � �
�#�#�-�-�/�/r �r
N) r �
__module__� __qualname__�__doc__�strr r r r! �boolr � r r r r s< � � � �S� �T� ��#� �'�'� 0�4� 0r r c �8 � e Zd Zdeddfd�Zdefd�Zdd�Zdd�Zy) �_BaseLockMechanismr r
Nc � � || _ d| _ y)zk
Create a lock file mechanism for Unix.
:param str path: the path to the lock file
N)r �_fd)r r s r r z_BaseLockMechanism.__init__M s � �
��
�"&��r c � � | j duS )zvCheck if lock file is currently locked.
:return: True if the lock file is locked
:rtype: bool
N)r- r s r r z _BaseLockMechanism.is_lockedU s � �
�x�x�t�#�#r c � � y �Nr) r s r r z_BaseLockMechanism.acquire\ � � � r c � � y r0 r) r s r r! z_BaseLockMechanism.release_ r1 r r# ) r r$ r% r' r r( r r r! r) r r r+ r+ L s+ � �'�S� '�T� '�$�4� $�
�
r r+ c �@ � e Zd ZdZd d�Zdeddfd�Zdedefd�Zd d�Z y)
r z�
A UNIX lock file mechanism.
This lock file is released when the locked file is closed or the
process exits. It cannot be used to provide synchronization between
threads. It is based on the lock_file package by Martin Horcicka.
r
Nc � � | j ��t j | j t j
t j z d� } | j |� | j |� r|| _ | j �t j |� | j ���yy# | j �t j |� w w xY w)zAcquire the lock.N� )
r- r �openr r �O_CREAT�O_WRONLY� _try_lock�
_lock_success�close)r �fds r r z_UnixLockMechanism.acquirej s� � ��h�h� �� � ����R�Z�Z�"�+�+�-E�u�M�B�
!����r�"��%�%�b�)� !�D�H� �8�8�#��H�H�R�L� �h�h� �� �8�8�#��H�H�R�L� $�s �)B( �($C r< c �V � t j |t j t j z � y# t $ rg}|j
t
j t
j fv r5t j d| j � t j d� �� d}~ww xY w)z�
Try to acquire the lock file without blocking.
:param int fd: file descriptor of the opened file to lock
�(A lock on %s is held by another process.�/Another instance of Certbot is already running.N)
�fcntl�lockf�LOCK_EX�LOCK_NB�IOError�errno�EACCES�EAGAIN�logger�debugr r � LockError)r r< �errs r r9 z _UnixLockMechanism._try_lockx ss � �
� �K�K��E�M�M�E�M�M� 9� :��� ��y�y�U�\�\�5�<�<� 8�8�� � � G����T� �&�&�'X�Y�Y� �� �s �58 � B(�A"B#�#B(c � � ddl m} ddl m} || j � } ||� }|j |j k( xr |j |j k( S # t $ r(}|j
t
j k( rY d}~y� d}~ww xY w)a�
Did we successfully grab the lock?
Because this class deletes the locked file when the lock is
released, it is possible another process removed and recreated
the file between us opening the file and acquiring the lock.
:param int fd: file descriptor of the opened file to lock
:returns: True if the lock was successfully acquired
:rtype: bool
r )�fstat)�statNF) r rM rN r �OSErrorrE �ENOENT�st_dev�st_ino)r r< rM rN �stat1rK �stat2s r r: z _UnixLockMechanism._lock_success� sw � � �� �����$�E� �b� �� �|�|�u�|�|�+�L�� � �� � �0L�L�� � ��y�y�E�L�L�(� � �� �s �A � B
�% B�B�B
c �v � t j | j � | j � t d� � t j
| j � d| _ y# d| _ w xY w# | j � t d� � t j
| j � d| _ w # d| _ w xY wxY w)z)Remove, close, and release the lock file.NzError, self._fd is None.)r �remover r- � TypeErrorr; r s r r! z_UnixLockMechanism.release� s� � �
� �I�I�d�j�j� !� �x�x� � � :�;�;�
�������"� ����4���� �x�x� � � :�;�;�
�������"� ����4���s. � A, � A � A)�,B8� B,�$B8�, B5�5B8r# )
r r$ r% r& r �intr9 r( r: r! r) r r r r c s: � �� !� �C� �D� �M�� M�� M�6 r r c � � e Zd ZdZdd�Zdd�Zy)r a"
A Windows lock file mechanism.
By default on Windows, acquiring a file handler gives exclusive access to the process
and results in an effective lock. However, it is possible to explicitly acquire the
file handler in shared access in terms of read and write, and this is done by os.open
and io.open in Python. So an explicit lock needs to be done through the call of
msvcrt.locking, that will lock the first byte of the file. In theory, it is also
possible to access a file in shared delete access, allowing other processes to delete an
opened file. But this needs also to be done explicitly by all processes using the Windows
low level APIs, and Python does not do it. As of Python 3.7 and below, Python developers
state that deleting a file opened by a process from another process is not possible with
os.open and io.open.
Consequently, msvcrt.locking is sufficient to obtain an effective lock, and the race
condition encountered on Linux is not possible on Windows, leading to a simpler workflow.
Nc �
� t j t j z t j z }d} t j
| j |d� }t j |t j d� || _ y# t t f$ ro}|rt j |� |j t j k7 r� t j! d| j � t# j$ d� �d}~ww xY w)zAcquire the lockNr5 � r> r? )r �O_RDWRr7 �O_TRUNCr r6 r �msvcrt�locking�LK_NBLCKrD rO r; rE rF rH rI r rJ r- )r � open_moder< rK s r r z _WindowsLockMechanism.acquire� s� � ��I�I��
�
�*�R�Z�Z�7� �
�� V� � � ����Y��>�B�
�N�N�2�v���� 2� ���� ��!� V������ ��y�y�E�L�L�(�� �L�L�C�T�Z�Z� P��"�"�#T�U� U�� V�s �AB �D�A*C=�=Dc � � | j st j d� �t j | j t j
d� t
j | j � t
j | j � d| _ y# t $ r(}t j t |� � Y d}~�4d}~ww xY w# d| _ w xY w)zRelease the lock.z%The lock has not been acquired first.r[ N)r- r �Errorr^ r_ �LK_UNLCKr r; rV r rO rH rI r' )r �es r r! z _WindowsLockMechanism.release� s� � � ��8�8� �l�l�#J�K�K�
�N�N�4�8�8�V�_�_�a� 8� �H�H�T�X�X� �
%�� � �$�*�*�%� �D�H�� �
%� � � �S��V�$�$��
%��
�D�H�s0 �A/C
�2 B � C
�" C� C
�C
�
C
�
Cr# )r r$ r% r& r r! r) r r r r � s � �� �0 r r �dir_pathr
c �T � t t j j | d� � S )a3 Place a lock file on the directory at dir_path.
The lock file is placed in the root of dir_path with the name
.certbot.lock.
:param str dir_path: path to directory
:returns: the locked LockFile object
:rtype: LockFile
:raises errors.LockError: if unable to acquire the lock
z
.certbot.lock)r r r �join)rf s r �lock_dirri � s � � �B�G�G�L�L��?�;� <�<r )r& rE �logging�typingr �certbotr �certbot.compatr r r@ r
� ImportErrorr^ � getLoggerr rH r r+ r r r' ri r) r r �<module>rp s� �� `� � � � � %� ���
�J�
�� � �8� $��30� 30�l
�
�.R �+� R �j: � .� : �z=�s� =�x� =��S � ���J��s �A/ �/ A=�<A=