o #jx@s`UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZmZddlmZddlmZddlmZmZddlmZdd lmZdd lmZdd lmZdd l m!Z!erydd l"m#Z#m$Z$edZ%dZ&dZ'e(eddZ)e j*dkoej+ej,vZ-eZ.de/d<e 0a1da2da3eddGdddZ4eGdddZ5eddGdddZ6eGdddZ7Gd d!d!e8Z9Gd"d#d#e9d$Z:Gd%d&d&e j;ZdPd7d8Z?dd'dQd=d>Z@dd'dRd?d@ZAdd'dRdAdBZBdSdDdEZCdTdFdGZDdUdHdIZEdUdJdKZFdUdLdMZGd#gZHdS)VzZCross-process and cross-host reader/writer lock built on :class:`SoftFileLock` primitives.) annotationsN)contextmanagersuppress) dataclass)Path) TYPE_CHECKINGLiteral)WeakValueDictionary)AcquireReturnProxy)Timeout) SoftFileLock)ensure_directory_exists)Callable Generator)readwritez.breaki O_NOFOLLOWwin32,WeakValueDictionary[Path, SoftReadWriteLock]_all_instancesFT)frozenc@s&eZdZUded<ded<ded<dS)_PathsstrstaterreadersN__name__ __module__ __qualname____annotations__r r X/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/filelock/_soft_rw/_sync.pyr-  rc@s&eZdZUded<ded<ded<dS)_Locksthreading.Lockinternal transactionr rNrr r r r!r#4r"r#c@s&eZdZUded<ded<ded<dS) _MarkerInfortokenintpidhostnameNrr r r r!r';r"r'c@sReZdZUdZded<ded<ded<ded <d ed <ded <d ed<ded<dS)_HoldzYEverything that exists only while a lock is held; ``None`` when the instance has no lock.r)level_Modemode int | Nonewrite_thread_idr marker_namebool is_readerr(_HeartbeatThreadheartbeat_threadthreading.Eventheartbeat_stopN)rrr__doc__rr r r r!r,Bs  r,csBeZdZUded<ded< dddddd d dfddZZS) _SoftRWMetar _instancesr$_instances_lockT>@N?blocking is_singletonheartbeat_intervalstale_threshold poll_interval lock_filestr | os.PathLike[str]timeoutfloatrAr3rBrCrD float | NonerEreturnSoftReadWriteLockc s|stj|||||||dSt|}|jE|j|} | dur6tj|||||||d} | |j|<n| j|ks@| j|krTd| jd| jd|d|} t | | WdS1s`wYdS)Nr@z$Singleton lock created with timeout=z , blocking=z, cannot be changed to timeout=) super__call__rresolver<r;getrHrA ValueError) clsrFrHrArBrCrDrE normalizedinstancemsg __class__r r!rNTsD    $z_SoftRWMeta.__call__r=)rFrGrHrIrAr3rBr3rCrIrDrJrErIrKrL)rrrrrN __classcell__r r rVr!r:Ps r:c@s4eZdZUdZeZded<eZ dNdddddd dOddZ e dPdddQddZ e dPdddQddZ dPdddRd!d"ZdPdddRd#d$ZdSd%d&Zd'd(dTd*d+Ze dNdddUd,d-ZdVd0d1ZdWd2d3ZdXd8d9ZdXd:d;ZdYd>d?ZdSd@dAZdZdBdCZd[dEdFZd\dHdIZdZdJdKZdSdLdMZdS)]rLu Cross-process and cross-host reader/writer lock built on :class:`SoftFileLock` primitives. Use this class instead of :class:`~filelock.ReadWriteLock` when the lock file lives on a network filesystem (NFS, Lustre with ``-o flock``, HPC cluster shared storage). ``ReadWriteLock`` is backed by SQLite and cannot run on NFS because SQLite's ``fcntl`` locking is unreliable there. Layout on disk for a lock at ``foo.lock``: - ``foo.lock.state`` — a :class:`SoftFileLock` taken only during state transitions (microseconds). - ``foo.lock.write`` — writer marker; its presence means a writer is claiming or holding the lock. - ``foo.lock.readers/..`` — one file per reader. Each marker stores a random token (``secrets.token_hex(16)``), the holder's pid, and the holder's hostname. A daemon heartbeat thread refreshes ``mtime`` on every held marker. A marker whose mtime has not advanced in ``stale_threshold`` seconds may be evicted by any process on any host, giving correct behavior when a compute node crashes with a lock held. Writer acquire is two-phase and writer-preferring: phase 1 claims ``.write`` (blocking any new reader), phase 2 waits for existing readers to drain. Writer starvation is impossible. Reentrancy, upgrade/downgrade rules, thread pinning, and singleton caching by resolved path match :class:`~filelock.ReadWriteLock`. Forking while holding a lock invalidates the inherited instance in the child so the child cannot double-own the lock with its parent; ``release()`` on a fork-invalidated instance is a no-op, and the child must re-acquire if it needs a lock. Trust boundary: protects against same-UID non-cooperating processes (one host or cross-host) and same-host different-UID users via ``0o600`` / ``0o700`` permissions. Does not protect against root compromise, NTP tampering on same-UID cross-host nodes, or multi-tenant mounts where hostile co-tenants share the UID. :param lock_file: path to the lock file; sidecar state/write/readers live next to it :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately on contention :param is_singleton: if ``True``, reuse existing instances for the same resolved path :param heartbeat_interval: seconds between heartbeat refreshes; default 30 s :param stale_threshold: seconds of ``mtime`` inactivity before a marker is stale; defaults to ``3 * heartbeat_interval``, matching etcd's ``LeaseKeepAlive`` convention :param poll_interval: seconds between acquire retries under contention; default 0.25 s .. versionadded:: 3.27.0 rr;r=Tr>Nr?r@rFrGrHrIrAr3rBrCrDrJrErKNonec Cs@|dkr d|}t||dur|d}||kr&d|d|d}t||dkr3d|}t|t||_||_||_||_||_||_t |jd|jd |jd d |_ t |jt t t t|j jd d d|_d|_d|_d|_d|_t|tt|j<tWddS1swYdS)Nrz)heartbeat_interval must be positive, got z0stale_threshold must exceed heartbeat_interval (z <= )z$poll_interval must be positive, got z.statez.writez.readers)rrrr=rHr%r&rF)rQosfspathrFrHrArCrDrEr_pathsr r# threadingLockr r_locks_readers_dir_fd_hold_fork_invalidated_closed_all_instances_lockrrrO_register_hooks) selfrFrHrArBrCrDrErUr r r!__init__sH       "zSoftReadWriteLock.__init__rA bool | NoneGenerator[None]cc0|j||dz dVW|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 :raises RuntimeError: if a write lock is already held on this instance :raises Timeout: if the lock cannot be acquired within *timeout* seconds rmN) acquire_readreleaserkrHrAr r r! read_lock zSoftReadWriteLock.read_lockccrp)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 :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 rmN) acquire_writerrrsr r r! write_lockruzSoftReadWriteLock.write_lockr cC|jd||dS)uf 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). On the 0→1 transition a daemon heartbeat thread is started that refreshes the reader marker's ``mtime`` every ``heartbeat_interval`` seconds so peers on other hosts do not evict the marker as stale. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable; ``None`` uses the instance default :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, if this instance was invalidated by :func:`os.fork`, or if :meth:`close` was called :raises Timeout: if the lock cannot be acquired within *timeout* seconds rrm_acquirersr r r!rq szSoftReadWriteLock.acquire_readcCrx)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`. Writer acquisition runs in two phases. Phase 1 atomically claims ``.write`` via ``O_CREAT | O_EXCL``, which immediately blocks any new reader on any host. Phase 2 waits for existing readers to drain. Writer starvation is impossible: new readers see ``.write`` during phase 2 and wait behind the pending writer. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable; ``None`` uses the instance default :returns: a proxy that can be used as a context manager to release the lock :raises RuntimeError: if a read lock is already held, if a write lock is held by a different thread, if this instance was invalidated by :func:`os.fork`, or if :meth:`close` was called :raises Timeout: if the lock cannot be acquired within *timeout* seconds rrmryrsr r r!rv$szSoftReadWriteLock.acquire_writec Cs|jdd|jjB|jr WddSd|_|jdurDttt|jWdn1s4wYd|_WddSWddS1sOwYdS)u Release any held lock and release internal filesystem resources. Idempotent. After calling this method the instance can no longer acquire locks — subsequent acquires raise :class:`RuntimeError`. A fork-invalidated instance is closed without raising. TforceN) rrrdr%rhrerOSErrorr_closerkr r r!r~?s    "zSoftReadWriteLock.closeFr{r|cCs |jjW|jrd|_ WddS|j}|dur6|r& WddSd|jdt|d}t||rtjjjtdtjjr WddSz tjjWnt y9YWddSwWddS1sEwYdS)NrDnowFT) rdr_break_stale_markerrarrDr _file_exists_atomic_create_markerFileExistsErrorr rkr(r r!try_claim_writers    z@SoftReadWriteLock._acquire_writer_slot..try_claim_writerc sxjj.tttjjWdn1swYt WdS1s5wYdSN) rdrrr}_touchrar_break_stale_readersr _any_readersr rr r!readers_drained_touchings  $zHSoftReadWriteLock._acquire_writer_slot..readers_drained_touchingrFrKr3)_open_readers_dir _wait_forr rrar)rkr(rrArrr rr!rs      z&SoftReadWriteLock._acquire_writer_slotcsxtjdtjttj j dfdd }j |||ddur8dfSdfS) N.rKr3csjj6tjjjtdtjjr WddSdur,tdnt WddS1s=wYdS)NrFrT) rdrrrarrDrrrr rZfull_reader_pathZ reader_namerkr(r r!try_claim_readers   $z@SoftReadWriteLock._acquire_reader_slot..try_claim_readerrTr) ruuiduuid4hexr_getpidrerrrarr)rkr(rrArr rr!rs z&SoftReadWriteLock._acquire_reader_slot predicateCallable[[], bool]cCsj |rdSt}|st|j|dur||krt|j|j}|dur/t|t||d}t|q)NTg)rrr rFrEminmaxsleep)rkrrrArZ sleep_forr r r!r,s   zSoftReadWriteLock._wait_forcCst|jj}tt|jddWdn1swYt|jj}t |j s3t |j s>|jjd}t ||j dur[tr]tjttddBtB}t|jj||_ dSdSdS)Ni)r/zB exists but is not a directory or is a symlink; refusing to use it O_DIRECTORYr)rrarrrmkdirr_lstatstatS_ISLNKst_modeS_ISDIRrre_SUPPORTS_DIR_FDO_RDONLYgetattr _O_NOFOLLOWopen)rk readers_pathstrUflagsr r r!r@s  z#SoftReadWriteLock._open_readers_dircCs|D]}dSdS)NTF)_iter_reader_entries)rk_r r r!rNs zSoftReadWriteLock._any_readersGenerator[tuple[str, bool]]ccs|jdur/t|j}|D] }t|js|jdfVqWddS1s(wYdSt|jj}t|}|D]}t|jsNt||jdfVq=WddS1sZwYdS)a# Yield ``(name, dirfd_relative)`` pairs for every live reader marker. ``dirfd_relative`` is ``True`` when *name* should be passed to ``dir_fd=``-aware syscalls; ``False`` when *name* is a full path because dirfd-relative I/O is unavailable on this platform. NTF) rer_scandir_is_housekeeping_namerrrarr)rkitentryrr r r!rSs(       "z&SoftReadWriteLock._iter_reader_entriesrcCslg}z|D]\}}|||r|jndfqWn ty#YdSw|D] \}}t||j||dq&dS)N)rDrr)rappendrer}rrD)rkrnamesrZdirfd_relativefdr r r!rfs  z&SoftReadWriteLock._break_stale_readerscCs|jj&|j}|dur WddS|j}|j}|jr!|jnd}Wdn1s-wYt||d}|dur>dS|\}}|dusMt |j|sOdSz t ||dWdSt ybYdSw)NFrT) rdr%rfr2r(r4re _read_markerhmaccompare_digestrFileNotFoundError)rkrr2r(r read_resultinfoZ_mtimer r r!rps*   z!SoftReadWriteLock._refresh_markercCs:tttt|jjddd|_d|_d|_d|_ dS)Nr=r]r^T) r#rbrcr rarrdrfrergrr r r!_reset_after_fork_in_childs z,SoftReadWriteLock._reset_after_fork_in_childrX)rFrGrHrIrAr3rBr3rCrIrDrJrErIrKrZr)rHrJrArnrKro)rHrJrArnrKr rKrZ)r|r3rKrZ)rFrGrHrIrAr3rKrL)r/r.rHrJrArnrKr )r/r.rKr )r(rrrJrAr3rKr)rrrrJrAr3rKrZr)rKr)rrIrKrZ)rrrr9r r;rrbrcr<rlrrtrwrqrvr~rr classmethodrrzrrrrrrrrrrr r r r!rLsH .2 *  F  (      rL) metaclasscs(eZdZdfd d Zdd dZZS)r5rrrrIrr7rrrKrZcs&tj|dd||_||_||_dS)NT)rdaemon)rMrl_refresh _interval _stop_event)rkrrrrrVr r!rls z_HeartbeatThread.__init__cCs:|j|js|s|jdS|j|jrdSdSr)rwaitrrrrr r r!runs  z_HeartbeatThread.run) rrrrIrr7rrrKrZr)rrrrlrrYr r rVr!r5s r5rrrr(rr0rKrZc CstjtjBtjBtB}tr|durtj||d|d}nt||d}z |dtdt d d}t ||Wt |dSt |w)Nir ascii) r_O_CREATO_EXCLO_WRONLYrrrrsocket gethostnameencoderr~)rr(rrrcontentr r r!rs $r'tuple[_MarkerInfo | None, float] | Nonec CstjtB}ztr|durtj|||dnt||}Wn ty%YdSwz'zt|}t|td}WntyFYWt |dSwWt |nt |wt ||j fS)Nrr) r_rrrrr}fstatr_MAX_MARKER_SIZEr~_parse_marker_bytesst_mtime)rrrrrdatar r r!rs" ,   rrbytes_MarkerInfo | NonecCs|rt|tkr dSz|d}Wn tyYdSwtd|tj}|dur*dSt|dd}|dkr7dSt|d||ddS) Nru \A # start of string (?P [0-9a-f]{32} ) \n # 128-bit hex token (?P [1-9][0-9]{0,9} ) \n # decimal pid: no leading zero, ≤ 10 digits (?P [\x21-\x7e]{1,253}) # printable non-whitespace ASCII (RFC 1123 hostname limit) \n* # tolerate sloppy writers that append extra newlines \Z # end of string r* ir(r+)r(r*r+) lenrdecodeUnicodeDecodeErrorrematchVERBOSEr)r')rtextrr*r r r!rs$  rrDrIrr3c Cst||d}|dur dS|\}}|||krdS|dur$t||ddS|tdtdtd}ztrF|durFtj||||dnt ||Wn t yXYdSwt||d}|duredS|\} } | durut||ddSt |j | j sdS| |krdSt||ddS)NrFTrr)Z src_dir_fdZ dst_dir_fd)rr _BREAK_SUFFIXr_rrrrrenamerr}rrr() rrDrrrZ info_beforeZ mtime_beforeZ break_nameZ read_afterZ info_afterZ mtime_afterr r r!rs>   "     rcCsftt%tr|durtj||dnt|WddSWddS1s,wYdSNr)rrrr_unlinkrrrr r r!rs  "rcCs0tr|durtj|d|ddSt|ddSr)rr_utimer r r r!rs rpathcCs0zt|}Wn tyYdSwt|jS)NF)r_rrrS_ISREGr)r rr r r!r&s   rcCs|dpt|vS)Nr) startswithr)rr r r!r.srcCs&tattD]}|q dSr)rbrcrilistrvaluesrrTr r r!_reset_all_after_fork2s rc CsJttD]}tt|jddWdn1swYqdS)NTr{)rrrr Exceptionrrrr r r!_cleanup_all_instances<s  rcCs<ts ttdatsttdrtjtddadSdSdS)NTregister_at_fork)after_in_child) _atexit_registeredatexitregisterr_fork_registeredhasattrr_rrr r r r!rjBs  rj)rrr(rrr0rKrZ)rrrr0rKr)rrrKr) rrrDrIrrIrr0rKr3)rrrr0rKrZ)r rrKr3)rrrKr3r)Ir9 __future__rrrr_rrrrsysrbrr contextlibrr dataclassesrpathlibrtypingrrweakrefr Z filelock._apir Zfilelock._errorr Zfilelock._softr Zfilelock._utilr collections.abcrrr.rrrrplatformrsupports_dir_fdrrrrcrirrrr#r'r,typer:rLThreadr5rrrrrrrrrrrj__all__r r r r!s|          1 #-