"j5 d Z ddlZddlZddlZddlmZ ddlmZmZm Z m
Z
ddl m Z dZ
ej d Z G d d Z G d
d e Zy) au
Implements two storage providers for `LockManager`.
Two alternative lock storage classes are defined here: one in-memory
(dict-based), and one persistent low performance variant using shelve.
See :class:`~wsgidav.lock_man.lock_manager.LockManager`
See :class:`~wsgidav.lock_man.lock_storage.LockStorageDict`
See :class:`~wsgidav.lock_man.lock_storage.LockStorageShelve`
N)util)generate_lock_token lock_stringnormalize_lock_root
validate_lock)
ReadWriteLockreStructuredTextzwsgidav.lock_manc ` e Zd ZdZdZdZd Zd Zd Zd Z d Z
d Z d
Z d Z
d Zd
Zd Zd Zy)LockStorageDictaq
An in-memory lock manager storage implementation using a dictionary.
R/W access is guarded by a thread.lock object.
Also, to make it work with a Shelve dictionary, modifying dictionary
members is done by re-assignment and we call a _flush() method.
This is obviously not persistent, but should be enough in some cases.
For a persistent implementation, see lock_storage.LockStorageShelve().
Notes:
expire is stored as expiration date in seconds since epoch (not in
seconds until expiration).
The dictionary is built like::
{ 'URL2TOKEN:/temp/litmus/lockme': ['opaquelocktoken:0x1d7b86...',
'opaquelocktoken:0xd7d4c0...'],
'opaquelocktoken:0x1d7b86...': {
'depth': '0',
'owner': "\n"
+ "litmus test suite\n",
'principal': 'tester',
'root': '/temp/litmus/lockme',
'scope': 'shared',
'expire': 1261328382.4530001,
'token': 'opaquelocktoken:0x1d7b86...',
'type': 'write',
},
'opaquelocktoken:0xd7d4c0...': {
'depth': '0',
'owner': '\n'
+ 'litmus: notowner_sharedlock\n',
'principal': 'tester',
'root': '/temp/litmus/lockme',
'scope': 'shared',
'expire': 1261328381.6040001,
'token': 'opaquelocktoken:0xd7d4c0...',
'type': 'write'
},
}
i: i $ c 0 d | _ t | _ y N)_dictr _lockselfs L/srv/dav/.venv/lib/python3.12/site-packages/wsgidav/lock_man/lock_storage.py__init__zLockStorageDict.__init__b s
"_
c . | j j S r
) __class____name__r s r __repr__zLockStorageDict.__repr__f s ~~&&&r c y)z$Overloaded by Shelve implementation.N r s r _flushzLockStorageDict._flushl r c . | j J i | _ y)zVCalled before first use.
May be implemented to initialize a storage.
Nr r s r openzLockStorageDict.openp s
zz!!!
r c d| _ y)zCalled on shutdown.Nr r s r closezLockStorageDict.closex s
r c y)z Purge expired locks (optional).Nr r s r cleanupzLockStorageDict.cleanup| r r c R | j | j j yyzDelete all entries.N)r clearr s r r& zLockStorageDict.clear s! :: ! JJ "r c h | j j | j j | }|Et j d| | j
| | j j yt |d }|dk\ rh|t j k rQt j d| dt | | j
| | j j y|| j j S # | j j w xY w)a# Return a lock dictionary for a token.
If the lock does not exist or is expired, None is returned.
token:
lock token
Returns:
Lock dictionary or
Side effect: if lock is expired, it will be purged and None is returned.
NzLock purged dangling: expirer zLock timed-out(): ) r acquire_readr get_loggerdebugdeletereleasefloattimer )r tokenlockr( s r r+ zLockStorageDict.get s
! !::>>%(D|
6ug >? E"
JJ 4>*F{v 3
xs;t;L:M NO E"
JJ JJ DJJ s AD >A D 9D D1c | j j |j d J |j d J d |rd|v sJ |}t | }||d< t |j d }|t
j }n(|dk s|t
j kD rt
j }||d< t j |z |d< t | t }||d< || j |< d| }|| j vr|g| j |< n/| j | }|j | || j |< | j t j d |d
t! | || j j# S # | j j# w xY w) a Create a direct lock for a resource path.
path:
Normalized path (utf8 encoded string, no trailing '/')
lock:
lock dictionary, without a token entry
Returns:
New unique lock token.:
- lock['timeout'] may be normalized and shorter than requested
- lock['token'] is added
r2 r( z Use timeout instead of expire/roottimeoutr
URL2TOKEN:zLockStorageDict.set(r) )r
acquire_writer+ r r0 r LOCK_TIME_OUT_DEFAULTLOCK_TIME_OUT_MAXr1 r r r appendr r, r- r r/ )r pathr3 org_pathr7 r2 keytokLists r createzLockStorageDict.create s
"+ !88G$, ,,88H%- N/N N-C4K '' H&t,D DL DHHY /0G)??1/*K*K K);; %DO !YY[7 2DN $ ')E !DM !%DJJu tf%C$**$#('
3 **S/u%")
3 KKM MM 0 C D@Q?RS T JJ DJJ s E*F! ! F=c || j v sJ d |dk( s|dkD sJ |dk s|t j kD rt j }| j j | j | }||d< t j
|z |d< || j |< | j
| j j |S # | j j w xY w)aM Modify an existing lock's timeout.
token:
Valid lock token.
timeout:
Suggested lifetime in seconds (-1 for infinite).
The real expiration time may be shorter than requested!
Returns:
Lock dictionary.
Raises ValueError, if token is invalid.
zLock must existr r7 r( )r r r; r r9 r1 r r/ )r r2 r7 r3 s r refreshzLockStorageDict.refresh s
"5$55""}! ++ Q;'O$E$EE%77G
" ! ::e$D %DO !YY[7 2DN $DJJu KKM JJ
JJ s
%A
C C*c | j j | j j | }t j dt
| | | j j ydj |j d }|| j v rK| j | }t | dkD r!|j | || j |< n
| j |= | j |= | j | j j y# | j j w xY w)zfDelete lock.
Returns True on success. False, if token does not exist, or is expired.
zdelete Fz URL2TOKEN:{}r6 T) r r9 r r+ r, r- r r/ formatlenremover )r r2 r3 r? r@ s r r. zLockStorageDict.delete s
" !::>>%(D MMGK$5#67 8| $
JJ ! !''(89Cdjj **S/wD' 6BD' ' Ec
t j | sJ |r|j d sJ |s|sJ
fd}t | } j j d| } j j |g }g
|r || |rA j j D ]$ \ }} t j || s || &
j j S # j j w xY w)aw Return a list of direct locks for .
Expired locks are *not* returned (but may be purged).
path:
Normalized path (utf8 encoded string, no trailing '/')
include_root:
False: don't add lock (only makes sense, when include_children
is True).
include_children:
True: Also check all sub-paths for existing locks.
token_only:
True: only a list of token is returned. This may be implemented
more efficiently by some providers.
Returns:
List of valid lock dictionaries (may be empty).
r5 c | D ]> }j | }|srj |d .j | @ y )Nr2 )r+ r< )toklistr2 r3 lockListr
token_onlys r
__appendLocksz4LockStorageDict.get_lock_list..__appendLocks3 sC !
.xx! W
6 -
.r r8 ) r is_str
startswithr r r* r r+ items is_child_urir/ ) r r= include_rootinclude_childrenrN _LockStorageDict__appendLocksr? r@ ultoksrM s ` ` @r
get_lock_listz LockStorageDict.get_lock_list s $ {{4 ,,, /// . #4(
! ! tf%CjjnnS"-GH g& $
0 0 2 -HAu((a0%e,- JJ DJJ s #A%C/ C/ / D N)r
__module__ __qualname____doc__r: r; r r r r r! r# r& r+ rA rD r. rY r r r r r 2 sS *X #"%'
!:<!| < >1!r r c @ e Zd ZdZ fdZd Zd Zd Zd Zd Z xZ
S )LockStorageShelvezE
A low performance lock manager implementation using shelve.
c j t | t j j | | _ y r
)superr osr= abspath
_storage_path)r storage_pathr s r r zLockStorageShelve.__init__[ s#
WW__\ :r c " d| j dS )NzLockStorageShelve())rc r s r r zLockStorageShelve.__repr___ s #D$6$6#9;;r c
t j d | j j | j j | j j
y# | j j
w xY w)z$Write persistent dictionary to disc.z_flush()N)r, r- r r9 r syncr/ r s r r zLockStorageShelve._flushb sR
j!
" ! JJOO JJ DJJ s A& & Bc | j j | j du }|r| j t | j r4| j j | j j
|r| j | j j y# | j j w xY wr% ) r r9 r r rH r& rh r! r/ )r
was_closeds r r& zLockStorageShelve.cleark s
"
! t+J 4::
"
!
JJ DJJ s A;B2 2 Cc t j d| j d t j | j d | _ y )Nzopen(rf F) writeback)r, r- rc shelver r r s r r zLockStorageShelve.openz s8
d 0 0 3156 [[!3!3uE
r c 0 t j d | j j | j !| j j d | _ | j j
y # | j j
w xY w)Nzclose())r, r- r r9 r r! r/ r s r r! zLockStorageShelve.close se
i
" !zz%
" !
JJ DJJ s -A9 9 B) r rZ r[ r\ r r r r& r r!
__classcell__)r s @r r^ r^ V s' ;<!
! F!r r^ )r\ ra rm r1 wsgidavr wsgidav.lock_man.lock_managerr r r r wsgidav.rw_lockr
__docformat__get_module_loggerr, r r^ r r r ru sZ
*"
!$
!3
4$\! \!H 6! 6!r