if repos_path is None:

            repos_path = self.repos_path

        baseui = make_ui('db')

        repos_list = {}

        for name, path in get_filesystem_repos(repos_path, recursive=True):

            try:

                if name in repos_list:

                    raise RepositoryError('Duplicate repository name %s '

                                    'found in %s' % (name, path))

                else:

                    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

            this have to be a list of  just the repository names

        """

        if all_repos is None:

            repos = self.sa.query(Repository)\

                        .order_by(Repository.repo_name).all()

            all_repos = [r.repo_name for r in repos]

        #get the repositories that should be invalidated

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

                             self.sa.query(CacheInvalidation.cache_key)\

                             .filter(CacheInvalidation.cache_active == False)\

                             .all()]

        for r_name in all_repos:

            r_dbr = self.get(r_name, invalidation_list)

            if r_dbr is not None:

                repo, dbrepo = r_dbr

                    log.error('Repository %s looks somehow corrupted', r_name)

                    continue

                last_change = repo.last_change

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

                tmp_d = {}

                tmp_d['name'] = dbrepo.repo_name

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

                tmp_d['description'] = 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'] = dbrepo.user.full_contact

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

                tmp_d['owner_sort'] = tmp_d['contact']

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

                tmp_d['last_msg'] = tip.message

                tmp_d['repo'] = repo

                tmp_d['dbrepo'] = dbrepo.get_dict()

                tmp_d['dbrepo_fork'] = dbrepo.fork.get_dict() if dbrepo.fork \

                                                                        else {}

                yield tmp_d

    def get(self, repo_name, invalidation_list=None, retval='all'):

        """Returns a tuple of Repository,DbRepository,

        Get's repository from given name, creates BackendInstance and

        propagates it's data from database with all additional information

        :param repo_name:

        :param invalidation_list: if a invalidation list is given the get

            method should not manually check if this repository needs

            invalidation and just invalidate the repositories in list

        :param retval: string specifing what to return one of 'repo','dbrepo',

            'all'if repo or dbrepo is given it'll just lazy load chosen type

            and return None as the second

        """

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

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

            return

        #======================================================================

        # CACHE FUNCTION

        #======================================================================

        @cache_region('long_term')