feature(caches): refactor how invalidationContext works, fixes many issues with the previousl solution

- much more simpler now
- no more key leak

rhodecode/lib/rc_cache/__init__.py

@@ -1,120 +1,119 b''
 # Copyright (C) 2015-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import threading
 
 from dogpile.cache import register_backend
 
 from . import region_meta
 from .utils import (
     ActiveRegionCache,
-    FreshRegionCache,
     InvalidationContext,
     backend_key_generator,
     clear_cache_namespace,
     get_default_cache_settings,
     get_or_create_region,
     make_region,
     str2bool,
 )
 
 module_name = 'rhodecode'
 
 register_backend(
     "dogpile.cache.rc.memory_lru", f"{module_name}.lib.rc_cache.backends",
     "LRUMemoryBackend")
 
 register_backend(
     "dogpile.cache.rc.file_namespace", f"{module_name}.lib.rc_cache.backends",
     "FileNamespaceBackend")
 
 register_backend(
     "dogpile.cache.rc.redis", f"{module_name}.lib.rc_cache.backends",
     "RedisPickleBackend")
 
 register_backend(
     "dogpile.cache.rc.redis_msgpack", f"{module_name}.lib.rc_cache.backends",
     "RedisMsgPackBackend")
 
 
 log = logging.getLogger(__name__)
 
 
 FILE_TREE_CACHE_VER = 'v5'
 LICENSE_CACHE_VER = 'v3'
 PERMISSIONS_CACHE_VER = 'v2'
 
 CLEAR_DELETE = 'delete'
 CLEAR_INVALIDATE = 'invalidate'
 
 
 def async_creation_runner(cache, cache_key, creator, mutex):
 
     def runner():
         try:
             value = creator()
             cache.set(cache_key, value)
         finally:
             mutex.release()
 
     thread = threading.Thread(target=runner)
     thread.start()
 
 
 def configure_dogpile_cache(settings):
     cache_dir = settings.get('cache_dir')
     if cache_dir:
         region_meta.dogpile_config_defaults['cache_dir'] = cache_dir
 
     rc_cache_data = get_default_cache_settings(settings, prefixes=['rc_cache.'])
 
     # inspect available namespaces
     avail_regions = set()
     for key in rc_cache_data.keys():
         namespace_name = key.split('.', 1)[0]
         if namespace_name in avail_regions:
             continue
 
         avail_regions.add(namespace_name)
         log.debug('dogpile: found following cache regions: %s', namespace_name)
 
         new_region = make_region(
             name=namespace_name,
             function_key_generator=None,
             async_creation_runner=None
         )
 
         new_region.configure_from_config(settings, f'rc_cache.{namespace_name}.')
         new_region.function_key_generator = backend_key_generator(new_region.actual_backend)
 
         async_creator = str2bool(settings.pop(f'rc_cache.{namespace_name}.async_creator', 'false'))
         if async_creator:
             log.debug('configuring region %s with async creator', new_region)
             new_region.async_creation_runner = async_creation_runner
 
         if log.isEnabledFor(logging.DEBUG):
             region_args = dict(backend=new_region.actual_backend,
                                region_invalidator=new_region.region_invalidator.__class__)
             log.debug('dogpile: registering a new region key=`%s` args=%s', namespace_name, region_args)
 
         region_meta.dogpile_cache_regions[namespace_name] = new_region
 
 
 def includeme(config):
     configure_dogpile_cache(config.registry.settings)

rhodecode/lib/rc_cache/utils.py

@@ -1,403 +1,358 b''
-# Copyright (C) 2015-2023 RhodeCode GmbH
+# Copyright (C) 2015-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import functools
 import logging
 import os
 import threading
 import time
 
 import decorator
 from dogpile.cache import CacheRegion
 
 import rhodecode
 from rhodecode.lib.hash_utils import sha1
 from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.lib.type_utils import str2bool # noqa :required by imports from .utils
 
 from . import region_meta
 
 log = logging.getLogger(__name__)
 
 
 def isCython(func):
     """
     Private helper that checks if a function is a cython function.
     """
     return func.__class__.__name__ == 'cython_function_or_method'
 
 
 class RhodeCodeCacheRegion(CacheRegion):
 
     def __repr__(self):
         return f'{self.__class__}(name={self.name})'
 
     def conditional_cache_on_arguments(
             self, namespace=None,
             expiration_time=None,
             should_cache_fn=None,
             to_str=str,
             function_key_generator=None,
             condition=True):
         """
         Custom conditional decorator, that will not touch any dogpile internals if
         condition isn't meet. This works a bit different from should_cache_fn
         And it's faster in cases we don't ever want to compute cached values
         """
         expiration_time_is_callable = callable(expiration_time)
         if not namespace:
             namespace = getattr(self, '_default_namespace', None)
 
         if function_key_generator is None:
             function_key_generator = self.function_key_generator
 
         def get_or_create_for_user_func(func_key_generator, user_func, *arg, **kw):
 
             if not condition:
                 log.debug('Calling un-cached method:%s', user_func.__name__)
                 start = time.time()
                 result = user_func(*arg, **kw)
                 total = time.time() - start
                 log.debug('un-cached method:%s took %.4fs', user_func.__name__, total)
                 return result
 
             key = func_key_generator(*arg, **kw)
 
             timeout = expiration_time() if expiration_time_is_callable \
                 else expiration_time
 
             log.debug('Calling cached method:`%s`', user_func.__name__)
             return self.get_or_create(key, user_func, timeout, should_cache_fn, (arg, kw))
 
         def cache_decorator(user_func):
             if to_str is str:
                 # backwards compatible
                 key_generator = function_key_generator(namespace, user_func)
             else:
                 key_generator = function_key_generator(namespace, user_func, to_str=to_str)
 
             def refresh(*arg, **kw):
                 """
                 Like invalidate, but regenerates the value instead
                 """
                 key = key_generator(*arg, **kw)
                 value = user_func(*arg, **kw)
                 self.set(key, value)
                 return value
 
             def invalidate(*arg, **kw):
                 key = key_generator(*arg, **kw)
                 self.delete(key)
 
             def set_(value, *arg, **kw):
                 key = key_generator(*arg, **kw)
                 self.set(key, value)
 
             def get(*arg, **kw):
                 key = key_generator(*arg, **kw)
                 return self.get(key)
 
             user_func.set = set_
             user_func.invalidate = invalidate
             user_func.get = get
             user_func.refresh = refresh
             user_func.key_generator = key_generator
             user_func.original = user_func
 
             # Use `decorate` to preserve the signature of :param:`user_func`.
             return decorator.decorate(user_func, functools.partial(
                 get_or_create_for_user_func, key_generator))
 
         return cache_decorator
 
 
 def make_region(*arg, **kw):
     return RhodeCodeCacheRegion(*arg, **kw)
 
 
 def get_default_cache_settings(settings, prefixes=None):
     prefixes = prefixes or []
     cache_settings = {}
     for key in settings.keys():
         for prefix in prefixes:
             if key.startswith(prefix):
                 name = key.split(prefix)[1].strip()
                 val = settings[key]
                 if isinstance(val, str):
                     val = val.strip()
                 cache_settings[name] = val
     return cache_settings
 
 
 def compute_key_from_params(*args):
     """
     Helper to compute key from given params to be used in cache manager
     """
     return sha1(safe_bytes("_".join(map(str, args))))
 
 
 def custom_key_generator(backend, namespace, fn):
     func_name = fn.__name__
 
     def generate_key(*args):
         backend_pref = getattr(backend, 'key_prefix', None) or 'backend_prefix'
         namespace_pref = namespace or 'default_namespace'
         arg_key = compute_key_from_params(*args)
         final_key = f"{backend_pref}:{namespace_pref}:{func_name}_{arg_key}"
 
         return final_key
 
     return generate_key
 
 
 def backend_key_generator(backend):
     """
     Special wrapper that also sends over the backend to the key generator
     """
     def wrapper(namespace, fn):
         return custom_key_generator(backend, namespace, fn)
     return wrapper
 
 
 def get_or_create_region(region_name, region_namespace: str = None, use_async_runner=False):
     from .backends import FileNamespaceBackend
     from . import async_creation_runner
 
     region_obj = region_meta.dogpile_cache_regions.get(region_name)
     if not region_obj:
         reg_keys = list(region_meta.dogpile_cache_regions.keys())
         raise OSError(f'Region `{region_name}` not in configured: {reg_keys}.')
 
     region_uid_name = f'{region_name}:{region_namespace}'
 
     # Special case for ONLY the FileNamespaceBackend backend. We register one-file-per-region
     if isinstance(region_obj.actual_backend, FileNamespaceBackend):
         if not region_namespace:
             raise ValueError(f'{FileNamespaceBackend} used requires to specify region_namespace param')
 
         region_exist = region_meta.dogpile_cache_regions.get(region_namespace)
         if region_exist:
             log.debug('Using already configured region: %s', region_namespace)
             return region_exist
 
         expiration_time = region_obj.expiration_time
 
         cache_dir = region_meta.dogpile_config_defaults['cache_dir']
         namespace_cache_dir = cache_dir
 
         # we default the namespace_cache_dir to our default cache dir.
         # however, if this backend is configured with filename= param, we prioritize that
         # so all caches within that particular region, even those namespaced end up in the same path
         if region_obj.actual_backend.filename:
             namespace_cache_dir = os.path.dirname(region_obj.actual_backend.filename)
 
         if not os.path.isdir(namespace_cache_dir):
             os.makedirs(namespace_cache_dir)
         new_region = make_region(
             name=region_uid_name,
             function_key_generator=backend_key_generator(region_obj.actual_backend)
         )
 
         namespace_filename = os.path.join(
             namespace_cache_dir, f"{region_name}_{region_namespace}.cache_db")
         # special type that allows 1db per namespace
         new_region.configure(
             backend='dogpile.cache.rc.file_namespace',
             expiration_time=expiration_time,
             arguments={"filename": namespace_filename}
         )
 
         # create and save in region caches
         log.debug('configuring new region: %s', region_uid_name)
         region_obj = region_meta.dogpile_cache_regions[region_namespace] = new_region
 
     region_obj._default_namespace = region_namespace
     if use_async_runner:
         region_obj.async_creation_runner = async_creation_runner
     return region_obj
 
 
 def clear_cache_namespace(cache_region: str | RhodeCodeCacheRegion, cache_namespace_uid: str, method: str) -> int:
     from . import CLEAR_DELETE, CLEAR_INVALIDATE
 
     if not isinstance(cache_region, RhodeCodeCacheRegion):
         cache_region = get_or_create_region(cache_region, cache_namespace_uid)
     log.debug('clearing cache region: %s [prefix:%s] with method=%s',
               cache_region, cache_namespace_uid, method)
 
     num_affected_keys = 0
 
     if method == CLEAR_INVALIDATE:
         # NOTE: The CacheRegion.invalidate() method’s default mode of
         # operation is to set a timestamp local to this CacheRegion in this Python process only.
         # It does not impact other Python processes or regions as the timestamp is only stored locally in memory.
         cache_region.invalidate(hard=True)
 
     if method == CLEAR_DELETE:
         num_affected_keys = cache_region.backend.delete_multi_by_prefix(prefix=cache_namespace_uid)
 
     return num_affected_keys
 
 
 class ActiveRegionCache(object):
-    def __init__(self, context, cache_data):
+    def __init__(self, context, cache_data: dict):
         self.context = context
         self.cache_data = cache_data
 
-    def should_invalidate(self):
-        return False
-
-
-class FreshRegionCache(object):
-    def __init__(self, context, cache_data):
-        self.context = context
-        self.cache_data = cache_data
-
-    def should_invalidate(self):
-        return True
+    @property
+    def state_uid(self) -> str:
+        return self.cache_data['cache_state_uid']
 
 
 class InvalidationContext(object):
     """
     usage::
 
         from rhodecode.lib import rc_cache
 
-        cache_namespace_uid = CacheKey.SOME_NAMESPACE.format(1)
-        region = rc_cache.get_or_create_region('some_region', cache_namespace_uid)
+        repo_namespace_key = 'some-cache-for-repo-id-100'
+        inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key)
+
+        def cache_generator(_state_uid):
 
-        @region.conditional_cache_on_arguments(namespace=cache_namespace_uid, condition=True)
-        def heavy_compute(cache_name, param1, param2):
-            print('COMPUTE {}, {}, {}'.format(cache_name, param1, param2))
-
-        # invalidation namespace is shared namespace key for all process caches
-        # we use it to send a global signal
-        invalidation_namespace = 'repo_cache:1'
+            @region.conditional_cache_on_arguments(namespace='some-common-namespace-100')
+            def _dummy_func(*args):
+                # compute heavy function
+                return _state_uid, 'result'
 
-        inv_context_manager = rc_cache.InvalidationContext(
-            uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
+            return _dummy_func
+
         with inv_context_manager as invalidation_context:
-            args = ('one', 'two')
-            # re-compute and store cache if we get invalidate signal
-            if invalidation_context.should_invalidate():
-                result = heavy_compute.refresh(*args)
-            else:
-                result = heavy_compute(*args)
+            cache_state_uid = invalidation_context.state_uid
+            cache_func = cache_generator(cache_state_uid)
+            previous_state_uid, result = cache_func(*call_args)
 
-            compute_time = inv_context_manager.compute_time
-            log.debug('result computed in %.4fs', compute_time)
+            should_invalidate = previous_state_uid != cache_state_uid
+            if should_invalidate:
+                _, result = cache_func.refresh(*call_args)
 
         # To send global invalidation signal, simply run
-        CacheKey.set_invalidate(invalidation_namespace)
+        CacheKey.set_invalidate(repo_namespace_key)
 
     """
 
     def __repr__(self):
-        return f'<InvalidationContext:{self.cache_key}[{self.uid}]>'
+        return f'<InvalidationContext:{self.cache_key}>'
 
-    def __init__(self, uid, invalidation_namespace='',
-                 raise_exception=False, thread_scoped=None):
-        self.uid = uid
-        self.invalidation_namespace = invalidation_namespace
+    def __init__(self, key, raise_exception=False, thread_scoped=None):
+        self.cache_key = key
+
         self.raise_exception = raise_exception
-        self.proc_id = rhodecode.CONFIG.get('instance_id') or 'DEFAULT'
+        self.proc_id = rhodecode.ConfigGet().get_str('instance_id') or 'DEFAULT'
         self.thread_id = 'global'
 
         if thread_scoped is None:
             # if we set "default" we can override this via .ini settings
             thread_scoped = rhodecode.ConfigGet().get_bool('cache_thread_scoped')
 
         # Append the thread id to the cache key if this invalidation context
         # should be scoped to the current thread.
         if thread_scoped is True:
             self.thread_id = threading.current_thread().ident
 
-        self.cache_key = compute_key_from_params(uid)
-        self.cache_key = 'proc:{}|thread:{}|params:{}'.format(
-            self.proc_id, self.thread_id, self.cache_key)
-        self.proc_key = f'proc:{self.proc_id}'
+        self.proc_key = f'proc:{self.proc_id}|thread:{self.thread_id}|key:{self.cache_key}'
         self.compute_time = 0
 
-    def get_or_create_cache_obj(self, cache_type, invalidation_namespace=''):
-        from rhodecode.model.db import CacheKey
+    def get_or_create_cache_obj(self):
+        from rhodecode.model.db import CacheKey, Session, IntegrityError
 
-        invalidation_namespace = invalidation_namespace or self.invalidation_namespace
-        # fetch all cache keys for this namespace and convert them to a map to find if we
-        # have specific cache_key object registered. We do this because we want to have
-        # all consistent cache_state_uid for newly registered objects
-        cache_obj_map = CacheKey.get_namespace_map(invalidation_namespace)
-        cache_obj = cache_obj_map.get(self.cache_key)
+        cache_obj = CacheKey.get_active_cache(self.cache_key)
         log.debug('Fetched cache obj %s using %s cache key.', cache_obj, self.cache_key)
 
         if not cache_obj:
-            new_cache_args = invalidation_namespace
-            first_cache_obj = next(iter(cache_obj_map.values())) if cache_obj_map else None
-            cache_state_uid = None
-            if first_cache_obj:
-                cache_state_uid = first_cache_obj.cache_state_uid
-            cache_obj = CacheKey(self.cache_key, cache_args=new_cache_args,
-                                 cache_state_uid=cache_state_uid)
-
-        return cache_obj
-
-    def __enter__(self):
-        """
-        Test if current object is valid, and return CacheRegion function
-        that does invalidation and calculation
-        """
-        log.debug('Entering cache invalidation check context: %s', self.invalidation_namespace)
-        # register or get a new key based on uid
-        self.cache_obj = self.get_or_create_cache_obj(cache_type=self.uid)
-        cache_data = self.cache_obj.get_dict()
-        self._start_time = time.time()
-        if self.cache_obj.cache_active:
-            # means our cache obj is existing and marked as it's
-            # cache is not outdated, we return ActiveRegionCache
-            self.skip_cache_active_change = True
-
-            return ActiveRegionCache(context=self, cache_data=cache_data)
-
-        # the key is either not existing or set to False, we return
-        # the real invalidator which re-computes value. We additionally set
-        # the flag to actually update the Database objects
-        self.skip_cache_active_change = False
-        return FreshRegionCache(context=self, cache_data=cache_data)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        from rhodecode.model.db import IntegrityError, Session
-
-        # save compute time
-        self.compute_time = time.time() - self._start_time
-
-        if self.skip_cache_active_change:
-            return
-
+            # generate new UID for non-existing cache object
+            cache_state_uid = CacheKey.generate_new_state_uid()
+            cache_obj = CacheKey(self.cache_key, cache_args=f'repo_state:{self._start_time}',
+                                 cache_state_uid=cache_state_uid, cache_active=True)
         try:
-            self.cache_obj.cache_active = True
-            Session().add(self.cache_obj)
+                Session().add(cache_obj)
             Session().commit()
         except IntegrityError:
             # if we catch integrity error, it means we inserted this object
             # assumption is that's really an edge race-condition case and
             # it's safe is to skip it
             Session().rollback()
         except Exception:
             log.exception('Failed to commit on cache key update')
             Session().rollback()
             if self.raise_exception:
                 raise
+        return cache_obj
+
+    def __enter__(self):
+        log.debug('Entering cache invalidation check context: %s', self)
+        self._start_time = time.time()
+
+        self.cache_obj = self.get_or_create_cache_obj()
+        cache_data = self.cache_obj.get_dict()
+
+        return ActiveRegionCache(context=self, cache_data=cache_data)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # save compute time
+        self.compute_time = time.time() - self._start_time

rhodecode/model/db.py

