self.cache_id, self.cache_key)

    def get_prefix(self):

        """

        Guess prefix that might have been used in _get_cache_key to generate self.cache_key .

        Only used for informational purposes in repo_edit.html .

        """

        return self.cache_key.split(self.cache_args, 1)[0]

    @classmethod

    def _get_cache_key(cls, key):

        """

        Wrapper for generating a unique cache key for this instance and "key".

        key must / will start with a repo_name which will be stored in .cache_args .

        """

        import rhodecode

        prefix = rhodecode.CONFIG.get('instance_id', '')

        return "%s%s" % (prefix, key)

    @classmethod

    def invalidate(cls, key):

        """

        Returns Invalidation object if the local cache with the given key is invalid,

        None otherwise.

        """

        repo_name = key

        repo_name = remove_suffix(repo_name, '_README')

        repo_name = remove_suffix(repo_name, '_RSS')

        repo_name = remove_suffix(repo_name, '_ATOM')

        cache_key = cls._get_cache_key(key)

        inv_obj = Session().query(cls).filter(cls.cache_key == cache_key).scalar()

        if not inv_obj:

            try:

                inv_obj = CacheInvalidation(cache_key, repo_name)

                Session().add(inv_obj)

                Session().commit()

            except Exception:

                log.error(traceback.format_exc())

                Session().rollback()

                return

        if not inv_obj.cache_active:

            # `cache_active = False` means that this cache

            # no longer is valid

            return inv_obj

    @classmethod

        """

        """

        invalidated_keys = []

            inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        try:

            for inv_obj in inv_objs:

                inv_obj.cache_active = False

                invalidated_keys.append(inv_obj.cache_key)

                Session().add(inv_obj)

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            Session().rollback()

        return invalidated_keys

    @classmethod

    def set_valid(cls, cache_key):

        """

        Mark this cache key as active and currently cached

        """

        inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

        inv_obj.cache_active = True

        Session().add(inv_obj)

        Session().commit()

    @classmethod

    def get_cache_map(cls):

        class cachemapdict(dict):

            def __init__(self, *args, **kwargs):

                self.fixkey = kwargs.pop('fixkey', False)

                super(cachemapdict, self).__init__(*args, **kwargs)

            def __getattr__(self, name):

                cache_key = name

                if self.fixkey:

                    cache_key = cls._get_cache_key(name)

                if cache_key in self.__dict__:

                    return self.__dict__[cache_key]

                else:

                    return self[cache_key]

            def __getitem__(self, name):

                cache_key = name

                if self.fixkey:

                    cache_key = cls._get_cache_key(name)

                try:

                    return super(cachemapdict, self).__getitem__(cache_key)

                except KeyError:

                    return None

        cache_map = cachemapdict(fixkey=True)

        for obj in cls.query().all():

            cache_map[obj.cache_key] = cachemapdict(obj.get_dict())

                    if path[0] == 'hg' and path[0] in BACKENDS.keys():

                        repos[name] = klass(safe_str(path[1]), baseui=baseui)

                    if path[0] == 'git' and path[0] in BACKENDS.keys():

                        repos[name] = klass(path[1])

            except OSError:

                continue

        log.debug('found %s paths with repositories' % (len(repos)))

        return repos

    def get_repos(self, all_repos=None, sort_key=None, simple=False):

        """

        Get all repos 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 repos

        :param simple: use SimpleCachedList - one without the SCM info

        """

        if all_repos is None:

            all_repos = self.sa.query(Repository)\

                        .filter(Repository.group_id == None)\

                        .order_by(func.lower(Repository.repo_name)).all()

        if simple:

            repo_iter = SimpleCachedRepoList(all_repos,

                                             repos_path=self.repos_path,

                                             order_by=sort_key)

        else:

            repo_iter = CachedRepoList(all_repos,

                                       repos_path=self.repos_path,

                                       order_by=sort_key)

        return repo_iter

    def get_repos_groups(self, all_groups=None):

        if all_groups is None:

            all_groups = RepoGroup.query()\

                .filter(RepoGroup.group_parent_id == None).all()

        return [x for x in GroupList(all_groups)]

    def mark_for_invalidation(self, repo_name):

        """

        Mark caches of this repo invalid in the database.

        :param repo_name: the repo for which caches should be marked invalid

        """

        repo = Repository.get_by_repo_name(repo_name)

        if repo:

            repo.update_changeset_cache()

        return invalidated_keys

    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)

                action_logger(UserTemp(user_id),

                              'stopped_following_repo',

                              RepoTemp(follow_repo_id))

                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)

            action_logger(UserTemp(user_id),

                          'started_following_repo',

                          RepoTemp(follow_repo_id))

        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