automatic import of python-mongolockopeneuler20.03

3 files changed, 296 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..28fade7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/mongolock-1.3.4.tar.gz
diff --git a/python-mongolock.spec b/python-mongolock.spec
new file mode 100644
index 0000000..f375717
--- /dev/null
+++ b/python-mongolock.spec
@@ -0,0 +1,294 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-mongolock
+Version:	1.3.4
+Release:	1
+Summary:	Python Mongodb based Distributed Lock
+License:	BSD
+URL:		https://github.com/lorehov/mongolock
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/7b/41/07ce80317f0d4a9ac14900002246b432584e428ad507825714df37460973/mongolock-1.3.4.tar.gz
+BuildArch:	noarch
+
+
+%description
+# Usage
+
+    from mongolock import MongoLock
+
+    lock = MongoLock()
+
+    # you can use it as context:
+    # (if lock is already taken by another worker, MongoLockLocked will be raised)
+    with lock('key', 'my_worker_name', expire=60, timeout=10):
+       # some work here
+
+    # or simply by calling methods:
+    if lock.lock('key', 'my_worker_name'):
+        try:
+            # some useful work
+        finally:
+            lock.release('key', 'my_worker_name')
+
+    # you can also renew lock by touching it:
+    with lock('key', 'my_worker_name', expire=60, timeout=10):
+       # some looong looong work here
+       lock.touch('key', 'my_worker_name')
+
+Parameters in `lock` method:
+
+  * `key` - name of task to lock
+  * `owner` - name of worker which takes a lock
+  * `expire` (optional) - duration in seconds after which lock can be stealed
+  * `timeout` (optional) - how long we can wait for a lock (in seconds)
+
+# Configuration nuances
+
+You can configure connection either by specifying connection string,
+
+    lock = MongoLock('localhost:27017')
+
+or by passing configured instance of MongoClient/MongoReplicaSetClient in MongoLock constructor:
+
+    client = MongoClient('localhost:27017')
+    lock = MongoLock(client=client)
+
+The second is preferred, as in such a way you can perform more fine grained configuration:
+
+  * use MongoReplicaSetClient
+  * specify write concern
+  * specify tags
+  * etc
+
+# Important things to think about
+
+#### Lock stealing and releasing
+
+You should use unique names for all your workers, if you don't - some strange things may happen.
+Consider following sequence:
+
+  * worker1 and worker2 has the same names: worker
+  * worker1 achieves lock with expire +30s
+  * worker2 tries to get lock after 30s (worker1 is still working)
+  * as lock expires, worker2 steals it
+  * now worker1 ends his work and releases lock, as they has same names - lock is released
+  * worker3 takes a lock, while worker2 is still working ...
+
+#### Lock simply doesn't work
+
+If you use cron (or some analogue) to launch tasks on different machines, take in account time drift between machines as well
+  as duration of critical section of your tasks.
+
+  * machine1 and machine2 have a time drift 5s
+  * worker on machine1 takes a lock on TaskA
+  * worker on machine1 done a TaskA in 1s
+  * now worker on machine2 comes in play
+  * it doesn't know that worker on machine1 have already completed TaskA
+  * it takes a lock on TaskA (without problem as lock was released 4s before) and do it
+
+To prevent such a weird situation, you can simply add some part of time (for example YmdHM) to a key with task name.
+
+%package -n python3-mongolock
+Summary:	Python Mongodb based Distributed Lock
+Provides:	python-mongolock
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-mongolock
+# Usage
+
+    from mongolock import MongoLock
+
+    lock = MongoLock()
+
+    # you can use it as context:
+    # (if lock is already taken by another worker, MongoLockLocked will be raised)
+    with lock('key', 'my_worker_name', expire=60, timeout=10):
+       # some work here
+
+    # or simply by calling methods:
+    if lock.lock('key', 'my_worker_name'):
+        try:
+            # some useful work
+        finally:
+            lock.release('key', 'my_worker_name')
+
+    # you can also renew lock by touching it:
+    with lock('key', 'my_worker_name', expire=60, timeout=10):
+       # some looong looong work here
+       lock.touch('key', 'my_worker_name')
+
+Parameters in `lock` method:
+
+  * `key` - name of task to lock
+  * `owner` - name of worker which takes a lock
+  * `expire` (optional) - duration in seconds after which lock can be stealed
+  * `timeout` (optional) - how long we can wait for a lock (in seconds)
+
+# Configuration nuances
+
+You can configure connection either by specifying connection string,
+
+    lock = MongoLock('localhost:27017')
+
+or by passing configured instance of MongoClient/MongoReplicaSetClient in MongoLock constructor:
+
+    client = MongoClient('localhost:27017')
+    lock = MongoLock(client=client)
+
+The second is preferred, as in such a way you can perform more fine grained configuration:
+
+  * use MongoReplicaSetClient
+  * specify write concern
+  * specify tags
+  * etc
+
+# Important things to think about
+
+#### Lock stealing and releasing
+
+You should use unique names for all your workers, if you don't - some strange things may happen.
+Consider following sequence:
+
+  * worker1 and worker2 has the same names: worker
+  * worker1 achieves lock with expire +30s
+  * worker2 tries to get lock after 30s (worker1 is still working)
+  * as lock expires, worker2 steals it
+  * now worker1 ends his work and releases lock, as they has same names - lock is released
+  * worker3 takes a lock, while worker2 is still working ...
+
+#### Lock simply doesn't work
+
+If you use cron (or some analogue) to launch tasks on different machines, take in account time drift between machines as well
+  as duration of critical section of your tasks.
+
+  * machine1 and machine2 have a time drift 5s
+  * worker on machine1 takes a lock on TaskA
+  * worker on machine1 done a TaskA in 1s
+  * now worker on machine2 comes in play
+  * it doesn't know that worker on machine1 have already completed TaskA
+  * it takes a lock on TaskA (without problem as lock was released 4s before) and do it
+
+To prevent such a weird situation, you can simply add some part of time (for example YmdHM) to a key with task name.
+
+%package help
+Summary:	Development documents and examples for mongolock
+Provides:	python3-mongolock-doc
+%description help
+# Usage
+
+    from mongolock import MongoLock
+
+    lock = MongoLock()
+
+    # you can use it as context:
+    # (if lock is already taken by another worker, MongoLockLocked will be raised)
+    with lock('key', 'my_worker_name', expire=60, timeout=10):
+       # some work here
+
+    # or simply by calling methods:
+    if lock.lock('key', 'my_worker_name'):
+        try:
+            # some useful work
+        finally:
+            lock.release('key', 'my_worker_name')
+
+    # you can also renew lock by touching it:
+    with lock('key', 'my_worker_name', expire=60, timeout=10):
+       # some looong looong work here
+       lock.touch('key', 'my_worker_name')
+
+Parameters in `lock` method:
+
+  * `key` - name of task to lock
+  * `owner` - name of worker which takes a lock
+  * `expire` (optional) - duration in seconds after which lock can be stealed
+  * `timeout` (optional) - how long we can wait for a lock (in seconds)
+
+# Configuration nuances
+
+You can configure connection either by specifying connection string,
+
+    lock = MongoLock('localhost:27017')
+
+or by passing configured instance of MongoClient/MongoReplicaSetClient in MongoLock constructor:
+
+    client = MongoClient('localhost:27017')
+    lock = MongoLock(client=client)
+
+The second is preferred, as in such a way you can perform more fine grained configuration:
+
+  * use MongoReplicaSetClient
+  * specify write concern
+  * specify tags
+  * etc
+
+# Important things to think about
+
+#### Lock stealing and releasing
+
+You should use unique names for all your workers, if you don't - some strange things may happen.
+Consider following sequence:
+
+  * worker1 and worker2 has the same names: worker
+  * worker1 achieves lock with expire +30s
+  * worker2 tries to get lock after 30s (worker1 is still working)
+  * as lock expires, worker2 steals it
+  * now worker1 ends his work and releases lock, as they has same names - lock is released
+  * worker3 takes a lock, while worker2 is still working ...
+
+#### Lock simply doesn't work
+
+If you use cron (or some analogue) to launch tasks on different machines, take in account time drift between machines as well
+  as duration of critical section of your tasks.
+
+  * machine1 and machine2 have a time drift 5s
+  * worker on machine1 takes a lock on TaskA
+  * worker on machine1 done a TaskA in 1s
+  * now worker on machine2 comes in play
+  * it doesn't know that worker on machine1 have already completed TaskA
+  * it takes a lock on TaskA (without problem as lock was released 4s before) and do it
+
+To prevent such a weird situation, you can simply add some part of time (for example YmdHM) to a key with task name.
+
+%prep
+%autosetup -n mongolock-1.3.4
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-mongolock -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Wed May 10 2023 Python_Bot <Python_Bot@openeuler.org> - 1.3.4-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..fe674b4
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+69a09be87a1d3b9493023116ea6eec96  mongolock-1.3.4.tar.gz