@@ -1,5877 +1,5886 b''
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Database Models for RhodeCode Enterprise
 """
 
 import re
 import os
 import time
 import string
 import logging
 import datetime
 import uuid
 import warnings
 import ipaddress
 import functools
 import traceback
 import collections
 
 from sqlalchemy import (
     or_, and_, not_, func, cast, TypeDecorator, event, select,
     true, false, null,
     Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
     Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
     Text, Float, PickleType, BigInteger)
 from sqlalchemy.sql.expression import case
 from sqlalchemy.sql.functions import coalesce, count  # pragma: no cover
 from sqlalchemy.orm import (
     relationship, lazyload, joinedload, class_mapper, validates, aliased, load_only)
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.exc import IntegrityError  # pragma: no cover
 from sqlalchemy.dialects.mysql import LONGTEXT
 from zope.cachedescriptors.property import Lazy as LazyProperty
 from pyramid.threadlocal import get_current_request
 from webhelpers2.text import remove_formatting
 
 from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.translation import _
 from rhodecode.lib.vcs import get_vcs_instance, VCSError
 from rhodecode.lib.vcs.backends.base import (
     EmptyCommit, Reference, unicode_to_reference, reference_to_unicode)
 from rhodecode.lib.utils2 import (
     str2bool, safe_str, get_commit_safe, sha1_safe,
     time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
     glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time)
 from rhodecode.lib.jsonalchemy import (
     MutationObj, MutationList, JsonType, JsonRaw)
 from rhodecode.lib.hash_utils import sha1
 from rhodecode.lib import ext_json
 from rhodecode.lib import enc_utils
 from rhodecode.lib.ext_json import json, str_json
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.exceptions import (
     ArtifactMetadataDuplicate, ArtifactMetadataBadValueType)
 from rhodecode.model.meta import Base, Session
 
 URL_SEP = '/'
 log = logging.getLogger(__name__)
 
 # =============================================================================
 # BASE CLASSES
 # =============================================================================
 
 # this is propagated from .ini file rhodecode.encrypted_values.secret or
 # beaker.session.secret if first is not set.
 # and initialized at environment.py
 ENCRYPTION_KEY: bytes = b''
 
 # used to sort permissions by types, '#' used here is not allowed to be in
 # usernames, and it's very early in sorted string.printable table.
 PERMISSION_TYPE_SORT = {
     'admin': '####',
     'write': '###',
     'read':  '##',
     'none':  '#',
 }
 
 
 def display_user_sort(obj):
     """
     Sort function used to sort permissions in .permissions() function of
     Repository, RepoGroup, UserGroup. Also it put the default user in front
     of all other resources
     """
 
     if obj.username == User.DEFAULT_USER:
         return '#####'
     prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
     extra_sort_num = '1'  # default
 
     # NOTE(dan): inactive duplicates goes last
     if getattr(obj, 'duplicate_perm', None):
         extra_sort_num = '9'
     return prefix + extra_sort_num + obj.username
 
 
 def display_user_group_sort(obj):
     """
     Sort function used to sort permissions in .permissions() function of
     Repository, RepoGroup, UserGroup. Also it put the default user in front
     of all other resources
     """
 
     prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
     return prefix + obj.users_group_name
 
 
 def _hash_key(k):
     return sha1_safe(k)
 
 
 def in_filter_generator(qry, items, limit=500):
     """
     Splits IN() into multiple with OR
     e.g.::
     cnt = Repository.query().filter(
         or_(
             *in_filter_generator(Repository.repo_id, range(100000))
         )).count()
     """
     if not items:
         # empty list will cause empty query which might cause security issues
         # this can lead to hidden unpleasant results
         items = [-1]
 
     parts = []
     for chunk in range(0, len(items), limit):
         parts.append(
             qry.in_(items[chunk: chunk + limit])
         )
 
     return parts
 
 
 base_table_args = {
     'extend_existing': True,
     'mysql_engine': 'InnoDB',
     'mysql_charset': 'utf8',
     'sqlite_autoincrement': True
 }
 
 
 class EncryptedTextValue(TypeDecorator):
     """
     Special column for encrypted long text data, use like::
 
         value = Column("encrypted_value", EncryptedValue(), nullable=False)
 
     This column is intelligent so if value is in unencrypted form it return
     unencrypted form, but on save it always encrypts
     """
     cache_ok = True
     impl = Text
 
     def process_bind_param(self, value, dialect):
         """
         Setter for storing value
         """
         import rhodecode
         if not value:
             return value
 
         # protect against double encrypting if values is already encrypted
         if value.startswith('enc$aes$') \
                 or value.startswith('enc$aes_hmac$') \
                 or value.startswith('enc2$'):
             raise ValueError('value needs to be in unencrypted format, '
                              'ie. not starting with enc$ or enc2$')
 
         algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes'
         bytes_val = enc_utils.encrypt_value(value, enc_key=ENCRYPTION_KEY, algo=algo)
         return safe_str(bytes_val)
 
     def process_result_value(self, value, dialect):
         """
         Getter for retrieving value
         """
 
         import rhodecode
         if not value:
             return value
 
         enc_strict_mode = rhodecode.ConfigGet().get_bool('rhodecode.encrypted_values.strict', missing=True)
 
         bytes_val = enc_utils.decrypt_value(value, enc_key=ENCRYPTION_KEY, strict_mode=enc_strict_mode)
 
         return safe_str(bytes_val)
 
 
 class BaseModel(object):
     """
     Base Model for all classes
     """
 
     @classmethod
     def _get_keys(cls):
         """return column names for this model """
         return class_mapper(cls).c.keys()
 
     def get_dict(self):
         """
         return dict with keys and values corresponding
         to this model data """
 
         d = {}
         for k in self._get_keys():
             d[k] = getattr(self, k)
 
         # also use __json__() if present to get additional fields
         _json_attr = getattr(self, '__json__', None)
         if _json_attr:
             # update with attributes from __json__
             if callable(_json_attr):
                 _json_attr = _json_attr()
             for k, val in _json_attr.items():
                 d[k] = val
         return d
 
     def get_appstruct(self):
         """return list with keys and values tuples corresponding
         to this model data """
 
         lst = []
         for k in self._get_keys():
             lst.append((k, getattr(self, k),))
         return lst
 
     def populate_obj(self, populate_dict):
         """populate model with data from given populate_dict"""
 
         for k in self._get_keys():
             if k in populate_dict:
                 setattr(self, k, populate_dict[k])
 
     @classmethod
     def query(cls):
         return Session().query(cls)
 
     @classmethod
     def select(cls, custom_cls=None):
         """
         stmt = cls.select().where(cls.user_id==1)
         # optionally
         stmt = cls.select(User.user_id).where(cls.user_id==1)
         result = cls.execute(stmt) | cls.scalars(stmt)
         """
 
         if custom_cls:
             stmt = select(custom_cls)
         else:
             stmt = select(cls)
         return stmt
 
     @classmethod
     def execute(cls, stmt):
         return Session().execute(stmt)
 
     @classmethod
     def scalars(cls, stmt):
         return Session().scalars(stmt)
 
     @classmethod
     def get(cls, id_):
         if id_:
             return cls.query().get(id_)
 
     @classmethod
     def get_or_404(cls, id_):
         from pyramid.httpexceptions import HTTPNotFound
 
         try:
             id_ = int(id_)
         except (TypeError, ValueError):
             raise HTTPNotFound()
 
         res = cls.query().get(id_)
         if not res:
             raise HTTPNotFound()
         return res
 
     @classmethod
     def getAll(cls):
         # deprecated and left for backward compatibility
         return cls.get_all()
 
     @classmethod
     def get_all(cls):
         return cls.query().all()
 
     @classmethod
     def delete(cls, id_):
         obj = cls.query().get(id_)
         Session().delete(obj)
 
     @classmethod
     def identity_cache(cls, session, attr_name, value):
         exist_in_session = []
         for (item_cls, pkey), instance in session.identity_map.items():
             if cls == item_cls and getattr(instance, attr_name) == value:
                 exist_in_session.append(instance)
         if exist_in_session:
             if len(exist_in_session) == 1:
                 return exist_in_session[0]
             log.exception(
                 'multiple objects with attr %s and '
                 'value %s found with same name: %r',
                 attr_name, value, exist_in_session)
 
     @property
     def cls_name(self):
         return self.__class__.__name__
 
     def __repr__(self):
         return f'<DB:{self.cls_name}>'
 
 
 class RhodeCodeSetting(Base, BaseModel):
     __tablename__ = 'rhodecode_settings'
     __table_args__ = (
         UniqueConstraint('app_settings_name'),
         base_table_args
     )
 
     SETTINGS_TYPES = {
         'str': safe_str,
         'int': safe_int,
         'unicode': safe_str,
         'bool': str2bool,
         'list': functools.partial(aslist, sep=',')
     }
     DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
     GLOBAL_CONF_KEY = 'app_settings'
 
     app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
     _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
     _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
 
     def __init__(self, key='', val='', type='unicode'):
         self.app_settings_name = key
         self.app_settings_type = type
         self.app_settings_value = val
 
     @validates('_app_settings_value')
     def validate_settings_value(self, key, val):
         assert type(val) == str
         return val
 
     @hybrid_property
     def app_settings_value(self):
         v = self._app_settings_value
         _type = self.app_settings_type
         if _type:
             _type = self.app_settings_type.split('.')[0]
             # decode the encrypted value
             if 'encrypted' in self.app_settings_type:
                 cipher = EncryptedTextValue()
                 v = safe_str(cipher.process_result_value(v, None))
 
         converter = self.SETTINGS_TYPES.get(_type) or \
             self.SETTINGS_TYPES['unicode']
         return converter(v)
 
     @app_settings_value.setter
     def app_settings_value(self, val):
         """
         Setter that will always make sure we use unicode in app_settings_value
 
         :param val:
         """
         val = safe_str(val)
         # encode the encrypted value
         if 'encrypted' in self.app_settings_type:
             cipher = EncryptedTextValue()
             val = safe_str(cipher.process_bind_param(val, None))
         self._app_settings_value = val
 
     @hybrid_property
     def app_settings_type(self):
         return self._app_settings_type
 
     @app_settings_type.setter
     def app_settings_type(self, val):
         if val.split('.')[0] not in self.SETTINGS_TYPES:
             raise Exception('type must be one of %s got %s'
                             % (self.SETTINGS_TYPES.keys(), val))
         self._app_settings_type = val
 
     @classmethod
     def get_by_prefix(cls, prefix):
         return RhodeCodeSetting.query()\
             .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\
             .all()
 
     def __repr__(self):
         return "<%s('%s:%s[%s]')>" % (
             self.cls_name,
             self.app_settings_name, self.app_settings_value,
             self.app_settings_type
         )
 
 
 class RhodeCodeUi(Base, BaseModel):
     __tablename__ = 'rhodecode_ui'
     __table_args__ = (
         UniqueConstraint('ui_key'),
         base_table_args
     )
     # Sync those values with vcsserver.config.hooks
 
     HOOK_REPO_SIZE = 'changegroup.repo_size'
     # HG
     HOOK_PRE_PULL = 'preoutgoing.pre_pull'
     HOOK_PULL = 'outgoing.pull_logger'
     HOOK_PRE_PUSH = 'prechangegroup.pre_push'
     HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
     HOOK_PUSH = 'changegroup.push_logger'
     HOOK_PUSH_KEY = 'pushkey.key_push'
 
     HOOKS_BUILTIN = [
         HOOK_PRE_PULL,
         HOOK_PULL,
         HOOK_PRE_PUSH,
         HOOK_PRETX_PUSH,
         HOOK_PUSH,
         HOOK_PUSH_KEY,
     ]
 
     # TODO: johbo: Unify way how hooks are configured for git and hg,
     # git part is currently hardcoded.
 
     # SVN PATTERNS
     SVN_BRANCH_ID = 'vcs_svn_branch'
     SVN_TAG_ID = 'vcs_svn_tag'
 
     ui_id = Column(
         "ui_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     ui_section = Column(
         "ui_section", String(255), nullable=True, unique=None, default=None)
     ui_key = Column(
         "ui_key", String(255), nullable=True, unique=None, default=None)
     ui_value = Column(
         "ui_value", String(255), nullable=True, unique=None, default=None)
     ui_active = Column(
         "ui_active", Boolean(), nullable=True, unique=None, default=True)
 
     def __repr__(self):
         return '<%s[%s]%s=>%s]>' % (self.cls_name, self.ui_section,
                                     self.ui_key, self.ui_value)
 
 
 class RepoRhodeCodeSetting(Base, BaseModel):
     __tablename__ = 'repo_rhodecode_settings'
     __table_args__ = (
         UniqueConstraint(
             'app_settings_name', 'repository_id',
             name='uq_repo_rhodecode_setting_name_repo_id'),
         base_table_args
     )
 
     repository_id = Column(
         "repository_id", Integer(), ForeignKey('repositories.repo_id'),
         nullable=False)
     app_settings_id = Column(
         "app_settings_id", Integer(), nullable=False, unique=True,
         default=None, primary_key=True)
     app_settings_name = Column(
         "app_settings_name", String(255), nullable=True, unique=None,
         default=None)
     _app_settings_value = Column(
         "app_settings_value", String(4096), nullable=True, unique=None,
         default=None)
     _app_settings_type = Column(
         "app_settings_type", String(255), nullable=True, unique=None,
         default=None)
 
     repository = relationship('Repository', viewonly=True)
 
     def __init__(self, repository_id, key='', val='', type='unicode'):
         self.repository_id = repository_id
         self.app_settings_name = key
         self.app_settings_type = type
         self.app_settings_value = val
 
     @validates('_app_settings_value')
     def validate_settings_value(self, key, val):
         assert type(val) == str
         return val
 
     @hybrid_property
     def app_settings_value(self):
         v = self._app_settings_value
         type_ = self.app_settings_type
         SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
         converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
         return converter(v)
 
     @app_settings_value.setter
     def app_settings_value(self, val):
         """
         Setter that will always make sure we use unicode in app_settings_value
 
         :param val:
         """
         self._app_settings_value = safe_str(val)
 
     @hybrid_property
     def app_settings_type(self):
         return self._app_settings_type
 
     @app_settings_type.setter
     def app_settings_type(self, val):
         SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
         if val not in SETTINGS_TYPES:
             raise Exception('type must be one of %s got %s'
                             % (SETTINGS_TYPES.keys(), val))
         self._app_settings_type = val
 
     def __repr__(self):
         return "<%s('%s:%s:%s[%s]')>" % (
             self.cls_name, self.repository.repo_name,
             self.app_settings_name, self.app_settings_value,
             self.app_settings_type
         )
 
 
 class RepoRhodeCodeUi(Base, BaseModel):
     __tablename__ = 'repo_rhodecode_ui'
     __table_args__ = (
         UniqueConstraint(
             'repository_id', 'ui_section', 'ui_key',
             name='uq_repo_rhodecode_ui_repository_id_section_key'),
         base_table_args
     )
 
     repository_id = Column(
         "repository_id", Integer(), ForeignKey('repositories.repo_id'),
         nullable=False)
     ui_id = Column(
         "ui_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     ui_section = Column(
         "ui_section", String(255), nullable=True, unique=None, default=None)
     ui_key = Column(
         "ui_key", String(255), nullable=True, unique=None, default=None)
     ui_value = Column(
         "ui_value", String(255), nullable=True, unique=None, default=None)
     ui_active = Column(
         "ui_active", Boolean(), nullable=True, unique=None, default=True)
 
     repository = relationship('Repository', viewonly=True)
 
     def __repr__(self):
         return '<%s[%s:%s]%s=>%s]>' % (
             self.cls_name, self.repository.repo_name,
             self.ui_section, self.ui_key, self.ui_value)
 
 
 class User(Base, BaseModel):
     __tablename__ = 'users'
     __table_args__ = (
         UniqueConstraint('username'), UniqueConstraint('email'),
         Index('u_username_idx', 'username'),
         Index('u_email_idx', 'email'),
         base_table_args
     )
 
     DEFAULT_USER = 'default'
     DEFAULT_USER_EMAIL = '[e-mail]'
     DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
 
     user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     username = Column("username", String(255), nullable=True, unique=None, default=None)
     password = Column("password", String(255), nullable=True, unique=None, default=None)
     active = Column("active", Boolean(), nullable=True, unique=None, default=True)
     admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
     name = Column("firstname", String(255), nullable=True, unique=None, default=None)
     lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
     _email = Column("email", String(255), nullable=True, unique=None, default=None)
     last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
     last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
     description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
 
     extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
     extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
     _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data
 
     user_log = relationship('UserLog', back_populates='user')
     user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all, delete-orphan')
 
     repositories = relationship('Repository', back_populates='user')
     repository_groups = relationship('RepoGroup', back_populates='user')
     user_groups = relationship('UserGroup', back_populates='user')
 
     user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all', back_populates='follows_user')
     followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all', back_populates='user')
 
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all, delete-orphan')
     repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan', back_populates='user')
     user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan', back_populates='user')
 
     group_member = relationship('UserGroupMember', cascade='all', back_populates='user')
 
     notifications = relationship('UserNotification', cascade='all', back_populates='user')
     # notifications assigned to this user
     user_created_notifications = relationship('Notification', cascade='all', back_populates='created_by_user')
     # comments created by this user
     user_comments = relationship('ChangesetComment', cascade='all', back_populates='author')
     # user profile extra info
     user_emails = relationship('UserEmailMap', cascade='all', back_populates='user')
     user_ip_map = relationship('UserIpMap', cascade='all', back_populates='user')
     user_auth_tokens = relationship('UserApiKeys', cascade='all', back_populates='user')
     user_ssh_keys = relationship('UserSshKeys', cascade='all', back_populates='user')
 
     # gists
     user_gists = relationship('Gist', cascade='all', back_populates='owner')
     # user pull requests
     user_pull_requests = relationship('PullRequest', cascade='all', back_populates='author')
 
     # external identities
     external_identities = relationship('ExternalIdentity', primaryjoin="User.user_id==ExternalIdentity.local_user_id", cascade='all')
     # review rules
     user_review_rules = relationship('RepoReviewRuleUser', cascade='all', back_populates='user')
 
     # artifacts owned
     artifacts = relationship('FileStore', primaryjoin='FileStore.user_id==User.user_id', back_populates='upload_user')
 
     # no cascade, set NULL
     scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_user_id==User.user_id', cascade='', back_populates='user')
 
     def __repr__(self):
         return f"<{self.cls_name}('id={self.user_id}, username={self.username}')>"
 
     @hybrid_property
     def email(self):
         return self._email
 
     @email.setter
     def email(self, val):
         self._email = val.lower() if val else None
 
     @hybrid_property
     def first_name(self):
         from rhodecode.lib import helpers as h
         if self.name:
             return h.escape(self.name)
         return self.name
 
     @hybrid_property
     def last_name(self):
         from rhodecode.lib import helpers as h
         if self.lastname:
             return h.escape(self.lastname)
         return self.lastname
 
     @hybrid_property
     def api_key(self):
         """
         Fetch if exist an auth-token with role ALL connected to this user
         """
         user_auth_token = UserApiKeys.query()\
             .filter(UserApiKeys.user_id == self.user_id)\
             .filter(or_(UserApiKeys.expires == -1,
                             UserApiKeys.expires >= time.time()))\
             .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
         if user_auth_token:
             user_auth_token = user_auth_token.api_key
 
         return user_auth_token
 
     @api_key.setter
     def api_key(self, val):
         # don't allow to set API key this is deprecated for now
         self._api_key = None
 
     @property
     def reviewer_pull_requests(self):
         return PullRequestReviewers.query() \
             .options(joinedload(PullRequestReviewers.pull_request)) \
             .filter(PullRequestReviewers.user_id == self.user_id) \
             .all()
 
     @property
     def firstname(self):
         # alias for future
         return self.name
 
     @property
     def emails(self):
         other = UserEmailMap.query()\
             .filter(UserEmailMap.user == self) \
             .order_by(UserEmailMap.email_id.asc()) \
             .all()
         return [self.email] + [x.email for x in other]
 
     def emails_cached(self):
         emails = []
         if self.user_id != self.get_default_user_id():
             emails = UserEmailMap.query()\
                 .filter(UserEmailMap.user == self) \
                 .order_by(UserEmailMap.email_id.asc())
 
             emails = emails.options(
                 FromCache("sql_cache_short", f"get_user_{self.user_id}_emails")
             )
 
         return [self.email] + [x.email for x in emails]
 
     @property
     def auth_tokens(self):
         auth_tokens = self.get_auth_tokens()
         return [x.api_key for x in auth_tokens]
 
     def get_auth_tokens(self):
         return UserApiKeys.query()\
             .filter(UserApiKeys.user == self)\
             .order_by(UserApiKeys.user_api_key_id.asc())\
             .all()
 
     @LazyProperty
     def feed_token(self):
         return self.get_feed_token()
 
     def get_feed_token(self, cache=True):
         feed_tokens = UserApiKeys.query()\
             .filter(UserApiKeys.user == self)\
             .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
         if cache:
             feed_tokens = feed_tokens.options(
                 FromCache("sql_cache_short", f"get_user_feed_token_{self.user_id}"))
 
         feed_tokens = feed_tokens.all()
         if feed_tokens:
             return feed_tokens[0].api_key
         return 'NO_FEED_TOKEN_AVAILABLE'
 
     @LazyProperty
     def artifact_token(self):
         return self.get_artifact_token()
 
     def get_artifact_token(self, cache=True):
         artifacts_tokens = UserApiKeys.query()\
             .filter(UserApiKeys.user == self) \
             .filter(or_(UserApiKeys.expires == -1,
                         UserApiKeys.expires >= time.time())) \
             .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD)
 
         if cache:
             artifacts_tokens = artifacts_tokens.options(
                 FromCache("sql_cache_short", f"get_user_artifact_token_{self.user_id}"))
 
         artifacts_tokens = artifacts_tokens.all()
         if artifacts_tokens:
             return artifacts_tokens[0].api_key
         return 'NO_ARTIFACT_TOKEN_AVAILABLE'
 
     def get_or_create_artifact_token(self):
         artifacts_tokens = UserApiKeys.query()\
             .filter(UserApiKeys.user == self) \
             .filter(or_(UserApiKeys.expires == -1,
                         UserApiKeys.expires >= time.time())) \
             .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD)
 
         artifacts_tokens = artifacts_tokens.all()
         if artifacts_tokens:
             return artifacts_tokens[0].api_key
         else:
             from rhodecode.model.auth_token import AuthTokenModel
             artifact_token = AuthTokenModel().create(
                 self, 'auto-generated-artifact-token',
                 lifetime=-1, role=UserApiKeys.ROLE_ARTIFACT_DOWNLOAD)
             Session.commit()
             return artifact_token.api_key
 
     @classmethod
     def get(cls, user_id, cache=False):
         if not user_id:
             return
 
         user = cls.query()
         if cache:
             user = user.options(
                 FromCache("sql_cache_short", f"get_users_{user_id}"))
         return user.get(user_id)
 
     @classmethod
     def extra_valid_auth_tokens(cls, user, role=None):
         tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
                 .filter(or_(UserApiKeys.expires == -1,
                             UserApiKeys.expires >= time.time()))
         if role:
             tokens = tokens.filter(or_(UserApiKeys.role == role,
                                        UserApiKeys.role == UserApiKeys.ROLE_ALL))
         return tokens.all()
 
     def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
         from rhodecode.lib import auth
 
         log.debug('Trying to authenticate user: %s via auth-token, '
                   'and roles: %s', self, roles)
 
         if not auth_token:
             return False
 
         roles = (roles or []) + [UserApiKeys.ROLE_ALL]
         tokens_q = UserApiKeys.query()\
             .filter(UserApiKeys.user_id == self.user_id)\
             .filter(or_(UserApiKeys.expires == -1,
                         UserApiKeys.expires >= time.time()))
 
         tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
 
         crypto_backend = auth.crypto_backend()
         enc_token_map = {}
         plain_token_map = {}
         for token in tokens_q:
             if token.api_key.startswith(crypto_backend.ENC_PREF):
                 enc_token_map[token.api_key] = token
             else:
                 plain_token_map[token.api_key] = token
         log.debug(
             'Found %s plain and %s encrypted tokens to check for authentication for this user',
             len(plain_token_map), len(enc_token_map))
 
         # plain token match comes first
         match = plain_token_map.get(auth_token)
 
         # check encrypted tokens now
         if not match:
             for token_hash, token in enc_token_map.items():
                 # NOTE(marcink): this is expensive to calculate, but most secure
                 if crypto_backend.hash_check(auth_token, token_hash):
                     match = token
                     break
 
         if match:
             log.debug('Found matching token %s', match)
             if match.repo_id:
                 log.debug('Found scope, checking for scope match of token %s', match)
                 if match.repo_id == scope_repo_id:
                     return True
                 else:
                     log.debug(
                         'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, '
                         'and calling scope is:%s, skipping further checks',
                          match.repo, scope_repo_id)
                     return False
             else:
                 return True
 
         return False
 
     @property
     def ip_addresses(self):
         ret = UserIpMap.query().filter(UserIpMap.user == self).all()
         return [x.ip_addr for x in ret]
 
     @property
     def username_and_name(self):
         return f'{self.username} ({self.first_name} {self.last_name})'
 
     @property
     def username_or_name_or_email(self):
         full_name = self.full_name if self.full_name != ' ' else None
         return self.username or full_name or self.email
 
     @property
     def full_name(self):
         return f'{self.first_name} {self.last_name}'
 
     @property
     def full_name_or_username(self):
         return (f'{self.first_name} {self.last_name}'
                 if (self.first_name and self.last_name) else self.username)
 
     @property
     def full_contact(self):
         return f'{self.first_name} {self.last_name} <{self.email}>'
 
     @property
     def short_contact(self):
         return f'{self.first_name} {self.last_name}'
 
     @property
     def is_admin(self):
         return self.admin
 
     @property
     def language(self):
         return self.user_data.get('language')
 
     def AuthUser(self, **kwargs):
         """
         Returns instance of AuthUser for this user
         """
         from rhodecode.lib.auth import AuthUser
         return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
 
     @hybrid_property
     def user_data(self):
         if not self._user_data:
             return {}
 
         try:
             return json.loads(self._user_data) or {}
         except TypeError:
             return {}
 
     @user_data.setter
     def user_data(self, val):
         if not isinstance(val, dict):
             raise Exception('user_data must be dict, got %s' % type(val))
         try:
             self._user_data = safe_bytes(json.dumps(val))
         except Exception:
             log.error(traceback.format_exc())
 
     @classmethod
     def get_by_username(cls, username, case_insensitive=False,
                         cache=False):
 
         if case_insensitive:
             q = cls.select().where(
                 func.lower(cls.username) == func.lower(username))
         else:
             q = cls.select().where(cls.username == username)
 
         if cache:
             hash_key = _hash_key(username)
             q = q.options(
                 FromCache("sql_cache_short", f"get_user_by_name_{hash_key}"))
 
         return cls.execute(q).scalar_one_or_none()
 
     @classmethod
     def get_by_auth_token(cls, auth_token, cache=False):
 
         q = cls.select(User)\
             .join(UserApiKeys)\
             .where(UserApiKeys.api_key == auth_token)\
             .where(or_(UserApiKeys.expires == -1,
                        UserApiKeys.expires >= time.time()))
 
         if cache:
             q = q.options(
                 FromCache("sql_cache_short", f"get_auth_token_{auth_token}"))
 
         matched_user = cls.execute(q).scalar_one_or_none()
 
         return matched_user
 
     @classmethod
     def get_by_email(cls, email, case_insensitive=False, cache=False):
 
         if case_insensitive:
             q = cls.select().where(func.lower(cls.email) == func.lower(email))
         else:
             q = cls.select().where(cls.email == email)
 
         if cache:
             email_key = _hash_key(email)
             q = q.options(
                 FromCache("sql_cache_short", f"get_email_key_{email_key}"))
 
         ret = cls.execute(q).scalar_one_or_none()
 
         if ret is None:
             q = cls.select(UserEmailMap)
             # try fetching in alternate email map
             if case_insensitive:
                 q = q.where(func.lower(UserEmailMap.email) == func.lower(email))
             else:
                 q = q.where(UserEmailMap.email == email)
             q = q.options(joinedload(UserEmailMap.user))
             if cache:
                 q = q.options(
                     FromCache("sql_cache_short", f"get_email_map_key_{email_key}"))
 
             result = cls.execute(q).scalar_one_or_none()
             ret = getattr(result, 'user', None)
 
         return ret
 
     @classmethod
     def get_from_cs_author(cls, author):
         """
         Tries to get User objects out of commit author string
 
         :param author:
         """
         from rhodecode.lib.helpers import email, author_name
         # Valid email in the attribute passed, see if they're in the system
         _email = email(author)
         if _email:
             user = cls.get_by_email(_email, case_insensitive=True)
             if user:
                 return user
         # Maybe we can match by username?
         _author = author_name(author)
         user = cls.get_by_username(_author, case_insensitive=True)
         if user:
             return user
 
     def update_userdata(self, **kwargs):
         usr = self
         old = usr.user_data
         old.update(**kwargs)
         usr.user_data = old
         Session().add(usr)
         log.debug('updated userdata with %s', kwargs)
 
     def update_lastlogin(self):
         """Update user lastlogin"""
         self.last_login = datetime.datetime.now()
         Session().add(self)
         log.debug('updated user %s lastlogin', self.username)
 
     def update_password(self, new_password):
         from rhodecode.lib.auth import get_crypt_password
 
         self.password = get_crypt_password(new_password)
         Session().add(self)
 
     @classmethod
     def get_first_super_admin(cls):
         stmt = cls.select().where(User.admin == true()).order_by(User.user_id.asc())
         user = cls.scalars(stmt).first()
 
         if user is None:
             raise Exception('FATAL: Missing administrative account!')
         return user
 
     @classmethod
     def get_all_super_admins(cls, only_active=False):
         """
         Returns all admin accounts sorted by username
         """
         qry = User.query().filter(User.admin == true()).order_by(User.username.asc())
         if only_active:
             qry = qry.filter(User.active == true())
         return qry.all()
 
     @classmethod
     def get_all_user_ids(cls, only_active=True):
         """
         Returns all users IDs
         """
         qry = Session().query(User.user_id)
 
         if only_active:
             qry = qry.filter(User.active == true())
         return [x.user_id for x in qry]
 
     @classmethod
     def get_default_user(cls, cache=False, refresh=False):
         user = User.get_by_username(User.DEFAULT_USER, cache=cache)
         if user is None:
             raise Exception('FATAL: Missing default account!')
         if refresh:
             # The default user might be based on outdated state which
             # has been loaded from the cache.
             # A call to refresh() ensures that the
             # latest state from the database is used.
             Session().refresh(user)
 
         return user
 
     @classmethod
     def get_default_user_id(cls):
         import rhodecode
         return rhodecode.CONFIG['default_user_id']
 
     def _get_default_perms(self, user, suffix=''):
         from rhodecode.model.permission import PermissionModel
         return PermissionModel().get_default_perms(user.user_perms, suffix)
 
     def get_default_perms(self, suffix=''):
         return self._get_default_perms(self, suffix)
 
     def get_api_data(self, include_secrets=False, details='full'):
         """
         Common function for generating user related data for API
 
         :param include_secrets: By default secrets in the API data will be replaced
            by a placeholder value to prevent exposing this data by accident. In case
            this data shall be exposed, set this flag to ``True``.
 
         :param details: details can be 'basic|full' basic gives only a subset of
            the available user information that includes user_id, name and emails.
         """
         user = self
         user_data = self.user_data
         data = {
             'user_id': user.user_id,
             'username': user.username,
             'firstname': user.name,
             'lastname': user.lastname,
             'description': user.description,
             'email': user.email,
             'emails': user.emails,
         }
         if details == 'basic':
             return data
 
         auth_token_length = 40
         auth_token_replacement = '*' * auth_token_length
 
         extras = {
             'auth_tokens': [auth_token_replacement],
             'active': user.active,
             'admin': user.admin,
             'extern_type': user.extern_type,
             'extern_name': user.extern_name,
             'last_login': user.last_login,
             'last_activity': user.last_activity,
             'ip_addresses': user.ip_addresses,
             'language': user_data.get('language')
         }
         data.update(extras)
 
         if include_secrets:
             data['auth_tokens'] = user.auth_tokens
         return data
 
     def __json__(self):
         data = {
             'full_name': self.full_name,
             'full_name_or_username': self.full_name_or_username,
             'short_contact': self.short_contact,
             'full_contact': self.full_contact,
         }
         data.update(self.get_api_data())
         return data
 
 
 class UserApiKeys(Base, BaseModel):
     __tablename__ = 'user_api_keys'
     __table_args__ = (
         Index('uak_api_key_idx', 'api_key'),
         Index('uak_api_key_expires_idx', 'api_key', 'expires'),
         base_table_args
     )
 
     # ApiKey role
     ROLE_ALL = 'token_role_all'
     ROLE_VCS = 'token_role_vcs'
     ROLE_API = 'token_role_api'
     ROLE_HTTP = 'token_role_http'
     ROLE_FEED = 'token_role_feed'
     ROLE_ARTIFACT_DOWNLOAD = 'role_artifact_download'
     # The last one is ignored in the list as we only
     # use it for one action, and cannot be created by users
     ROLE_PASSWORD_RESET = 'token_password_reset'
 
     ROLES = [ROLE_ALL, ROLE_VCS, ROLE_API, ROLE_HTTP, ROLE_FEED, ROLE_ARTIFACT_DOWNLOAD]
 
     user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     api_key = Column("api_key", String(255), nullable=False, unique=True)
     description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
     expires = Column('expires', Float(53), nullable=False)
     role = Column('role', String(255), nullable=True)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     # scope columns
     repo_id = Column(
         'repo_id', Integer(), ForeignKey('repositories.repo_id'),
         nullable=True, unique=None, default=None)
     repo = relationship('Repository', lazy='joined', back_populates='scoped_tokens')
 
     repo_group_id = Column(
         'repo_group_id', Integer(), ForeignKey('groups.group_id'),
         nullable=True, unique=None, default=None)
     repo_group = relationship('RepoGroup', lazy='joined')
 
     user = relationship('User', lazy='joined', back_populates='user_auth_tokens')
 
     def __repr__(self):
         return f"<{self.cls_name}('{self.role}')>"
 
     def __json__(self):
         data = {
             'auth_token': self.api_key,
             'role': self.role,
             'scope': self.scope_humanized,
             'expired': self.expired
         }
         return data
 
     def get_api_data(self, include_secrets=False):
         data = self.__json__()
         if include_secrets:
             return data
         else:
             data['auth_token'] = self.token_obfuscated
             return data
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @property
     def expired(self):
         if self.expires == -1:
             return False
         return time.time() > self.expires
 
     @classmethod
     def _get_role_name(cls, role):
         return {
             cls.ROLE_ALL: _('all'),
             cls.ROLE_HTTP: _('http/web interface'),
             cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
             cls.ROLE_API: _('api calls'),
             cls.ROLE_FEED: _('feed access'),
             cls.ROLE_ARTIFACT_DOWNLOAD: _('artifacts downloads'),
         }.get(role, role)
 
     @classmethod
     def _get_role_description(cls, role):
         return {
             cls.ROLE_ALL: _('Token for all actions.'),
             cls.ROLE_HTTP: _('Token to access RhodeCode pages via web interface without '
                              'login using `api_access_controllers_whitelist` functionality.'),
             cls.ROLE_VCS: _('Token to interact over git/hg/svn protocols. '
                             'Requires auth_token authentication plugin to be active. <br/>'
                             'Such Token should be used then instead of a password to '
                             'interact with a repository, and additionally can be '
                             'limited to single repository using repo scope.'),
             cls.ROLE_API: _('Token limited to api calls.'),
             cls.ROLE_FEED: _('Token to read RSS/ATOM feed.'),
             cls.ROLE_ARTIFACT_DOWNLOAD: _('Token for artifacts downloads.'),
         }.get(role, role)
 
     @property
     def role_humanized(self):
         return self._get_role_name(self.role)
 
     def _get_scope(self):
         if self.repo:
             return 'Repository: {}'.format(self.repo.repo_name)
         if self.repo_group:
             return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name)
         return 'Global'
 
     @property
     def scope_humanized(self):
         return self._get_scope()
 
     @property
     def token_obfuscated(self):
         if self.api_key:
             return self.api_key[:4] + "****"
 
 
 class UserEmailMap(Base, BaseModel):
     __tablename__ = 'user_email_map'
     __table_args__ = (
         Index('uem_email_idx', 'email'),
         Index('uem_user_id_idx', 'user_id'),
         UniqueConstraint('email'),
         base_table_args
     )
 
     email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     _email = Column("email", String(255), nullable=True, unique=False, default=None)
     user = relationship('User', lazy='joined', back_populates='user_emails')
 
     @validates('_email')
     def validate_email(self, key, email):
         # check if this email is not main one
         main_email = Session().query(User).filter(User.email == email).scalar()
         if main_email is not None:
             raise AttributeError('email %s is present is user table' % email)
         return email
 
     @hybrid_property
     def email(self):
         return self._email
 
     @email.setter
     def email(self, val):
         self._email = val.lower() if val else None
 
 
 class UserIpMap(Base, BaseModel):
     __tablename__ = 'user_ip_map'
     __table_args__ = (
         UniqueConstraint('user_id', 'ip_addr'),
         base_table_args
     )
 
     ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
     active = Column("active", Boolean(), nullable=True, unique=None, default=True)
     description = Column("description", String(10000), nullable=True, unique=None, default=None)
     user = relationship('User', lazy='joined', back_populates='user_ip_map')
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @classmethod
     def _get_ip_range(cls, ip_addr):
         net = ipaddress.ip_network(safe_str(ip_addr), strict=False)
         return [str(net.network_address), str(net.broadcast_address)]
 
     def __json__(self):
         return {
           'ip_addr': self.ip_addr,
           'ip_range': self._get_ip_range(self.ip_addr),
         }
 
     def __repr__(self):
         return f"<{self.cls_name}('user_id={self.user_id} => ip={self.ip_addr}')>"
 
 
 class UserSshKeys(Base, BaseModel):
     __tablename__ = 'user_ssh_keys'
     __table_args__ = (
         Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
 
         UniqueConstraint('ssh_key_fingerprint'),
 
         base_table_args
     )
 
     ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
     ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
     ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
 
     description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
 
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
 
     user = relationship('User', lazy='joined', back_populates='user_ssh_keys')
 
     def __json__(self):
         data = {
             'ssh_fingerprint': self.ssh_key_fingerprint,
             'description': self.description,
             'created_on': self.created_on
         }
         return data
 
     def get_api_data(self):
         data = self.__json__()
         return data
 
 
 class UserLog(Base, BaseModel):
     __tablename__ = 'user_logs'
     __table_args__ = (
         base_table_args,
     )
 
     VERSION_1 = 'v1'
     VERSION_2 = 'v2'
     VERSIONS = [VERSION_1, VERSION_2]
 
     user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None)
     username = Column("username", String(255), nullable=True, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)
     repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
     user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
     action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
     action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
 
     version = Column("version", String(255), nullable=True, default=VERSION_1)
     user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
     action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
     user = relationship('User', cascade='', back_populates='user_log')
     repository = relationship('Repository', cascade='', back_populates='logs')
 
     def __repr__(self):
         return f"<{self.cls_name}('id:{self.repository_name}:{self.action}')>"
 
     def __json__(self):
         return {
             'user_id': self.user_id,
             'username': self.username,
             'repository_id': self.repository_id,
             'repository_name': self.repository_name,
             'user_ip': self.user_ip,
             'action_date': self.action_date,
             'action': self.action,
         }
 
     @hybrid_property
     def entry_id(self):
         return self.user_log_id
 
     @property
     def action_as_day(self):
         return datetime.date(*self.action_date.timetuple()[:3])
 
 
 class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = (
         base_table_args,
     )
 
     users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
     user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data
 
     members = relationship('UserGroupMember', cascade="all, delete-orphan", lazy="joined", back_populates='users_group')
     users_group_to_perm = relationship('UserGroupToPerm', cascade='all', back_populates='users_group')
     users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all', back_populates='users_group')
     users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all', back_populates='users_group')
     user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all', back_populates='user_group')
 
     user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all', back_populates='target_user_group')
 
     user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all', back_populates='users_group')
     user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id", back_populates='user_groups')
 
     @classmethod
     def _load_group_data(cls, column):
         if not column:
             return {}
 
         try:
             return json.loads(column) or {}
         except TypeError:
             return {}
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.user_group_description)
 
     @hybrid_property
     def group_data(self):
         return self._load_group_data(self._group_data)
 
     @group_data.expression
     def group_data(self, **kwargs):
         return self._group_data
 
     @group_data.setter
     def group_data(self, val):
         try:
             self._group_data = json.dumps(val)
         except Exception:
             log.error(traceback.format_exc())
 
     @classmethod
     def _load_sync(cls, group_data):
         if group_data:
             return group_data.get('extern_type')
 
     @property
     def sync(self):
         return self._load_sync(self.group_data)
 
     def __repr__(self):
         return f"<{self.cls_name}('id:{self.users_group_id}:{self.users_group_name}')>"
 
     @classmethod
     def get_by_group_name(cls, group_name, cache=False,
                           case_insensitive=False):
         if case_insensitive:
             q = cls.query().filter(func.lower(cls.users_group_name) ==
                                    func.lower(group_name))
 
         else:
             q = cls.query().filter(cls.users_group_name == group_name)
         if cache:
             name_key = _hash_key(group_name)
             q = q.options(
                 FromCache("sql_cache_short", f"get_group_{name_key}"))
         return q.scalar()
 
     @classmethod
     def get(cls, user_group_id, cache=False):
         if not user_group_id:
             return
 
         user_group = cls.query()
         if cache:
             user_group = user_group.options(
                 FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
         return user_group.get(user_group_id)
 
     def permissions(self, with_admins=True, with_owner=True,
                     expand_from_user_groups=False):
         """
         Permissions for user groups
         """
         _admin_perm = 'usergroup.admin'
 
         owner_row = []
         if with_owner:
             usr = AttributeDict(self.user.get_dict())
             usr.owner_row = True
             usr.permission = _admin_perm
             owner_row.append(usr)
 
         super_admin_ids = []
         super_admin_rows = []
         if with_admins:
             for usr in User.get_all_super_admins():
                 super_admin_ids.append(usr.user_id)
                 # if this admin is also owner, don't double the record
                 if usr.user_id == owner_row[0].user_id:
                     owner_row[0].admin_row = True
                 else:
                     usr = AttributeDict(usr.get_dict())
                     usr.admin_row = True
                     usr.permission = _admin_perm
                     super_admin_rows.append(usr)
 
         q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
         q = q.options(joinedload(UserUserGroupToPerm.user_group),
                       joinedload(UserUserGroupToPerm.user),
                       joinedload(UserUserGroupToPerm.permission),)
 
         # get owners and admins and permissions. We do a trick of re-writing
         # objects from sqlalchemy to named-tuples due to sqlalchemy session
         # has a global reference and changing one object propagates to all
         # others. This means if admin is also an owner admin_row that change
         # would propagate to both objects
         perm_rows = []
         for _usr in q.all():
             usr = AttributeDict(_usr.user.get_dict())
             # if this user is also owner/admin, mark as duplicate record
             if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
                 usr.duplicate_perm = True
             usr.permission = _usr.permission.permission_name
             perm_rows.append(usr)
 
         # filter the perm rows by 'default' first and then sort them by
         # admin,write,read,none permissions sorted again alphabetically in
         # each group
         perm_rows = sorted(perm_rows, key=display_user_sort)
 
         user_groups_rows = []
         if expand_from_user_groups:
             for ug in self.permission_user_groups(with_members=True):
                 for user_data in ug.members:
                     user_groups_rows.append(user_data)
 
         return super_admin_rows + owner_row + perm_rows + user_groups_rows
 
     def permission_user_groups(self, with_members=False):
         q = UserGroupUserGroupToPerm.query()\
             .filter(UserGroupUserGroupToPerm.target_user_group == self)
         q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
                       joinedload(UserGroupUserGroupToPerm.target_user_group),
                       joinedload(UserGroupUserGroupToPerm.permission),)
 
         perm_rows = []
         for _user_group in q.all():
             entry = AttributeDict(_user_group.user_group.get_dict())
             entry.permission = _user_group.permission.permission_name
             if with_members:
                 entry.members = [x.user.get_dict()
                                  for x in _user_group.user_group.members]
             perm_rows.append(entry)
 
         perm_rows = sorted(perm_rows, key=display_user_group_sort)
         return perm_rows
 
     def _get_default_perms(self, user_group, suffix=''):
         from rhodecode.model.permission import PermissionModel
         return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
 
     def get_default_perms(self, suffix=''):
         return self._get_default_perms(self, suffix)
 
     def get_api_data(self, with_group_members=True, include_secrets=False):
         """
         :param include_secrets: See :meth:`User.get_api_data`, this parameter is
            basically forwarded.
 
         """
         user_group = self
         data = {
             'users_group_id': user_group.users_group_id,
             'group_name': user_group.users_group_name,
             'group_description': user_group.user_group_description,
             'active': user_group.users_group_active,
             'owner': user_group.user.username,
             'sync': user_group.sync,
             'owner_email': user_group.user.email,
         }
 
         if with_group_members:
             users = []
             for user in user_group.members:
                 user = user.user
                 users.append(user.get_api_data(include_secrets=include_secrets))
             data['users'] = users
 
         return data
 
 
 class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = (
         base_table_args,
     )
 
     users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined', back_populates='group_member')
     users_group = relationship('UserGroup', back_populates='members')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
         self.user_id = u_id
 
 
 class RepositoryField(Base, BaseModel):
     __tablename__ = 'repositories_fields'
     __table_args__ = (
         UniqueConstraint('repository_id', 'field_key'),  # no-multi field
         base_table_args,
     )
 
     PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields
 
     repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     field_key = Column("field_key", String(250))
     field_label = Column("field_label", String(1024), nullable=False)
     field_value = Column("field_value", String(10000), nullable=False)
     field_desc = Column("field_desc", String(1024), nullable=False)
     field_type = Column("field_type", String(255), nullable=False, unique=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     repository = relationship('Repository', back_populates='extra_fields')
 
     @property
     def field_key_prefixed(self):
         return 'ex_%s' % self.field_key
 
     @classmethod
     def un_prefix_key(cls, key):
         if key.startswith(cls.PREFIX):
             return key[len(cls.PREFIX):]
         return key
 
     @classmethod
     def get_by_key_name(cls, key, repo):
         row = cls.query()\
                 .filter(cls.repository == repo)\
                 .filter(cls.field_key == key).scalar()
         return row
 
 
 class Repository(Base, BaseModel):
     __tablename__ = 'repositories'
     __table_args__ = (
         Index('r_repo_name_idx', 'repo_name', mysql_length=255),
         base_table_args,
     )
     DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
     DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
     DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
 
     STATE_CREATED = 'repo_state_created'
     STATE_PENDING = 'repo_state_pending'
     STATE_ERROR = 'repo_state_error'
 
     LOCK_AUTOMATIC = 'lock_auto'
     LOCK_API = 'lock_api'
     LOCK_WEB = 'lock_web'
     LOCK_PULL = 'lock_pull'
 
     NAME_SEP = URL_SEP
 
     repo_id = Column(
         "repo_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     _repo_name = Column(
         "repo_name", Text(), nullable=False, default=None)
     repo_name_hash = Column(
         "repo_name_hash", String(255), nullable=False, unique=True)
     repo_state = Column("repo_state", String(255), nullable=True)
 
     clone_uri = Column(
         "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
         default=None)
     push_uri = Column(
         "push_uri", EncryptedTextValue(), nullable=True, unique=False,
         default=None)
     repo_type = Column(
         "repo_type", String(255), nullable=False, unique=False, default=None)
     user_id = Column(
         "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
         unique=False, default=None)
     private = Column(
         "private", Boolean(), nullable=True, unique=None, default=None)
     archived = Column(
         "archived", Boolean(), nullable=True, unique=None, default=None)
     enable_statistics = Column(
         "statistics", Boolean(), nullable=True, unique=None, default=True)
     enable_downloads = Column(
         "downloads", Boolean(), nullable=True, unique=None, default=True)
     description = Column(
         "description", String(10000), nullable=True, unique=None, default=None)
     created_on = Column(
         'created_on', DateTime(timezone=False), nullable=True, unique=None,
         default=datetime.datetime.now)
     updated_on = Column(
         'updated_on', DateTime(timezone=False), nullable=True, unique=None,
         default=datetime.datetime.now)
     _landing_revision = Column(
         "landing_revision", String(255), nullable=False, unique=False,
         default=None)
     enable_locking = Column(
         "enable_locking", Boolean(), nullable=False, unique=None,
         default=False)
     _locked = Column(
         "locked", String(255), nullable=True, unique=False, default=None)
     _changeset_cache = Column(
         "changeset_cache", LargeBinary(), nullable=True)  # JSON data
 
     fork_id = Column(
         "fork_id", Integer(), ForeignKey('repositories.repo_id'),
         nullable=True, unique=False, default=None)
     group_id = Column(
         "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
         unique=False, default=None)
 
     user = relationship('User', lazy='joined', back_populates='repositories')
     fork = relationship('Repository', remote_side=repo_id, lazy='joined')
     group = relationship('RepoGroup', lazy='joined')
     repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
     users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all', back_populates='repository')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all', back_populates='follows_repository')
     extra_fields = relationship('RepositoryField', cascade="all, delete-orphan", back_populates='repository')
 
     logs = relationship('UserLog', back_populates='repository')
 
     comments = relationship('ChangesetComment', cascade="all, delete-orphan", back_populates='repo')
 
     pull_requests_source = relationship(
         'PullRequest',
         primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
         cascade="all, delete-orphan",
         #back_populates="pr_source"
     )
     pull_requests_target = relationship(
         'PullRequest',
         primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
         cascade="all, delete-orphan",
         #back_populates="pr_target"
     )
 
     ui = relationship('RepoRhodeCodeUi', cascade="all")
     settings = relationship('RepoRhodeCodeSetting', cascade="all")
     integrations = relationship('Integration', cascade="all, delete-orphan", back_populates='repo')
 
     scoped_tokens = relationship('UserApiKeys', cascade="all", back_populates='repo')
 
     # no cascade, set NULL
     artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_id==Repository.repo_id', viewonly=True)
 
     review_rules = relationship('RepoReviewRule')
     user_branch_perms = relationship('UserToRepoBranchPermission')
     user_group_branch_perms = relationship('UserGroupToRepoBranchPermission')
 
     def __repr__(self):
         return "<%s('%s:%s')>" % (self.cls_name, self.repo_id, self.repo_name)
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @hybrid_property
     def landing_rev(self):
         # always should return [rev_type, rev], e.g ['branch', 'master']
         if self._landing_revision:
             _rev_info = self._landing_revision.split(':')
             if len(_rev_info) < 2:
                 _rev_info.insert(0, 'rev')
             return [_rev_info[0], _rev_info[1]]
         return [None, None]
 
     @property
     def landing_ref_type(self):
         return self.landing_rev[0]
 
     @property
     def landing_ref_name(self):
         return self.landing_rev[1]
 
     @landing_rev.setter
     def landing_rev(self, val):
         if ':' not in val:
             raise ValueError('value must be delimited with `:` and consist '
                              'of <rev_type>:<rev>, got %s instead' % val)
         self._landing_revision = val
 
     @hybrid_property
     def locked(self):
         if self._locked:
             user_id, timelocked, reason = self._locked.split(':')
             lock_values = int(user_id), timelocked, reason
         else:
             lock_values = [None, None, None]
         return lock_values
 
     @locked.setter
     def locked(self, val):
         if val and isinstance(val, (list, tuple)):
             self._locked = ':'.join(map(str, val))
         else:
             self._locked = None
 
     @classmethod
     def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
         from rhodecode.lib.vcs.backends.base import EmptyCommit
         dummy = EmptyCommit().__json__()
         if not changeset_cache_raw:
             dummy['source_repo_id'] = repo_id
             return json.loads(json.dumps(dummy))
 
         try:
             return json.loads(changeset_cache_raw)
         except TypeError:
             return dummy
         except Exception:
             log.error(traceback.format_exc())
             return dummy
 
     @hybrid_property
     def changeset_cache(self):
         return self._load_changeset_cache(self.repo_id, self._changeset_cache)
 
     @changeset_cache.setter
     def changeset_cache(self, val):
         try:
             self._changeset_cache = json.dumps(val)
         except Exception:
             log.error(traceback.format_exc())
 
     @hybrid_property
     def repo_name(self):
         return self._repo_name
 
     @repo_name.setter
     def repo_name(self, value):
         self._repo_name = value
         self.repo_name_hash = sha1(safe_bytes(value))
 
     @classmethod
     def normalize_repo_name(cls, repo_name):
         """
         Normalizes os specific repo_name to the format internally stored inside
         database using URL_SEP
 
         :param cls:
         :param repo_name:
         """
         return cls.NAME_SEP.join(repo_name.split(os.sep))
 
     @classmethod
     def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
         session = Session()
         q = session.query(cls).filter(cls.repo_name == repo_name)
 
         if cache:
             if identity_cache:
                 val = cls.identity_cache(session, 'repo_name', repo_name)
                 if val:
                     return val
             else:
                 cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
                 q = q.options(
                     FromCache("sql_cache_short", cache_key))
 
         return q.scalar()
 
     @classmethod
     def get_by_id_or_repo_name(cls, repoid):
         if isinstance(repoid, int):
             try:
                 repo = cls.get(repoid)
             except ValueError:
                 repo = None
         else:
             repo = cls.get_by_repo_name(repoid)
         return repo
 
     @classmethod
     def get_by_full_path(cls, repo_full_path):
         repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
         repo_name = cls.normalize_repo_name(repo_name)
         return cls.get_by_repo_name(repo_name.strip(URL_SEP))
 
     @classmethod
     def get_repo_forks(cls, repo_id):
         return cls.query().filter(Repository.fork_id == repo_id)
 
     @classmethod
     def base_path(cls):
         """
         Returns base path when all repos are stored
 
         :param cls:
         """
         from rhodecode.lib.utils import get_rhodecode_base_path
         return get_rhodecode_base_path()
 
     @classmethod
     def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
                       case_insensitive=True, archived=False):
         q = Repository.query()
 
         if not archived:
             q = q.filter(Repository.archived.isnot(true()))
 
         if not isinstance(user_id, Optional):
             q = q.filter(Repository.user_id == user_id)
 
         if not isinstance(group_id, Optional):
             q = q.filter(Repository.group_id == group_id)
 
         if case_insensitive:
             q = q.order_by(func.lower(Repository.repo_name))
         else:
             q = q.order_by(Repository.repo_name)
 
         return q.all()
 
     @property
     def repo_uid(self):
         return '_{}'.format(self.repo_id)
 
     @property
     def forks(self):
         """
         Return forks of this repo
         """
         return Repository.get_repo_forks(self.repo_id)
 
     @property
     def parent(self):
         """
         Returns fork parent
         """
         return self.fork
 
     @property
     def just_name(self):
         return self.repo_name.split(self.NAME_SEP)[-1]
 
     @property
     def groups_with_parents(self):
         groups = []
         if self.group is None:
             return groups
 
         cur_gr = self.group
         groups.insert(0, cur_gr)
         while 1:
             gr = getattr(cur_gr, 'parent_group', None)
             cur_gr = cur_gr.parent_group
             if gr is None:
                 break
             groups.insert(0, gr)
 
         return groups
 
     @property
     def groups_and_repo(self):
         return self.groups_with_parents, self
 
     @LazyProperty
     def repo_path(self):
         """
         Returns base full path for that repository means where it actually
         exists on a filesystem
         """
         q = Session().query(RhodeCodeUi).filter(
             RhodeCodeUi.ui_key == self.NAME_SEP)
         q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
         return q.one().ui_value
 
     @property
     def repo_full_path(self):
         p = [self.repo_path]
         # we need to split the name by / since this is how we store the
         # names in the database, but that eventually needs to be converted
         # into a valid system path
         p += self.repo_name.split(self.NAME_SEP)
         return os.path.join(*map(safe_str, p))
 
     @property
     def cache_keys(self):
         """
         Returns associated cache keys for that repo
         """
-        invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
-            repo_id=self.repo_id)
+        repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=self.repo_id)
         return CacheKey.query()\
-            .filter(CacheKey.cache_args == invalidation_namespace)\
+            .filter(CacheKey.cache_key == repo_namespace_key)\
             .order_by(CacheKey.cache_key)\
             .all()
 
     @property
     def cached_diffs_relative_dir(self):
         """
         Return a relative to the repository store path of cached diffs
         used for safe display for users, who shouldn't know the absolute store
         path
         """
         return os.path.join(
             os.path.dirname(self.repo_name),
             self.cached_diffs_dir.split(os.path.sep)[-1])
 
     @property
     def cached_diffs_dir(self):
         path = self.repo_full_path
         return os.path.join(
             os.path.dirname(path),
             f'.__shadow_diff_cache_repo_{self.repo_id}')
 
     def cached_diffs(self):
         diff_cache_dir = self.cached_diffs_dir
         if os.path.isdir(diff_cache_dir):
             return os.listdir(diff_cache_dir)
         return []
 
     def shadow_repos(self):
         shadow_repos_pattern = f'.__shadow_repo_{self.repo_id}'
         return [
             x for x in os.listdir(os.path.dirname(self.repo_full_path))
             if x.startswith(shadow_repos_pattern)
         ]
 
     def get_new_name(self, repo_name):
         """
         returns new full repository name based on assigned group and new new
 
         :param repo_name:
         """
         path_prefix = self.group.full_path_splitted if self.group else []
         return self.NAME_SEP.join(path_prefix + [repo_name])
 
     @property
     def _config(self):
         """
         Returns db based config object.
         """
         from rhodecode.lib.utils import make_db_config
         return make_db_config(clear_session=False, repo=self)
 
     def permissions(self, with_admins=True, with_owner=True,
                     expand_from_user_groups=False):
         """
         Permissions for repositories
         """
         _admin_perm = 'repository.admin'
 
         owner_row = []
         if with_owner:
             usr = AttributeDict(self.user.get_dict())
             usr.owner_row = True
             usr.permission = _admin_perm
             usr.permission_id = None
             owner_row.append(usr)
 
         super_admin_ids = []
         super_admin_rows = []
         if with_admins:
             for usr in User.get_all_super_admins():
                 super_admin_ids.append(usr.user_id)
                 # if this admin is also owner, don't double the record
                 if usr.user_id == owner_row[0].user_id:
                     owner_row[0].admin_row = True
                 else:
                     usr = AttributeDict(usr.get_dict())
                     usr.admin_row = True
                     usr.permission = _admin_perm
                     usr.permission_id = None
                     super_admin_rows.append(usr)
 
         q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
         q = q.options(joinedload(UserRepoToPerm.repository),
                       joinedload(UserRepoToPerm.user),
                       joinedload(UserRepoToPerm.permission),)
 
         # get owners and admins and permissions. We do a trick of re-writing
         # objects from sqlalchemy to named-tuples due to sqlalchemy session
         # has a global reference and changing one object propagates to all
         # others. This means if admin is also an owner admin_row that change
         # would propagate to both objects
         perm_rows = []
         for _usr in q.all():
             usr = AttributeDict(_usr.user.get_dict())
             # if this user is also owner/admin, mark as duplicate record
             if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
                 usr.duplicate_perm = True
             # also check if this permission is maybe used by branch_permissions
             if _usr.branch_perm_entry:
                 usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry]
 
             usr.permission = _usr.permission.permission_name
             usr.permission_id = _usr.repo_to_perm_id
             perm_rows.append(usr)
 
         # filter the perm rows by 'default' first and then sort them by
         # admin,write,read,none permissions sorted again alphabetically in
         # each group
         perm_rows = sorted(perm_rows, key=display_user_sort)
 
         user_groups_rows = []
         if expand_from_user_groups:
             for ug in self.permission_user_groups(with_members=True):
                 for user_data in ug.members:
                     user_groups_rows.append(user_data)
 
         return super_admin_rows + owner_row + perm_rows + user_groups_rows
 
     def permission_user_groups(self, with_members=True):
         q = UserGroupRepoToPerm.query()\
             .filter(UserGroupRepoToPerm.repository == self)
         q = q.options(joinedload(UserGroupRepoToPerm.repository),
                       joinedload(UserGroupRepoToPerm.users_group),
                       joinedload(UserGroupRepoToPerm.permission),)
 
         perm_rows = []
         for _user_group in q.all():
             entry = AttributeDict(_user_group.users_group.get_dict())
             entry.permission = _user_group.permission.permission_name
             if with_members:
                 entry.members = [x.user.get_dict()
                                  for x in _user_group.users_group.members]
             perm_rows.append(entry)
 
         perm_rows = sorted(perm_rows, key=display_user_group_sort)
         return perm_rows
 
     def get_api_data(self, include_secrets=False):
         """
         Common function for generating repo api data
 
         :param include_secrets: See :meth:`User.get_api_data`.
 
         """
         # TODO: mikhail: Here there is an anti-pattern, we probably need to
         # move this methods on models level.
         from rhodecode.model.settings import SettingsModel
         from rhodecode.model.repo import RepoModel
 
         repo = self
         _user_id, _time, _reason = self.locked
 
         data = {
             'repo_id': repo.repo_id,
             'repo_name': repo.repo_name,
             'repo_type': repo.repo_type,
             'clone_uri': repo.clone_uri or '',
             'push_uri': repo.push_uri or '',
             'url': RepoModel().get_url(self),
             'private': repo.private,
             'created_on': repo.created_on,
             'description': repo.description_safe,
             'landing_rev': repo.landing_rev,
             'owner': repo.user.username,
             'fork_of': repo.fork.repo_name if repo.fork else None,
             'fork_of_id': repo.fork.repo_id if repo.fork else None,
             'enable_statistics': repo.enable_statistics,
             'enable_locking': repo.enable_locking,
             'enable_downloads': repo.enable_downloads,
             'last_changeset': repo.changeset_cache,
             'locked_by': User.get(_user_id).get_api_data(
                 include_secrets=include_secrets) if _user_id else None,
             'locked_date': time_to_datetime(_time) if _time else None,
             'lock_reason': _reason if _reason else None,
         }
 
         # TODO: mikhail: should be per-repo settings here
         rc_config = SettingsModel().get_all_settings()
         repository_fields = str2bool(
             rc_config.get('rhodecode_repository_fields'))
         if repository_fields:
             for f in self.extra_fields:
                 data[f.field_key_prefixed] = f.field_value
 
         return data
 
     @classmethod
     def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
         if not lock_time:
             lock_time = time.time()
         if not lock_reason:
             lock_reason = cls.LOCK_AUTOMATIC
         repo.locked = [user_id, lock_time, lock_reason]
         Session().add(repo)
         Session().commit()
 
     @classmethod
     def unlock(cls, repo):
         repo.locked = None
         Session().add(repo)
         Session().commit()
 
     @classmethod
     def getlock(cls, repo):
         return repo.locked
 
     def get_locking_state(self, action, user_id, only_when_enabled=True):
         """
         Checks locking on this repository, if locking is enabled and lock is
         present returns a tuple of make_lock, locked, locked_by.
         make_lock can have 3 states None (do nothing) True, make lock
         False release lock, This value is later propagated to hooks, which
         do the locking. Think about this as signals passed to hooks what to do.
 
         """
         # TODO: johbo: This is part of the business logic and should be moved
         # into the RepositoryModel.
 
         if action not in ('push', 'pull'):
             raise ValueError("Invalid action value: %s" % repr(action))
 
         # defines if locked error should be thrown to user
         currently_locked = False
         # defines if new lock should be made, tri-state
         make_lock = None
         repo = self
         user = User.get(user_id)
 
         lock_info = repo.locked
 
         if repo and (repo.enable_locking or not only_when_enabled):
             if action == 'push':
                 # check if it's already locked !, if it is compare users
                 locked_by_user_id = lock_info[0]
                 if user.user_id == locked_by_user_id:
                     log.debug(
                         'Got `push` action from user %s, now unlocking', user)
                     # unlock if we have push from user who locked
                     make_lock = False
                 else:
                     # we're not the same user who locked, ban with
                     # code defined in settings (default is 423 HTTP Locked) !
                     log.debug('Repo %s is currently locked by %s', repo, user)
                     currently_locked = True
             elif action == 'pull':
                 # [0] user [1] date
                 if lock_info[0] and lock_info[1]:
                     log.debug('Repo %s is currently locked by %s', repo, user)
                     currently_locked = True
                 else:
                     log.debug('Setting lock on repo %s by %s', repo, user)
                     make_lock = True
 
         else:
             log.debug('Repository %s do not have locking enabled', repo)
 
         log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
                   make_lock, currently_locked, lock_info)
 
         from rhodecode.lib.auth import HasRepoPermissionAny
         perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
         if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
             # if we don't have at least write permission we cannot make a lock
             log.debug('lock state reset back to FALSE due to lack '
                       'of at least read permission')
             make_lock = False
 
         return make_lock, currently_locked, lock_info
 
     @property
     def last_commit_cache_update_diff(self):
         return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
 
     @classmethod
     def _load_commit_change(cls, last_commit_cache):
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
         date_latest = last_commit_cache.get('date', empty_date)
         try:
             return parse_datetime(date_latest)
         except Exception:
             return empty_date
 
     @property
     def last_commit_change(self):
         return self._load_commit_change(self.changeset_cache)
 
     @property
     def last_db_change(self):
         return self.updated_on
 
     @property
     def clone_uri_hidden(self):
         clone_uri = self.clone_uri
         if clone_uri:
             import urlobject
             url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
             if url_obj.password:
                 clone_uri = url_obj.with_password('*****')
         return clone_uri
 
     @property
     def push_uri_hidden(self):
         push_uri = self.push_uri
         if push_uri:
             import urlobject
             url_obj = urlobject.URLObject(cleaned_uri(push_uri))
             if url_obj.password:
                 push_uri = url_obj.with_password('*****')
         return push_uri
 
     def clone_url(self, **override):
         from rhodecode.model.settings import SettingsModel
 
         uri_tmpl = None
         if 'with_id' in override:
             uri_tmpl = self.DEFAULT_CLONE_URI_ID
             del override['with_id']
 
         if 'uri_tmpl' in override:
             uri_tmpl = override['uri_tmpl']
             del override['uri_tmpl']
 
         ssh = False
         if 'ssh' in override:
             ssh = True
             del override['ssh']
 
         # we didn't override our tmpl from **overrides
         request = get_current_request()
         if not uri_tmpl:
             if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'):
                 rc_config = request.call_context.rc_config
             else:
                 rc_config = SettingsModel().get_all_settings(cache=True)
 
             if ssh:
                 uri_tmpl = rc_config.get(
                     'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
 
             else:
                 uri_tmpl = rc_config.get(
                     'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
 
         return get_clone_url(request=request,
                              uri_tmpl=uri_tmpl,
                              repo_name=self.repo_name,
                              repo_id=self.repo_id,
                              repo_type=self.repo_type,
                              **override)
 
     def set_state(self, state):
         self.repo_state = state
         Session().add(self)
     #==========================================================================
     # SCM PROPERTIES
     #==========================================================================
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None, maybe_unreachable=False, reference_obj=None):
         return get_commit_safe(
             self.scm_instance(), commit_id, commit_idx, pre_load=pre_load,
             maybe_unreachable=maybe_unreachable, reference_obj=reference_obj)
 
     def get_changeset(self, rev=None, pre_load=None):
         warnings.warn("Use get_commit", DeprecationWarning)
         commit_id = None
         commit_idx = None
         if isinstance(rev, str):
             commit_id = rev
         else:
             commit_idx = rev
         return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
                                pre_load=pre_load)
 
     def get_landing_commit(self):
         """
         Returns landing commit, or if that doesn't exist returns the tip
         """
         _rev_type, _rev = self.landing_rev
         commit = self.get_commit(_rev)
         if isinstance(commit, EmptyCommit):
             return self.get_commit()
         return commit
 
     def flush_commit_cache(self):
         self.update_commit_cache(cs_cache={'raw_id':'0'})
         self.update_commit_cache()
 
     def update_commit_cache(self, cs_cache=None, config=None):
         """
         Update cache of last commit for repository
         cache_keys should be::
 
             source_repo_id
             short_id
             raw_id
             revision
             parents
             message
             date
             author
             updated_on
 
         """
         from rhodecode.lib.vcs.backends.base import BaseCommit
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
         repo_commit_count = 0
 
         if cs_cache is None:
             # use no-cache version here
             try:
                 scm_repo = self.scm_instance(cache=False, config=config)
             except VCSError:
                 scm_repo = None
             empty = scm_repo is None or scm_repo.is_empty()
 
             if not empty:
                 cs_cache = scm_repo.get_commit(
                     pre_load=["author", "date", "message", "parents", "branch"])
                 repo_commit_count = scm_repo.count()
             else:
                 cs_cache = EmptyCommit()
 
         if isinstance(cs_cache, BaseCommit):
             cs_cache = cs_cache.__json__()
 
         def is_outdated(new_cs_cache):
             if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
                 new_cs_cache['revision'] != self.changeset_cache['revision']):
                 return True
             return False
 
         # check if we have maybe already latest cached revision
         if is_outdated(cs_cache) or not self.changeset_cache:
             _current_datetime = datetime.datetime.utcnow()
             last_change = cs_cache.get('date') or _current_datetime
             # we check if last update is newer than the new value
             # if yes, we use the current timestamp instead. Imagine you get
             # old commit pushed 1y ago, we'd set last update 1y to ago.
             last_change_timestamp = datetime_to_time(last_change)
             current_timestamp = datetime_to_time(last_change)
             if last_change_timestamp > current_timestamp and not empty:
                 cs_cache['date'] = _current_datetime
 
             # also store size of repo
             cs_cache['repo_commit_count'] = repo_commit_count
 
             _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
             cs_cache['updated_on'] = time.time()
             self.changeset_cache = cs_cache
             self.updated_on = last_change
             Session().add(self)
             Session().commit()
 
         else:
             if empty:
                 cs_cache = EmptyCommit().__json__()
             else:
                 cs_cache = self.changeset_cache
 
             _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
 
             cs_cache['updated_on'] = time.time()
             self.changeset_cache = cs_cache
             self.updated_on = _date_latest
             Session().add(self)
             Session().commit()
 
         log.debug('updated repo `%s` with new commit cache %s, and last update_date: %s',
                   self.repo_name, cs_cache, _date_latest)
 
     @property
     def tip(self):
         return self.get_commit('tip')
 
     @property
     def author(self):
         return self.tip.author
 
     @property
     def last_change(self):
         return self.scm_instance().last_change
 
     def get_comments(self, revisions=None):
         """
         Returns comments for this repository grouped by revisions
 
         :param revisions: filter query by revisions only
         """
         cmts = ChangesetComment.query()\
             .filter(ChangesetComment.repo == self)
         if revisions:
             cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
         grouped = collections.defaultdict(list)
         for cmt in cmts.all():
             grouped[cmt.revision].append(cmt)
         return grouped
 
     def statuses(self, revisions=None):
         """
         Returns statuses for this repository
 
         :param revisions: list of revisions to get statuses for
         """
         statuses = ChangesetStatus.query()\
             .filter(ChangesetStatus.repo == self)\
             .filter(ChangesetStatus.version == 0)
 
         if revisions:
             # Try doing the filtering in chunks to avoid hitting limits
             size = 500
             status_results = []
             for chunk in range(0, len(revisions), size):
                 status_results += statuses.filter(
                     ChangesetStatus.revision.in_(
                         revisions[chunk: chunk+size])
                 ).all()
         else:
             status_results = statuses.all()
 
         grouped = {}
 
         # maybe we have open new pullrequest without a status?
         stat = ChangesetStatus.STATUS_UNDER_REVIEW
         status_lbl = ChangesetStatus.get_status_lbl(stat)
         for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
             for rev in pr.revisions:
                 pr_id = pr.pull_request_id
                 pr_repo = pr.target_repo.repo_name
                 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
 
         for stat in status_results:
             pr_id = pr_repo = None
             if stat.pull_request:
                 pr_id = stat.pull_request.pull_request_id
                 pr_repo = stat.pull_request.target_repo.repo_name
             grouped[stat.revision] = [str(stat.status), stat.status_lbl,
                                       pr_id, pr_repo]
         return grouped
 
     # ==========================================================================
     # SCM CACHE INSTANCE
     # ==========================================================================
 
     def scm_instance(self, **kwargs):
         import rhodecode
 
         # Passing a config will not hit the cache currently only used
         # for repo2dbmapper
         config = kwargs.pop('config', None)
         cache = kwargs.pop('cache', None)
         vcs_full_cache = kwargs.pop('vcs_full_cache', None)
         if vcs_full_cache is not None:
             # allows override global config
             full_cache = vcs_full_cache
         else:
             full_cache = rhodecode.ConfigGet().get_bool('vcs_full_cache')
         # if cache is NOT defined use default global, else we have a full
         # control over cache behaviour
         if cache is None and full_cache and not config:
             log.debug('Initializing pure cached instance for %s', self.repo_path)
             return self._get_instance_cached()
 
         # cache here is sent to the "vcs server"
         return self._get_instance(cache=bool(cache), config=config)
 
     def _get_instance_cached(self):
         from rhodecode.lib import rc_cache
 
         cache_namespace_uid = f'repo_instance.{self.repo_id}'
-        invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
-            repo_id=self.repo_id)
         region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
 
-        @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
-        def get_instance_cached(repo_id, context_id, _cache_state_uid):
-            return self._get_instance(repo_state_uid=_cache_state_uid)
-
         # we must use thread scoped cache here,
         # because each thread of gevent needs it's own not shared connection and cache
         # we also alter `args` so the cache key is individual for every green thread.
-        inv_context_manager = rc_cache.InvalidationContext(
-            uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace,
-            thread_scoped=True)
+        repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=self.repo_id)
+        inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key, thread_scoped=True)
+
+        # our wrapped caching function that takes state_uid to save the previous state in
+        def cache_generator(_state_uid):
+
+            @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
+            def get_instance_cached(_repo_id, _process_context_id):
+                # we save in cached func the generation state so we can detect a change and invalidate caches
+                return _state_uid, self._get_instance(repo_state_uid=_state_uid)
+
+            return get_instance_cached
+
         with inv_context_manager as invalidation_context:
-            cache_state_uid = invalidation_context.cache_data['cache_state_uid']
-            args = (self.repo_id, inv_context_manager.cache_key, cache_state_uid)
-
-            # re-compute and store cache if we get invalidate signal
-            if invalidation_context.should_invalidate():
-                instance = get_instance_cached.refresh(*args)
-            else:
-                instance = get_instance_cached(*args)
+            cache_state_uid = invalidation_context.state_uid
+            cache_func = cache_generator(cache_state_uid)
+
+            args = self.repo_id, inv_context_manager.proc_key
+
+            previous_state_uid, instance = cache_func(*args)
+
+            if instance:
+                # now compare keys, the "cache" state vs expected state.
+                if previous_state_uid != cache_state_uid:
+                    log.warning('Cached state uid %s is different than current state uid %s',
+                                previous_state_uid, cache_state_uid)
+                    _, instance = cache_func.refresh(*args)
 
             log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time)
             return instance
 
     def _get_instance(self, cache=True, config=None, repo_state_uid=None):
         log.debug('Initializing %s instance `%s` with cache flag set to: %s',
                   self.repo_type, self.repo_path, cache)
         config = config or self._config
         custom_wire = {
             'cache': cache,  # controls the vcs.remote cache
             'repo_state_uid': repo_state_uid
         }
         repo = get_vcs_instance(
             repo_path=safe_str(self.repo_full_path),
             config=config,
             with_wire=custom_wire,
             create=False,
             _vcs_alias=self.repo_type)
         if repo is not None:
             repo.count()  # cache rebuild
+
         return repo
 
     def get_shadow_repository_path(self, workspace_id):
         from rhodecode.lib.vcs.backends.base import BaseRepository
         shadow_repo_path = BaseRepository._get_shadow_repository_path(
             self.repo_full_path, self.repo_id, workspace_id)
         return shadow_repo_path
 
     def __json__(self):
         return {'landing_rev': self.landing_rev}
 
     def get_dict(self):
 
         # Since we transformed `repo_name` to a hybrid property, we need to
         # keep compatibility with the code which uses `repo_name` field.
 
         result = super(Repository, self).get_dict()
         result['repo_name'] = result.pop('_repo_name', None)
         result.pop('_changeset_cache', '')
         return result
 
 
 class RepoGroup(Base, BaseModel):
     __tablename__ = 'groups'
     __table_args__ = (
         UniqueConstraint('group_name', 'group_parent_id'),
         base_table_args,
     )
 
     CHOICES_SEPARATOR = '/'  # used to generate select2 choices for nested groups
 
     group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
     group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False)
     group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
     group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
     enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
     personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
     _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True)  # JSON data
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id', back_populates='group')
     users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all', back_populates='group')
     parent_group = relationship('RepoGroup', remote_side=group_id)
     user = relationship('User', back_populates='repository_groups')
     integrations = relationship('Integration', cascade="all, delete-orphan", back_populates='repo_group')
 
     # no cascade, set NULL
     scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_group_id==RepoGroup.group_id', viewonly=True)
 
     def __init__(self, group_name='', parent_group=None):
         self.group_name = group_name
         self.parent_group = parent_group
 
     def __repr__(self):
         return f"<{self.cls_name}('id:{self.group_id}:{self.group_name}')>"
 
     @hybrid_property
     def group_name(self):
         return self._group_name
 
     @group_name.setter
     def group_name(self, value):
         self._group_name = value
         self.group_name_hash = self.hash_repo_group_name(value)
 
     @classmethod
     def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
         from rhodecode.lib.vcs.backends.base import EmptyCommit
         dummy = EmptyCommit().__json__()
         if not changeset_cache_raw:
             dummy['source_repo_id'] = repo_id
             return json.loads(json.dumps(dummy))
 
         try:
             return json.loads(changeset_cache_raw)
         except TypeError:
             return dummy
         except Exception:
             log.error(traceback.format_exc())
             return dummy
 
     @hybrid_property
     def changeset_cache(self):
         return self._load_changeset_cache('', self._changeset_cache)
 
     @changeset_cache.setter
     def changeset_cache(self, val):
         try:
             self._changeset_cache = json.dumps(val)
         except Exception:
             log.error(traceback.format_exc())
 
     @validates('group_parent_id')
     def validate_group_parent_id(self, key, val):
         """
         Check cycle references for a parent group to self
         """
         if self.group_id and val:
             assert val != self.group_id
 
         return val
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.group_description)
 
     @classmethod
     def hash_repo_group_name(cls, repo_group_name):
         val = remove_formatting(repo_group_name)
         val = safe_str(val).lower()
         chars = []
         for c in val:
             if c not in string.ascii_letters:
                 c = str(ord(c))
             chars.append(c)
 
         return ''.join(chars)
 
     @classmethod
     def _generate_choice(cls, repo_group):
         from webhelpers2.html import literal as _literal
 
         def _name(k):
             return _literal(cls.CHOICES_SEPARATOR.join(k))
 
         return repo_group.group_id, _name(repo_group.full_path_splitted)
 
     @classmethod
     def groups_choices(cls, groups=None, show_empty_group=True):
         if not groups:
             groups = cls.query().all()
 
         repo_groups = []
         if show_empty_group:
             repo_groups = [(-1, '-- %s --' % _('No parent'))]
 
         repo_groups.extend([cls._generate_choice(x) for x in groups])
 
         repo_groups = sorted(
             repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
         return repo_groups
 
     @classmethod
     def url_sep(cls):
         return URL_SEP
 
     @classmethod
     def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
         if case_insensitive:
             gr = cls.query().filter(func.lower(cls.group_name)
                                     == func.lower(group_name))
         else:
             gr = cls.query().filter(cls.group_name == group_name)
         if cache:
             name_key = _hash_key(group_name)
             gr = gr.options(
                 FromCache("sql_cache_short", f"get_group_{name_key}"))
         return gr.scalar()
 
     @classmethod
     def get_user_personal_repo_group(cls, user_id):
         user = User.get(user_id)
         if user.username == User.DEFAULT_USER:
             return None
 
         return cls.query()\
             .filter(cls.personal == true()) \
             .filter(cls.user == user) \
             .order_by(cls.group_id.asc()) \
             .first()
 
     @classmethod
     def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
                             case_insensitive=True):
         q = RepoGroup.query()
 
         if not isinstance(user_id, Optional):
             q = q.filter(RepoGroup.user_id == user_id)
 
         if not isinstance(group_id, Optional):
             q = q.filter(RepoGroup.group_parent_id == group_id)
 
         if case_insensitive:
             q = q.order_by(func.lower(RepoGroup.group_name))
         else:
             q = q.order_by(RepoGroup.group_name)
         return q.all()
 
     @property
     def parents(self, parents_recursion_limit=10):
         groups = []
         if self.parent_group is None:
             return groups
         cur_gr = self.parent_group
         groups.insert(0, cur_gr)
         cnt = 0
         while 1:
             cnt += 1
             gr = getattr(cur_gr, 'parent_group', None)
             cur_gr = cur_gr.parent_group
             if gr is None:
                 break
             if cnt == parents_recursion_limit:
                 # this will prevent accidental infinit loops
                 log.error('more than %s parents found for group %s, stopping '
                           'recursive parent fetching', parents_recursion_limit, self)
                 break
 
             groups.insert(0, gr)
         return groups
 
     @property
     def last_commit_cache_update_diff(self):
         return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
 
     @classmethod
     def _load_commit_change(cls, last_commit_cache):
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
         date_latest = last_commit_cache.get('date', empty_date)
         try:
             return parse_datetime(date_latest)
         except Exception:
             return empty_date
 
     @property
     def last_commit_change(self):
         return self._load_commit_change(self.changeset_cache)
 
     @property
     def last_db_change(self):
         return self.updated_on
 
     @property
     def children(self):
         return RepoGroup.query().filter(RepoGroup.parent_group == self)
 
     @property
     def name(self):
         return self.group_name.split(RepoGroup.url_sep())[-1]
 
     @property
     def full_path(self):
         return self.group_name
 
     @property
     def full_path_splitted(self):
         return self.group_name.split(RepoGroup.url_sep())
 
     @property
     def repositories(self):
         return Repository.query()\
                 .filter(Repository.group == self)\
                 .order_by(Repository.repo_name)
 
     @property
     def repositories_recursive_count(self):
         cnt = self.repositories.count()
 
         def children_count(group):
             cnt = 0
             for child in group.children:
                 cnt += child.repositories.count()
                 cnt += children_count(child)
             return cnt
 
         return cnt + children_count(self)
 
     def _recursive_objects(self, include_repos=True, include_groups=True):
         all_ = []
 
         def _get_members(root_gr):
             if include_repos:
                 for r in root_gr.repositories:
                     all_.append(r)
             childs = root_gr.children.all()
             if childs:
                 for gr in childs:
                     if include_groups:
                         all_.append(gr)
                     _get_members(gr)
 
         root_group = []
         if include_groups:
             root_group = [self]
 
         _get_members(self)
         return root_group + all_
 
     def recursive_groups_and_repos(self):
         """
         Recursive return all groups, with repositories in those groups
         """
         return self._recursive_objects()
 
     def recursive_groups(self):
         """
         Returns all children groups for this group including children of children
         """
         return self._recursive_objects(include_repos=False)
 
     def recursive_repos(self):
         """
         Returns all children repositories for this group
         """
         return self._recursive_objects(include_groups=False)
 
     def get_new_name(self, group_name):
         """
         returns new full group name based on parent and new name
 
         :param group_name:
         """
         path_prefix = (self.parent_group.full_path_splitted if
                        self.parent_group else [])
         return RepoGroup.url_sep().join(path_prefix + [group_name])
 
     def update_commit_cache(self, config=None):
         """
         Update cache of last commit for newest repository inside this repository group.
         cache_keys should be::
 
             source_repo_id
             short_id
             raw_id
             revision
             parents
             message
             date
             author
 
         """
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
 
         def repo_groups_and_repos(root_gr):
             for _repo in root_gr.repositories:
                 yield _repo
             for child_group in root_gr.children.all():
                 yield child_group
 
         latest_repo_cs_cache = {}
         for obj in repo_groups_and_repos(self):
             repo_cs_cache = obj.changeset_cache
             date_latest = latest_repo_cs_cache.get('date', empty_date)
             date_current = repo_cs_cache.get('date', empty_date)
             current_timestamp = datetime_to_time(parse_datetime(date_latest))
             if current_timestamp < datetime_to_time(parse_datetime(date_current)):
                 latest_repo_cs_cache = repo_cs_cache
                 if hasattr(obj, 'repo_id'):
                     latest_repo_cs_cache['source_repo_id'] = obj.repo_id
                 else:
                     latest_repo_cs_cache['source_repo_id'] = repo_cs_cache.get('source_repo_id')
 
         _date_latest = parse_datetime(latest_repo_cs_cache.get('date') or empty_date)
 
         latest_repo_cs_cache['updated_on'] = time.time()
         self.changeset_cache = latest_repo_cs_cache
         self.updated_on = _date_latest
         Session().add(self)
         Session().commit()
 
         log.debug('updated repo group `%s` with new commit cache %s, and last update_date: %s',
                   self.group_name, latest_repo_cs_cache, _date_latest)
 
     def permissions(self, with_admins=True, with_owner=True,
                     expand_from_user_groups=False):
         """
         Permissions for repository groups
         """
         _admin_perm = 'group.admin'
 
         owner_row = []
         if with_owner:
             usr = AttributeDict(self.user.get_dict())
             usr.owner_row = True
             usr.permission = _admin_perm
             owner_row.append(usr)
 
         super_admin_ids = []
         super_admin_rows = []
         if with_admins:
             for usr in User.get_all_super_admins():
                 super_admin_ids.append(usr.user_id)
                 # if this admin is also owner, don't double the record
                 if usr.user_id == owner_row[0].user_id:
                     owner_row[0].admin_row = True
                 else:
                     usr = AttributeDict(usr.get_dict())
                     usr.admin_row = True
                     usr.permission = _admin_perm
                     super_admin_rows.append(usr)
 
         q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
         q = q.options(joinedload(UserRepoGroupToPerm.group),
                       joinedload(UserRepoGroupToPerm.user),
                       joinedload(UserRepoGroupToPerm.permission),)
 
         # get owners and admins and permissions. We do a trick of re-writing
         # objects from sqlalchemy to named-tuples due to sqlalchemy session
         # has a global reference and changing one object propagates to all
         # others. This means if admin is also an owner admin_row that change
         # would propagate to both objects
         perm_rows = []
         for _usr in q.all():
             usr = AttributeDict(_usr.user.get_dict())
             # if this user is also owner/admin, mark as duplicate record
             if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
                 usr.duplicate_perm = True
             usr.permission = _usr.permission.permission_name
             perm_rows.append(usr)
 
         # filter the perm rows by 'default' first and then sort them by
         # admin,write,read,none permissions sorted again alphabetically in
         # each group
         perm_rows = sorted(perm_rows, key=display_user_sort)
 
         user_groups_rows = []
         if expand_from_user_groups:
             for ug in self.permission_user_groups(with_members=True):
                 for user_data in ug.members:
                     user_groups_rows.append(user_data)
 
         return super_admin_rows + owner_row + perm_rows + user_groups_rows
 
     def permission_user_groups(self, with_members=False):
         q = UserGroupRepoGroupToPerm.query()\
             .filter(UserGroupRepoGroupToPerm.group == self)
         q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
                       joinedload(UserGroupRepoGroupToPerm.users_group),
                       joinedload(UserGroupRepoGroupToPerm.permission),)
 
         perm_rows = []
         for _user_group in q.all():
             entry = AttributeDict(_user_group.users_group.get_dict())
             entry.permission = _user_group.permission.permission_name
             if with_members:
                 entry.members = [x.user.get_dict()
                                  for x in _user_group.users_group.members]
             perm_rows.append(entry)
 
         perm_rows = sorted(perm_rows, key=display_user_group_sort)
         return perm_rows
 
     def get_api_data(self):
         """
         Common function for generating api data
 
         """
         group = self
         data = {
             'group_id': group.group_id,
             'group_name': group.group_name,
             'group_description': group.description_safe,
             'parent_group': group.parent_group.group_name if group.parent_group else None,
             'repositories': [x.repo_name for x in group.repositories],
             'owner': group.user.username,
         }
         return data
 
     def get_dict(self):
         # Since we transformed `group_name` to a hybrid property, we need to
         # keep compatibility with the code which uses `group_name` field.
         result = super(RepoGroup, self).get_dict()
         result['group_name'] = result.pop('_group_name', None)
         result.pop('_changeset_cache', '')
         return result
 
 
 class Permission(Base, BaseModel):
     __tablename__ = 'permissions'
     __table_args__ = (
         Index('p_perm_name_idx', 'permission_name'),
         base_table_args,
     )
 
     PERMS = [
         ('hg.admin', _('RhodeCode Super Administrator')),
 
         ('repository.none', _('Repository no access')),
         ('repository.read', _('Repository read access')),
         ('repository.write', _('Repository write access')),
         ('repository.admin', _('Repository admin access')),
 
         ('group.none', _('Repository group no access')),
         ('group.read', _('Repository group read access')),
         ('group.write', _('Repository group write access')),
         ('group.admin', _('Repository group admin access')),
 
         ('usergroup.none', _('User group no access')),
         ('usergroup.read', _('User group read access')),
         ('usergroup.write', _('User group write access')),
         ('usergroup.admin', _('User group admin access')),
 
         ('branch.none', _('Branch no permissions')),
         ('branch.merge', _('Branch access by web merge')),
         ('branch.push', _('Branch access by push')),
         ('branch.push_force', _('Branch access by push with force')),
 
         ('hg.repogroup.create.false', _('Repository Group creation disabled')),
         ('hg.repogroup.create.true', _('Repository Group creation enabled')),
 
         ('hg.usergroup.create.false', _('User Group creation disabled')),
         ('hg.usergroup.create.true', _('User Group creation enabled')),
 
         ('hg.create.none', _('Repository creation disabled')),
         ('hg.create.repository', _('Repository creation enabled')),
         ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
         ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
 
         ('hg.fork.none', _('Repository forking disabled')),
         ('hg.fork.repository', _('Repository forking enabled')),
 
         ('hg.register.none', _('Registration disabled')),
         ('hg.register.manual_activate', _('User Registration with manual account activation')),
         ('hg.register.auto_activate', _('User Registration with automatic account activation')),
 
         ('hg.password_reset.enabled', _('Password reset enabled')),
         ('hg.password_reset.hidden', _('Password reset hidden')),
         ('hg.password_reset.disabled', _('Password reset disabled')),
 
         ('hg.extern_activate.manual', _('Manual activation of external account')),
         ('hg.extern_activate.auto', _('Automatic activation of external account')),
 
         ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
         ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
     ]
 
     # definition of system default permissions for DEFAULT user, created on
     # system setup
     DEFAULT_USER_PERMISSIONS = [
         # object perms
         'repository.read',
         'group.read',
         'usergroup.read',
         # branch, for backward compat we need same value as before so forced pushed
         'branch.push_force',
         # global
         'hg.create.repository',
         'hg.repogroup.create.false',
         'hg.usergroup.create.false',
         'hg.create.write_on_repogroup.true',
         'hg.fork.repository',
         'hg.register.manual_activate',
         'hg.password_reset.enabled',
         'hg.extern_activate.auto',
         'hg.inherit_default_perms.true',
     ]
 
     # defines which permissions are more important higher the more important
     # Weight defines which permissions are more important.
     # The higher number the more important.
     PERM_WEIGHTS = {
         'repository.none': 0,
         'repository.read': 1,
         'repository.write': 3,
         'repository.admin': 4,
 
         'group.none': 0,
         'group.read': 1,
         'group.write': 3,
         'group.admin': 4,
 
         'usergroup.none': 0,
         'usergroup.read': 1,
         'usergroup.write': 3,
         'usergroup.admin': 4,
 
         'branch.none': 0,
         'branch.merge': 1,
         'branch.push': 3,
         'branch.push_force': 4,
 
         'hg.repogroup.create.false': 0,
         'hg.repogroup.create.true': 1,
 
         'hg.usergroup.create.false': 0,
         'hg.usergroup.create.true': 1,
 
         'hg.fork.none': 0,
         'hg.fork.repository': 1,
         'hg.create.none': 0,
         'hg.create.repository': 1
     }
 
     permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
     permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
 
     def __repr__(self):
         return "<%s('%s:%s')>" % (
             self.cls_name, self.permission_id, self.permission_name
         )
 
     @classmethod
     def get_by_key(cls, key):
         return cls.query().filter(cls.permission_name == key).scalar()
 
     @classmethod
     def get_default_repo_perms(cls, user_id, repo_id=None):
         q = Session().query(UserRepoToPerm, Repository, Permission)\
             .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
             .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
             .filter(UserRepoToPerm.user_id == user_id)
         if repo_id:
             q = q.filter(UserRepoToPerm.repository_id == repo_id)
         return q.all()
 
     @classmethod
     def get_default_repo_branch_perms(cls, user_id, repo_id=None):
         q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \
             .join(
                 Permission,
                 UserToRepoBranchPermission.permission_id == Permission.permission_id) \
             .join(
                 UserRepoToPerm,
                 UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \
             .filter(UserRepoToPerm.user_id == user_id)
 
         if repo_id:
             q = q.filter(UserToRepoBranchPermission.repository_id == repo_id)
         return q.order_by(UserToRepoBranchPermission.rule_order).all()
 
     @classmethod
     def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
         q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
             .join(
                 Permission,
                 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
             .join(
                 Repository,
                 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
             .join(
                 UserGroup,
                 UserGroupRepoToPerm.users_group_id ==
                 UserGroup.users_group_id)\
             .join(
                 UserGroupMember,
                 UserGroupRepoToPerm.users_group_id ==
                 UserGroupMember.users_group_id)\
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
         if repo_id:
             q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
         return q.all()
 
     @classmethod
     def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None):
         q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \
             .join(
                 Permission,
                 UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \
             .join(
                 UserGroupRepoToPerm,
                 UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \
             .join(
                 UserGroup,
                 UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \
             .join(
                 UserGroupMember,
                 UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
 
         if repo_id:
             q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id)
         return q.order_by(UserGroupToRepoBranchPermission.rule_order).all()
 
     @classmethod
     def get_default_group_perms(cls, user_id, repo_group_id=None):
         q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
             .join(
                 Permission,
                 UserRepoGroupToPerm.permission_id == Permission.permission_id)\
             .join(
                 RepoGroup,
                 UserRepoGroupToPerm.group_id == RepoGroup.group_id)\
             .filter(UserRepoGroupToPerm.user_id == user_id)
         if repo_group_id:
             q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
         return q.all()
 
     @classmethod
     def get_default_group_perms_from_user_group(
             cls, user_id, repo_group_id=None):
         q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
             .join(
                 Permission,
                 UserGroupRepoGroupToPerm.permission_id ==
                 Permission.permission_id)\
             .join(
                 RepoGroup,
                 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
             .join(
                 UserGroup,
                 UserGroupRepoGroupToPerm.users_group_id ==
                 UserGroup.users_group_id)\
             .join(
                 UserGroupMember,
                 UserGroupRepoGroupToPerm.users_group_id ==
                 UserGroupMember.users_group_id)\
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
         if repo_group_id:
             q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
         return q.all()
 
     @classmethod
     def get_default_user_group_perms(cls, user_id, user_group_id=None):
         q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
             .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
             .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
             .filter(UserUserGroupToPerm.user_id == user_id)
         if user_group_id:
             q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
         return q.all()
 
     @classmethod
     def get_default_user_group_perms_from_user_group(
             cls, user_id, user_group_id=None):
         TargetUserGroup = aliased(UserGroup, name='target_user_group')
         q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
             .join(
                 Permission,
                 UserGroupUserGroupToPerm.permission_id ==
                 Permission.permission_id)\
             .join(
                 TargetUserGroup,
                 UserGroupUserGroupToPerm.target_user_group_id ==
                 TargetUserGroup.users_group_id)\
             .join(
                 UserGroup,
                 UserGroupUserGroupToPerm.user_group_id ==
                 UserGroup.users_group_id)\
             .join(
                 UserGroupMember,
                 UserGroupUserGroupToPerm.user_group_id ==
                 UserGroupMember.users_group_id)\
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
         if user_group_id:
             q = q.filter(
                 UserGroupUserGroupToPerm.user_group_id == user_group_id)
 
         return q.all()
 
 
 class UserRepoToPerm(Base, BaseModel):
     __tablename__ = 'repo_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'repository_id', 'permission_id'),
         base_table_args
     )
 
     repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', back_populates="repo_to_perm")
     repository = relationship('Repository', back_populates="repo_to_perm")
     permission = relationship('Permission')
 
     branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete-orphan", lazy='joined', back_populates='user_repo_to_perm')
 
     @classmethod
     def create(cls, user, repository, permission):
         n = cls()
         n.user = user
         n.repository = repository
         n.permission = permission
         Session().add(n)
         return n
 
     def __repr__(self):
         return f'<{self.user} => {self.repository} >'
 
 
 class UserUserGroupToPerm(Base, BaseModel):
     __tablename__ = 'user_user_group_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
         base_table_args
     )
 
     user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', back_populates='user_group_to_perm')
     user_group = relationship('UserGroup', back_populates='user_user_group_to_perm')
     permission = relationship('Permission')
 
     @classmethod
     def create(cls, user, user_group, permission):
         n = cls()
         n.user = user
         n.user_group = user_group
         n.permission = permission
         Session().add(n)
         return n
 
     def __repr__(self):
         return f'<{self.user} => {self.user_group} >'
 
 
 class UserToPerm(Base, BaseModel):
     __tablename__ = 'user_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'permission_id'),
         base_table_args
     )
 
     user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', back_populates='user_perms')
     permission = relationship('Permission', lazy='joined')
 
     def __repr__(self):
         return f'<{self.user} => {self.permission} >'
 
 
 class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (
         UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
         base_table_args
     )
 
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UserGroup', back_populates='users_group_repo_to_perm')
     permission = relationship('Permission')
     repository = relationship('Repository', back_populates='users_group_to_perm')
     user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all', back_populates='user_group_repo_to_perm')
 
     @classmethod
     def create(cls, users_group, repository, permission):
         n = cls()
         n.users_group = users_group
         n.repository = repository
         n.permission = permission
         Session().add(n)
         return n
 
     def __repr__(self):
         return f'<UserGroupRepoToPerm:{self.users_group} => {self.repository} >'
 
 
 class UserGroupUserGroupToPerm(Base, BaseModel):
     __tablename__ = 'user_group_user_group_to_perm'
     __table_args__ = (
         UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
         CheckConstraint('target_user_group_id != user_group_id'),
         base_table_args
     )
 
     user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
 
     target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id', back_populates='user_group_user_group_to_perm')
     user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
     permission = relationship('Permission')
 
     @classmethod
     def create(cls, target_user_group, user_group, permission):
         n = cls()
         n.target_user_group = target_user_group
         n.user_group = user_group
         n.permission = permission
         Session().add(n)
         return n
 
     def __repr__(self):
         return f'<UserGroupUserGroup:{self.target_user_group} => {self.user_group} >'
 
 
 class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'permission_id',),
         base_table_args
     )
 
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UserGroup', back_populates='users_group_to_perm')
     permission = relationship('Permission')
 
 
 class UserRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'user_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'group_id', 'permission_id'),
         base_table_args
     )
 
     group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', back_populates='repo_group_to_perm')
     group = relationship('RepoGroup', back_populates='repo_group_to_perm')
     permission = relationship('Permission')
 
     @classmethod
     def create(cls, user, repository_group, permission):
         n = cls()
         n.user = user
         n.group = repository_group
         n.permission = permission
         Session().add(n)
         return n
 
 
 class UserGroupRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'group_id'),
         base_table_args
     )
 
     users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UserGroup', back_populates='users_group_repo_group_to_perm')
     permission = relationship('Permission')
     group = relationship('RepoGroup', back_populates='users_group_to_perm')
 
     @classmethod
     def create(cls, user_group, repository_group, permission):
         n = cls()
         n.users_group = user_group
         n.group = repository_group
         n.permission = permission
         Session().add(n)
         return n
 
     def __repr__(self):
         return '<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
 
 
 class Statistics(Base, BaseModel):
     __tablename__ = 'statistics'
     __table_args__ = (
          base_table_args
     )
 
     stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
     stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
     commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)  #JSON data
     commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)  #JSON data
     languages = Column("languages", LargeBinary(1000000), nullable=False)  #JSON data
 
     repository = relationship('Repository', single_parent=True, viewonly=True)
 
 
 class UserFollowing(Base, BaseModel):
     __tablename__ = 'user_followings'
     __table_args__ = (
         UniqueConstraint('user_id', 'follows_repository_id'),
         UniqueConstraint('user_id', 'follows_user_id'),
         base_table_args
     )
 
     user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
     follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
 
     user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id', back_populates='followings')
 
     follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
     follows_repository = relationship('Repository', order_by='Repository.repo_name', back_populates='followers')
 
     @classmethod
     def get_repo_followers(cls, repo_id):
         return cls.query().filter(cls.follows_repo_id == repo_id)
 
 
 class CacheKey(Base, BaseModel):
     __tablename__ = 'cache_invalidation'
     __table_args__ = (
         UniqueConstraint('cache_key'),
         Index('key_idx', 'cache_key'),
         Index('cache_args_idx', 'cache_args'),
         base_table_args,
     )
 
     CACHE_TYPE_FEED = 'FEED'
 
     # namespaces used to register process/thread aware caches
     REPO_INVALIDATION_NAMESPACE = 'repo_cache.v1:{repo_id}'
 
     cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
     cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
     cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None)
     cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
 
-    def __init__(self, cache_key, cache_args='', cache_state_uid=None):
+    def __init__(self, cache_key, cache_args='', cache_state_uid=None, cache_active=False):
         self.cache_key = cache_key
         self.cache_args = cache_args
-        self.cache_active = False
+        self.cache_active = cache_active
         # first key should be same for all entries, since all workers should share it
         self.cache_state_uid = cache_state_uid or self.generate_new_state_uid()
 
     def __repr__(self):
         return "<%s('%s:%s[%s]')>" % (
             self.cls_name,
             self.cache_id, self.cache_key, self.cache_active)
 
     def _cache_key_partition(self):
         prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
         return prefix, repo_name, suffix
 
     def get_prefix(self):
         """
         Try to extract prefix from existing cache key. The key could consist
         of prefix, repo_name, suffix
         """
         # this returns prefix, repo_name, suffix
         return self._cache_key_partition()[0]
 
     def get_suffix(self):
         """
         get suffix that might have been used in _get_cache_key to
         generate self.cache_key. Only used for informational purposes
         in repo_edit.mako.
         """
         # prefix, repo_name, suffix
         return self._cache_key_partition()[2]
 
     @classmethod
     def generate_new_state_uid(cls, based_on=None):
         if based_on:
             return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on)))
         else:
             return str(uuid.uuid4())
 
     @classmethod
     def delete_all_cache(cls):
         """
         Delete all cache keys from database.
         Should only be run when all instances are down and all entries
         thus stale.
         """
         cls.query().delete()
         Session().commit()
 
     @classmethod
     def set_invalidate(cls, cache_uid, delete=False):
         """
         Mark all caches of a repo as invalid in the database.
         """
-
         try:
-            qry = Session().query(cls).filter(cls.cache_args == cache_uid)
+            qry = Session().query(cls).filter(cls.cache_key == cache_uid)
             if delete:
                 qry.delete()
                 log.debug('cache objects deleted for cache args %s',
                           safe_str(cache_uid))
             else:
-                qry.update({"cache_active": False,
-                            "cache_state_uid": cls.generate_new_state_uid()})
-                log.debug('cache objects marked as invalid for cache args %s',
-                          safe_str(cache_uid))
+                new_uid = cls.generate_new_state_uid()
+                qry.update({"cache_state_uid": new_uid,
+                            "cache_args": f"repo_state:{time.time()}"})
+                log.debug('cache object %s set new UID %s',
+                          safe_str(cache_uid), new_uid)
 
             Session().commit()
         except Exception:
             log.exception(
                 'Cache key invalidation failed for cache args %s',
                 safe_str(cache_uid))
             Session().rollback()
 
     @classmethod
     def get_active_cache(cls, cache_key):
         inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
         if inv_obj:
             return inv_obj
         return None
 
     @classmethod
     def get_namespace_map(cls, namespace):
         return {
             x.cache_key: x
             for x in cls.query().filter(cls.cache_args == namespace)}
 
 
 class ChangesetComment(Base, BaseModel):
     __tablename__ = 'changeset_comments'
     __table_args__ = (
         Index('cc_revision_idx', 'revision'),
         base_table_args,
     )
 
     COMMENT_OUTDATED = 'comment_outdated'
     COMMENT_TYPE_NOTE = 'note'
     COMMENT_TYPE_TODO = 'todo'
     COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
 
     OP_IMMUTABLE = 'immutable'
     OP_CHANGEABLE = 'changeable'
 
     comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
     repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
     revision = Column('revision', String(40), nullable=True)
     pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
     pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
     line_no = Column('line_no', Unicode(10), nullable=True)
     hl_lines = Column('hl_lines', Unicode(512), nullable=True)
     f_path = Column('f_path', Unicode(1000), nullable=True)
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
     text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     renderer = Column('renderer', Unicode(64), nullable=True)
     display_state = Column('display_state',  Unicode(128), nullable=True)
     immutable_state = Column('immutable_state', Unicode(128), nullable=True, default=OP_CHANGEABLE)
     draft = Column('draft', Boolean(), nullable=True, default=False)
 
     comment_type = Column('comment_type',  Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
     resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
 
     resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by')
     resolved_by = relationship('ChangesetComment', back_populates='resolved_comment')
 
     author = relationship('User', lazy='select', back_populates='user_comments')
     repo = relationship('Repository', back_populates='comments')
     status_change = relationship('ChangesetStatus', cascade="all, delete-orphan", lazy='select', back_populates='comment')
     pull_request = relationship('PullRequest', lazy='select', back_populates='comments')
     pull_request_version = relationship('PullRequestVersion', lazy='select')
     history = relationship('ChangesetCommentHistory', cascade='all, delete-orphan', lazy='select', order_by='ChangesetCommentHistory.version', back_populates="comment")
 
     @classmethod
     def get_users(cls, revision=None, pull_request_id=None):
         """
         Returns user associated with this ChangesetComment. ie those
         who actually commented
 
         :param cls:
         :param revision:
         """
         q = Session().query(User).join(ChangesetComment.author)
         if revision:
             q = q.filter(cls.revision == revision)
         elif pull_request_id:
             q = q.filter(cls.pull_request_id == pull_request_id)
         return q.all()
 
     @classmethod
     def get_index_from_version(cls, pr_version, versions=None, num_versions=None) -> int:
         if pr_version is None:
             return 0
 
         if versions is not None:
             num_versions = [x.pull_request_version_id for x in versions]
 
         num_versions = num_versions or []
         try:
             return num_versions.index(pr_version) + 1
         except (IndexError, ValueError):
             return 0
 
     @property
     def outdated(self):
         return self.display_state == self.COMMENT_OUTDATED
 
     @property
     def outdated_js(self):
         return str_json(self.display_state == self.COMMENT_OUTDATED)
 
     @property
     def immutable(self):
         return self.immutable_state == self.OP_IMMUTABLE
 
     def outdated_at_version(self, version: int) -> bool:
         """
         Checks if comment is outdated for given pull request version
         """
 
         def version_check():
             return self.pull_request_version_id and self.pull_request_version_id != version
 
         if self.is_inline:
             return self.outdated and version_check()
         else:
             # general comments don't have .outdated set, also latest don't have a version
             return version_check()
 
     def outdated_at_version_js(self, version):
         """
         Checks if comment is outdated for given pull request version
         """
         return str_json(self.outdated_at_version(version))
 
     def older_than_version(self, version: int) -> bool:
         """
         Checks if comment is made from a previous version than given.
         Assumes self.pull_request_version.pull_request_version_id is an integer if not None.
         """
 
         # If version is None, return False as the current version cannot be less than None
         if version is None:
             return False
 
         # Ensure that the version is an integer to prevent TypeError on comparison
         if not isinstance(version, int):
             raise ValueError("The provided version must be an integer.")
 
         # Initialize current version to 0 or pull_request_version_id if it's available
         cur_ver = 0
         if self.pull_request_version and self.pull_request_version.pull_request_version_id is not None:
             cur_ver = self.pull_request_version.pull_request_version_id
 
         # Return True if the current version is less than the given version
         return cur_ver < version
 
     def older_than_version_js(self, version):
         """
         Checks if comment is made from previous version than given
         """
         return str_json(self.older_than_version(version))
 
     @property
     def commit_id(self):
         """New style naming to stop using .revision"""
         return self.revision
 
     @property
     def resolved(self):
         return self.resolved_by[0] if self.resolved_by else None
 
     @property
     def is_todo(self):
         return self.comment_type == self.COMMENT_TYPE_TODO
 
     @property
     def is_inline(self):
         if self.line_no and self.f_path:
             return True
         return False
 
     @property
     def last_version(self):
         version = 0
         if self.history:
             version = self.history[-1].version
         return version
 
     def get_index_version(self, versions):
         return self.get_index_from_version(
             self.pull_request_version_id, versions)
 
     @property
     def review_status(self):
         if self.status_change:
             return self.status_change[0].status
 
     @property
     def review_status_lbl(self):
         if self.status_change:
             return self.status_change[0].status_lbl
 
     def __repr__(self):
         if self.comment_id:
             return f'<DB:Comment #{self.comment_id}>'
         else:
             return f'<DB:Comment at {id(self)!r}>'
 
     def get_api_data(self):
         comment = self
 
         data = {
             'comment_id': comment.comment_id,
             'comment_type': comment.comment_type,
             'comment_text': comment.text,
             'comment_status': comment.status_change,
             'comment_f_path': comment.f_path,
             'comment_lineno': comment.line_no,
             'comment_author': comment.author,
             'comment_created_on': comment.created_on,
             'comment_resolved_by': self.resolved,
             'comment_commit_id': comment.revision,
             'comment_pull_request_id': comment.pull_request_id,
             'comment_last_version': self.last_version
         }
         return data
 
     def __json__(self):
         data = dict()
         data.update(self.get_api_data())
         return data
 
 
 class ChangesetCommentHistory(Base, BaseModel):
     __tablename__ = 'changeset_comments_history'
     __table_args__ = (
         Index('cch_comment_id_idx', 'comment_id'),
         base_table_args,
     )
 
     comment_history_id = Column('comment_history_id', Integer(), nullable=False, primary_key=True)
     comment_id = Column('comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)
     version = Column("version", Integer(), nullable=False, default=0)
     created_by_user_id = Column('created_by_user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
     text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     deleted = Column('deleted', Boolean(), default=False)
 
     author = relationship('User', lazy='joined')
     comment = relationship('ChangesetComment', cascade="all, delete", back_populates="history")
 
     @classmethod
     def get_version(cls, comment_id):
         q = Session().query(ChangesetCommentHistory).filter(
             ChangesetCommentHistory.comment_id == comment_id).order_by(ChangesetCommentHistory.version.desc())
         if q.count() == 0:
             return 1
         elif q.count() >= q[0].version:
             return q.count() + 1
         else:
             return q[0].version + 1
 
 
 class ChangesetStatus(Base, BaseModel):
     __tablename__ = 'changeset_statuses'
     __table_args__ = (
         Index('cs_revision_idx', 'revision'),
         Index('cs_version_idx', 'version'),
         UniqueConstraint('repo_id', 'revision', 'version'),
         base_table_args
     )
 
     STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
     STATUS_APPROVED = 'approved'
     STATUS_REJECTED = 'rejected'
     STATUS_UNDER_REVIEW = 'under_review'
 
     STATUSES = [
         (STATUS_NOT_REVIEWED, _("Not Reviewed")),  # (no icon) and default
         (STATUS_APPROVED, _("Approved")),
         (STATUS_REJECTED, _("Rejected")),
         (STATUS_UNDER_REVIEW, _("Under Review")),
     ]
 
     changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
     repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
     revision = Column('revision', String(40), nullable=False)
     status = Column('status', String(128), nullable=False, default=DEFAULT)
     changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
     modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
     version = Column('version', Integer(), nullable=False, default=0)
     pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
 
     author = relationship('User', lazy='select')
     repo = relationship('Repository', lazy='select')
     comment = relationship('ChangesetComment', lazy='select', back_populates='status_change')
     pull_request = relationship('PullRequest', lazy='select', back_populates='statuses')
 
     def __repr__(self):
         return f"<{self.cls_name}('{self.status}[v{self.version}]:{self.author}')>"
 
     @classmethod
     def get_status_lbl(cls, value):
         return dict(cls.STATUSES).get(value)
 
     @property
     def status_lbl(self):
         return ChangesetStatus.get_status_lbl(self.status)
 
     def get_api_data(self):
         status = self
         data = {
             'status_id': status.changeset_status_id,
             'status': status.status,
         }
         return data
 
     def __json__(self):
         data = dict()
         data.update(self.get_api_data())
         return data
 
 
 class _SetState(object):
     """
     Context processor allowing changing state for sensitive operation such as
     pull request update or merge
     """
 
     def __init__(self, pull_request, pr_state, back_state=None):
         self._pr = pull_request
         self._org_state = back_state or pull_request.pull_request_state
         self._pr_state = pr_state
         self._current_state = None
 
     def __enter__(self):
         log.debug('StateLock: entering set state context of pr %s, setting state to: `%s`',
                   self._pr, self._pr_state)
         self.set_pr_state(self._pr_state)
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_val is not None or exc_type is not None:
             log.error(traceback.format_tb(exc_tb))
             return None
 
         self.set_pr_state(self._org_state)
         log.debug('StateLock: exiting set state context of pr %s, setting state to: `%s`',
                   self._pr, self._org_state)
 
     @property
     def state(self):
         return self._current_state
 
     def set_pr_state(self, pr_state):
         try:
             self._pr.pull_request_state = pr_state
             Session().add(self._pr)
             Session().commit()
             self._current_state = pr_state
         except Exception:
             log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state)
             raise
 
 
 class _PullRequestBase(BaseModel):
     """
     Common attributes of pull request and version entries.
     """
 
     # .status values
     STATUS_NEW = 'new'
     STATUS_OPEN = 'open'
     STATUS_CLOSED = 'closed'
 
     # available states
     STATE_CREATING = 'creating'
     STATE_UPDATING = 'updating'
     STATE_MERGING = 'merging'
     STATE_CREATED = 'created'
 
     title = Column('title', Unicode(255), nullable=True)
     description = Column(
         'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
         nullable=True)
     description_renderer = Column('description_renderer', Unicode(64), nullable=True)
 
     # new/open/closed status of pull request (not approve/reject/etc)
     status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
     created_on = Column(
         'created_on', DateTime(timezone=False), nullable=False,
         default=datetime.datetime.now)
     updated_on = Column(
         'updated_on', DateTime(timezone=False), nullable=False,
         default=datetime.datetime.now)
 
     pull_request_state = Column("pull_request_state", String(255), nullable=True)
 
     @declared_attr
     def user_id(cls):
         return Column(
             "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
             unique=None)
 
     # 500 revisions max
     _revisions = Column(
         'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
 
     common_ancestor_id = Column('common_ancestor_id', Unicode(255), nullable=True)
 
     @declared_attr
     def source_repo_id(cls):
         # TODO: dan: rename column to source_repo_id
         return Column(
             'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
             nullable=False)
 
     @declared_attr
     def pr_source(cls):
         return relationship(
             'Repository',
             primaryjoin=f'{cls.__name__}.source_repo_id==Repository.repo_id',
             overlaps="pull_requests_source"
         )
 
     _source_ref = Column('org_ref', Unicode(255), nullable=False)
 
     @hybrid_property
     def source_ref(self):
         return self._source_ref
 
     @source_ref.setter
     def source_ref(self, val):
         parts = (val or '').split(':')
         if len(parts) != 3:
             raise ValueError(
                 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
         self._source_ref = safe_str(val)
 
     _target_ref = Column('other_ref', Unicode(255), nullable=False)
 
     @hybrid_property
     def target_ref(self):
         return self._target_ref
 
     @target_ref.setter
     def target_ref(self, val):
         parts = (val or '').split(':')
         if len(parts) != 3:
             raise ValueError(
                 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
         self._target_ref = safe_str(val)
 
     @declared_attr
     def target_repo_id(cls):
         # TODO: dan: rename column to target_repo_id
         return Column(
             'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
             nullable=False)
 
     @declared_attr
     def pr_target(cls):
         return relationship(
             'Repository',
             primaryjoin=f'{cls.__name__}.target_repo_id==Repository.repo_id',
             overlaps="pull_requests_target"
         )
 
     _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
 
     # TODO: dan: rename column to last_merge_source_rev
     _last_merge_source_rev = Column(
         'last_merge_org_rev', String(40), nullable=True)
     # TODO: dan: rename column to last_merge_target_rev
     _last_merge_target_rev = Column(
         'last_merge_other_rev', String(40), nullable=True)
     _last_merge_status = Column('merge_status', Integer(), nullable=True)
     last_merge_metadata = Column(
         'last_merge_metadata', MutationObj.as_mutable(
             JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
 
     merge_rev = Column('merge_rev', String(40), nullable=True)
 
     reviewer_data = Column(
         'reviewer_data_json', MutationObj.as_mutable(
             JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
 
     @property
     def reviewer_data_json(self):
         return str_json(self.reviewer_data)
 
     @property
     def last_merge_metadata_parsed(self):
         metadata = {}
         if not self.last_merge_metadata:
             return metadata
 
         if hasattr(self.last_merge_metadata, 'de_coerce'):
             for k, v in self.last_merge_metadata.de_coerce().items():
                 if k in ['target_ref', 'source_ref']:
                     metadata[k] = Reference(v['type'], v['name'], v['commit_id'])
                 else:
                     if hasattr(v, 'de_coerce'):
                         metadata[k] = v.de_coerce()
                     else:
                         metadata[k] = v
         return metadata
 
     @property
     def work_in_progress(self):
         """checks if pull request is work in progress by checking the title"""
         title = self.title.upper()
         if re.match(r'^(\[WIP\]\s*|WIP:\s*|WIP\s+)', title):
             return True
         return False
 
     @property
     def title_safe(self):
         return self.title\
             .replace('{', '{{')\
             .replace('}', '}}')
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @hybrid_property
     def revisions(self):
         return self._revisions.split(':') if self._revisions else []
 
     @revisions.setter
     def revisions(self, val):
         self._revisions = ':'.join(val)
 
     @hybrid_property
     def last_merge_status(self):
         return safe_int(self._last_merge_status)
 
     @last_merge_status.setter
     def last_merge_status(self, val):
         self._last_merge_status = val
 
     @declared_attr
     def author(cls):
         return relationship(
             'User', lazy='joined',
             #TODO, problem that is somehow :?
             #back_populates='user_pull_requests'
             )
 
     @declared_attr
     def source_repo(cls):
         return relationship(
             'Repository',
             primaryjoin=f'{cls.__name__}.source_repo_id==Repository.repo_id',
             #back_populates=''
         )
 
     @property
     def source_ref_parts(self):
         return self.unicode_to_reference(self.source_ref)
 
     @declared_attr
     def target_repo(cls):
         return relationship(
             'Repository',
             primaryjoin=f'{cls.__name__}.target_repo_id==Repository.repo_id'
         )
 
     @property
     def target_ref_parts(self):
         return self.unicode_to_reference(self.target_ref)
 
     @property
     def shadow_merge_ref(self):
         return self.unicode_to_reference(self._shadow_merge_ref)
 
     @shadow_merge_ref.setter
     def shadow_merge_ref(self, ref):
         self._shadow_merge_ref = self.reference_to_unicode(ref)
 
     @staticmethod
     def unicode_to_reference(raw):
         return unicode_to_reference(raw)
 
     @staticmethod
     def reference_to_unicode(ref):
         return reference_to_unicode(ref)
 
     def get_api_data(self, with_merge_state=True):
         from rhodecode.model.pull_request import PullRequestModel
 
         pull_request = self
         if with_merge_state:
             merge_response, merge_status, msg = \
                 PullRequestModel().merge_status(pull_request)
             merge_state = {
                 'status': merge_status,
                 'message': safe_str(msg),
             }
         else:
             merge_state = {'status': 'not_available',
                            'message': 'not_available'}
 
         merge_data = {
             'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
             'reference': (
                 pull_request.shadow_merge_ref.asdict()
                 if pull_request.shadow_merge_ref else None),
         }
 
         data = {
             'pull_request_id': pull_request.pull_request_id,
             'url': PullRequestModel().get_url(pull_request),
             'title': pull_request.title,
             'description': pull_request.description,
             'status': pull_request.status,
             'state': pull_request.pull_request_state,
             'created_on': pull_request.created_on,
             'updated_on': pull_request.updated_on,
             'commit_ids': pull_request.revisions,
             'review_status': pull_request.calculated_review_status(),
             'mergeable': merge_state,
             'source': {
                 'clone_url': pull_request.source_repo.clone_url(),
                 'repository': pull_request.source_repo.repo_name,
                 'reference': {
                     'name': pull_request.source_ref_parts.name,
                     'type': pull_request.source_ref_parts.type,
                     'commit_id': pull_request.source_ref_parts.commit_id,
                 },
             },
             'target': {
                 'clone_url': pull_request.target_repo.clone_url(),
                 'repository': pull_request.target_repo.repo_name,
                 'reference': {
                     'name': pull_request.target_ref_parts.name,
                     'type': pull_request.target_ref_parts.type,
                     'commit_id': pull_request.target_ref_parts.commit_id,
                 },
             },
             'merge': merge_data,
             'author': pull_request.author.get_api_data(include_secrets=False,
                                                        details='basic'),
             'reviewers': [
                 {
                     'user': reviewer.get_api_data(include_secrets=False,
                                                   details='basic'),
                     'reasons': reasons,
                     'review_status': st[0][1].status if st else 'not_reviewed',
                 }
                 for obj, reviewer, reasons, mandatory, st in
                 pull_request.reviewers_statuses()
             ]
         }
 
         return data
 
     def set_state(self, pull_request_state, final_state=None):
         """
         # goes from initial state to updating to initial state.
         # initial state can be changed by specifying back_state=
         with pull_request_obj.set_state(PullRequest.STATE_UPDATING):
            pull_request.merge()
 
         :param pull_request_state:
         :param final_state:
 
         """
 
         return _SetState(self, pull_request_state, back_state=final_state)
 
 
 class PullRequest(Base, _PullRequestBase):
     __tablename__ = 'pull_requests'
     __table_args__ = (
         base_table_args,
     )
     LATEST_VER = 'latest'
 
     pull_request_id = Column(
         'pull_request_id', Integer(), nullable=False, primary_key=True)
 
     def __repr__(self):
         if self.pull_request_id:
             return f'<DB:PullRequest #{self.pull_request_id}>'
         else:
             return f'<DB:PullRequest at {id(self)!r}>'
 
     reviewers = relationship('PullRequestReviewers', cascade="all, delete-orphan", back_populates='pull_request')
     statuses = relationship('ChangesetStatus', cascade="all, delete-orphan", back_populates='pull_request')
     comments = relationship('ChangesetComment', cascade="all, delete-orphan", back_populates='pull_request')
     versions = relationship('PullRequestVersion', cascade="all, delete-orphan", lazy='dynamic', back_populates='pull_request')
 
     @classmethod
     def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
                               internal_methods=None):
 
         class PullRequestDisplay(object):
             """
             Special object wrapper for showing PullRequest data via Versions
             It mimics PR object as close as possible. This is read only object
             just for display
             """
 
             def __init__(self, attrs, internal=None):
                 self.attrs = attrs
                 # internal have priority over the given ones via attrs
                 self.internal = internal or ['versions']
 
             def __getattr__(self, item):
                 if item in self.internal:
                     return getattr(self, item)
                 try:
                     return self.attrs[item]
                 except KeyError:
                     raise AttributeError(
                         '%s object has no attribute %s' % (self, item))
 
             def __repr__(self):
                 pr_id = self.attrs.get('pull_request_id')
                 return f'<DB:PullRequestDisplay #{pr_id}>'
 
             def versions(self):
                 return pull_request_obj.versions.order_by(
                     PullRequestVersion.pull_request_version_id).all()
 
             def is_closed(self):
                 return pull_request_obj.is_closed()
 
             def is_state_changing(self):
                 return pull_request_obj.is_state_changing()
 
             @property
             def pull_request_version_id(self):
                 return getattr(pull_request_obj, 'pull_request_version_id', None)
 
             @property
             def pull_request_last_version(self):
                 return pull_request_obj.pull_request_last_version
 
         attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False))
 
         attrs.author = StrictAttributeDict(
             pull_request_obj.author.get_api_data())
         if pull_request_obj.target_repo:
             attrs.target_repo = StrictAttributeDict(
                 pull_request_obj.target_repo.get_api_data())
             attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
 
         if pull_request_obj.source_repo:
             attrs.source_repo = StrictAttributeDict(
                 pull_request_obj.source_repo.get_api_data())
             attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
 
         attrs.source_ref_parts = pull_request_obj.source_ref_parts
         attrs.target_ref_parts = pull_request_obj.target_ref_parts
         attrs.revisions = pull_request_obj.revisions
         attrs.common_ancestor_id = pull_request_obj.common_ancestor_id
         attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
         attrs.reviewer_data = org_pull_request_obj.reviewer_data
         attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
 
         return PullRequestDisplay(attrs, internal=internal_methods)
 
     def is_closed(self):
         return self.status == self.STATUS_CLOSED
 
     def is_state_changing(self):
         return self.pull_request_state != PullRequest.STATE_CREATED
 
     def __json__(self):
         return {
             'revisions': self.revisions,
             'versions': self.versions_count
         }
 
     def calculated_review_status(self):
         from rhodecode.model.changeset_status import ChangesetStatusModel
         return ChangesetStatusModel().calculated_review_status(self)
 
     def reviewers_statuses(self, user=None):
         from rhodecode.model.changeset_status import ChangesetStatusModel
         return ChangesetStatusModel().reviewers_statuses(self, user=user)
 
     def get_pull_request_reviewers(self, role=None):
         qry = PullRequestReviewers.query()\
             .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)
         if role:
             qry = qry.filter(PullRequestReviewers.role == role)
 
         return qry.all()
 
     @property
     def reviewers_count(self):
         qry = PullRequestReviewers.query()\
             .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\
             .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_REVIEWER)
         return qry.count()
 
     @property
     def observers_count(self):
         qry = PullRequestReviewers.query()\
             .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\
             .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER)
         return qry.count()
 
     def observers(self):
         qry = PullRequestReviewers.query()\
             .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\
             .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER)\
             .all()
 
         for entry in qry:
             yield entry, entry.user
 
     @property
     def workspace_id(self):
         from rhodecode.model.pull_request import PullRequestModel
         return PullRequestModel()._workspace_id(self)
 
     def get_shadow_repo(self):
         workspace_id = self.workspace_id
         shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id)
         if os.path.isdir(shadow_repository_path):
             vcs_obj = self.target_repo.scm_instance()
             return vcs_obj.get_shadow_instance(shadow_repository_path)
 
     @property
     def versions_count(self):
         """
         return number of versions this PR have, e.g a PR that once been
         updated will have 2 versions
         """
         return self.versions.count() + 1
 
     @property
     def pull_request_last_version(self):
         return self.versions_count
 
 
 class PullRequestVersion(Base, _PullRequestBase):
     __tablename__ = 'pull_request_versions'
     __table_args__ = (
         base_table_args,
     )
 
     pull_request_version_id = Column('pull_request_version_id', Integer(), nullable=False, primary_key=True)
     pull_request_id = Column('pull_request_id', Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=False)
     pull_request = relationship('PullRequest',  back_populates='versions')
 
     def __repr__(self):
         if self.pull_request_version_id:
             return f'<DB:PullRequestVersion #{self.pull_request_version_id}>'
         else:
             return f'<DB:PullRequestVersion at {id(self)!r}>'
 
     @property
     def reviewers(self):
         return self.pull_request.reviewers
 
     @property
     def versions(self):
         return self.pull_request.versions
 
     def is_closed(self):
         # calculate from original
         return self.pull_request.status == self.STATUS_CLOSED
 
     def is_state_changing(self):
         return self.pull_request.pull_request_state != PullRequest.STATE_CREATED
 
     def calculated_review_status(self):
         return self.pull_request.calculated_review_status()
 
     def reviewers_statuses(self):
         return self.pull_request.reviewers_statuses()
 
     def observers(self):
         return self.pull_request.observers()
 
 
 class PullRequestReviewers(Base, BaseModel):
     __tablename__ = 'pull_request_reviewers'
     __table_args__ = (
         base_table_args,
     )
     ROLE_REVIEWER = 'reviewer'
     ROLE_OBSERVER = 'observer'
     ROLES = [ROLE_REVIEWER, ROLE_OBSERVER]
 
     @hybrid_property
     def reasons(self):
         if not self._reasons:
             return []
         return self._reasons
 
     @reasons.setter
     def reasons(self, val):
         val = val or []
         if any(not isinstance(x, str) for x in val):
             raise Exception('invalid reasons type, must be list of strings')
         self._reasons = val
 
     pull_requests_reviewers_id = Column(
         'pull_requests_reviewers_id', Integer(), nullable=False,
         primary_key=True)
     pull_request_id = Column(
         "pull_request_id", Integer(),
         ForeignKey('pull_requests.pull_request_id'), nullable=False)
     user_id = Column(
         "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
     _reasons = Column(
         'reason', MutationList.as_mutable(
             JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
 
     mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
     role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
 
     user = relationship('User')
     pull_request = relationship('PullRequest', back_populates='reviewers')
 
     rule_data = Column(
         'rule_data_json',
         JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
 
     def rule_user_group_data(self):
         """
         Returns the voting user group rule data for this reviewer
         """
 
         if self.rule_data and 'vote_rule' in self.rule_data:
             user_group_data = {}
             if 'rule_user_group_entry_id' in self.rule_data:
                 # means a group with voting rules !
                 user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
                 user_group_data['name'] = self.rule_data['rule_name']
                 user_group_data['vote_rule'] = self.rule_data['vote_rule']
 
             return user_group_data
 
     @classmethod
     def get_pull_request_reviewers(cls, pull_request_id, role=None):
         qry = PullRequestReviewers.query()\
             .filter(PullRequestReviewers.pull_request_id == pull_request_id)
         if role:
             qry = qry.filter(PullRequestReviewers.role == role)
 
         return qry.all()
 
     def __repr__(self):
         return f"<{self.cls_name}('id:{self.pull_requests_reviewers_id}')>"
 
 
 class Notification(Base, BaseModel):
     __tablename__ = 'notifications'
     __table_args__ = (
         Index('notification_type_idx', 'type'),
         base_table_args,
     )
 
     TYPE_CHANGESET_COMMENT = 'cs_comment'
     TYPE_MESSAGE = 'message'
     TYPE_MENTION = 'mention'
     TYPE_REGISTRATION = 'registration'
     TYPE_PULL_REQUEST = 'pull_request'
     TYPE_PULL_REQUEST_COMMENT = 'pull_request_comment'
     TYPE_PULL_REQUEST_UPDATE = 'pull_request_update'
 
     notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
     subject = Column('subject', Unicode(512), nullable=True)
     body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
     created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     type_ = Column('type', Unicode(255))
 
     created_by_user = relationship('User', back_populates='user_created_notifications')
     notifications_to_users = relationship('UserNotification', lazy='joined', cascade="all, delete-orphan", back_populates='notification')
 
     @property
     def recipients(self):
         return [x.user for x in UserNotification.query()\
                 .filter(UserNotification.notification == self)\
                 .order_by(UserNotification.user_id.asc()).all()]
 
     @classmethod
     def create(cls, created_by, subject, body, recipients, type_=None):
         if type_ is None:
             type_ = Notification.TYPE_MESSAGE
 
         notification = cls()
         notification.created_by_user = created_by
         notification.subject = subject
         notification.body = body
         notification.type_ = type_
         notification.created_on = datetime.datetime.now()
 
         # For each recipient link the created notification to his account
         for u in recipients:
             assoc = UserNotification()
             assoc.user_id = u.user_id
             assoc.notification = notification
 
             # if created_by is inside recipients mark his notification
             # as read
             if u.user_id == created_by.user_id:
                 assoc.read = True
             Session().add(assoc)
 
         Session().add(notification)
 
         return notification
 
 
 class UserNotification(Base, BaseModel):
     __tablename__ = 'user_to_notification'
     __table_args__ = (
         UniqueConstraint('user_id', 'notification_id'),
         base_table_args
     )
 
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
     notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
     read = Column('read', Boolean, default=False)
     sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
 
     user = relationship('User', lazy="joined", back_populates='notifications')
     notification = relationship('Notification', lazy="joined", order_by=lambda: Notification.created_on.desc(), back_populates='notifications_to_users')
 
     def mark_as_read(self):
         self.read = True
         Session().add(self)
 
 
 class UserNotice(Base, BaseModel):
     __tablename__ = 'user_notices'
     __table_args__ = (
         base_table_args
     )
 
     NOTIFICATION_TYPE_MESSAGE = 'message'
     NOTIFICATION_TYPE_NOTICE = 'notice'
 
     NOTIFICATION_LEVEL_INFO = 'info'
     NOTIFICATION_LEVEL_WARNING = 'warning'
     NOTIFICATION_LEVEL_ERROR = 'error'
 
     user_notice_id = Column('gist_id', Integer(), primary_key=True)
 
     notice_subject = Column('notice_subject', Unicode(512), nullable=True)
     notice_body = Column('notice_body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
 
     notice_read = Column('notice_read', Boolean, default=False)
 
     notification_level = Column('notification_level', String(1024), default=NOTIFICATION_LEVEL_INFO)
     notification_type = Column('notification_type', String(1024), default=NOTIFICATION_TYPE_NOTICE)
 
     notice_created_by = Column('notice_created_by', Integer(), ForeignKey('users.user_id'), nullable=True)
     notice_created_on = Column('notice_created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'))
     user = relationship('User', lazy="joined", primaryjoin='User.user_id==UserNotice.user_id')
 
     @classmethod
     def create_for_user(cls, user, subject, body, notice_level=NOTIFICATION_LEVEL_INFO, allow_duplicate=False):
 
         if notice_level not in [cls.NOTIFICATION_LEVEL_ERROR,
                                 cls.NOTIFICATION_LEVEL_WARNING,
                                 cls.NOTIFICATION_LEVEL_INFO]:
             return
 
         from rhodecode.model.user import UserModel
         user = UserModel().get_user(user)
 
         new_notice = UserNotice()
         if not allow_duplicate:
             existing_msg = UserNotice().query() \
                 .filter(UserNotice.user == user) \
                 .filter(UserNotice.notice_body == body) \
                 .filter(UserNotice.notice_read == false()) \
                 .scalar()
             if existing_msg:
                 log.warning('Ignoring duplicate notice for user %s', user)
                 return
 
         new_notice.user = user
         new_notice.notice_subject = subject
         new_notice.notice_body = body
         new_notice.notification_level = notice_level
         Session().add(new_notice)
         Session().commit()
 
 
 class Gist(Base, BaseModel):
     __tablename__ = 'gists'
     __table_args__ = (
         Index('g_gist_access_id_idx', 'gist_access_id'),
         Index('g_created_on_idx', 'created_on'),
         base_table_args
     )
 
     GIST_PUBLIC = 'public'
     GIST_PRIVATE = 'private'
     DEFAULT_FILENAME = 'gistfile1.txt'
 
     ACL_LEVEL_PUBLIC = 'acl_public'
     ACL_LEVEL_PRIVATE = 'acl_private'
 
     gist_id = Column('gist_id', Integer(), primary_key=True)
     gist_access_id = Column('gist_access_id', Unicode(250))
     gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
     gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
     gist_expires = Column('gist_expires', Float(53), nullable=False)
     gist_type = Column('gist_type', Unicode(128), nullable=False)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     acl_level = Column('acl_level', Unicode(128), nullable=True)
 
     owner = relationship('User', back_populates='user_gists')
 
     def __repr__(self):
         return f'<Gist:[{self.gist_type}]{self.gist_access_id}>'
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.gist_description)
 
     @classmethod
     def get_or_404(cls, id_):
         from pyramid.httpexceptions import HTTPNotFound
 
         res = cls.query().filter(cls.gist_access_id == id_).scalar()
         if not res:
             log.debug('WARN: No DB entry with id %s', id_)
             raise HTTPNotFound()
         return res
 
     @classmethod
     def get_by_access_id(cls, gist_access_id):
         return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
 
     def gist_url(self):
         from rhodecode.model.gist import GistModel
         return GistModel().get_url(self)
 
     @classmethod
     def base_path(cls):
         """
         Returns base path when all gists are stored
 
         :param cls:
         """
         from rhodecode.model.gist import GIST_STORE_LOC
         q = Session().query(RhodeCodeUi)\
             .filter(RhodeCodeUi.ui_key == URL_SEP)
         q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
         return os.path.join(q.one().ui_value, GIST_STORE_LOC)
 
     def get_api_data(self):
         """
         Common function for generating gist related data for API
         """
         gist = self
         data = {
             'gist_id': gist.gist_id,
             'type': gist.gist_type,
             'access_id': gist.gist_access_id,
             'description': gist.gist_description,
             'url': gist.gist_url(),
             'expires': gist.gist_expires,
             'created_on': gist.created_on,
             'modified_at': gist.modified_at,
             'content': None,
             'acl_level': gist.acl_level,
         }
         return data
 
     def __json__(self):
         data = dict(
         )
         data.update(self.get_api_data())
         return data
     # SCM functions
 
     def scm_instance(self, **kwargs):
         """
         Get an instance of VCS Repository
 
         :param kwargs:
         """
         from rhodecode.model.gist import GistModel
         full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
         return get_vcs_instance(
             repo_path=safe_str(full_repo_path), create=False,
             _vcs_alias=GistModel.vcs_backend)
 
 
 class ExternalIdentity(Base, BaseModel):
     __tablename__ = 'external_identities'
     __table_args__ = (
         Index('local_user_id_idx', 'local_user_id'),
         Index('external_id_idx', 'external_id'),
         base_table_args
     )
 
     external_id = Column('external_id', Unicode(255), default='', primary_key=True)
     external_username = Column('external_username', Unicode(1024), default='')
     local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
     provider_name = Column('provider_name', Unicode(255), default='', primary_key=True)
     access_token = Column('access_token', String(1024), default='')
     alt_token = Column('alt_token', String(1024), default='')
     token_secret = Column('token_secret', String(1024), default='')
 
     @classmethod
     def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None):
         """
         Returns ExternalIdentity instance based on search params
 
         :param external_id:
         :param provider_name:
         :return: ExternalIdentity
         """
         query = cls.query()
         query = query.filter(cls.external_id == external_id)
         query = query.filter(cls.provider_name == provider_name)
         if local_user_id:
             query = query.filter(cls.local_user_id == local_user_id)
         return query.first()
 
     @classmethod
     def user_by_external_id_and_provider(cls, external_id, provider_name):
         """
         Returns User instance based on search params
 
         :param external_id:
         :param provider_name:
         :return: User
         """
         query = User.query()
         query = query.filter(cls.external_id == external_id)
         query = query.filter(cls.provider_name == provider_name)
         query = query.filter(User.user_id == cls.local_user_id)
         return query.first()
 
     @classmethod
     def by_local_user_id(cls, local_user_id):
         """
         Returns all tokens for user
 
         :param local_user_id:
         :return: ExternalIdentity
         """
         query = cls.query()
         query = query.filter(cls.local_user_id == local_user_id)
         return query
 
     @classmethod
     def load_provider_plugin(cls, plugin_id):
         from rhodecode.authentication.base import loadplugin
         _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id)
         auth_plugin = loadplugin(_plugin_id)
         return auth_plugin
 
 
 class Integration(Base, BaseModel):
     __tablename__ = 'integrations'
     __table_args__ = (
         base_table_args
     )
 
     integration_id = Column('integration_id', Integer(), primary_key=True)
     integration_type = Column('integration_type', String(255))
     enabled = Column('enabled', Boolean(), nullable=False)
     name = Column('name', String(255), nullable=False)
     child_repos_only = Column('child_repos_only', Boolean(), nullable=False, default=False)
 
     settings = Column(
         'settings_json', MutationObj.as_mutable(
             JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
     repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
     repo = relationship('Repository', lazy='joined', back_populates='integrations')
 
     repo_group_id = Column('repo_group_id', Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
     repo_group = relationship('RepoGroup', lazy='joined', back_populates='integrations')
 
     @property
     def scope(self):
         if self.repo:
             return repr(self.repo)
         if self.repo_group:
             if self.child_repos_only:
                 return repr(self.repo_group) + ' (child repos only)'
             else:
                 return repr(self.repo_group) + ' (recursive)'
         if self.child_repos_only:
             return 'root_repos'
         return 'global'
 
     def __repr__(self):
         return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
 
 
 class RepoReviewRuleUser(Base, BaseModel):
     __tablename__ = 'repo_review_rules_users'
     __table_args__ = (
         base_table_args
     )
     ROLE_REVIEWER = 'reviewer'
     ROLE_OBSERVER = 'observer'
     ROLES = [ROLE_REVIEWER, ROLE_OBSERVER]
 
     repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)
     repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)
     mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
     role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
     user = relationship('User', back_populates='user_review_rules')
 
     def rule_data(self):
         return {
             'mandatory': self.mandatory,
             'role': self.role,
         }
 
 
 class RepoReviewRuleUserGroup(Base, BaseModel):
     __tablename__ = 'repo_review_rules_users_groups'
     __table_args__ = (
         base_table_args
     )
 
     VOTE_RULE_ALL = -1
     ROLE_REVIEWER = 'reviewer'
     ROLE_OBSERVER = 'observer'
     ROLES = [ROLE_REVIEWER, ROLE_OBSERVER]
 
     repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)
     repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)
     mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
     role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
     vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
     users_group = relationship('UserGroup')
 
     def rule_data(self):
         return {
             'mandatory': self.mandatory,
             'role': self.role,
             'vote_rule': self.vote_rule
         }
 
     @property
     def vote_rule_label(self):
         if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
             return 'all must vote'
         else:
             return 'min. vote {}'.format(self.vote_rule)
 
 
 class RepoReviewRule(Base, BaseModel):
     __tablename__ = 'repo_review_rules'
     __table_args__ = (
         base_table_args
     )
 
     repo_review_rule_id = Column(
         'repo_review_rule_id', Integer(), primary_key=True)
     repo_id = Column(
         "repo_id", Integer(), ForeignKey('repositories.repo_id'))
     repo = relationship('Repository', back_populates='review_rules')
 
     review_rule_name = Column('review_rule_name', String(255))
     _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*')  # glob
     _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*')  # glob
     _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default='*')  # glob
 
     use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)
 
     # Legacy fields, just for backward compat
     _forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
     _forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
 
     pr_author = Column("pr_author", UnicodeText().with_variant(UnicodeText(255), 'mysql'), nullable=True)
     commit_author = Column("commit_author", UnicodeText().with_variant(UnicodeText(255), 'mysql'), nullable=True)
 
     forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
 
     rule_users = relationship('RepoReviewRuleUser')
     rule_user_groups = relationship('RepoReviewRuleUserGroup')
 
     def _validate_pattern(self, value):
         re.compile('^' + glob2re(value) + '$')
 
     @hybrid_property
     def source_branch_pattern(self):
         return self._branch_pattern or '*'
 
     @source_branch_pattern.setter
     def source_branch_pattern(self, value):
         self._validate_pattern(value)
         self._branch_pattern = value or '*'
 
     @hybrid_property
     def target_branch_pattern(self):
         return self._target_branch_pattern or '*'
 
     @target_branch_pattern.setter
     def target_branch_pattern(self, value):
         self._validate_pattern(value)
         self._target_branch_pattern = value or '*'
 
     @hybrid_property
     def file_pattern(self):
         return self._file_pattern or '*'
 
     @file_pattern.setter
     def file_pattern(self, value):
         self._validate_pattern(value)
         self._file_pattern = value or '*'
 
     @hybrid_property
     def forbid_pr_author_to_review(self):
         return self.pr_author == 'forbid_pr_author'
 
     @hybrid_property
     def include_pr_author_to_review(self):
         return self.pr_author == 'include_pr_author'
 
     @hybrid_property
     def forbid_commit_author_to_review(self):
         return self.commit_author == 'forbid_commit_author'
 
     @hybrid_property
     def include_commit_author_to_review(self):
         return self.commit_author == 'include_commit_author'
 
     def matches(self, source_branch, target_branch, files_changed):
         """
         Check if this review rule matches a branch/files in a pull request
 
         :param source_branch: source branch name for the commit
         :param target_branch: target branch name for the commit
         :param files_changed: list of file paths changed in the pull request
         """
 
         source_branch = source_branch or ''
         target_branch = target_branch or ''
         files_changed = files_changed or []
 
         branch_matches = True
         if source_branch or target_branch:
             if self.source_branch_pattern == '*':
                 source_branch_match = True
             else:
                 if self.source_branch_pattern.startswith('re:'):
                     source_pattern = self.source_branch_pattern[3:]
                 else:
                     source_pattern = '^' + glob2re(self.source_branch_pattern) + '$'
                 source_branch_regex = re.compile(source_pattern)
                 source_branch_match = bool(source_branch_regex.search(source_branch))
             if self.target_branch_pattern == '*':
                 target_branch_match = True
             else:
                 if self.target_branch_pattern.startswith('re:'):
                     target_pattern = self.target_branch_pattern[3:]
                 else:
                     target_pattern = '^' + glob2re(self.target_branch_pattern) + '$'
                 target_branch_regex = re.compile(target_pattern)
                 target_branch_match = bool(target_branch_regex.search(target_branch))
 
             branch_matches = source_branch_match and target_branch_match
 
         files_matches = True
         if self.file_pattern != '*':
             files_matches = False
             if self.file_pattern.startswith('re:'):
                 file_pattern = self.file_pattern[3:]
             else:
                 file_pattern = glob2re(self.file_pattern)
             file_regex = re.compile(file_pattern)
             for file_data in files_changed:
                 filename = file_data.get('filename')
 
                 if file_regex.search(filename):
                     files_matches = True
                     break
 
         return branch_matches and files_matches
 
     @property
     def review_users(self):
         """ Returns the users which this rule applies to """
 
         users = collections.OrderedDict()
 
         for rule_user in self.rule_users:
             if rule_user.user.active:
                 if rule_user.user not in users:
                     users[rule_user.user.username] = {
                         'user': rule_user.user,
                         'source': 'user',
                         'source_data': {},
                         'data': rule_user.rule_data()
                     }
 
         for rule_user_group in self.rule_user_groups:
             source_data = {
                 'user_group_id': rule_user_group.users_group.users_group_id,
                 'name': rule_user_group.users_group.users_group_name,
                 'members': len(rule_user_group.users_group.members)
             }
             for member in rule_user_group.users_group.members:
                 if member.user.active:
                     key = member.user.username
                     if key in users:
                         # skip this member as we have him already
                         # this prevents from override the "first" matched
                         # users with duplicates in multiple groups
                         continue
 
                     users[key] = {
                         'user': member.user,
                         'source': 'user_group',
                         'source_data': source_data,
                         'data': rule_user_group.rule_data()
                     }
 
         return users
 
     def user_group_vote_rule(self, user_id):
 
         rules = []
         if not self.rule_user_groups:
             return rules
 
         for user_group in self.rule_user_groups:
             user_group_members = [x.user_id for x in user_group.users_group.members]
             if user_id in user_group_members:
                 rules.append(user_group)
         return rules
 
     def __repr__(self):
         return f'<RepoReviewerRule(id={self.repo_review_rule_id}, repo={self.repo!r})>'
 
 
 class ScheduleEntry(Base, BaseModel):
     __tablename__ = 'schedule_entries'
     __table_args__ = (
         UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
         UniqueConstraint('task_uid', name='s_task_uid_idx'),
         base_table_args,
     )
     SCHEDULE_TYPE_INTEGER = "integer"
     SCHEDULE_TYPE_CRONTAB = "crontab"
 
     schedule_types = [SCHEDULE_TYPE_CRONTAB, SCHEDULE_TYPE_INTEGER]
     schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
 
     schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
     schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
     schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
 
     _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
     schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
 
     schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
     schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
 
     # task
     task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
     task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
     task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
     task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
 
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
 
     @hybrid_property
     def schedule_type(self):
         return self._schedule_type
 
     @schedule_type.setter
     def schedule_type(self, val):
         if val not in self.schedule_types:
             raise ValueError('Value must be on of `{}` and got `{}`'.format(
                 val, self.schedule_type))
 
         self._schedule_type = val
 
     @classmethod
     def get_uid(cls, obj):
         args = obj.task_args
         kwargs = obj.task_kwargs
         if isinstance(args, JsonRaw):
             try:
                 args = json.loads(args)
             except ValueError:
                 args = tuple()
 
         if isinstance(kwargs, JsonRaw):
             try:
                 kwargs = json.loads(kwargs)
             except ValueError:
                 kwargs = dict()
 
         dot_notation = obj.task_dot_notation
         val = '.'.join(map(safe_str, [
             sorted(dot_notation), args, sorted(kwargs.items())]))
         return sha1(safe_bytes(val))
 
     @classmethod
     def get_by_schedule_name(cls, schedule_name):
         return cls.query().filter(cls.schedule_name == schedule_name).scalar()
 
     @classmethod
     def get_by_schedule_id(cls, schedule_id):
         return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
 
     @property
     def task(self):
         return self.task_dot_notation
 
     @property
     def schedule(self):
         from rhodecode.lib.celerylib.utils import raw_2_schedule
         schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
         return schedule
 
     @property
     def args(self):
         try:
             return list(self.task_args or [])
         except ValueError:
             return list()
 
     @property
     def kwargs(self):
         try:
             return dict(self.task_kwargs or {})
         except ValueError:
             return dict()
 
     def _as_raw(self, val, indent=False):
         if hasattr(val, 'de_coerce'):
             val = val.de_coerce()
             if val:
                 if indent:
                     val = ext_json.formatted_str_json(val)
                 else:
                     val = ext_json.str_json(val)
 
         return val
 
     @property
     def schedule_definition_raw(self):
         return self._as_raw(self.schedule_definition)
 
     def args_raw(self, indent=False):
         return self._as_raw(self.task_args, indent)
 
     def kwargs_raw(self, indent=False):
         return self._as_raw(self.task_kwargs, indent)
 
     def __repr__(self):
         return f'<DB:ScheduleEntry({self.schedule_entry_id}:{self.schedule_name})>'
 
 
 @event.listens_for(ScheduleEntry, 'before_update')
 def update_task_uid(mapper, connection, target):
     target.task_uid = ScheduleEntry.get_uid(target)
 
 
 @event.listens_for(ScheduleEntry, 'before_insert')
 def set_task_uid(mapper, connection, target):
     target.task_uid = ScheduleEntry.get_uid(target)
 
 
 class _BaseBranchPerms(BaseModel):
     @classmethod
     def compute_hash(cls, value):
         return sha1_safe(value)
 
     @hybrid_property
     def branch_pattern(self):
         return self._branch_pattern or '*'
 
     @hybrid_property
     def branch_hash(self):
         return self._branch_hash
 
     def _validate_glob(self, value):
         re.compile('^' + glob2re(value) + '$')
 
     @branch_pattern.setter
     def branch_pattern(self, value):
         self._validate_glob(value)
         self._branch_pattern = value or '*'
         # set the Hash when setting the branch pattern
         self._branch_hash = self.compute_hash(self._branch_pattern)
 
     def matches(self, branch):
         """
         Check if this the branch matches entry
 
         :param branch: branch name for the commit
         """
 
         branch = branch or ''
 
         branch_matches = True
         if branch:
             branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
             branch_matches = bool(branch_regex.search(branch))
 
         return branch_matches
 
 
 class UserToRepoBranchPermission(Base, _BaseBranchPerms):
     __tablename__ = 'user_to_repo_branch_permissions'
     __table_args__ = (
         base_table_args
     )
 
     branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
 
     repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     repo = relationship('Repository', back_populates='user_branch_perms')
 
     permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     permission = relationship('Permission')
 
     rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None)
     user_repo_to_perm = relationship('UserRepoToPerm', back_populates='branch_perm_entry')
 
     rule_order = Column('rule_order', Integer(), nullable=False)
     _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default='*')  # glob
     _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
 
     def __repr__(self):
         return f'<UserBranchPermission({self.user_repo_to_perm} => {self.branch_pattern!r})>'
 
 
 class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms):
     __tablename__ = 'user_group_to_repo_branch_permissions'
     __table_args__ = (
         base_table_args
     )
 
     branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
 
     repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     repo = relationship('Repository', back_populates='user_group_branch_perms')
 
     permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     permission = relationship('Permission')
 
     rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('users_group_repo_to_perm.users_group_to_perm_id'), nullable=False, unique=None, default=None)
     user_group_repo_to_perm = relationship('UserGroupRepoToPerm', back_populates='user_group_branch_perms')
 
     rule_order = Column('rule_order', Integer(), nullable=False)
     _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default='*')  # glob
     _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
 
     def __repr__(self):
         return f'<UserBranchPermission({self.user_group_repo_to_perm} => {self.branch_pattern!r})>'
 
 
 class UserBookmark(Base, BaseModel):
     __tablename__ = 'user_bookmarks'
     __table_args__ = (
         UniqueConstraint('user_id', 'bookmark_repo_id'),
         UniqueConstraint('user_id', 'bookmark_repo_group_id'),
         UniqueConstraint('user_id', 'bookmark_position'),
         base_table_args
     )
 
     user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     position = Column("bookmark_position", Integer(), nullable=False)
     title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None)
     redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None)
     created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None)
     bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None)
 
     user = relationship("User")
 
     repository = relationship("Repository")
     repository_group = relationship("RepoGroup")
 
     @classmethod
     def get_by_position_for_user(cls, position, user_id):
         return cls.query() \
             .filter(UserBookmark.user_id == user_id) \
             .filter(UserBookmark.position == position).scalar()
 
     @classmethod
     def get_bookmarks_for_user(cls, user_id, cache=True):
         bookmarks = cls.query() \
             .filter(UserBookmark.user_id == user_id) \
             .options(joinedload(UserBookmark.repository)) \
             .options(joinedload(UserBookmark.repository_group)) \
             .order_by(UserBookmark.position.asc())
 
         if cache:
             bookmarks = bookmarks.options(
                 FromCache("sql_cache_short", "get_user_{}_bookmarks".format(user_id))
             )
 
         return bookmarks.all()
 
     def __repr__(self):
         return f'<UserBookmark({self.position} @ {self.redirect_url!r})>'
 
 
 class FileStore(Base, BaseModel):
     __tablename__ = 'file_store'
     __table_args__ = (
         base_table_args
     )
 
     file_store_id = Column('file_store_id', Integer(), primary_key=True)
     file_uid = Column('file_uid', String(1024), nullable=False)
     file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True)
     file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True)
     file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False)
 
     # sha256 hash
     file_hash = Column('file_hash', String(512), nullable=False)
     file_size = Column('file_size', BigInteger(), nullable=False)
 
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True)
     accessed_count = Column('accessed_count', Integer(), default=0)
 
     enabled = Column('enabled', Boolean(), nullable=False, default=True)
 
     # if repo/repo_group reference is set, check for permissions
     check_acl = Column('check_acl', Boolean(), nullable=False, default=True)
 
     # hidden defines an attachment that should be hidden from showing in artifact listing
     hidden = Column('hidden', Boolean(), nullable=False, default=False)
 
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
     upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id', back_populates='artifacts')
 
     file_metadata = relationship('FileStoreMetadata', lazy='joined')
 
     # scope limited to user, which requester have access to
     scope_user_id = Column(
         'scope_user_id', Integer(), ForeignKey('users.user_id'),
         nullable=True, unique=None, default=None)
     user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id', back_populates='scope_artifacts')
 
     # scope limited to user group, which requester have access to
     scope_user_group_id = Column(
         'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'),
         nullable=True, unique=None, default=None)
     user_group = relationship('UserGroup', lazy='joined')
 
     # scope limited to repo, which requester have access to
     scope_repo_id = Column(
         'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'),
         nullable=True, unique=None, default=None)
     repo = relationship('Repository', lazy='joined')
 
     # scope limited to repo group, which requester have access to
     scope_repo_group_id = Column(
         'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'),
         nullable=True, unique=None, default=None)
     repo_group = relationship('RepoGroup', lazy='joined')
 
     @classmethod
     def get_scope(cls, scope_type, scope_id):
         if scope_type == 'repo':
             return f'repo:{scope_id}'
         elif scope_type == 'repo-group':
             return f'repo-group:{scope_id}'
         elif scope_type == 'user':
             return f'user:{scope_id}'
         elif scope_type == 'user-group':
             return f'user-group:{scope_id}'
         else:
             return scope_type
 
     @classmethod
     def get_by_store_uid(cls, file_store_uid, safe=False):
         if safe:
             return FileStore.query().filter(FileStore.file_uid == file_store_uid).first()
         else:
             return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar()
 
     @classmethod
     def create(cls, file_uid, filename, file_hash, file_size, file_display_name='',
                file_description='', enabled=True, hidden=False, check_acl=True,
                user_id=None, scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None):
 
         store_entry = FileStore()
         store_entry.file_uid = file_uid
         store_entry.file_display_name = file_display_name
         store_entry.file_org_name = filename
         store_entry.file_size = file_size
         store_entry.file_hash = file_hash
         store_entry.file_description = file_description
 
         store_entry.check_acl = check_acl
         store_entry.enabled = enabled
         store_entry.hidden = hidden
 
         store_entry.user_id = user_id
         store_entry.scope_user_id = scope_user_id
         store_entry.scope_repo_id = scope_repo_id
         store_entry.scope_repo_group_id = scope_repo_group_id
 
         return store_entry
 
     @classmethod
     def store_metadata(cls, file_store_id, args, commit=True):
         file_store = FileStore.get(file_store_id)
         if file_store is None:
             return
 
         for section, key, value, value_type in args:
             has_key = FileStoreMetadata().query() \
                 .filter(FileStoreMetadata.file_store_id == file_store.file_store_id) \
                 .filter(FileStoreMetadata.file_store_meta_section == section) \
                 .filter(FileStoreMetadata.file_store_meta_key == key) \
                 .scalar()
             if has_key:
                 msg = 'key `{}` already defined under section `{}` for this file.'\
                     .format(key, section)
                 raise ArtifactMetadataDuplicate(msg, err_section=section, err_key=key)
 
             # NOTE(marcink): raises ArtifactMetadataBadValueType
             FileStoreMetadata.valid_value_type(value_type)
 
             meta_entry = FileStoreMetadata()
             meta_entry.file_store = file_store
             meta_entry.file_store_meta_section = section
             meta_entry.file_store_meta_key = key
             meta_entry.file_store_meta_value_type = value_type
             meta_entry.file_store_meta_value = value
 
             Session().add(meta_entry)
 
         try:
             if commit:
                 Session().commit()
         except IntegrityError:
             Session().rollback()
             raise ArtifactMetadataDuplicate('Duplicate section/key found for this file.')
 
     @classmethod
     def bump_access_counter(cls, file_uid, commit=True):
         FileStore().query()\
             .filter(FileStore.file_uid == file_uid)\
             .update({FileStore.accessed_count: (FileStore.accessed_count + 1),
                      FileStore.accessed_on: datetime.datetime.now()})
         if commit:
             Session().commit()
 
     def __json__(self):
         data = {
             'filename': self.file_display_name,
             'filename_org': self.file_org_name,
             'file_uid': self.file_uid,
             'description': self.file_description,
             'hidden': self.hidden,
             'size': self.file_size,
             'created_on': self.created_on,
             'uploaded_by': self.upload_user.get_api_data(details='basic'),
             'downloaded_times': self.accessed_count,
             'sha256': self.file_hash,
             'metadata': self.file_metadata,
         }
 
         return data
 
     def __repr__(self):
         return f'<FileStore({self.file_store_id})>'
 
 
 class FileStoreMetadata(Base, BaseModel):
     __tablename__ = 'file_store_metadata'
     __table_args__ = (
         UniqueConstraint('file_store_id', 'file_store_meta_section_hash', 'file_store_meta_key_hash'),
         Index('file_store_meta_section_idx', 'file_store_meta_section', mysql_length=255),
         Index('file_store_meta_key_idx', 'file_store_meta_key', mysql_length=255),
         base_table_args
     )
     SETTINGS_TYPES = {
         'str': safe_str,
         'int': safe_int,
         'unicode': safe_str,
         'bool': str2bool,
         'list': functools.partial(aslist, sep=',')
     }
 
     file_store_meta_id = Column(
         "file_store_meta_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     _file_store_meta_section = Column(
         "file_store_meta_section", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
         nullable=True, unique=None, default=None)
     _file_store_meta_section_hash = Column(
         "file_store_meta_section_hash", String(255),
         nullable=True, unique=None, default=None)
     _file_store_meta_key = Column(
         "file_store_meta_key", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
         nullable=True, unique=None, default=None)
     _file_store_meta_key_hash = Column(
         "file_store_meta_key_hash", String(255), nullable=True, unique=None, default=None)
     _file_store_meta_value = Column(
         "file_store_meta_value", UnicodeText().with_variant(UnicodeText(20480), 'mysql'),
         nullable=True, unique=None, default=None)
     _file_store_meta_value_type = Column(
         "file_store_meta_value_type", String(255), nullable=True, unique=None,
         default='unicode')
 
     file_store_id = Column(
         'file_store_id', Integer(), ForeignKey('file_store.file_store_id'),
         nullable=True, unique=None, default=None)
 
     file_store = relationship('FileStore', lazy='joined', viewonly=True)
 
     @classmethod
     def valid_value_type(cls, value):
         if value.split('.')[0] not in cls.SETTINGS_TYPES:
             raise ArtifactMetadataBadValueType(
                 'value_type must be one of %s got %s' % (cls.SETTINGS_TYPES.keys(), value))
 
     @hybrid_property
     def file_store_meta_section(self):
         return self._file_store_meta_section
 
     @file_store_meta_section.setter
     def file_store_meta_section(self, value):
         self._file_store_meta_section = value
         self._file_store_meta_section_hash = _hash_key(value)
 
     @hybrid_property
     def file_store_meta_key(self):
         return self._file_store_meta_key
 
     @file_store_meta_key.setter
     def file_store_meta_key(self, value):
         self._file_store_meta_key = value
         self._file_store_meta_key_hash = _hash_key(value)
 
     @hybrid_property
     def file_store_meta_value(self):
         val = self._file_store_meta_value
 
         if self._file_store_meta_value_type:
             # e.g unicode.encrypted == unicode
             _type = self._file_store_meta_value_type.split('.')[0]
             # decode the encrypted value if it's encrypted field type
             if '.encrypted' in self._file_store_meta_value_type:
                 cipher = EncryptedTextValue()
                 val = safe_str(cipher.process_result_value(val, None))
             # do final type conversion
             converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']
             val = converter(val)
 
         return val
 
     @file_store_meta_value.setter
     def file_store_meta_value(self, val):
         val = safe_str(val)
         # encode the encrypted value
         if '.encrypted' in self.file_store_meta_value_type:
             cipher = EncryptedTextValue()
             val = safe_str(cipher.process_bind_param(val, None))
         self._file_store_meta_value = val
 
     @hybrid_property
     def file_store_meta_value_type(self):
         return self._file_store_meta_value_type
 
     @file_store_meta_value_type.setter
     def file_store_meta_value_type(self, val):
         # e.g unicode.encrypted
         self.valid_value_type(val)
         self._file_store_meta_value_type = val
 
     def __json__(self):
         data = {
             'artifact': self.file_store.file_uid,
             'section': self.file_store_meta_section,
             'key': self.file_store_meta_key,
             'value': self.file_store_meta_value,
         }
 
         return data
 
     def __repr__(self):
         return '<%s[%s]%s=>%s]>' % (self.cls_name, self.file_store_meta_section,
                                     self.file_store_meta_key, self.file_store_meta_value)
 
 
 class DbMigrateVersion(Base, BaseModel):
     __tablename__ = 'db_migrate_version'
     __table_args__ = (
         base_table_args,
     )
 
     repository_id = Column('repository_id', String(250), primary_key=True)
     repository_path = Column('repository_path', Text)
     version = Column('version', Integer)
 
     @classmethod
     def set_version(cls, version):
         """
         Helper for forcing a different version, usually for debugging purposes via ishell.
         """
         ver = DbMigrateVersion.query().first()
         ver.version = version
         Session().commit()
 
 
 class DbSession(Base, BaseModel):
     __tablename__ = 'db_session'
     __table_args__ = (
         base_table_args,
     )
 
     def __repr__(self):
         return f'<DB:DbSession({self.id})>'
 
     id = Column('id', Integer())
     namespace = Column('namespace', String(255), primary_key=True)
     accessed = Column('accessed', DateTime, nullable=False)
     created = Column('created', DateTime, nullable=False)
     data = Column('data', PickleType, nullable=False)

rhodecode/model/scm.py

@@ -1,1063 +1,1062 b''
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Scm model for RhodeCode
 """
 
 import os.path
 import traceback
 import logging
 import io
 
 from sqlalchemy import func
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 import rhodecode
 from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.lib.vcs import get_backend
 from rhodecode.lib.vcs.exceptions import RepositoryError, NodeNotChangedError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib import helpers as h, rc_cache
 from rhodecode.lib.auth import (
     HasRepoPermissionAny, HasRepoGroupPermissionAny,
     HasUserGroupPermissionAny)
 from rhodecode.lib.exceptions import NonRelativePathError, IMCCommitError
 from rhodecode.lib import hooks_utils
 from rhodecode.lib.utils import (
     get_filesystem_repos, make_db_config)
 from rhodecode.lib.str_utils import safe_str
 from rhodecode.lib.system_info import get_system_info
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     or_, false, null,
     Repository, CacheKey, UserFollowing, UserLog, User, RepoGroup,
     PullRequest, FileStore)
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.validation_schema.validators import url_validator, InvalidCloneUrl
 
 log = logging.getLogger(__name__)
 
 
 class UserTemp(object):
     def __init__(self, user_id):
         self.user_id = user_id
 
     def __repr__(self):
         return "<{}('id:{}')>".format(self.__class__.__name__, self.user_id)
 
 
 class RepoTemp(object):
     def __init__(self, repo_id):
         self.repo_id = repo_id
 
     def __repr__(self):
         return "<{}('id:{}')>".format(self.__class__.__name__, self.repo_id)
 
 
 class SimpleCachedRepoList(object):
     """
     Lighter version of of iteration of repos without the scm initialisation,
     and with cache usage
     """
     def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):
         self.db_repo_list = db_repo_list
         self.repos_path = repos_path
         self.order_by = order_by
         self.reversed = (order_by or '').startswith('-')
         if not perm_set:
             perm_set = ['repository.read', 'repository.write',
                         'repository.admin']
         self.perm_set = perm_set
 
     def __len__(self):
         return len(self.db_repo_list)
 
     def __repr__(self):
         return '<{} ({})>'.format(self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         for dbr in self.db_repo_list:
             # check permission at this level
             has_perm = HasRepoPermissionAny(*self.perm_set)(
                 dbr.repo_name, 'SimpleCachedRepoList check')
             if not has_perm:
                 continue
 
             tmp_d = {
                 'name': dbr.repo_name,
                 'dbrepo': dbr.get_dict(),
                 'dbrepo_fork': dbr.fork.get_dict() if dbr.fork else {}
             }
             yield tmp_d
 
 
 class _PermCheckIterator(object):
 
     def __init__(
             self, obj_list, obj_attr, perm_set, perm_checker,
             extra_kwargs=None):
         """
         Creates iterator from given list of objects, additionally
         checking permission for them from perm_set var
 
         :param obj_list: list of db objects
         :param obj_attr: attribute of object to pass into perm_checker
         :param perm_set: list of permissions to check
         :param perm_checker: callable to check permissions against
         """
         self.obj_list = obj_list
         self.obj_attr = obj_attr
         self.perm_set = perm_set
         self.perm_checker = perm_checker(*self.perm_set)
         self.extra_kwargs = extra_kwargs or {}
 
     def __len__(self):
         return len(self.obj_list)
 
     def __repr__(self):
         return '<{} ({})>'.format(self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         for db_obj in self.obj_list:
             # check permission at this level
             # NOTE(marcink): the __dict__.get() is ~4x faster then getattr()
             name = db_obj.__dict__.get(self.obj_attr, None)
             if not self.perm_checker(name, self.__class__.__name__, **self.extra_kwargs):
                 continue
 
             yield db_obj
 
 
 class RepoList(_PermCheckIterator):
 
     def __init__(self, db_repo_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['repository.read', 'repository.write', 'repository.admin']
 
         super().__init__(
             obj_list=db_repo_list,
             obj_attr='_repo_name', perm_set=perm_set,
             perm_checker=HasRepoPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class RepoGroupList(_PermCheckIterator):
 
     def __init__(self, db_repo_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['group.read', 'group.write', 'group.admin']
 
         super().__init__(
             obj_list=db_repo_group_list,
             obj_attr='_group_name', perm_set=perm_set,
             perm_checker=HasRepoGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class UserGroupList(_PermCheckIterator):
 
     def __init__(self, db_user_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['usergroup.read', 'usergroup.write', 'usergroup.admin']
 
         super().__init__(
             obj_list=db_user_group_list,
             obj_attr='users_group_name', perm_set=perm_set,
             perm_checker=HasUserGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class ScmModel(BaseModel):
     """
     Generic Scm Model
     """
 
     @LazyProperty
     def repos_path(self):
         """
         Gets the repositories root path from database
         """
 
         settings_model = VcsSettingsModel(sa=self.sa)
         return settings_model.get_repos_location()
 
     def repo_scan(self, repos_path=None):
         """
         Listing of repositories in given path. This path should not be a
         repository itself. Return a dictionary of repository objects
 
         :param repos_path: path to directory containing repositories
         """
 
         if repos_path is None:
             repos_path = self.repos_path
 
         log.info('scanning for repositories in %s', repos_path)
 
         config = make_db_config()
         config.set('extensions', 'largefiles', '')
         repos = {}
 
         for name, path in get_filesystem_repos(repos_path, recursive=True):
             # name need to be decomposed and put back together using the /
             # since this is internal storage separator for rhodecode
             name = Repository.normalize_repo_name(name)
 
             try:
                 if name in repos:
                     raise RepositoryError('Duplicate repository name %s '
                                           'found in %s' % (name, path))
                 elif path[0] in rhodecode.BACKENDS:
                     backend = get_backend(path[0])
                     repos[name] = backend(path[1], config=config,
                                           with_wire={"cache": False})
             except OSError:
                 continue
             except RepositoryError:
                 log.exception('Failed to create a repo')
                 continue
 
         log.debug('found %s paths with repositories', len(repos))
         return repos
 
     def get_repos(self, all_repos=None, sort_key=None):
         """
         Get all repositories from db and for each repo create it's
         backend instance and fill that backed with information from database
 
         :param all_repos: list of repository names as strings
             give specific repositories list, good for filtering
 
         :param sort_key: initial sorting of repositories
         """
         if all_repos is None:
             all_repos = self.sa.query(Repository)\
                 .filter(Repository.group_id == null())\
                 .order_by(func.lower(Repository.repo_name)).all()
         repo_iter = SimpleCachedRepoList(
             all_repos, repos_path=self.repos_path, order_by=sort_key)
         return repo_iter
 
     @staticmethod
     def get_parent_commits(parent_commit, scm_instance):
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
         return parent_commit, parents
 
     def initialize_inmemory_vars(self, user, repo, message, author):
         """
         Initialize node specific objects for further usage
         """
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
         message = safe_str(message)
         commiter = user.full_contact
         author = safe_str(author) if author else commiter
         imc = scm_instance.in_memory_commit
 
         return user, scm_instance, message, commiter, author, imc
 
     def get_repo_groups(self, all_groups=None):
         if all_groups is None:
             all_groups = RepoGroup.query()\
                 .filter(RepoGroup.group_parent_id == null()).all()
         return [x for x in RepoGroupList(all_groups)]
 
     def mark_for_invalidation(self, repo_name, delete=False):
         """
         Mark caches of this repo invalid in the database. `delete` flag
         removes the cache entries
 
         :param repo_name: the repo_name for which caches should be marked
             invalid, or deleted
         :param delete: delete the entry keys instead of setting bool
             flag on them, and also purge caches used by the dogpile
         """
         repo = Repository.get_by_repo_name(repo_name)
 
         if repo:
-            invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
-                repo_id=repo.repo_id)
-            CacheKey.set_invalidate(invalidation_namespace, delete=delete)
+            repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=repo.repo_id)
+            CacheKey.set_invalidate(repo_namespace_key, delete=delete)
 
             repo_id = repo.repo_id
             config = repo._config
             config.set('extensions', 'largefiles', '')
             repo.update_commit_cache(config=config, cs_cache=None)
             if delete:
                 cache_namespace_uid = f'cache_repo.{repo_id}'
                 rc_cache.clear_cache_namespace('cache_repo', cache_namespace_uid, method=rc_cache.CLEAR_INVALIDATE)
 
     def toggle_following_repo(self, follow_repo_id, user_id):
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repo_id == follow_repo_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_repo_id = follow_repo_id
             self.sa.add(f)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def toggle_following_user(self, follow_user_id, user_id):
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user_id == follow_user_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_user_id = follow_user_id
             self.sa.add(f)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def is_following_repo(self, repo_name, user_id, cache=False):
         r = self.sa.query(Repository)\
             .filter(Repository.repo_name == repo_name).scalar()
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == r)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def is_following_user(self, username, user_id, cache=False):
         u = User.get_by_username(username)
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user == u)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def get_followers(self, repo):
         repo = self._get_repo(repo)
 
         return self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == repo).count()
 
     def get_forks(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(Repository)\
             .filter(Repository.fork == repo).count()
 
     def get_pull_requests(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(PullRequest)\
             .filter(PullRequest.target_repo == repo)\
             .filter(PullRequest.status != PullRequest.STATUS_CLOSED).count()
 
     def get_artifacts(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(FileStore)\
             .filter(FileStore.repo == repo)\
             .filter(or_(FileStore.hidden == null(), FileStore.hidden == false())).count()
 
     def mark_as_fork(self, repo, fork, user):
         repo = self._get_repo(repo)
         fork = self._get_repo(fork)
         if fork and repo.repo_id == fork.repo_id:
             raise Exception("Cannot set repository as fork of itself")
 
         if fork and repo.repo_type != fork.repo_type:
             raise RepositoryError(
                 "Cannot set repository as fork of repository with other type")
 
         repo.fork = fork
         self.sa.add(repo)
         return repo
 
     def pull_changes(self, repo, username, remote_uri=None, validate_uri=True, **kwargs):
         dbrepo = self._get_repo(repo)
         remote_uri = remote_uri or dbrepo.clone_uri
         if not remote_uri:
             raise Exception("This repository doesn't have a clone uri")
 
         repo = dbrepo.scm_instance(cache=False)
         repo.config.clear_section('hooks')
 
         try:
             # NOTE(marcink): add extra validation so we skip invalid urls
             # this is due this tasks can be executed via scheduler without
             # proper validation of remote_uri
             if validate_uri:
                 config = make_db_config(clear_session=False)
                 url_validator(remote_uri, dbrepo.repo_type, config)
         except InvalidCloneUrl:
             raise
 
         repo_name = dbrepo.repo_name
         try:
             # TODO: we need to make sure those operations call proper hooks !
             repo.fetch(remote_uri, **kwargs)
 
             self.mark_for_invalidation(repo_name)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def push_changes(self, repo, username, remote_uri=None, validate_uri=True, **kwargs):
         dbrepo = self._get_repo(repo)
         remote_uri = remote_uri or dbrepo.push_uri
         if not remote_uri:
             raise Exception("This repository doesn't have a clone uri")
 
         repo = dbrepo.scm_instance(cache=False)
         repo.config.clear_section('hooks')
 
         try:
             # NOTE(marcink): add extra validation so we skip invalid urls
             # this is due this tasks can be executed via scheduler without
             # proper validation of remote_uri
             if validate_uri:
                 config = make_db_config(clear_session=False)
                 url_validator(remote_uri, dbrepo.repo_type, config)
         except InvalidCloneUrl:
             raise
 
         try:
             repo.push(remote_uri, **kwargs)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def commit_change(self, repo, repo_name, commit, user, author, message,
                       content: bytes, f_path: bytes, branch: str = None):
         """
         Commits changes
         """
         user = self._get_user(user)
 
         # message and author needs to be unicode
         # proper backend should then translate that into required type
         message = safe_str(message)
         author = safe_str(author)
         imc = repo.in_memory_commit
         imc.change(FileNode(f_path, content, mode=commit.get_file_mode(f_path)))
         try:
             # TODO: handle pre-push action !
             tip = imc.commit(
                 message=message, author=author, parents=[commit],
                 branch=branch or commit.branch)
         except Exception as e:
             log.error(traceback.format_exc())
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo_name)
 
         # We trigger the post-push action
         hooks_utils.trigger_post_push_hook(
             username=user.username, action='push_local', hook_type='post_push',
             repo_name=repo_name, repo_type=repo.alias, commit_ids=[tip.raw_id])
         return tip
 
     def _sanitize_path(self, f_path: bytes):
         if f_path.startswith(b'/') or f_path.startswith(b'./') or b'../' in f_path:
             raise NonRelativePathError(b'%b is not an relative path' % f_path)
         if f_path:
             f_path = os.path.normpath(f_path)
         return f_path
 
     def get_dirnode_metadata(self, request, commit, dir_node):
         if not dir_node.is_dir():
             return []
 
         data = []
         for node in dir_node:
             if not node.is_file():
                 # we skip file-nodes
                 continue
 
             last_commit = node.last_commit
             last_commit_date = last_commit.date
             data.append({
                 'name': node.name,
                 'size': h.format_byte_size_binary(node.size),
                 'modified_at': h.format_date(last_commit_date),
                 'modified_ts': last_commit_date.isoformat(),
                 'revision': last_commit.revision,
                 'short_id': last_commit.short_id,
                 'message': h.escape(last_commit.message),
                 'author': h.escape(last_commit.author),
                 'user_profile': h.gravatar_with_user(
                     request, last_commit.author),
             })
 
         return data
 
     def get_nodes(self, repo_name, commit_id, root_path='/', flat=True,
                   extended_info=False, content=False, max_file_bytes=None):
         """
         recursive walk in root dir and return a set of all path in that dir
         based on repository walk function
 
         :param repo_name: name of repository
         :param commit_id: commit id for which to list nodes
         :param root_path: root path to list
         :param flat: return as a list, if False returns a dict with description
         :param extended_info: show additional info such as md5, binary, size etc
         :param content: add nodes content to the return data
         :param max_file_bytes: will not return file contents over this limit
 
         """
         _files = list()
         _dirs = list()
 
         try:
             _repo = self._get_repo(repo_name)
             commit = _repo.scm_instance().get_commit(commit_id=commit_id)
             root_path = root_path.lstrip('/')
 
             # get RootNode, inject pre-load options before walking
             top_node = commit.get_node(root_path)
             extended_info_pre_load = []
             if extended_info:
                 extended_info_pre_load += ['md5']
             top_node.default_pre_load = ['is_binary', 'size'] + extended_info_pre_load
 
             for __, dirs, files in commit.walk(top_node):
 
                 for f in files:
                     _content = None
                     _data = f_name = f.str_path
 
                     if not flat:
                         _data = {
                             "name": h.escape(f_name),
                             "type": "file",
                             }
                         if extended_info:
                             _data.update({
                                 "md5": f.md5,
                                 "binary": f.is_binary,
                                 "size": f.size,
                                 "extension": f.extension,
                                 "mimetype": f.mimetype,
                                 "lines": f.lines()[0]
                             })
 
                         if content:
                             over_size_limit = (max_file_bytes is not None
                                                and f.size > max_file_bytes)
                             full_content = None
                             if not f.is_binary and not over_size_limit:
                                 full_content = f.str_content
 
                             _data.update({
                                 "content": full_content,
                             })
                     _files.append(_data)
 
                 for d in dirs:
                     _data = d_name = d.str_path
                     if not flat:
                         _data = {
                             "name": h.escape(d_name),
                             "type": "dir",
                             }
                     if extended_info:
                         _data.update({
                             "md5": "",
                             "binary": False,
                             "size": 0,
                             "extension": "",
                         })
                     if content:
                         _data.update({
                             "content": None
                         })
                     _dirs.append(_data)
         except RepositoryError:
             log.exception("Exception in get_nodes")
             raise
 
         return _dirs, _files
 
     def get_quick_filter_nodes(self, repo_name, commit_id, root_path='/'):
         """
         Generate files for quick filter in files view
         """
 
         _files = list()
         _dirs = list()
         try:
             _repo = self._get_repo(repo_name)
             commit = _repo.scm_instance().get_commit(commit_id=commit_id)
             root_path = root_path.lstrip('/')
 
             top_node = commit.get_node(root_path)
             top_node.default_pre_load = []
 
             for __, dirs, files in commit.walk(top_node):
                 for f in files:
 
                     _data = {
                         "name": h.escape(f.str_path),
                         "type": "file",
                         }
 
                     _files.append(_data)
 
                 for d in dirs:
 
                     _data = {
                         "name": h.escape(d.str_path),
                         "type": "dir",
                         }
 
                     _dirs.append(_data)
         except RepositoryError:
             log.exception("Exception in get_quick_filter_nodes")
             raise
 
         return _dirs, _files
 
     def get_node(self, repo_name, commit_id, file_path,
                  extended_info=False, content=False, max_file_bytes=None, cache=True):
         """
         retrieve single node from commit
         """
 
         try:
 
             _repo = self._get_repo(repo_name)
             commit = _repo.scm_instance().get_commit(commit_id=commit_id)
 
             file_node = commit.get_node(file_path)
             if file_node.is_dir():
                 raise RepositoryError('The given path is a directory')
 
             _content = None
             f_name = file_node.str_path
 
             file_data = {
                 "name": h.escape(f_name),
                 "type": "file",
             }
 
             if extended_info:
                 file_data.update({
                     "extension": file_node.extension,
                     "mimetype": file_node.mimetype,
                 })
 
                 if cache:
                     md5 = file_node.md5
                     is_binary = file_node.is_binary
                     size = file_node.size
                 else:
                     is_binary, md5, size, _content = file_node.metadata_uncached()
 
                 file_data.update({
                     "md5": md5,
                     "binary": is_binary,
                     "size": size,
                 })
 
             if content and cache:
                 # get content + cache
                 size = file_node.size
                 over_size_limit = (max_file_bytes is not None and size > max_file_bytes)
                 full_content = None
                 all_lines = 0
                 if not file_node.is_binary and not over_size_limit:
                     full_content = safe_str(file_node.content)
                     all_lines, empty_lines = file_node.count_lines(full_content)
 
                 file_data.update({
                     "content": full_content,
                     "lines": all_lines
                 })
             elif content:
                 # get content *without* cache
                 if _content is None:
                     is_binary, md5, size, _content = file_node.metadata_uncached()
 
                 over_size_limit = (max_file_bytes is not None and size > max_file_bytes)
                 full_content = None
                 all_lines = 0
                 if not is_binary and not over_size_limit:
                     full_content = safe_str(_content)
                     all_lines, empty_lines = file_node.count_lines(full_content)
 
                 file_data.update({
                     "content": full_content,
                     "lines": all_lines
                 })
 
         except RepositoryError:
             log.exception("Exception in get_node")
             raise
 
         return file_data
 
     def get_fts_data(self, repo_name, commit_id, root_path='/'):
         """
         Fetch node tree for usage in full text search
         """
 
         tree_info = list()
 
         try:
             _repo = self._get_repo(repo_name)
             commit = _repo.scm_instance().get_commit(commit_id=commit_id)
             root_path = root_path.lstrip('/')
             top_node = commit.get_node(root_path)
             top_node.default_pre_load = []
 
             for __, dirs, files in commit.walk(top_node):
 
                 for f in files:
                     is_binary, md5, size, _content = f.metadata_uncached()
                     _data = {
                         "name": f.str_path,
                         "md5": md5,
                         "extension": f.extension,
                         "binary": is_binary,
                         "size": size
                     }
 
                     tree_info.append(_data)
 
         except RepositoryError:
             log.exception("Exception in get_nodes")
             raise
 
         return tree_info
 
     def create_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Commits given multiple nodes into repo
 
         :param user: RhodeCode User object or user_id, the commiter
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's
            initial commit
         :param author: author of commit, cna be different that commiter
            only for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new committed commit
         """
         user, scm_instance, message, commiter, author, imc = self.initialize_inmemory_vars(
             user, repo, message, author)
 
         parent_commit, parents = self.get_parent_commits(parent_commit, scm_instance)
 
         upload_file_types = (io.BytesIO, io.BufferedRandom)
         processed_nodes = []
         for filename, content_dict in nodes.items():
             if not isinstance(filename, bytes):
                 raise ValueError(f'filename key in nodes needs to be bytes , or {upload_file_types}')
             content = content_dict['content']
             if not isinstance(content, upload_file_types + (bytes,)):
                 raise ValueError('content key value in nodes needs to be bytes')
 
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             content = nodes[f_path]['content']
 
             # decoding here will force that we have proper encoded values
             # in any other case this will throw exceptions and deny commit
 
             if isinstance(content, bytes):
                 pass
             elif isinstance(content, upload_file_types):
                 content = content.read()
             else:
                 raise Exception(f'Content is of unrecognized type {type(content)}, expected {upload_file_types}')
             processed_nodes.append((f_path, content))
 
         # add multiple nodes
         for path, content in processed_nodes:
             imc.add(FileNode(path, content=content))
 
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_type=scm_instance.alias,
                 hook_type='post_push',
                 commit_ids=[tip.raw_id])
         return tip
 
     def update_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         user, scm_instance, message, commiter, author, imc = self.initialize_inmemory_vars(
             user, repo, message, author)
 
         parent_commit, parents = self.get_parent_commits(parent_commit, scm_instance)
 
         # add multiple nodes
         for _filename, data in nodes.items():
             # new filename, can be renamed from the old one, also sanitaze
             # the path for any hack around relative paths like ../../ etc.
             filename = self._sanitize_path(data['filename'])
             old_filename = self._sanitize_path(_filename)
             content = data['content']
             file_mode = data.get('mode')
             filenode = FileNode(old_filename, content=content, mode=file_mode)
             op = data['op']
             if op == 'add':
                 imc.add(filenode)
             elif op == 'del':
                 imc.remove(filenode)
             elif op == 'mod':
                 if filename != old_filename:
                     # TODO: handle renames more efficient, needs vcs lib changes
                     imc.remove(filenode)
                     imc.add(FileNode(filename, content=content, mode=file_mode))
                 else:
                     imc.change(filenode)
 
         try:
             # TODO: handle pre push scenario commit changes
             tip = imc.commit(message=message,
                              author=author,
                              parents=parents,
                              branch=parent_commit.branch)
         except NodeNotChangedError:
             raise
         except Exception as e:
             log.exception("Unexpected exception during call to imc.commit")
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo.repo_name)
 
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local', hook_type='post_push',
                 repo_name=repo.repo_name, repo_type=scm_instance.alias,
                 commit_ids=[tip.raw_id])
 
         return tip
 
     def update_binary_node(self, user, repo, message, node, parent_commit=None, author=None):
         user, scm_instance, message, commiter, author, imc = self.initialize_inmemory_vars(
             user, repo, message, author)
 
         parent_commit, parents = self.get_parent_commits(parent_commit, scm_instance)
 
         file_path = node.get('file_path')
         if isinstance(raw_content := node.get('content'), (io.BytesIO, io.BufferedRandom)):
             content = raw_content.read()
         else:
             raise Exception("Wrong content was provided")
         file_node = FileNode(file_path, content=content)
         imc.change(file_node)
 
         try:
             tip = imc.commit(message=message,
                              author=author,
                              parents=parents,
                              branch=parent_commit.branch)
         except NodeNotChangedError:
             raise
         except Exception as e:
             log.exception("Unexpected exception during call to imc.commit")
             raise IMCCommitError(str(e))
         finally:
             self.mark_for_invalidation(repo.repo_name)
 
         hooks_utils.trigger_post_push_hook(
             username=user.username, action='push_local', hook_type='post_push',
             repo_name=repo.repo_name, repo_type=scm_instance.alias,
             commit_ids=[tip.raw_id])
         return tip
 
     def delete_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Deletes given multiple nodes into `repo`
 
         :param user: RhodeCode User object or user_id, the committer
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's initial
            commit
         :param author: author of commit, cna be different that commiter only
            for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new commit after deletion
         """
 
         user, scm_instance, message, commiter, author, imc = self.initialize_inmemory_vars(
             user, repo, message, author)
 
         processed_nodes = []
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             # content can be empty but for compatibility it allows same dicts
             # structure as add_nodes
             content = nodes[f_path].get('content')
             processed_nodes.append((safe_bytes(f_path), content))
 
         parent_commit, parents = self.get_parent_commits(parent_commit, scm_instance)
 
         # add multiple nodes
         for path, content in processed_nodes:
             imc.remove(FileNode(path, content=content))
 
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local', hook_type='post_push',
                 repo_name=repo.repo_name, repo_type=scm_instance.alias,
                 commit_ids=[tip.raw_id])
         return tip
 
     def strip(self, repo, commit_id, branch):
         scm_instance = repo.scm_instance(cache=False)
         scm_instance.config.clear_section('hooks')
         scm_instance.strip(commit_id, branch)
         self.mark_for_invalidation(repo.repo_name)
 
     def get_unread_journal(self):
         return self.sa.query(UserLog).count()
 
     @classmethod
     def backend_landing_ref(cls, repo_type):
         """
         Return a default landing ref based on a repository type.
         """
 
         landing_ref = {
             'hg': ('branch:default', 'default'),
             'git': ('branch:master', 'master'),
             'svn': ('rev:tip', 'latest tip'),
             'default': ('rev:tip', 'latest tip'),
         }
 
         return landing_ref.get(repo_type) or landing_ref['default']
 
     def get_repo_landing_revs(self, translator, repo=None):
         """
         Generates select option with tags branches and bookmarks (for hg only)
         grouped by type
 
         :param repo:
         """
         from rhodecode.lib.vcs.backends.git import GitRepository
 
         _ = translator
         repo = self._get_repo(repo)
 
         if repo:
             repo_type = repo.repo_type
         else:
             repo_type = 'default'
 
         default_landing_ref, landing_ref_lbl = self.backend_landing_ref(repo_type)
 
         default_ref_options = [
             [default_landing_ref, landing_ref_lbl]
         ]
         default_choices = [
             default_landing_ref
         ]
 
         if not repo:
             # presented at NEW repo creation
             return default_choices, default_ref_options
 
         repo = repo.scm_instance()
 
         ref_options = [(default_landing_ref, landing_ref_lbl)]
         choices = [default_landing_ref]
 
         # branches
         branch_group = [(f'branch:{safe_str(b)}', safe_str(b)) for b in repo.branches]
         if not branch_group:
             # new repo, or without maybe a branch?
             branch_group = default_ref_options
 
         branches_group = (branch_group, _("Branches"))
         ref_options.append(branches_group)
         choices.extend([x[0] for x in branches_group[0]])
 
         # bookmarks for HG
         if repo.alias == 'hg':
             bookmarks_group = (
                 [(f'book:{safe_str(b)}', safe_str(b))
                     for b in repo.bookmarks],
                 _("Bookmarks"))
             ref_options.append(bookmarks_group)
             choices.extend([x[0] for x in bookmarks_group[0]])
 
         # tags
         tags_group = (
             [(f'tag:{safe_str(t)}', safe_str(t))
                 for t in repo.tags],
             _("Tags"))
         ref_options.append(tags_group)
         choices.extend([x[0] for x in tags_group[0]])
 
         return choices, ref_options
 
     def get_server_info(self, environ=None):
         server_info = get_system_info(environ)
         return server_info

rhodecode/tests/lib/test_libs.py

@@ -1,744 +1,748 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 """
 Package for testing various lib/helper functions in rhodecode
 """
 
 import datetime
 import string
 import mock
 import pytest
 import functools
+import time
 
 from rhodecode.tests import no_newline_id_generator
 from rhodecode.tests.utils import run_test_concurrently
 
 from rhodecode.lib import rc_cache
 from rhodecode.lib.helpers import InitialsGravatar
 from rhodecode.lib.utils2 import AttributeDict
 
 from rhodecode.model.db import Repository, CacheKey
 
 
 TEST_URLS = [
         ('127.0.0.1', '127.0.0.1'),
         ('marcink@127.0.0.1', '127.0.0.1'),
         ('marcink:pass@127.0.0.1', '127.0.0.1'),
         ('[e-mail]:pass@127.0.0.1', '127.0.0.1'),
 
         ('127.0.0.1:8080', '127.0.0.1:8080'),
         ('marcink@127.0.0.1:8080', '127.0.0.1:8080'),
         ('marcink:pass@127.0.0.1:8080', '127.0.0.1:8080'),
         ('[e-mail]:pass@127.0.0.1:8080', '127.0.0.1:8080'),
 
         ('domain.org', 'domain.org'),
         ('user:[e-mail]:8080', 'domain.org:8080'),
         ('[e-mail]:[e-mail]:8080', 'domain.org:8080'),
     ]
 
 
 @pytest.mark.parametrize("protocol", ['http://', 'https://'])
 @pytest.mark.parametrize("test_url, expected", TEST_URLS)
 def test_credentials_filter(protocol, test_url, expected):
     from rhodecode.lib.utils2 import credentials_filter
     test_url = protocol + test_url
     assert credentials_filter(test_url) == protocol + expected
 
 
 @pytest.mark.parametrize("str_bool, expected", [
     ('t', True),
     ('true', True),
     ('y', True),
     ('yes', True),
     ('on', True),
     ('1', True),
     ('Y', True),
     ('yeS', True),
     ('Y', True),
     ('TRUE', True),
     ('T', True),
     ('False', False),
     ('F', False),
     ('FALSE', False),
     ('0', False),
     ('-1', False),
     ('', False)
 ])
 def test_str2bool(str_bool, expected):
     from rhodecode.lib.utils2 import str2bool
     assert str2bool(str_bool) == expected
 
 
 @pytest.mark.parametrize("text, expected", functools.reduce(lambda a1, a2: a1+a2, [
 [
 (pref+"", []),
 (pref+"Hi there @marcink", ['marcink']),
 (pref+"Hi there @marcink and @bob", ['bob', 'marcink']),
 (pref+"Hi there @marcink\n", ['marcink']),
 (pref+"Hi there @marcink and @bob\n", ['bob', 'marcink']),
 (pref+"Hi there [e-mail]", []),
 (pref+"Hi there @john.malcovic and @bob\n", ['bob', 'john.malcovic']),
 (pref+"This needs to be reviewed: (@marcink,@john)", ["john", "marcink"]),
 (pref+"This needs to be reviewed: (@marcink, @john)", ["john", "marcink"]),
 (pref+"This needs to be reviewed: [@marcink,@john]", ["john", "marcink"]),
 (pref+"This needs to be reviewed: (@marcink @john)", ["john", "marcink"]),
 (pref+"@john @mary, please review", ["john", "mary"]),
 (pref+"@john,@mary, please review", ["john", "mary"]),
 (pref+"Hej @123, @22john,@mary, please review", ['123', '22john', 'mary']),
 (pref+"@first hi there @marcink here's my email [e-mail] "
  "@lukaszb check @one_more22 it pls @ ttwelve @D[] @one@two@three ", ['first', 'lukaszb', 'marcink', 'one', 'one_more22']),
 (pref+"@MARCIN    @maRCiN @2one_more22 @john please see this http://org.pl", ['2one_more22', 'john', 'MARCIN', 'maRCiN']),
 (pref+"@marian.user just do it @marco-polo and next extract @marco_polo", ['marco-polo', 'marco_polo', 'marian.user']),
 (pref+"user.dot  hej ! not-needed [e-mail]", []),
 (pref+"\n@marcin", ['marcin']),
 ]
 for pref in ['', '\n', 'hi !', '\t', '\n\n']]), ids=no_newline_id_generator)
 def test_mention_extractor(text, expected):
     from rhodecode.lib.utils2 import extract_mentioned_users
     got = extract_mentioned_users(text)
     assert sorted(got, key=lambda x: x.lower()) == got
     assert set(expected) == set(got)
 
 @pytest.mark.parametrize("age_args, expected, kw", [
     ({}, u'just now', {}),
     ({'seconds': -1}, u'1 second ago', {}),
     ({'seconds': -60 * 2}, u'2 minutes ago', {}),
     ({'hours': -1}, u'1 hour ago', {}),
     ({'hours': -24}, u'1 day ago', {}),
     ({'hours': -24 * 5}, u'5 days ago', {}),
     ({'months': -1}, u'1 month ago', {}),
     ({'months': -1, 'days': -2}, u'1 month and 2 days ago', {}),
     ({'years': -1, 'months': -1}, u'1 year and 1 month ago', {}),
     ({}, u'just now', {'short_format': True}),
     ({'seconds': -1}, u'1sec ago', {'short_format': True}),
     ({'seconds': -60 * 2}, u'2min ago', {'short_format': True}),
     ({'hours': -1}, u'1h ago', {'short_format': True}),
     ({'hours': -24}, u'1d ago', {'short_format': True}),
     ({'hours': -24 * 5}, u'5d ago', {'short_format': True}),
     ({'months': -1}, u'1m ago', {'short_format': True}),
     ({'months': -1, 'days': -2}, u'1m, 2d ago', {'short_format': True}),
     ({'years': -1, 'months': -1}, u'1y, 1m ago', {'short_format': True}),
 ])
 def test_age(age_args, expected, kw, baseapp):
     from rhodecode.lib.utils2 import age
     from dateutil import relativedelta
     n = datetime.datetime(year=2012, month=5, day=17)
     def delt(*args, **kwargs):
         return relativedelta.relativedelta(*args, **kwargs)
 
     def translate(elem):
         return elem.interpolate()
 
     assert translate(age(n + delt(**age_args), now=n, **kw)) == expected
 
 
 @pytest.mark.parametrize("age_args, expected, kw", [
     ({}, u'just now', {}),
     ({'seconds': 1}, u'in 1 second', {}),
     ({'seconds': 60 * 2}, u'in 2 minutes', {}),
     ({'hours': 1}, u'in 1 hour', {}),
     ({'hours': 24}, u'in 1 day', {}),
     ({'hours': 24 * 5}, u'in 5 days', {}),
     ({'months': 1}, u'in 1 month', {}),
     ({'months': 1, 'days': 1}, u'in 1 month and 1 day', {}),
     ({'years': 1, 'months': 1}, u'in 1 year and 1 month', {}),
     ({}, u'just now', {'short_format': True}),
     ({'seconds': 1}, u'in 1sec', {'short_format': True}),
     ({'seconds': 60 * 2}, u'in 2min', {'short_format': True}),
     ({'hours': 1}, u'in 1h', {'short_format': True}),
     ({'hours': 24}, u'in 1d', {'short_format': True}),
     ({'hours': 24 * 5}, u'in 5d', {'short_format': True}),
     ({'months': 1}, u'in 1m', {'short_format': True}),
     ({'months': 1, 'days': 1}, u'in 1m, 1d', {'short_format': True}),
     ({'years': 1, 'months': 1}, u'in 1y, 1m', {'short_format': True}),
 ])
 def test_age_in_future(age_args, expected, kw, baseapp):
     from rhodecode.lib.utils2 import age
     from dateutil import relativedelta
     n = datetime.datetime(year=2012, month=5, day=17)
     def delt(*args, **kwargs):
         return relativedelta.relativedelta(*args, **kwargs)
 
     def translate(elem):
         return elem.interpolate()
 
     assert translate(age(n + delt(**age_args), now=n, **kw)) == expected
 
 
 @pytest.mark.parametrize("sample, expected_tags", [
     # entry
     ((
              ""
      ),
      [
 
      ]),
     # entry
     ((
         "hello world [stale]"
      ),
      [
          ('state', '[stale]'),
      ]),
     # entry
     ((
          "hello world [v2.0.0] [v1.0.0]"
      ),
      [
          ('generic', '[v2.0.0]'),
          ('generic', '[v1.0.0]'),
      ]),
     # entry
     ((
              "he[ll]o wo[rl]d"
      ),
      [
          ('label', '[ll]'),
          ('label', '[rl]'),
      ]),
     # entry
     ((
         "hello world [stale]\n[featured]\n[stale] [dead] [dev]"
      ),
      [
          ('state', '[stale]'),
          ('state', '[featured]'),
          ('state', '[stale]'),
          ('state', '[dead]'),
          ('state', '[dev]'),
      ]),
     # entry
     ((
         "hello world \n\n [stale] \n [url =&gt; [name](http://rc.com)]"
      ),
      [
         ('state', '[stale]'),
         ('url', '[url =&gt; [name](http://rc.com)]'),
      ]),
     # entry
     ((
             "[url =&gt; [linkNameJS](javascript:alert(document.domain))]\n"
             "[url =&gt; [linkNameHTTP](http://rhodecode.com)]\n"
             "[url =&gt; [linkNameHTTPS](https://rhodecode.com)]\n"
             "[url =&gt; [linkNamePath](/repo_group)]\n"
      ),
      [
          ('generic', '[linkNameJS]'),
          ('url', '[url =&gt; [linkNameHTTP](http://rhodecode.com)]'),
          ('url', '[url =&gt; [linkNameHTTPS](https://rhodecode.com)]'),
          ('url', '[url =&gt; [linkNamePath](/repo_group)]'),
      ]),
     # entry
     ((
         "hello pta[tag] gog [[]] [[] sda ero[or]d [me =&gt;>< sa]"
         "[requires] [stale] [see<>=&gt;] [see =&gt; http://url.com]"
         "[requires =&gt; url] [lang =&gt; python] [just a tag] "
         "<html_tag first='abc' attr=\"my.url?attr=&another=\"></html_tag>"
         "[,d] [ =&gt; ULR ] [obsolete] [desc]]"
     ),
      [
         ('label', '[desc]'),
         ('label', '[obsolete]'),
         ('label', '[or]'),
         ('label', '[requires]'),
         ('label', '[tag]'),
         ('state', '[stale]'),
         ('lang', '[lang =&gt; python]'),
         ('ref', '[requires =&gt; url]'),
         ('see', '[see =&gt; http://url.com]'),
 
      ]),
 
 ], ids=no_newline_id_generator)
 def test_metatag_extraction(sample, expected_tags):
     from rhodecode.lib.helpers import extract_metatags
     tags, value = extract_metatags(sample)
     assert sorted(tags) == sorted(expected_tags)
 
 
 @pytest.mark.parametrize("tag_data, expected_html", [
 
     (('state', '[stable]'), '<div class="metatag" tag="state stable">stable</div>'),
     (('state', '[stale]'), '<div class="metatag" tag="state stale">stale</div>'),
     (('state', '[featured]'), '<div class="metatag" tag="state featured">featured</div>'),
     (('state', '[dev]'), '<div class="metatag" tag="state dev">dev</div>'),
     (('state', '[dead]'), '<div class="metatag" tag="state dead">dead</div>'),
 
     (('label', '[personal]'), '<div class="metatag" tag="label">personal</div>'),
     (('generic', '[v2.0.0]'), '<div class="metatag" tag="generic">v2.0.0</div>'),
 
     (('lang', '[lang =&gt; JavaScript]'), '<div class="metatag" tag="lang">JavaScript</div>'),
     (('lang', '[lang =&gt; C++]'), '<div class="metatag" tag="lang">C++</div>'),
     (('lang', '[lang =&gt; C#]'), '<div class="metatag" tag="lang">C#</div>'),
     (('lang', '[lang =&gt; Delphi/Object]'), '<div class="metatag" tag="lang">Delphi/Object</div>'),
     (('lang', '[lang =&gt; Objective-C]'), '<div class="metatag" tag="lang">Objective-C</div>'),
     (('lang', '[lang =&gt; .NET]'), '<div class="metatag" tag="lang">.NET</div>'),
 
     (('license', '[license =&gt; BSD 3-clause]'), '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/BSD 3-clause">BSD 3-clause</a></div>'),
     (('license', '[license =&gt; GPLv3]'), '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/GPLv3">GPLv3</a></div>'),
     (('license', '[license =&gt; MIT]'), '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/MIT">MIT</a></div>'),
     (('license', '[license =&gt; AGPLv3]'), '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/AGPLv3">AGPLv3</a></div>'),
 
     (('ref', '[requires =&gt; RepoName]'), '<div class="metatag" tag="ref requires">requires: <a href="/RepoName">RepoName</a></div>'),
     (('ref', '[recommends =&gt; GroupName]'), '<div class="metatag" tag="ref recommends">recommends: <a href="/GroupName">GroupName</a></div>'),
     (('ref', '[conflicts =&gt; SomeName]'), '<div class="metatag" tag="ref conflicts">conflicts: <a href="/SomeName">SomeName</a></div>'),
     (('ref', '[base =&gt; SomeName]'), '<div class="metatag" tag="ref base">base: <a href="/SomeName">SomeName</a></div>'),
 
     (('see', '[see =&gt; http://rhodecode.com]'), '<div class="metatag" tag="see">see: http://rhodecode.com </div>'),
 
     (('url', '[url =&gt; [linkName](https://rhodecode.com)]'), '<div class="metatag" tag="url"> <a href="https://rhodecode.com">linkName</a> </div>'),
     (('url', '[url =&gt; [example link](https://rhodecode.com)]'), '<div class="metatag" tag="url"> <a href="https://rhodecode.com">example link</a> </div>'),
     (('url', '[url =&gt; [v1.0.0](https://rhodecode.com)]'), '<div class="metatag" tag="url"> <a href="https://rhodecode.com">v1.0.0</a> </div>'),
 
 ])
 def test_metatags_stylize(tag_data, expected_html):
     from rhodecode.lib.helpers import style_metatag
     tag_type,value = tag_data
     assert style_metatag(tag_type, value) == expected_html
 
 
 @pytest.mark.parametrize("tmpl_url, email, expected", [
     ('http://test.com/{email}', '[e-mail]', 'http://test.com/[e-mail]'),
 
     ('http://test.com/{md5email}', '[e-mail]', 'http://test.com/3cb7232fcc48743000cb86d0d5022bd9'),
     ('http://test.com/{md5email}', 'testąć@foo.com', 'http://test.com/978debb907a3c55cd741872ab293ef30'),
 
     ('http://testX.com/{md5email}?s={size}', '[e-mail]', 'http://testX.com/3cb7232fcc48743000cb86d0d5022bd9?s=24'),
     ('http://testX.com/{md5email}?s={size}', 'testąć@foo.com', 'http://testX.com/978debb907a3c55cd741872ab293ef30?s=24'),
 
     ('{scheme}://{netloc}/{md5email}/{size}', '[e-mail]', 'https://server.com/3cb7232fcc48743000cb86d0d5022bd9/24'),
     ('{scheme}://{netloc}/{md5email}/{size}', 'testąć@foo.com', 'https://server.com/978debb907a3c55cd741872ab293ef30/24'),
 
     ('http://test.com/{email}', 'testąć@foo.com', 'http://test.com/testąć@foo.com'),
     ('http://test.com/{email}?size={size}', '[e-mail]', 'http://test.com/[e-mail]?size=24'),
     ('http://test.com/{email}?size={size}', 'testąć@foo.com', 'http://test.com/testąć@foo.com?size=24'),
 ])
 def test_gravatar_url_builder(tmpl_url, email, expected, request_stub):
     from rhodecode.lib.helpers import gravatar_url
 
     def fake_tmpl_context(_url):
         _c = AttributeDict()
         _c.visual = AttributeDict()
         _c.visual.use_gravatar = True
         _c.visual.gravatar_url = _url
         return _c
 
     # mock pyramid.threadlocals
     def fake_get_current_request():
         request_stub.scheme = 'https'
         request_stub.host = 'server.com'
 
         request_stub._call_context = fake_tmpl_context(tmpl_url)
         return request_stub
 
     with mock.patch('rhodecode.lib.helpers.get_current_request',
                     fake_get_current_request):
 
         grav = gravatar_url(email_address=email, size=24)
         assert grav == expected
 
 
 @pytest.mark.parametrize(
     "email, first_name, last_name, expected_initials, expected_color", [
 
         ('[e-mail]', '', '', 'TR', '#8a994d'),
         ('[e-mail]', '', '', 'MK', '#6559b3'),
         # special cases of email
         ('[e-mail]', '', '', 'JD', '#526600'),
         ('[e-mail]', '', '', 'GR', '#990052'),
         ('[e-mail]', 'Guido', 'Van Rossum', 'GR', '#990052'),
 
         ('[e-mail]', '', '', 'RR', '#46598c'),
         ('[e-mail]', 'Nguyễn Thái', 'Tgọc Duy', 'ND', '#665200'),
 
         ('[e-mail]', '', '', 'JF', '#73006b'),
         ('[e-mail]', 'Marcin', 'Kuzminski', 'MK', '#104036'),
         # partials
         ('[e-mail]', 'Marcin', '', 'MR', '#104036'),  # fn+email
         ('[e-mail]', '', 'Kuzminski', 'AK', '#104036'),  # em+ln
         # non-ascii
         ('[e-mail]', 'Marcin', 'Śuzminski', 'MS', '#104036'),
         ('[e-mail]', 'Łukasz', 'Śuzminski', 'LS', '#104036'),
         ('[e-mail]', 'Fabian', 'Łukaszewski', 'FL', '#104036'),
 
         ('marcin.ś[e-mail]', '', '', 'MS', '#73000f'),
 
         # special cases, LDAP can provide those...
         ('admin@', 'Marcin', 'Śuzminski', 'MS', '#aa00ff'),
         ('marcin.śuzminski', '', '', 'MS', '#402020'),
         ('null', '', '', 'NL', '#8c4646'),
         ('[e-mail]', 'some', '', 'SA', '#664e33')
 ])
 def test_initials_gravatar_pick_of_initials_and_color_algo(
         email, first_name, last_name, expected_initials, expected_color):
     instance = InitialsGravatar(email, first_name, last_name)
     assert instance.get_initials() == expected_initials
     assert instance.str2color(email) == expected_color
 
 
 def test_initials_gravatar_mapping_algo():
     pos = set()
     instance = InitialsGravatar('', '', '')
     iterations = 0
 
     variations = []
     for letter1 in string.ascii_letters:
         for letter2 in string.ascii_letters[::-1][:10]:
             for letter3 in string.ascii_letters[:10]:
                 variations.append(
                     '[e-mail]' % (letter1+letter2+letter3))
 
     max_variations = 4096
     for email in variations[:max_variations]:
         iterations += 1
         pos.add(
             instance.pick_color_bank_index(email,
                                            instance.get_color_bank()))
 
     # we assume that we have match all 256 possible positions,
     # in reasonable amount of different email addresses
     assert len(pos) == 256
     assert iterations == max_variations
 
 
 @pytest.mark.parametrize("tmpl, repo_name, overrides, prefix, expected", [
     (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '', 'http://vps1:8000/group/repo1'),
     (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'marcink'}, '', 'http://marcink@vps1:8000/group/repo1'),
     (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '/rc', 'http://vps1:8000/rc/group/repo1'),
     (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/rc', 'http://user@vps1:8000/rc/group/repo1'),
     (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'marcink'}, '/rc', 'http://marcink@vps1:8000/rc/group/repo1'),
     (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'user'}, '/rc/', 'http://user@vps1:8000/rc/group/repo1'),
     (Repository.DEFAULT_CLONE_URI, 'group/repo1', {'user': 'marcink'}, '/rc/', 'http://marcink@vps1:8000/rc/group/repo1'),
     ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {}, '', 'http://vps1:8000/_23'),
     ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'marcink'}, '', 'http://marcink@vps1:8000/_23'),
     ('http://{user}@{netloc}/_{repoid}', 'group/repo1', {'user': 'marcink'}, '', 'http://marcink@vps1:8000/_23'),
     ('http://{netloc}/_{repoid}', 'group/repo1', {'user': 'marcink'}, '', 'http://vps1:8000/_23'),
     ('https://{user}@proxy1.server.com/{repo}', 'group/repo1', {'user': 'marcink'}, '', 'https://[e-mail]/group/repo1'),
     ('https://{user}@proxy1.server.com/{repo}', 'group/repo1', {}, '', 'https://proxy1.server.com/group/repo1'),
     ('https://proxy1.server.com/{user}/{repo}', 'group/repo1', {'user': 'marcink'}, '', 'https://proxy1.server.com/marcink/group/repo1'),
 ])
 def test_clone_url_generator(tmpl, repo_name, overrides, prefix, expected):
     from rhodecode.lib.utils2 import get_clone_url
 
     class RequestStub(object):
         def request_url(self, name):
             return 'http://vps1:8000' + prefix
 
         def route_url(self, name):
             return self.request_url(name)
 
     clone_url = get_clone_url(
         request=RequestStub(),
         uri_tmpl=tmpl,
         repo_name=repo_name, repo_id=23, repo_type='hg', **overrides)
     assert clone_url == expected
 
 
 def test_clone_url_svn_ssh_generator():
     from rhodecode.lib.utils2 import get_clone_url
 
     class RequestStub(object):
         def request_url(self, name):
             return 'http://vps1:8000'
 
         def route_url(self, name):
             return self.request_url(name)
 
     clone_url = get_clone_url(
         request=RequestStub(),
         uri_tmpl=Repository.DEFAULT_CLONE_URI_SSH,
         repo_name='svn-test', repo_id=23, repo_type='svn', **{'sys_user': 'rcdev'})
     assert clone_url == 'svn+ssh://rcdev@vps1/svn-test'
 
 
 idx = 0
 
 
 def _quick_url(text, tmpl="""<a class="tooltip-hovercard revision-link" href="%s" data-hovercard-alt="Commit: %s" data-hovercard-url="/some-url">%s</a>""", url_=None, commits=''):
     """
     Changes `some text url[foo]` => `some text <a href="/">foo</a>
 
     :param text:
     """
     import re
     # quickly change expected url[] into a link
     url_pat = re.compile(r'(?:url\[)(.+?)(?:\])')
     commits = commits or []
 
     global idx
     idx = 0
 
     def url_func(match_obj):
         global idx
         _url = match_obj.groups()[0]
         if commits:
             commit = commits[idx]
             idx += 1
             return tmpl % (url_ or '/some-url', _url, commit)
         else:
             return tmpl % (url_ or '/some-url', _url)
 
     return url_pat.sub(url_func, text)
 
 
 @pytest.mark.parametrize("sample, expected, commits", [
     (
             "",
             "",
             [""]
     ),
     (
             "git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68",
             "git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68",
             [""]
     ),
     (
             "from rev 000000000000",
             "from rev url[000000000000]",
             ["000000000000"]
     ),
 
     (
             "from rev 000000000000123123 also rev 000000000000",
             "from rev url[000000000000123123] also rev url[000000000000]",
             ["000000000000123123", "000000000000"]
     ),
     (
             "this should-000 00",
             "this should-000 00",
             [""]
     ),
     (
             "longtextffffffffff rev 123123123123",
             "longtextffffffffff rev url[123123123123]",
             ["123123123123"]
     ),
     (
             "rev ffffffffffffffffffffffffffffffffffffffffffffffffff",
             "rev ffffffffffffffffffffffffffffffffffffffffffffffffff",
             ["ffffffffffffffffffffffffffffffffffffffffffffffffff"]
     ),
     (
             "ffffffffffff some text traalaa",
             "url[ffffffffffff] some text traalaa",
             ["ffffffffffff"]
     ),
     (
             """Multi line
             123123123123
             some text 000000000000
             sometimes !
             """,
             """Multi line
             url[123123123123]
             some text url[000000000000]
             sometimes !
             """,
             ["123123123123", "000000000000"]
     )
 ], ids=no_newline_id_generator)
 def test_urlify_commits(sample, expected, commits):
     def fake_url(self, *args, **kwargs):
         return '/some-url'
 
     expected = _quick_url(expected, commits=commits)
 
     with mock.patch('rhodecode.lib.helpers.route_url', fake_url):
         from rhodecode.lib.helpers import urlify_commits
         assert urlify_commits(sample, 'repo_name') == expected
 
 
 @pytest.mark.parametrize("sample, expected, url_", [
     ("",
      "",
      ""),
     ("https://svn.apache.org/repos",
      "url[https://svn.apache.org/repos]",
      "https://svn.apache.org/repos"),
     ("http://svn.apache.org/repos",
      "url[http://svn.apache.org/repos]",
      "http://svn.apache.org/repos"),
     ("from rev a also rev http://google.com",
      "from rev a also rev url[http://google.com]",
      "http://google.com"),
     ("""Multi line
      https://foo.bar.com
      some text lalala""",
      """Multi line
      url[https://foo.bar.com]
      some text lalala""",
      "https://foo.bar.com")
 ], ids=no_newline_id_generator)
 def test_urlify_test(sample, expected, url_):
     from rhodecode.lib.helpers import urlify_text
     expected = _quick_url(expected, tmpl="""<a href="%s">%s</a>""", url_=url_)
     assert urlify_text(sample) == expected
 
 
 @pytest.mark.parametrize("test, expected", [
   ("", None),
   ("/_2", '2'),
   ("_2", '2'),
   ("/_2/", '2'),
   ("_2/", '2'),
 
   ("/_21", '21'),
   ("_21", '21'),
   ("/_21/", '21'),
   ("_21/", '21'),
 
   ("/_21/foobar", '21'),
   ("_21/121", '21'),
   ("/_21/_12", '21'),
   ("_21/rc/foo", '21'),
 
 ])
 def test_get_repo_by_id(test, expected):
     from rhodecode.model.repo import RepoModel
     _test = RepoModel()._extract_id_from_repo_name(test)
     assert _test == expected
 
 
 def test_invalidation_context(baseapp):
     repo_id = 9999
