@cache_region('long_term')

        def _get_repo(repo_name):

            repo_path = os.path.join(self.repos_path, repo_name)

            alias = get_scm(repo_path)[0]

            log.debug('Creating instance of %s repository', alias)

            backend = get_backend(alias)

            #TODO: get the baseui from somewhere for this

            if alias == 'hg':

                from pylons import app_globals as g

                repo = backend(repo_path, create=False, baseui=g.baseui)

                #skip hidden web repository

                if repo._get_hidden():

                    return

            else:

                repo = backend(repo_path, create=False)

            dbrepo = self.sa.query(Repository)\

                .options(joinedload(Repository.fork))\

                .options(joinedload(Repository.user))\

                .filter(Repository.repo_name == repo_name)\

                .scalar()

            repo.dbrepo = dbrepo

            return repo

        pre_invalidate = True

        if invalidation_list:

            pre_invalidate = repo_name in invalidation_list

        if pre_invalidate:

            invalidate = self._should_invalidate(repo_name)

            if invalidate:

                log.info('invalidating cache for repository %s', repo_name)

                region_invalidate(_get_repo, None, repo_name)

                self._mark_invalidated(invalidate)

        return _get_repo(repo_name)

    def mark_for_invalidation(self, repo_name):

        """

        Puts cache invalidation task into db for 

        further global cache invalidation