klass = get_backend(path[0])

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

                        repos_list[name] = klass(path[1], baseui=baseui)

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

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

            except OSError:

                continue

        return repos_list

    def get_repos(self, all_repos=None):

        """

        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: give specific repositories list, good for filtering

        """

        if all_repos is None:

            all_repos = self.sa.query(Repository)\

                .order_by(Repository.repo_name).all()

        invalidation_list = [str(x.cache_key) for x in \

                             self.sa.query(CacheInvalidation.cache_key)\

                             .filter(CacheInvalidation.cache_active == False)\

                             .all()]

        for r in all_repos:

            repo = self.get(r.repo_name, invalidation_list)

            if repo is not None:

                last_change = repo.last_change

                tip = h.get_changeset_safe(repo, 'tip')

                tmp_d = {}

                tmp_d['name'] = repo.name

                tmp_d['name_sort'] = tmp_d['name'].lower()

                tmp_d['description'] = repo.dbrepo.description

                tmp_d['description_sort'] = tmp_d['description']

                tmp_d['last_change'] = last_change

                tmp_d['last_change_sort'] = time.mktime(last_change.timetuple())

                tmp_d['tip'] = tip.raw_id

                tmp_d['tip_sort'] = tip.revision

                tmp_d['rev'] = tip.revision

                tmp_d['contact'] = repo.dbrepo.user.full_contact

                tmp_d['contact_sort'] = tmp_d['contact']

                tmp_d['repo_archives'] = list(repo._get_archives())

                tmp_d['last_msg'] = tip.message

                tmp_d['repo'] = repo

                yield tmp_d

    def get_repo(self, repo_name):

        return self.get(repo_name)

    def get(self, repo_name, invalidation_list=None):

        """

        Get's repository from given name, creates BackendInstance and

        propagates it's data from database with all additional information

        :param repo_name:

        """

        if not HasRepoPermissionAny('repository.read', 'repository.write',

                            'repository.admin')(repo_name, 'get repo check'):

            return

        @cache_region('long_term')

        def _get_repo(repo_name):

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

            try:

                alias = get_scm(repo_path)[0]

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

                backend = get_backend(alias)

            except VCSError:

                log.error(traceback.format_exc())

                return

            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()

            make_transient(dbrepo)

            if dbrepo.user:

                make_transient(dbrepo.user)

            if dbrepo.fork:

                make_transient(dbrepo.fork)

            repo.dbrepo = dbrepo

            return repo

        return _get_repo(repo_name)

    def mark_for_invalidation(self, repo_name):

        """

        Puts cache invalidation task into db for 

        further global cache invalidation

        :param repo_name: this repo that should invalidation take place

        """

        log.debug('marking %s for invalidation', repo_name)

        cache = self.sa.query(CacheInvalidation)\

            .filter(CacheInvalidation.cache_key == repo_name).scalar()

        if cache:

            #mark this cache as inactive

            cache.cache_active = False

        else:

            log.debug('cache key not found in invalidation db -> creating one')

            cache = CacheInvalidation(repo_name)

        try:

            self.sa.add(cache)