+    calls = [1, 2]
+    call_args = ('some-key',)
+    region = rc_cache.get_or_create_region('cache_repo_longterm')
 
-    cache_namespace_uid = 'cache_repo_instance.{}_{}'.format(
-        repo_id, CacheKey.CACHE_TYPE_FEED)
-    invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
-        repo_id=repo_id)
-    region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
+    repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=repo_id)
+    inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key)
 
-    calls = [1, 2]
+    def cache_generator(_state_uid):
 
-    @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
-    def _dummy_func(cache_key):
+        @region.conditional_cache_on_arguments(namespace=f'some-common-namespace-{repo_id}')
+        def _dummy_func(*args):
         val = calls.pop(0)
-        return 'result:{}'.format(val)
+            return _state_uid, f'result:{val}'
 
-    inv_context_manager = rc_cache.InvalidationContext(
-        uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
+        return _dummy_func
 
     # 1st call, fresh caches
     with inv_context_manager as invalidation_context:
-        should_invalidate = invalidation_context.should_invalidate()
+        cache_state_uid = invalidation_context.state_uid
+        cache_func = cache_generator(cache_state_uid)
+        previous_state_uid, result = cache_func(*call_args)
+
+        should_invalidate = previous_state_uid != cache_state_uid
         if should_invalidate:
-            result = _dummy_func.refresh('some-key')
-        else:
-            result = _dummy_func('some-key')
+            _, result = cache_func.refresh(*call_args)
 
-        assert isinstance(invalidation_context, rc_cache.FreshRegionCache)
-        assert should_invalidate is True
+        assert should_invalidate is False  # 1st call, we don't need to invalidate
 
         assert 'result:1' == result
-        # should be cached so calling it twice will give the same result !
-        result = _dummy_func('some-key')
+        # should be already cached so calling it twice will give the same result!
+        _, result = cache_func(*call_args)
         assert 'result:1' == result
 
     # 2nd call, we create a new context manager, this should be now key aware, and
-    # return an active cache region
+    # return an active cache region from DB based on the same uid
     with inv_context_manager as invalidation_context:
-        should_invalidate = invalidation_context.should_invalidate()
-        assert isinstance(invalidation_context, rc_cache.ActiveRegionCache)
-        assert should_invalidate is False
+        cache_state_uid = invalidation_context.state_uid
+        cache_func = cache_generator(cache_state_uid)
+        previous_state_uid, result = cache_func(*call_args)
+
+        should_invalidate = previous_state_uid != cache_state_uid
+        if should_invalidate:
+            _, result = cache_func.refresh(*call_args)
+
+        assert should_invalidate is False  # 1st call, we don't need to invalidate
 
     # Mark invalidation
-    CacheKey.set_invalidate(invalidation_namespace)
+    CacheKey.set_invalidate(repo_namespace_key)
 
     # 3nd call, fresh caches
     with inv_context_manager as invalidation_context:
-        should_invalidate = invalidation_context.should_invalidate()
+        cache_state_uid = invalidation_context.state_uid
+        cache_func = cache_generator(cache_state_uid)
+        previous_state_uid, result = cache_func(*call_args)
+
+        should_invalidate = previous_state_uid != cache_state_uid
         if should_invalidate:
-            result = _dummy_func.refresh('some-key')
-        else:
-            result = _dummy_func('some-key')
+            _, result = cache_func.refresh(*call_args)
 
-        assert isinstance(invalidation_context, rc_cache.FreshRegionCache)
         assert should_invalidate is True
 
         assert 'result:2' == result
 
         # cached again, same result
-        result = _dummy_func('some-key')
+        _, result = cache_func(*call_args)
         assert 'result:2' == result
 
 
 def test_invalidation_context_exception_in_compute(baseapp):
     repo_id = 888
+    region = rc_cache.get_or_create_region('cache_repo_longterm')
 
-    cache_namespace_uid = 'cache_repo_instance.{}_{}'.format(
-        repo_id, CacheKey.CACHE_TYPE_FEED)
-    invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
-        repo_id=repo_id)
-    region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
+    repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=repo_id)
+    inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key)
 
