merged stable into default

rhodecode/lib/_vendor/redis_lock/__init__.py

@@ -0,0 +1,389 b''
+import sys
+import threading
+import weakref
+from base64 import b64encode
+from logging import getLogger
+from os import urandom
+
+from redis import StrictRedis
+
+__version__ = '3.7.0'
+
+loggers = {
+    k: getLogger("rhodecode" + ".".join((__name__, k)))
+    for k in [
+        "acquire",
+        "refresh.thread.start",
+        "refresh.thread.stop",
+        "refresh.thread.exit",
+        "refresh.start",
+        "refresh.shutdown",
+        "refresh.exit",
+        "release",
+    ]
+}
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    text_type = str
+    binary_type = bytes
+else:
+    text_type = unicode  # noqa
+    binary_type = str
+
+
+# Check if the id match. If not, return an error code.
+UNLOCK_SCRIPT = b"""
+    if redis.call("get", KEYS[1]) ~= ARGV[1] then
+        return 1
+    else
+        redis.call("del", KEYS[2])
+        redis.call("lpush", KEYS[2], 1)
+        redis.call("pexpire", KEYS[2], ARGV[2])
+        redis.call("del", KEYS[1])
+        return 0
+    end
+"""
+
+# Covers both cases when key doesn't exist and doesn't equal to lock's id
+EXTEND_SCRIPT = b"""
+    if redis.call("get", KEYS[1]) ~= ARGV[1] then
+        return 1
+    elseif redis.call("ttl", KEYS[1]) < 0 then
+        return 2
+    else
+        redis.call("expire", KEYS[1], ARGV[2])
+        return 0
+    end
+"""
+
+RESET_SCRIPT = b"""
+    redis.call('del', KEYS[2])
+    redis.call('lpush', KEYS[2], 1)
+    redis.call('pexpire', KEYS[2], ARGV[2])
+    return redis.call('del', KEYS[1])
+"""
+
+RESET_ALL_SCRIPT = b"""
+    local locks = redis.call('keys', 'lock:*')
+    local signal
+    for _, lock in pairs(locks) do
+        signal = 'lock-signal:' .. string.sub(lock, 6)
+        redis.call('del', signal)
+        redis.call('lpush', signal, 1)
+        redis.call('expire', signal, 1)
+        redis.call('del', lock)
+    end
+    return #locks
+"""
+
+
+class AlreadyAcquired(RuntimeError):
+    pass
+
+
+class NotAcquired(RuntimeError):
+    pass
+
+
+class AlreadyStarted(RuntimeError):
+    pass
+
+
+class TimeoutNotUsable(RuntimeError):
+    pass
+
+
+class InvalidTimeout(RuntimeError):
+    pass
+
+
+class TimeoutTooLarge(RuntimeError):
+    pass
+
+
+class NotExpirable(RuntimeError):
+    pass
+
+
+class Lock(object):
+    """
+    A Lock context manager implemented via redis SETNX/BLPOP.
+    """
+    unlock_script = None
+    extend_script = None
+    reset_script = None
+    reset_all_script = None
+
+    def __init__(self, redis_client, name, expire=None, id=None, auto_renewal=False, strict=True, signal_expire=1000):
+        """
+        :param redis_client:
+            An instance of :class:`~StrictRedis`.
+        :param name:
+            The name (redis key) the lock should have.
+        :param expire:
+            The lock expiry time in seconds. If left at the default (None)
+            the lock will not expire.
+        :param id:
+            The ID (redis value) the lock should have. A random value is
+            generated when left at the default.
+
+            Note that if you specify this then the lock is marked as "held". Acquires
+            won't be possible.
+        :param auto_renewal:
+            If set to ``True``, Lock will automatically renew the lock so that it
+            doesn't expire for as long as the lock is held (acquire() called
+            or running in a context manager).
+
+            Implementation note: Renewal will happen using a daemon thread with
+            an interval of ``expire*2/3``. If wishing to use a different renewal
+            time, subclass Lock, call ``super().__init__()`` then set
+            ``self._lock_renewal_interval`` to your desired interval.
+        :param strict:
+            If set ``True`` then the ``redis_client`` needs to be an instance of ``redis.StrictRedis``.
+        :param signal_expire:
+            Advanced option to override signal list expiration in milliseconds. Increase it for very slow clients. Default: ``1000``.
+        """
+        if strict and not isinstance(redis_client, StrictRedis):
+            raise ValueError("redis_client must be instance of StrictRedis. "
+                             "Use strict=False if you know what you're doing.")
+        if auto_renewal and expire is None:
+            raise ValueError("Expire may not be None when auto_renewal is set")
+
+        self._client = redis_client
+
+        if expire:
+            expire = int(expire)
+            if expire < 0:
+                raise ValueError("A negative expire is not acceptable.")
+        else:
+            expire = None
+        self._expire = expire
+
+        self._signal_expire = signal_expire
+        if id is None:
+            self._id = b64encode(urandom(18)).decode('ascii')
+        elif isinstance(id, binary_type):
+            try:
+                self._id = id.decode('ascii')
+            except UnicodeDecodeError:
+                self._id = b64encode(id).decode('ascii')
+        elif isinstance(id, text_type):
+            self._id = id
+        else:
+            raise TypeError("Incorrect type for `id`. Must be bytes/str not %s." % type(id))
+        self._name = 'lock:' + name
+        self._signal = 'lock-signal:' + name
+        self._lock_renewal_interval = (float(expire) * 2 / 3
+                                       if auto_renewal
+                                       else None)
+        self._lock_renewal_thread = None
+
+        self.register_scripts(redis_client)
+
+    @classmethod
+    def register_scripts(cls, redis_client):
+        global reset_all_script
+        if reset_all_script is None:
+            reset_all_script = redis_client.register_script(RESET_ALL_SCRIPT)
+            cls.unlock_script = redis_client.register_script(UNLOCK_SCRIPT)
+            cls.extend_script = redis_client.register_script(EXTEND_SCRIPT)
+            cls.reset_script = redis_client.register_script(RESET_SCRIPT)
+            cls.reset_all_script = redis_client.register_script(RESET_ALL_SCRIPT)
+
+    @property
+    def _held(self):
+        return self.id == self.get_owner_id()
+
+    def reset(self):
+        """
+        Forcibly deletes the lock. Use this with care.
+        """
+        self.reset_script(client=self._client, keys=(self._name, self._signal), args=(self.id, self._signal_expire))
+
+    @property
+    def id(self):
+        return self._id
+
+    def get_owner_id(self):
+        owner_id = self._client.get(self._name)
+        if isinstance(owner_id, binary_type):
+            owner_id = owner_id.decode('ascii', 'replace')
+        return owner_id
+
+    def acquire(self, blocking=True, timeout=None):
+        """
+        :param blocking:
+            Boolean value specifying whether lock should be blocking or not.
+        :param timeout:
+            An integer value specifying the maximum number of seconds to block.
+        """
+        logger = loggers["acquire"]
+
+        logger.debug("Getting %r ...", self._name)
+
+        if self._held:
+            raise AlreadyAcquired("Already acquired from this Lock instance.")
+
+        if not blocking and timeout is not None:
+            raise TimeoutNotUsable("Timeout cannot be used if blocking=False")
+
+        if timeout:
+            timeout = int(timeout)
+            if timeout < 0:
+                raise InvalidTimeout("Timeout (%d) cannot be less than or equal to 0" % timeout)
+
+            if self._expire and not self._lock_renewal_interval and timeout > self._expire:
+                raise TimeoutTooLarge("Timeout (%d) cannot be greater than expire (%d)" % (timeout, self._expire))
+
+        busy = True
+        blpop_timeout = timeout or self._expire or 0
+        timed_out = False
+        while busy:
+            busy = not self._client.set(self._name, self._id, nx=True, ex=self._expire)
+            if busy:
+                if timed_out:
+                    return False
+                elif blocking:
+                    timed_out = not self._client.blpop(self._signal, blpop_timeout) and timeout
+                else:
+                    logger.warning("Failed to get %r.", self._name)
+                    return False
+
+        logger.info("Got lock for %r.", self._name)
+        if self._lock_renewal_interval is not None:
+            self._start_lock_renewer()
+        return True
+
+    def extend(self, expire=None):
+        """Extends expiration time of the lock.
+
+        :param expire:
+            New expiration time. If ``None`` - `expire` provided during
+            lock initialization will be taken.
+        """
+        if expire:
+            expire = int(expire)
+            if expire < 0:
+                raise ValueError("A negative expire is not acceptable.")
+        elif self._expire is not None:
+            expire = self._expire
+        else:
+            raise TypeError(
+                "To extend a lock 'expire' must be provided as an "
+                "argument to extend() method or at initialization time."
+            )
+
+        error = self.extend_script(client=self._client, keys=(self._name, self._signal), args=(self._id, expire))
+        if error == 1:
+            raise NotAcquired("Lock %s is not acquired or it already expired." % self._name)
+        elif error == 2:
+            raise NotExpirable("Lock %s has no assigned expiration time" % self._name)
+        elif error:
+            raise RuntimeError("Unsupported error code %s from EXTEND script" % error)
+
+    @staticmethod
+    def _lock_renewer(lockref, interval, stop):
+        """
+        Renew the lock key in redis every `interval` seconds for as long
+        as `self._lock_renewal_thread.should_exit` is False.
+        """
+        while not stop.wait(timeout=interval):
+            loggers["refresh.thread.start"].debug("Refreshing lock")
+            lock = lockref()
+            if lock is None:
+                loggers["refresh.thread.stop"].debug(
+                    "The lock no longer exists, stopping lock refreshing"
+                )
+                break
+            lock.extend(expire=lock._expire)
+            del lock
+        loggers["refresh.thread.exit"].debug("Exit requested, stopping lock refreshing")
+
+    def _start_lock_renewer(self):
+        """
+        Starts the lock refresher thread.
+        """
+        if self._lock_renewal_thread is not None:
+            raise AlreadyStarted("Lock refresh thread already started")
+
+        loggers["refresh.start"].debug(
+            "Starting thread to refresh lock every %s seconds",
+            self._lock_renewal_interval
+        )
+        self._lock_renewal_stop = threading.Event()
+        self._lock_renewal_thread = threading.Thread(
+            group=None,
+            target=self._lock_renewer,
+            kwargs={'lockref': weakref.ref(self),
+                    'interval': self._lock_renewal_interval,
+                    'stop': self._lock_renewal_stop}
+        )
+        self._lock_renewal_thread.setDaemon(True)
+        self._lock_renewal_thread.start()
+
+    def _stop_lock_renewer(self):
+        """
+        Stop the lock renewer.
+
+        This signals the renewal thread and waits for its exit.
+        """
+        if self._lock_renewal_thread is None or not self._lock_renewal_thread.is_alive():
+            return
+        loggers["refresh.shutdown"].debug("Signalling the lock refresher to stop")
+        self._lock_renewal_stop.set()
+        self._lock_renewal_thread.join()
+        self._lock_renewal_thread = None
+        loggers["refresh.exit"].debug("Lock refresher has stopped")
+
+    def __enter__(self):
+        acquired = self.acquire(blocking=True)
+        assert acquired, "Lock wasn't acquired, but blocking=True"
+        return self
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        self.release()
+
+    def release(self):
+        """Releases the lock, that was acquired with the same object.
+
+        .. note::
+
+            If you want to release a lock that you acquired in a different place you have two choices:
+
+            * Use ``Lock("name", id=id_from_other_place).release()``
+            * Use ``Lock("name").reset()``
+        """
+        if self._lock_renewal_thread is not None:
+            self._stop_lock_renewer()
+        loggers["release"].debug("Releasing %r.", self._name)
+        error = self.unlock_script(client=self._client, keys=(self._name, self._signal), args=(self._id, self._signal_expire))
+        if error == 1:
+            raise NotAcquired("Lock %s is not acquired or it already expired." % self._name)
+        elif error:
+            raise RuntimeError("Unsupported error code %s from EXTEND script." % error)
+
+    def locked(self):
+        """
+        Return true if the lock is acquired.
+
+        Checks that lock with same name already exists. This method returns true, even if
+        lock have another id.
+        """
+        return self._client.exists(self._name) == 1
+
+
+reset_all_script = None
+
+
+def reset_all(redis_client):
+    """
+    Forcibly deletes all locks if its remains (like a crash reason). Use this with care.
+
+    :param redis_client:
+        An instance of :class:`~StrictRedis`.
+    """
+    Lock.register_scripts(redis_client)
+
+    reset_all_script(client=redis_client)  # noqa

