class NameLock(object):
"""a proxy for an RLock object that is stored in a name based
registry.
Multiple threads can get a reference to the same RLock based on the
name alone, and synchronize operations related to that name.
"""
locks = util.WeakValuedRegistry()
class NLContainer(object):
def __init__(self, reentrant):
if reentrant:
self.lock = _threading.RLock()
else:
self.lock = _threading.Lock()
def __call__(self):
return self.lock
def __init__(self, identifier=None, reentrant=False):
if identifier is None:
self._lock = NameLock.NLContainer(reentrant)
else:
self._lock = NameLock.locks.get(identifier, NameLock.NLContainer,
reentrant)
def acquire(self, wait=True):
return self._lock().acquire(wait)
def release(self):
self._lock().release()
class Synchronizer(object):
"""a read-many/single-writer synchronizer which globally synchronizes on a given string name."""
conditions = util.WeakValuedRegistry()
def __init__(self,
identifier=None,
use_files=False,
lock_dir=None,
digest_filenames=True):
if not has_flock:
use_files = False
if use_files:
syncs = Synchronizer.conditions.sync_get(
"file_%s" % identifier,
lambda: util.ThreadLocal(creator=lambda: FileSynchronizer(
identifier, lock_dir, digest_filenames)))
self._get_impl = lambda: syncs.get()
else:
condition = Synchronizer.conditions.sync_get(
"condition_%s" % identifier,
lambda: ConditionSynchronizer(identifier))
self._get_impl = lambda: condition
def release_read_lock(self):
self._get_impl().release_read_lock()
def acquire_read_lock(self, wait=True):
return self._get_impl().acquire_read_lock(wait=wait)
def acquire_write_lock(self, wait=True):
return self._get_impl().acquire_write_lock(wait=wait)
def release_write_lock(self):
self._get_impl().release_write_lock()
def __init__(self, identifier=None, reentrant=False):
if identifier is None:
self._lock = NameLock.NLContainer(reentrant)
else:
self._lock = NameLock.locks.get(identifier, NameLock.NLContainer,
reentrant)
def acquire(self, wait=True):
return self._lock().acquire(wait)
def release(self):
self._lock().release()
_synchronizers = util.WeakValuedRegistry()
def _synchronizer(identifier, cls, **kwargs):
return _synchronizers.sync_get((identifier, cls), cls, identifier,
**kwargs)
def file_synchronizer(identifier, **kwargs):
if not has_flock or 'lock_dir' not in kwargs:
return mutex_synchronizer(identifier)
else:
return _synchronizer(identifier, FileSynchronizer, **kwargs)
def mutex_synchronizer(identifier, **kwargs):
