oslo_concurrency.lockutils
¶
-
class
oslo_concurrency.lockutils.
Semaphores
¶ Bases:
object
A garbage collected container of semaphores.
This collection internally uses a weak value dictionary so that when a semaphore is no longer in use (by any threads) it will automatically be removed from this container by the garbage collector.
-
get
(name)¶ Gets (or creates) a semaphore with a given name.
Parameters: name – The semaphore name to get/create (used to associate previously created names with the same semaphore). Returns an newly constructed semaphore (or an existing one if it was already created for the given name).
-
-
oslo_concurrency.lockutils.
external_lock
(name, lock_file_prefix=None, lock_path=None)¶
-
oslo_concurrency.lockutils.
get_lock_path
(conf)¶ Return the path used for external file-based locks.
Parameters: conf (oslo_config.cfg.ConfigOpts) – Configuration object
-
oslo_concurrency.lockutils.
internal_lock
(name, semaphores=None)¶
-
oslo_concurrency.lockutils.
lock
(*args, **kwds)¶ Context based lock
This function yields a threading.Semaphore instance (if we don’t use eventlet.monkey_patch(), else semaphore.Semaphore) unless external is True, in which case, it’ll yield an InterProcessLock instance.
Parameters: - lock_file_prefix – The lock_file_prefix argument is used to provide lock files on disk with a meaningful prefix.
- external – The external keyword argument denotes whether this lock should work across multiple processes. This means that if two different workers both run a method decorated with @synchronized(‘mylock’, external=True), only one of them will execute at a time.
- lock_path – The path in which to store external lock files. For external locking to work properly, this must be the same for all references to the lock.
- do_log – Whether to log acquire/release messages. This is primarily intended to reduce log message duplication when lock is used from the synchronized decorator.
- semaphores – Container that provides semaphores to use when locking. This ensures that threads inside the same application can not collide, due to the fact that external process locks are unaware of a processes active threads.
- delay – Delay between acquisition attempts (in seconds).
-
oslo_concurrency.lockutils.
main
()¶
-
oslo_concurrency.lockutils.
remove_external_lock_file
(name, lock_file_prefix=None, lock_path=None, semaphores=None)¶ Remove an external lock file when it’s not used anymore This will be helpful when we have a lot of lock files
-
oslo_concurrency.lockutils.
set_defaults
(lock_path)¶ Set value for lock_path.
This can be used by tests to set lock_path to a temporary directory.
-
oslo_concurrency.lockutils.
synchronized
(name, lock_file_prefix=None, external=False, lock_path=None, semaphores=None, delay=0.01)¶ Synchronization decorator.
Decorating a method like so:
@synchronized('mylock') def foo(self, *args): ...
ensures that only one thread will execute the foo method at a time.
Different methods can share the same lock:
@synchronized('mylock') def foo(self, *args): ... @synchronized('mylock') def bar(self, *args): ...
This way only one of either foo or bar can be executing at a time.
-
oslo_concurrency.lockutils.
synchronized_with_prefix
(lock_file_prefix)¶ Partial object generator for the synchronization decorator.
Redefine @synchronized in each project like so:
(in nova/utils.py) from nova.openstack.common import lockutils synchronized = lockutils.synchronized_with_prefix('nova-') (in nova/foo.py) from nova import utils @utils.synchronized('mylock') def bar(self, *args): ...
The lock_file_prefix argument is used to provide lock files on disk with a meaningful prefix.