-    @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
-    def _dummy_func(cache_key):
+    def cache_generator(_state_uid):
+        @region.conditional_cache_on_arguments(namespace=f'some-common-namespace-{repo_id}')
+        def _dummy_func(*args):
         raise Exception('Error in cache func')
 
+        return _dummy_func
+
     with pytest.raises(Exception):
-        inv_context_manager = rc_cache.InvalidationContext(
-            uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
 
         # 1st call, fresh caches
         with inv_context_manager as invalidation_context:
-            should_invalidate = invalidation_context.should_invalidate()
-            if should_invalidate:
-                _dummy_func.refresh('some-key-2')
-            else:
-                _dummy_func('some-key-2')
+            cache_state_uid = invalidation_context.state_uid
+            cache_func = cache_generator(cache_state_uid)
+            cache_func(1, 2, 3)
 
 
 @pytest.mark.parametrize('execution_number', range(5))
 def test_cache_invalidation_race_condition(execution_number, baseapp):
-    import time
 
     repo_id = 777
 
-    cache_namespace_uid = 'cache_repo_instance.{}_{}'.format(
-        repo_id, CacheKey.CACHE_TYPE_FEED)
-    invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
-        repo_id=repo_id)
-    region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
+    region = rc_cache.get_or_create_region('cache_repo_longterm')
+    repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=repo_id)
 
     @run_test_concurrently(25)
     def test_create_and_delete_cache_keys():
         time.sleep(0.2)
 
-        @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
-        def _dummy_func(cache_key):
-            val = 'async'
-            return 'result:{}'.format(val)
+        def cache_generator(_state_uid):
 
-        inv_context_manager = rc_cache.InvalidationContext(
-            uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
+            @region.conditional_cache_on_arguments(namespace=f'some-common-namespace-{repo_id}')
+            def _dummy_func(*args):
+                return _state_uid, 'result:async'
+
+            return _dummy_func
+
+        inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key)
 
         # 1st call, fresh caches
         with inv_context_manager as invalidation_context:
-            should_invalidate = invalidation_context.should_invalidate()
+            cache_state_uid = invalidation_context.state_uid
+            cache_func = cache_generator(cache_state_uid)
+            previous_state_uid, result = cache_func('doo')
+
+            should_invalidate = previous_state_uid != cache_state_uid
             if should_invalidate:
-                _dummy_func.refresh('some-key-3')
-            else:
-                _dummy_func('some-key-3')
+                _, result = cache_func.refresh('doo')
 
         # Mark invalidation
-        CacheKey.set_invalidate(invalidation_namespace)
+        CacheKey.set_invalidate(repo_namespace_key)
 
     test_create_and_delete_cache_keys()

rhodecode/tests/vcs_operations/test_vcs_operations.py

@@ -1,375 +1,373 b''
 
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Test suite for making push/pull operations, on specially modified INI files
 
 .. important::
 
    You must have git >= 1.8.5 for tests to work fine. With 68b939b git started
    to redirect things to stderr instead of stdout.
 """
 
 
 import time
 import logging
 
 import pytest
 
 from rhodecode.lib import rc_cache
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.db import Repository, UserIpMap, CacheKey
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import (GIT_REPO, HG_REPO, TEST_USER_ADMIN_LOGIN)
 from rhodecode.tests.utils import assert_message_in_log
 
 from rhodecode.tests.vcs_operations import (
     Command, _check_proper_clone, _check_proper_git_push,
     _add_files_and_push, HG_REPO_WITH_GROUP, GIT_REPO_WITH_GROUP)
 
 
 @pytest.mark.usefixtures("disable_locking", "disable_anonymous_user")
 class TestVCSOperations(object):
 
     def test_clone_hg_repo_by_admin(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'hg')
 
     def test_clone_hg_repo_by_admin_pull_protocol(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO)
         stdout, stderr = Command('/tmp').execute(
             'hg clone --pull', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'hg')
 
     def test_clone_hg_repo_by_admin_pull_stream_protocol(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO)
         stdout, stderr = Command('/tmp').execute(
             'hg clone --pull --stream', clone_url, tmpdir.strpath)
         assert 'files to transfer,' in stdout
         assert 'transferred 1.' in stdout
         assert '114 files updated,' in stdout
 
     def test_clone_git_repo_by_admin(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO)
         cmd = Command('/tmp')
         stdout, stderr = cmd.execute('git clone', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'git')
         cmd.assert_returncode_success()
 
     def test_clone_git_repo_by_admin_with_git_suffix(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO)
         cmd = Command('/tmp')
         stdout, stderr = cmd.execute('git clone', clone_url+".git", tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'git')
         cmd.assert_returncode_success()
 
     def test_clone_hg_repo_by_id_by_admin(self, rc_web_server, tmpdir):
         repo_id = Repository.get_by_repo_name(HG_REPO).repo_id
         clone_url = rc_web_server.repo_clone_url('_%s' % repo_id)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'hg')
 
     def test_clone_git_repo_by_id_by_admin(self, rc_web_server, tmpdir):
         repo_id = Repository.get_by_repo_name(GIT_REPO).repo_id
         clone_url = rc_web_server.repo_clone_url('_%s' % repo_id)
         cmd = Command('/tmp')
         stdout, stderr = cmd.execute('git clone', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'git')
         cmd.assert_returncode_success()
 
     def test_clone_hg_repo_with_group_by_admin(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO_WITH_GROUP)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'hg')
 
     def test_clone_git_repo_with_group_by_admin(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO_WITH_GROUP)
         cmd = Command('/tmp')
         stdout, stderr = cmd.execute('git clone', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'git')
         cmd.assert_returncode_success()
 
     def test_clone_git_repo_shallow_by_admin(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO)
         cmd = Command('/tmp')
         stdout, stderr = cmd.execute(
             'git clone --depth=1', clone_url, tmpdir.strpath)
 
         assert '' == stdout
         assert 'Cloning into' in stderr
         cmd.assert_returncode_success()
 
     def test_clone_wrong_credentials_hg(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO, passwd='bad!')
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         assert 'abort: authorization failed' in stderr
 
     def test_clone_wrong_credentials_git(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO, passwd='bad!')
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
         assert 'fatal: Authentication failed' in stderr
 
     def test_clone_git_dir_as_hg(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         assert 'HTTP Error 404: Not Found' in stderr
 
     def test_clone_hg_repo_as_git(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO)
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
         assert 'not found' in stderr
 
     def test_clone_non_existing_path_hg(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url('trololo')
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         assert 'HTTP Error 404: Not Found' in stderr
 
     def test_clone_non_existing_path_git(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url('trololo')
         stdout, stderr = Command('/tmp').execute('git clone', clone_url)
         assert 'not found' in stderr
 
     def test_clone_hg_with_slashes(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url('//' + HG_REPO)
         stdout, stderr = Command('/tmp').execute('hg clone', clone_url, tmpdir.strpath)
         assert 'HTTP Error 404: Not Found' in stderr
 
     def test_clone_git_with_slashes(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url('//' + GIT_REPO)
         stdout, stderr = Command('/tmp').execute('git clone', clone_url)
         assert 'not found' in stderr
 
     def test_clone_existing_path_hg_not_in_database(
             self, rc_web_server, tmpdir, fs_repo_only):
 
         db_name = fs_repo_only('not-in-db-hg', repo_type='hg')
         clone_url = rc_web_server.repo_clone_url(db_name)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         assert 'HTTP Error 404: Not Found' in stderr
 
     def test_clone_existing_path_git_not_in_database(
             self, rc_web_server, tmpdir, fs_repo_only):
         db_name = fs_repo_only('not-in-db-git', repo_type='git')
         clone_url = rc_web_server.repo_clone_url(db_name)
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
         assert 'not found' in stderr
 
     def test_clone_existing_path_hg_not_in_database_different_scm(
             self, rc_web_server, tmpdir, fs_repo_only):
         db_name = fs_repo_only('not-in-db-git', repo_type='git')
         clone_url = rc_web_server.repo_clone_url(db_name)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         assert 'HTTP Error 404: Not Found' in stderr
 
     def test_clone_existing_path_git_not_in_database_different_scm(
             self, rc_web_server, tmpdir, fs_repo_only):
         db_name = fs_repo_only('not-in-db-hg', repo_type='hg')
         clone_url = rc_web_server.repo_clone_url(db_name)
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
         assert 'not found' in stderr
 
     def test_clone_non_existing_store_path_hg(self, rc_web_server, tmpdir, user_util):
         repo = user_util.create_repo()
         clone_url = rc_web_server.repo_clone_url(repo.repo_name)
 
         # Damage repo by removing it's folder
         RepoModel()._delete_filesystem_repo(repo)
 
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         assert 'HTTP Error 404: Not Found' in stderr
 
     def test_clone_non_existing_store_path_git(self, rc_web_server, tmpdir, user_util):
         repo = user_util.create_repo(repo_type='git')
         clone_url = rc_web_server.repo_clone_url(repo.repo_name)
 
         # Damage repo by removing it's folder
         RepoModel()._delete_filesystem_repo(repo)
 
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
         assert 'not found' in stderr
 
     def test_push_new_file_hg(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
 
         stdout, stderr = _add_files_and_push(
             'hg', tmpdir.strpath, clone_url=clone_url)
 
         assert 'pushing to' in stdout
         assert 'size summary' in stdout
 
     def test_push_new_file_git(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO)
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
 
         # commit some stuff into this repo
         stdout, stderr = _add_files_and_push(
             'git', tmpdir.strpath, clone_url=clone_url)
 
         _check_proper_git_push(stdout, stderr)
 
     def test_push_invalidates_cache(self, rc_web_server, tmpdir):
         hg_repo = Repository.get_by_repo_name(HG_REPO)
 
         # init cache objects
         CacheKey.delete_all_cache()
         cache_namespace_uid = 'cache_push_test.{}'.format(hg_repo.repo_id)
-        invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
-            repo_id=hg_repo.repo_id)
+        repo_namespace_key = CacheKey.REPO_INVALIDATION_NAMESPACE.format(repo_id=hg_repo.repo_id)
 
-        inv_context_manager = rc_cache.InvalidationContext(
-            uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace)
+        inv_context_manager = rc_cache.InvalidationContext(key=repo_namespace_key)
 
         with inv_context_manager as invalidation_context:
             # __enter__ will create and register cache objects
             pass
 
         # clone to init cache
         clone_url = rc_web_server.repo_clone_url(hg_repo.repo_name)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
 
         cache_keys = hg_repo.cache_keys
         assert cache_keys != []
         for key in cache_keys:
             assert key.cache_active is True
 
         # PUSH that should trigger invalidation cache
         stdout, stderr = _add_files_and_push(
             'hg', tmpdir.strpath, clone_url=clone_url, files_no=1)
 
         # flush...
         Session().commit()
         hg_repo = Repository.get_by_repo_name(HG_REPO)
         cache_keys = hg_repo.cache_keys
         assert cache_keys != []
         for key in cache_keys:
             # keys should be marked as not active
             assert key.cache_active is False
 
     def test_push_wrong_credentials_hg(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
 
         push_url = rc_web_server.repo_clone_url(
             HG_REPO, user='bad', passwd='name')
         stdout, stderr = _add_files_and_push(
             'hg', tmpdir.strpath, clone_url=push_url)
 
         assert 'abort: authorization failed' in stderr
 
     def test_push_wrong_credentials_git(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO)
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
 
         push_url = rc_web_server.repo_clone_url(
             GIT_REPO, user='bad', passwd='name')
         stdout, stderr = _add_files_and_push(
             'git', tmpdir.strpath, clone_url=push_url)
 
         assert 'fatal: Authentication failed' in stderr
 
     def test_push_back_to_wrong_url_hg(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(HG_REPO)
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
 
         stdout, stderr = _add_files_and_push(
             'hg', tmpdir.strpath,
             clone_url=rc_web_server.repo_clone_url('not-existing'))
 
         assert 'HTTP Error 404: Not Found' in stderr
 
     def test_push_back_to_wrong_url_git(self, rc_web_server, tmpdir):
         clone_url = rc_web_server.repo_clone_url(GIT_REPO)
         stdout, stderr = Command('/tmp').execute(
             'git clone', clone_url, tmpdir.strpath)
 
         stdout, stderr = _add_files_and_push(
             'git', tmpdir.strpath,
             clone_url=rc_web_server.repo_clone_url('not-existing'))
 
         assert 'not found' in stderr
 
     def test_ip_restriction_hg(self, rc_web_server, tmpdir):
         user_model = UserModel()
         try:
             user_model.add_extra_ip(TEST_USER_ADMIN_LOGIN, '10.10.10.10/32')
             Session().commit()
             time.sleep(2)
             clone_url = rc_web_server.repo_clone_url(HG_REPO)
             stdout, stderr = Command('/tmp').execute(
                 'hg clone', clone_url, tmpdir.strpath)
             assert 'abort: HTTP Error 403: Forbidden' in stderr
         finally:
             # release IP restrictions
             for ip in UserIpMap.getAll():
                 UserIpMap.delete(ip.ip_id)
             Session().commit()
 
         time.sleep(2)
 
         stdout, stderr = Command('/tmp').execute(
             'hg clone', clone_url, tmpdir.strpath)
         _check_proper_clone(stdout, stderr, 'hg')
 
     def test_ip_restriction_git(self, rc_web_server, tmpdir):
         user_model = UserModel()
         try:
             user_model.add_extra_ip(TEST_USER_ADMIN_LOGIN, '10.10.10.10/32')
             Session().commit()
             time.sleep(2)
             clone_url = rc_web_server.repo_clone_url(GIT_REPO)
             stdout, stderr = Command('/tmp').execute(
                 'git clone', clone_url, tmpdir.strpath)
             msg = "The requested URL returned error: 403"
             assert msg in stderr
         finally:
             # release IP restrictions
             for ip in UserIpMap.getAll():
                 UserIpMap.delete(ip.ip_id)
             Session().commit()
 
         time.sleep(2)
 
         cmd = Command('/tmp')
         stdout, stderr = cmd.execute('git clone', clone_url, tmpdir.strpath)
         cmd.assert_returncode_success()
         _check_proper_clone(stdout, stderr, 'git')