^jUdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZmZddlmZddlmZddlmZmZmZddlmZdd lmZmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+erdd l,m-Z-m.Z.edZ/dZ0de1d<dZ2de1d<e3eddZ4de1d<e3eddZ5de1d<e jldk7xrejnejpvZ9de1d<eZ:de1d<e jvad e1d!<Gd"d#e?Z@Gd$d%e@&ZAGd'd(e jZCdd)d@d*ZDdAd+ZEdd)dBd,ZFdd)dCd-ZGdDd.ZHdd)dEd/ZIdd) dFd0ZJdd)dGd1ZKdHd2ZLdId3ZMdJd4ZNed56Gd7d8ZOeGd9d:ZPed56Gd;d<ZQeGd=d>ZRdKd?ZSejeSe eAd%gZUy)LzZCross-process and cross-host reader/writer lock built on :class:`SoftFileLock` primitives.) annotationsN)contextmanagersuppress) dataclass)Path) TYPE_CHECKINGFinalLiteral)WeakValueDictionary)AcquireReturnProxy_ensure_current_process_fork_transition_raise_grouped_errors_register_fork_class_register_fork_object_register_owned_descriptor_unregister_owned_descriptor)Timeout) SoftFileLock)ensure_directory_existstouch write_all)Callable Generator)readwritez.breakz Final[str] _BREAK_SUFFIXiz Final[int]_MAX_MARKER_SIZE O_NOFOLLOW _O_NOFOLLOW O_NONBLOCK _O_NONBLOCKwin32z Final[bool]_SUPPORTS_DIR_FDz2Final[WeakValueDictionary[int, SoftReadWriteLock]]_ALL_INSTANCESthreading.Lock_ALL_INSTANCES_LOCKzFinal[set[Path]]_SINGLETONS_UNDER_CONSTRUCTIONcfeZdZUded<ded< d dddddd  d fd ZxZS) _SoftRWMeta,WeakValueDictionary[Path, SoftReadWriteLock] _instanceszthreading.RLock_instances_lockT>@N?blocking is_singletonheartbeat_intervalstale_threshold poll_intervalc t|st | |||||||St|j }|j 5|j j|} | |tvrd|} t| tj} tj| t | |||||||} tj|tj| k7r d} t| | |j |<nK| j|k7s| j|k7r-d| jd| jd|d|} t!| | cdddS#tj|wxYw#1swYyxYw)Nr0z2Singleton lock construction is already active for zOLock construction cannot continue after fork; construct a new lock in the childz$Singleton lock created with timeout=z , blocking=z, cannot be changed to timeout=)r super__call__rresolver-r,getr( RuntimeErrorosgetpidadddiscardtimeoutr1 ValueError) cls lock_filer@r1r2r3r4r5 normalizedinstancemsgconstruction_pid __class__s b/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/filelock/_soft_rw/_sync.pyr8z_SoftRWMeta.__call__:s !7#!)#5 /+$ )_,,.   ~~))*5H!??Nym\C&s++#%99; .22:> G$w/!!)%1+=(7&3 0 H3:::F99;"22kC&s++-5z*!!W,0A0AX0M:8;K;K:LKX`XiXiWjk55..`` — 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 invalidates the inherited instance in the child so the child cannot double-own the lock with its parent; ``release()`` on that instance is a no-op, and the child must construct a new instance 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 r+r,Tr.Nr/r0c6tj|_|dkrd|}t|||dz}||krd|d|d}t||dkrd|}t|tj||_||_||_||_||_ ||_ t|j d|j d |j d  |_ t|j ttj tj t#|jj$d |_d|_d|_d|_d|_t05|t2t5|<dddt7|y#1swYxYw)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)staterreadersrKr@internal transactionr]F)r<r= _creator_pidrAfspathrCr@r1r3r4r5_Paths_pathsr_Locks threadingLockrr]_locks_readers_dir_fd_readers_dir_fd_token_hold_closedr'r%idr) selfrCr@r1r2r3r4r5rFs rI__init__zSoftReadWriteLock.__init__sIIK  "=>P=QRCS/ !  "014O 0 0D_DUUYZlYmmnoCS/ ! A 8HCS/ ! ii 2% & );&5$1^^$F+^^$F+~~&h/  /^^%!(t{{00"=  ,015"#' "  ,'+N2d8 $ ,d# , ,s (FFctjat|_tj |_tjyN) rhrir'r r,RLockr-r(clear)rBs rI_reset_class_after_forkz)SoftReadWriteLock._reset_class_after_forks6(nn.,.'oo/&,,.rXr1c#K|j|| d|jy#|jwxYww)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 rwN) acquire_readreleaserpr@r1s rI read_lockzSoftReadWriteLock.read_locks5 'H5   LLNDLLNA,A>Ac#K|j|| d|jy#|jwxYww)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 rwN) acquire_writerzr{s rI write_lockzSoftReadWriteLock.write_locks5 7X6   LLNDLLNr}c*|jd||S)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 rrw_acquirer{s rIryzSoftReadWriteLock.acquire_reads*}}VWx}@@rXc*|jd||S)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 rrwrr{s rIrzSoftReadWriteLock.acquire_writes2}}Wg}AArXc||||S)a Return the singleton :class:`SoftReadWriteLock` for *lock_file*. :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 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 rw)rBrCr@r1s rIget_lockzSoftReadWriteLock.get_lock9s(9g99rXc<|jtjk7ry|jd|jj 5|j r dddyd|_|j|t5|jt|jd|_ |jdc}|_tt5tj|dddddddddy#1swYxYw#1swYxYw#1swYyxYw)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. NTforce)rcr<r=rzrjrarnrkrrlrrOSErrorclose)rpfds rIrzSoftReadWriteLock.closeOs    +  4  [[ ! ! %|| % % DL##/%'%11=4T5O5OP15D./3/C/CT,B,!'*% % % % %%% %% % %sC D"D?A D C:!D)D:D ?DD DDFrc|jtjk7ry|jj5|j }|3|r dddyd|j dt|d}t||rd|_ n|xjdzc_ |jdkDr dddyd|_dddjj|jj|jdz|jr"t!|j"|j$ y|j'|j(y#1swYxYw) a8 Release one level of the current lock. When the lock level reaches zero the heartbeat thread is stopped and the held marker file is unlinked. On a fork-invalidated instance (that is, the child of a :func:`os.fork` call made while the parent held a lock) this method is a no-op so inherited ``with`` blocks can unwind cleanly in the child. :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`` NzCannot release a lock on (lock id: z) that is not heldrg?r_dir_fd)rcr<r=rjrarmrCror;levelheartbeat_stopsetheartbeat_threadjoinr3 is_reader_unlink marker_namerk_unlink_writer_marker_if_ourstoken)rprholdrFs rIrzzSoftReadWriteLock.releasefs$    +  [[ ! ! ::D|   2$..1ARPTXJVhi"3''  a zzA~  DJ " ! ""4+B+BS+H"I >> D$$T-A-A B  . .tzz :-  sEAE3EEcP|jj5t|jjx} dddy|\}}| t j |j|s dddyt|jjdddy#1swYyxYwrs) rjr] _read_markerrfrhmaccompare_digestrr)rprrinfo_s rIrz/SoftReadWriteLock._unlink_writer_marker_if_ourss[[   '$T[[%6%677@ ' 'GD!|4#6#6tzz5#I  ' ' DKK%% &  ' ' 's#B(B4BB%c|jtjk7rd|jd}t || |j n|}| |j n|}|jj5|jrd|jd}t ||j|j|cdddS dddtj}|s'|jjjd}nS|dk(r'|jjjd}n'|jjjd|}|st!|jd |j#|||||jjj%S#1swYxYw#|jjj%wxYw) NzSoftReadWriteLock on z4 was invalidated by fork(); construct a new instancez has been closedFrwrKT)r1r@)rcr<r=rCr;r@r1rjrarnrm_validate_reentranttime perf_counterrbacquirer_do_acquire_innerrz)rpmoder@r1rFstartacquireds rIrzSoftReadWriteLock._acquires    +)$..)99mnCs# #")/$,,w$,$44==( [[ ! ! 6||-dnn-==MN"3''zz%//5  6 6&  6!!#{{..666FH ]{{..666EH{{..66g6VH$..)t 3 .))$)R KK # # + + -' 6 6& KK # # + + -s3AF,3F8,F58&Gc |jj5|j|j|cdddS ddd|dk(rdn||z}t j d}|dk(r|j |||\}}n|j|||\}}tj} t|j|j| dt|d} |jj5td||dk(rtjnd|||| | |_ddd| j!t#| S#1swYxYw#1swY2xYw) NrKrdeadliner1zfilelock-heartbeat-x)refreshinterval stop_eventnamer)rrwrite_thread_idrrrrrlock)rjrarmrsecrets token_hex_acquire_writer_slot_acquire_reader_slotrhEvent_HeartbeatThread_refresh_markerr3ro_Hold get_identrr ) rpreffective_timeoutrr1rrrrr heartbeats rIrz#SoftReadWriteLock._do_acquire_inners][[ ! ! 6zz%//5 6 6% 6-24@Q8Q!!"% 7?%)%>%>uxbj%>%k "K%)%>%>uxbj%>%k "K__& $((,,!&r$xl3  [[ ! ! 9= 3 3 5d'#!*) DJ  !t,,9 6 6  sE 62E EE"c |j}|J|j|k7rB|dk(rdnd}|dk(rdnd}d|d|jdt|d|d |d }t ||dk(rYt j x}|jk7r6d |jdt|d |d |j}t ||xjdz c_t|S)Nrr downgradeupgradezCannot acquire z lock on rz): already holding a z lock (z not allowed)zCannot acquire write lock on z) from thread z while it is held by thread rr) rmrrCror;rhrrrr )rprropposite directionrFcurs rIrz%SoftReadWriteLock._validate_reentrantszz 99 "&&.wfH'+v~ 9I!$y0@ BtH:V%%-Jgi[ O s# # 7?y':':'< <AUAUU//?{2d8*U"e#?@T@T?UW s# # a !t,,rXcjdfd }dfd }j||| j|||jj dfS#t$rjwxYw)Nc~jj5jcdddS#1swYyxYwrs)rjr]_claim_writer_markerrprsrItry_claim_writerz@SoftReadWriteLock._acquire_writer_slot..try_claim_writers3"" 8007 8 8 8s3<cjj5jsjs dddyj t j j cdddS#1swYyxYwNF)rjr]_touch_writer_marker_if_oursr_break_stale_readersr _any_readersrsrIreaders_drained_touchingzHSoftReadWriteLock._acquire_writer_slot..readers_drained_touchingsu"" /88?HaHabgHh  / / ))$))+6,,..  / / /s$B3BB rFrPrN)_open_readers_dir _wait_forrrrfr)rprrr1rrs`` rIrz&SoftReadWriteLock._acquire_writer_slots   8 / '(XN  NN3hQYN Z {{  %''    . .u 5   s A""A>c t|jj|jt jt |jjry t |jj|y#t$rYywxYw)Nr4nowFT)_break_stale_markerrfrr4r _file_exists_atomic_create_markerFileExistsErrorrs rIrz&SoftReadWriteLock._claim_writer_markersq DKK--t?S?SY]YbYbYde  )) *  !$++"3"3U ;  s B B  B c@t|jj}|y tj|t dz}t|}| tj|j|s tj|ytt 5t|jj|ddd tj|y#t $rYtj|ywxYw#1swYDxYw#tj|wxYw)NFrrT) _open_markerrfrr<rrrr_parse_marker_bytesrrrrr)rprrdatars rIrz.SoftReadWriteLock._touch_writer_marker_if_ours's$++++ , :  wwr#3a#78't,D|4#6#6tzz5#I HHRL '" 0dkk''B/ 0 HHRL  HHRL   0 0 HHRLsGC-DD"C:7D C7D6C77D:D?DDcTjtjjdt j j ttjjz dfd }j|||dfSdfS)N.cfjj5tjjj t j tjjr dddytn t dddy#1swYyxYw)NrFrT) rjr]rrfrr4rrr)rfull_reader_path reader_namerprsrItry_claim_readerz@SoftReadWriteLock._acquire_reader_slot..try_claim_readerHs"" #DKK$5$5tG[G[aeajajalm 1 12   %)+uVL)*:EB   sAB'B''B0rTr) ruuiduuid4hexr<r=rkstrrrfr^r)rprrr1rrrrs`` @@@rIrz&SoftReadWriteLock._acquire_reader_slot<s  ))*!BIIK=9 %%tDKK$7$78;FG   '(XN%1 $NN7G$NNrXc |rytj}|st|j|||k\rt|j|j}|t |t ||z d}tj|)Ng)rrrrCr5minmaxsleep)rp predicaterr1r sleep_fors rIrzSoftReadWriteLock._wait_forVs{##%Cdnn--#xdnn--**I# 3x#~s+CD JJy !rXc t|jj}tt5|j ddddt j|jj}tj|jstj|js$|jjd}t||jtrt5t j |jjt j"t%t ddzt&z} t)|}||_ ||_dddyyy#1swY(xYw#t*$r?} t j,|#t*$r}t/d||Yd}~d}~wwxYwd}~wwxYw#1swYyxYw)Ni)rzB exists but is not a directory or is a symlink; refusing to use it O_DIRECTORYrz>reader directory registration and descriptor close both failed)rrfr^rrmkdirr<lstatstatS_ISLNKst_modeS_ISDIRr;rkr$ropenO_RDONLYgetattrr r BaseExceptionrrrl)rp readers_pathstrFrrregistration_error close_errors rIrz#SoftReadWriteLock._open_readers_dirjs}DKK//0 o & +   E  * +XXdkk)) * << #4<< +C[[(())klCs# #    ',<!# 3WWT[[00"++M[\@]2]`k2kl 6r:E(*$-2* 3 3-= ' + +%   )-\.'     3 3s`E(1AG E5G(E25 F=?FF8 F5 F0+F80F55F88F==GG c0|jD]}yy)NTF)_iter_reader_entries)rprs rIrzSoftReadWriteLock._any_readerss **, A rXc#K|jWtj|j5}|D](}t|jr|jdf* dddyt |j j}tj|5}|D]4}t|jrt||jz df6 dddy#1swYyxYw#1swYyxYww)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) rkr<scandir_is_housekeeping_namerrrfr^r)rpitentryrs rIrz&SoftReadWriteLock._iter_reader_entriess    +D001 /R/E0<#jj$../ / DKK//0 ZZ % @ @,UZZ8lUZZ78%?? @ @ @  /  @ @s@,C6C C=C6C*6C* C6C'#C6*C3/C6cg} |jD]&\}}|j||r |jndf( |D]\}}t ||j || y#t$rYywxYw)N)r4rr)rappendrkrrr4)rprnamesrdirfd_relativers rIrz&SoftReadWriteLock._break_stale_readerss.0 (,(A(A(C W$n dND$8$8PTUV W `HD" d6J6JPS\^ _ `   s9A"" A.-A.c|jj5|j}| dddy|j}|j}|j r |j nd}ddd t} t|}t|}| tj|js tj|yt!t5t#||ddd tj|y#1swYxYw#t$rYyt$rYywxYw#t$rYtj|ywxYw#1swYixYw#tj|wxYw)NFrTr)rjrarmrrrrk_open_marker_fdFileNotFoundErrorr_read_marker_fdr<rrrrrr)rprrrrrrrs rIrz!SoftReadWriteLock._refresh_markersM [[ ! ! F::D| F F**KJJE-1^^T))F  F  V [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 pid irhostname)rr4r6) lenrdecodeUnicodeDecodeErrorrematchVERBOSEint _MarkerInfo)rtextr;r4s rIrrs 3t9//{{7# HH    E } eElB C Y U7^uZ?P QQ' sA99 BBctt5tr|tj||nt |j dddy#1swYyxYwr.)rrr$r<unlinkrr1s rIrr5sF # $  2 IId6 * J       s :AAc(t||x}y|\}}||z |kry|t||y|tdtjdt j d} tr|tj||||nt|j|t||}|y|\} } | t||ytj|j| jsy| |kDryt||y#t$rYywxYw)NrFTrr) src_dir_fd dst_dir_fd)rrrr<r=rrr$renamerrrrr) rr4rr read_result info_before mtime_before break_name read_after info_after mtime_afters rIrr>s"$D88 A +K \_,V$6-"))+a8I8I"8M7NOJ  2 IIdJ6f M J  j )j8J(J  6*   {00*2B2B C\! Jv&  s%EF. WWT5% 7 WWT5% ((,H  XXb\99bii'"r"))+b1C1C1E0FbIPPQXYZ     JtXf$M D ( s 6A5D=D>c tr|tj||ntj|}|j|j f|k(S#t$rYywxYw)NrF)r$r<rrrRrS)rrXrrs rIrWrWs[.>6CURXXd6 *[][c[cdh[i IIryy !X -- s4A AAc tj|}tj|j S#t$rYywxYwr)r<rrrr*r)pathrs rIrrs= XXd^ << ## s6 AAc8|jdxst|vS)Nr) startswithr)rs rIrrs ??3  8=D#88rXT)frozenc,eZdZUded<ded<ded<y)rerr]rr^NrRrSrTrUrrXrIreres J J LrXrec,eZdZUded<ded<ded<y)rgr&rarbrr]Nr`rrXrIrgrgs rXrgc,eZdZUded<ded<ded<y)r>rrr=r4r6Nr`rrXrIr>r>s J HMrXr>cbeZdZUdZded<ded<ded<ded <d ed <ded <d ed<ded<y)rzYEverything that exists only while a lock is held; ``None`` when the instance has no lock.r=rrr int | NonerrrrNrrrrr'rN)rRrSrTrrUrrXrIrrs1c J KO J&&##rXrcttjD],}tt5|j dddd.y#1swY9xYw)NTr)listr%valuesr Exceptionrz)rEs rI_cleanup_all_instancesrisR..01) i  )   4  ( ) )) ) )s AA )rrrrdrPz'tuple[_MarkerInfo | None, float] | None)rr=rPbytes)rrrrdrPr=)rrrrdrPrd)rrjrPz_MarkerInfo | None)rrrrdrPr) rrr4rMrrMrrdrPrN)rrrrrrdrPr)rrrXztuple[int, int]rrdrPrN)r[rrPrN)rrrPrNr)Vr __future__ratexitrr<r:rrTrsysrhrr contextlibrr dataclassesrpathlibrtypingrr r weakrefr filelock._apir r rrrrrrfilelock._errorrfilelock._softrfilelock._utilrrrcollections.abcrrrrrUrrr r"platformrsupports_dir_fdr$r%rir'rr(typer*rQThreadrrrrrrrrrrWrrrergr>rriregister__all__rrXrIr~sS`"   /!00'   $'DD3  $ z$#*#!"lA6 Z6!"lA6 Z6!$  7 YBGGrGYGY