rhodecode/apps/_base/__init__.py

@@ -119,8 +119,16 b' class BaseAppView(object):'
             request.matched_route.name, self._rhodecode_db_user)
 
     def _maybe_needs_password_change(self, view_name, user_obj):
+
+        dont_check_views = [
+            'channelstream_connect'
+        ]
+        if view_name in dont_check_views:
+            return
+
         log.debug('Checking if user %s needs password change on view %s',
                   user_obj, view_name)
+
         skip_user_views = [
             'logout', 'login',
             'my_account_password', 'my_account_password_update'

rhodecode/apps/repository/views/repo_pull_requests.py

@@ -326,8 +326,9 b' class RepoPullRequestsView(RepoAppView, '
         _new_state = {
             'created': PullRequest.STATE_CREATED,
         }.get(self.request.GET.get('force_state'))
+        can_force_state = c.is_super_admin or HasRepoPermissionAny('repository.admin')(c.repo_name)
 
-        if c.is_super_admin and _new_state:
+        if can_force_state and _new_state:
             with pull_request.set_state(PullRequest.STATE_UPDATING, final_state=_new_state):
                 h.flash(
                     _('Pull Request state was force changed to `{}`').format(_new_state),
@@ -1268,6 +1269,9 b' class RepoPullRequestsView(RepoAppView, '
 
         c = self.load_default_context()
         redirect_url = None
+        # we do this check as first, because we want to know ASAP in the flow that
+        # pr is updating currently
+        is_state_changing = pull_request.is_state_changing()
 
         if pull_request.is_closed():
             log.debug('update: forbidden because pull request is closed')
@@ -1276,7 +1280,6 b' class RepoPullRequestsView(RepoAppView, '
             return {'response': True,
                     'redirect_url': redirect_url}
 
-        is_state_changing = pull_request.is_state_changing()
         c.pr_broadcast_channel = channelstream.pr_channel(pull_request)
 
         # only owner or admin can update it
@@ -1285,7 +1288,8 b' class RepoPullRequestsView(RepoAppView, '
 
         if allowed_to_update:
             controls = peppercorn.parse(self.request.POST.items())
-            force_refresh = str2bool(self.request.POST.get('force_refresh'))
+            force_refresh = str2bool(self.request.POST.get('force_refresh', 'false'))
+            do_update_commits = str2bool(self.request.POST.get('update_commits', 'false'))
 
             if 'review_members' in controls:
                 self._update_reviewers(
@@ -1299,7 +1303,7 b' class RepoPullRequestsView(RepoAppView, '
                     pull_request, controls['observer_members'],
                     pull_request.reviewer_data,
                     PullRequestReviewers.ROLE_OBSERVER)
-            elif str2bool(self.request.POST.get('update_commits', 'false')):
+            elif do_update_commits:
                 if is_state_changing:
                     log.debug('commits update: forbidden because pull request is in state %s',
                               pull_request.pull_request_state)
@@ -1352,8 +1356,9 b' class RepoPullRequestsView(RepoAppView, '
 
     def _update_commits(self, c, pull_request):
         _ = self.request.translate
+        log.debug('pull-request: running update commits actions')
 
-        @retry(exception=Exception, n_tries=3)
+        @retry(exception=Exception, n_tries=3, delay=2)
         def commits_update():
             return PullRequestModel().update_commits(
                 pull_request, self._rhodecode_db_user)

rhodecode/apps/ssh_support/lib/backends/__init__.py

@@ -34,6 +34,9 b' log = logging.getLogger(__name__)'
 
 
 class SshWrapper(object):
+    hg_cmd_pat  = re.compile(r'^hg\s+\-R\s+(\S+)\s+serve\s+\-\-stdio$')
+    git_cmd_pat = re.compile(r'^git-(receive-pack|upload-pack)\s\'[/]?(\S+?)(|\.git)\'$')
+    svn_cmd_pat = re.compile(r'^svnserve -t')
 
     def __init__(self, command, connection_info, mode,
                  user, user_id, key_id, shell, ini_path, env):
@@ -90,35 +93,42 b' class SshWrapper(object):'
         return conn
 
     def maybe_translate_repo_uid(self, repo_name):
+        _org_name = repo_name
+        if _org_name.startswith('_'):
+            # remove format of _ID/subrepo
+            _org_name = _org_name.split('/', 1)[0]
+
         if repo_name.startswith('_'):
             from rhodecode.model.repo import RepoModel
+            org_repo_name = repo_name
+            log.debug('translating UID repo %s', org_repo_name)
             by_id_match = RepoModel().get_repo_by_id(repo_name)
             if by_id_match:
                 repo_name = by_id_match.repo_name
-        return repo_name
+                log.debug('translation of UID repo %s got `%s`', org_repo_name, repo_name)
+
+        return repo_name, _org_name
 
     def get_repo_details(self, mode):
         vcs_type = mode if mode in ['svn', 'hg', 'git'] else None
         repo_name = None
 
-        hg_pattern = r'^hg\s+\-R\s+(\S+)\s+serve\s+\-\-stdio$'
-        hg_match = re.match(hg_pattern, self.command)
+        hg_match = self.hg_cmd_pat.match(self.command)
         if hg_match is not None:
             vcs_type = 'hg'
-            repo_name = self.maybe_translate_repo_uid(hg_match.group(1).strip('/'))
+            repo_id = hg_match.group(1).strip('/')
+            repo_name, org_name = self.maybe_translate_repo_uid(repo_id)
             return vcs_type, repo_name, mode
 
-        git_pattern = r'^git-(receive-pack|upload-pack)\s\'[/]?(\S+?)(|\.git)\'$'
-        git_match = re.match(git_pattern, self.command)
+        git_match = self.git_cmd_pat.match(self.command)
         if git_match is not None:
+            mode = git_match.group(1)
             vcs_type = 'git'
-            repo_name = self.maybe_translate_repo_uid(git_match.group(2).strip('/'))
-            mode = git_match.group(1)
+            repo_id = git_match.group(2).strip('/')
+            repo_name, org_name = self.maybe_translate_repo_uid(repo_id)
             return vcs_type, repo_name, mode
 
-        svn_pattern = r'^svnserve -t'
-        svn_match = re.match(svn_pattern, self.command)
-
+        svn_match = self.svn_cmd_pat.match(self.command)
         if svn_match is not None:
             vcs_type = 'svn'
             # Repo name should be extracted from the input stream, we're unable to

rhodecode/lib/audit_logger.py

@@ -261,7 +261,6 b' def store(action, user, action_data=None'
         ip_address = safe_unicode(ip_addr)
 
         with sa_session.no_autoflush:
-            update_user_last_activity(sa_session, user_id)
 
             user_log = _store_log(
                 action_name=action_name,
@@ -275,11 +274,15 b' def store(action, user, action_data=None'
             )
 
             sa_session.add(user_log)
+            if commit:
+                sa_session.commit()
+            entry_id = user_log.entry_id or ''
+
+            update_user_last_activity(sa_session, user_id)
 
             if commit:
                 sa_session.commit()
 
-        entry_id = user_log.entry_id or ''
         log.info('AUDIT[%s]: Logging action: `%s` by user:id:%s[%s] ip:%s',
                  entry_id, action_name, user_id, username, ip_address)
 
@@ -295,4 +298,6 b' def update_user_last_activity(sa_session'
         log.debug(
             'updated user `%s` last activity to:%s', user_id, _last_activity)
     except Exception:
-        log.exception("Failed last activity update")
+        log.exception("Failed last activity update for user_id: %s", user_id)
+        sa_session.rollback()
+

rhodecode/lib/celerylib/tasks.py

@@ -102,7 +102,7 b' def send_email(recipients, subject, body'
         # Location of maildir
         # queue_path='',
 
-        default_sender=email_config.get('app_email_from', 'RhodeCode'),
+        default_sender=email_config.get('app_email_from', '[e-mail]'),
 
         debug=str2bool(email_config.get('smtp_debug')),
         # /usr/sbin/sendmail	Sendmail executable

rhodecode/lib/rc_cache/backends.py

@@ -183,8 +183,11 b' class FileNamespaceBackend(PickleSeriali'
             return False
 
         with self._dbm_file(True) as dbm:
-
-            return filter(cond, dbm.keys())
+            try:
+                return filter(cond, dbm.keys())
+            except Exception:
+                log.error('Failed to fetch DBM keys from DB: %s', self.get_store())
+                raise
 
     def get_store(self):
         return self.filename
@@ -283,11 +286,18 b' class BaseRedisBackend(redis_backend.Red'
             pipe.execute()
 
     def get_mutex(self, key):
-        u = redis_backend.u
         if self.distributed_lock:
-            lock_key = u('_lock_{0}').format(key)
+            import redis_lock
+            lock_key = redis_backend.u('_lock_{0}').format(key)
             log.debug('Trying to acquire Redis lock for key %s', lock_key)
-            return self.client.lock(lock_key, self.lock_timeout, self.lock_sleep)
+            lock = redis_lock.Lock(
+                redis_client=self.client,
+                name=lock_key,
+                expire=self.lock_timeout,
+                auto_renewal=False,
+                strict=True,
+            )
+            return lock
         else:
             return None
 

rhodecode/model/pull_request.py

@@ -1198,14 +1198,20 b' class PullRequestModel(BaseModel):'
                     pull_request=pull_request,
                     revision=commit_id)
 
+        # initial commit
+        Session().commit()
+
+        if pr_has_changes:
             # send update email to users
             try:
                 self.notify_users(pull_request=pull_request, updating_user=updating_user,
                                   ancestor_commit_id=ancestor_commit_id,
                                   commit_changes=commit_changes,
                                   file_changes=file_changes)
+                Session().commit()
             except Exception:
                 log.exception('Failed to send email notification to users')
+                Session().rollback()
 
         log.debug(
             'Updated pull request %s, added_ids: %s, common_ids: %s, '
@@ -1221,7 +1227,7 b' class PullRequestModel(BaseModel):'
             pull_request.pull_request_id, source_ref_id,
             pull_request.source_ref_parts.commit_id,
             pull_request_version.pull_request_version_id)
-        Session().commit()
+
         self.trigger_pull_request_hook(pull_request, pull_request.author, 'update')
 
         return UpdateResponse(

rhodecode/model/validation_schema/schemas/repo_group_schema.py

@@ -22,6 +22,7 b''
 import colander
 import deform.widget
 
+from rhodecode.model.validation_schema.utils import username_converter
 from rhodecode.translation import _
 from rhodecode.model.validation_schema import validators, preparers, types
 
@@ -120,6 +121,7 b' def deferred_repo_group_owner_validator('
 
     def repo_owner_validator(node, value):
         from rhodecode.model.db import User
+        value = username_converter(value)
         existing = User.get_by_username(value)
         if not existing:
             msg = _(u'Repo group owner with id `{}` does not exists').format(

rhodecode/model/validation_schema/schemas/repo_schema.py

@@ -22,7 +22,7 b' import colander'
 import deform.widget
 
 from rhodecode.translation import _
-from rhodecode.model.validation_schema.utils import convert_to_optgroup
+from rhodecode.model.validation_schema.utils import convert_to_optgroup, username_converter
 from rhodecode.model.validation_schema import validators, preparers, types
 
 DEFAULT_LANDING_REF = 'rev:tip'
@@ -55,6 +55,7 b' def deferred_repo_owner_validator(node, '
 
     def repo_owner_validator(node, value):
         from rhodecode.model.db import User
+        value = username_converter(value)
         existing = User.get_by_username(value)
         if not existing:
             msg = _(u'Repo owner with id `{}` does not exists').format(value)

rhodecode/model/validation_schema/schemas/user_group_schema.py

@@ -21,6 +21,7 b' import re'
 import colander
 
 from rhodecode.model.validation_schema import types, validators
+from rhodecode.model.validation_schema.utils import username_converter
 from rhodecode.translation import _
 
 
@@ -43,6 +44,7 b' def deferred_user_group_owner_validator('
 
     def owner_validator(node, value):
         from rhodecode.model.db import User
+        value = username_converter(value)
         existing = User.get_by_username(value)
         if not existing:
             msg = _(u'User group owner with id `{}` does not exists').format(value)

rhodecode/model/validation_schema/utils.py

@@ -47,3 +47,10 b' def convert_to_optgroup(items):'
             result.append((value, label))
 
     return result
+
+
+def username_converter(value):
+    for noise in ('/', ',', '*', '"', "'", '<', '>', '(', ')', '[', ']', ';'):
+        value = value.replace(noise, '')
+
+    return value

rhodecode/templates/pullrequests/pullrequest_show.mako

@@ -274,11 +274,12 b''
   % if c.state_progressing:
 
     <h2 style="text-align: center">
-        ${_('Cannot show diff when pull request state is changing. Current progress state')}: <span class="tag tag-merge-state-${c.pull_request.state}">${c.pull_request.state}</span>
+        ${_('Cannot show diff when pull request state is changing. Current progress state')}: <span class="tag tag-merge-state-${c.pull_request.state}">${c.pull_request.state}</span><br/>
+        ${_('Consider refreshing the page to check if the status transition was finished')}.
 
-        % if c.is_super_admin:
+        % if c.is_super_admin or h.HasRepoPermissionAny('repository.admin')(c.repo_name):
         <br/>
-        If you think this is an error try <a href="${h.current_route_path(request, force_state='created')}">forced state reset</a> to <span class="tag tag-merge-state-created">created</span> state.
+        ${_('If you think this is an error try ')}<a href="${h.current_route_path(request, force_state='created')}">forced state reset</a> to <span class="tag tag-merge-state-created">created</span> state.
         % endif
     </h2>
 

rhodecode/tests/events/test_repo.py

@@ -20,6 +20,7 b''
 
 import pytest
 
+from rhodecode.events import UserPermissionsChange
 from rhodecode.lib.utils2 import StrictAttributeDict
 from rhodecode.tests.events.conftest import EventCatcher
 
@@ -97,7 +98,7 b' def test_vcs_repo_push_event_serialize(c'
 def test_create_delete_repo_fires_events(backend):
     with EventCatcher() as event_catcher:
         repo = backend.create_repo()
-    assert event_catcher.events_types == [RepoPreCreateEvent, RepoCreateEvent]
+    assert event_catcher.events_types == [RepoPreCreateEvent, RepoCreateEvent, UserPermissionsChange]
 
     with EventCatcher() as event_catcher:
         RepoModel().delete(repo)

rhodecode/tests/models/test_pullrequest.py

@@ -127,7 +127,7 b' class TestPullRequestModel(object):'
         Session().commit()
 
         prs = PullRequestModel().get_awaiting_my_review(
-            pull_request.target_repo, user_id=pull_request.author.user_id)
+            pull_request.target_repo.repo_name, user_id=pull_request.author.user_id)
         assert isinstance(prs, list)
         assert len(prs) == 1
 
@@ -138,7 +138,7 b' class TestPullRequestModel(object):'
         Session().commit()
 
         pr_count = PullRequestModel().count_awaiting_my_review(
-            pull_request.target_repo, user_id=pull_request.author.user_id)
+            pull_request.target_repo.repo_name, user_id=pull_request.author.user_id)
         assert pr_count == 1
 
     def test_delete_calls_cleanup_merge(self, pull_request):