release: Merge default into stable for release preparation

.bumpversion.cfg

@@ -1,6 +1,5 b''
 [bumpversion]
-current_version = 4.25.2
+current_version = 4.26.0
 message = release: Bump version {current_version} to {new_version}
 
 [bumpversion:file:vcsserver/VERSION]
-

.release.cfg

@@ -5,12 +5,10 b' done = false'
 done = true
 
 [task:fixes_on_stable]
-done = true
 
 [task:pip2nix_generated]
-done = true
 
 [release]
-state = prepared
-version = 4.25.2
+state = in_progress
+version = 4.26.0
 

configs/development.ini

@@ -191,6 +191,9 b' rc_cache.repo_object.expiration_time = 2'
 ; more Redis options: https://dogpilecache.sqlalchemy.org/en/latest/api.html#redis-backends
 #rc_cache.repo_object.arguments.distributed_lock = true
 
+; auto-renew lock to prevent stale locks, slower but safer. Use only if problems happen
+#rc_cache.repo_object.arguments.lock_auto_renewal = true
+
 ; Statsd client config
 #statsd.enabled = false
 #statsd.statsd_host = 0.0.0.0

configs/production.ini

@@ -154,6 +154,9 b' rc_cache.repo_object.expiration_time = 2'
 ; more Redis options: https://dogpilecache.sqlalchemy.org/en/latest/api.html#redis-backends
 #rc_cache.repo_object.arguments.distributed_lock = true
 
+; auto-renew lock to prevent stale locks, slower but safer. Use only if problems happen
+#rc_cache.repo_object.arguments.lock_auto_renewal = true
+
 ; Statsd client config
 #statsd.enabled = false
 #statsd.statsd_host = 0.0.0.0

pkgs/python-packages.nix

@@ -784,7 +784,7 b' self: super: {'
     };
   };
   "rhodecode-vcsserver" = super.buildPythonPackage {
-    name = "rhodecode-vcsserver-4.25.2";
+    name = "rhodecode-vcsserver-4.26.0";
     buildInputs = [
       self."pytest"
       self."py"

vcsserver/VERSION

@@ -1,1 +1,1 b''
-4.25.2
  No newline at end of file
+4.26.0
  No newline at end of file

vcsserver/lib/rc_cache/backends.py

@@ -29,6 +29,8 b' from dogpile.cache.backends import redis'
 from dogpile.cache.backends.file import NO_VALUE, compat, FileLock
 from dogpile.cache.util import memoized_property
 
+from pyramid.settings import asbool
+
 from vcsserver.lib.memory_lru_dict import LRUDict, LRUDictDebug
 
 
@@ -189,6 +191,16 b' class FileNamespaceBackend(PickleSeriali'
 
 
 class BaseRedisBackend(redis_backend.RedisBackend):
+    key_prefix = ''
+
+    def __init__(self, arguments):
+        super(BaseRedisBackend, self).__init__(arguments)
+        self._lock_timeout = self.lock_timeout
+        self._lock_auto_renewal = asbool(arguments.pop("lock_auto_renewal", True))
+
+        if self._lock_auto_renewal and not self._lock_timeout:
+            # set default timeout for auto_renewal
+            self._lock_timeout = 30
 
     def _create_client(self):
         args = {}
@@ -254,14 +266,8 b' class BaseRedisBackend(redis_backend.Red'
         if self.distributed_lock:
             lock_key = redis_backend.u('_lock_{0}').format(key)
             log.debug('Trying to acquire Redis lock for key %s', lock_key)
-
-            auto_renewal = True
-            lock_timeout = self.lock_timeout
-            if auto_renewal and not self.lock_timeout:
-                # set default timeout for auto_renewal
-                lock_timeout = 10
-            return get_mutex_lock(self.client, lock_key, lock_timeout,
-                                  auto_renewal=auto_renewal)
+            return get_mutex_lock(self.client, lock_key, self._lock_timeout,
+                                  auto_renewal=self._lock_auto_renewal)
         else:
             return None
 
@@ -282,11 +288,8 b' def get_mutex_lock(client, lock_key, loc'
     class _RedisLockWrapper(object):
         """LockWrapper for redis_lock"""
 
-        def __init__(self):
-            pass
-
-        @property
-        def lock(self):
+        @classmethod
+        def get_lock(cls):
             return redis_lock.Lock(
                 redis_client=client,
                 name=lock_key,
@@ -295,8 +298,17 b' def get_mutex_lock(client, lock_key, loc'
                 strict=True,
             )
 
+        def __init__(self):
+            self.lock = self.get_lock()
+
         def acquire(self, wait=True):
-            return self.lock.acquire(wait)
+            try:
+                return self.lock.acquire(wait)
+            except redis_lock.AlreadyAcquired:
+                return False
+            except redis_lock.AlreadyStarted:
+                # refresh thread exists, but it also means we acquired the lock
+                return True
 
         def release(self):
             try: