except OSError:

                continue

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

        return repos

    def get_repos(self, repos):

        """Return the repos the user has access to"""

        return RepoList(repos, perm_level='read')

    def get_repo_groups(self, groups=None):

        """Return the repo groups the user has access to

        If no groups are specified, use top level groups.

        """

        if groups is None:

            groups = RepoGroup.query() \

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

        return RepoGroupList(groups, perm_level='read')

    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

        """

        CacheInvalidation.set_invalidate(repo_name)

        repo = Repository.get_by_repo_name(repo_name)

        if repo is not None:

            repo.update_changeset_cache()

    def toggle_following_repo(self, follow_repo_id, user_id):

        f = UserFollowing.query() \

            .filter(UserFollowing.follows_repository_id == follow_repo_id) \

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

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

        dbrepo = self.__get_repo(repo)

        if clone_uri is None:

            clone_uri = dbrepo.clone_uri or dbrepo.fork and dbrepo.fork.repo_full_path

        if not clone_uri:

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        repo_name = dbrepo.repo_name

        try:

            if repo.alias == 'git':

                repo.fetch(clone_uri)

                # git doesn't really have something like post-fetch action

                # we fake that now.

                # TODO: extract fetched revisions ... somehow ...

                self._handle_push(repo,

                                  username=username,

                                  ip_addr=ip_addr,

                                  action='push_remote',

                                  repo_name=repo_name,

                                  revisions=[])

            else:

                set_hook_environment(username, ip_addr, dbrepo.repo_name,

                                           repo.alias, action='push_remote')

                repo.pull(clone_uri)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, ip_addr, author, message,

                      content, f_path):

        """

        Commit a change to a single file

        :param repo: a db_repo.scm_instance

        """

        user = User.guess_instance(user)

        IMC = self._get_IMC_module(repo.alias)

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)

        # message and author needs to be unicode

        # proper backend should then translate that into required type

        message = safe_unicode(message)

        author = safe_unicode(author)

        imc = IMC(repo)

        imc.change(FileNode(path, content, mode=cs.get_file_mode(f_path)))

        try:

            tip = imc.commit(message=message, author=author,

                             parents=[cs], branch=cs.branch)

        except Exception as e:

            log.error(traceback.format_exc())

            raise IMCCommitError(str(e))

        self._handle_push(repo,

                          username=user.username,

                          ip_addr=ip_addr,

                          action='push_local',

                          repo_name=repo_name,

                          revisions=[tip.raw_id])

        return tip

    def _sanitize_path(self, f_path):

        if f_path.startswith('/') or f_path.startswith('.') or '../' in f_path:

            raise NonRelativePathError('%s is not an relative path' % f_path)

        if f_path:

            f_path = posixpath.normpath(f_path)

        return f_path

    def get_nodes(self, repo_name, revision, root_path='/', flat=True):

        """

        Recursively walk root dir and return a set of all paths found.

        :param repo_name: name of repository

        :param revision: revision for which to list nodes

        :param root_path: root path to list

        :param flat: return as a list, if False returns a dict with description

        message = safe_unicode(message)

        committer = user.full_contact

        author = safe_unicode(author) if author else committer

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

            imc.add(FileNode(path, content=content))

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

        return tip

    def update_nodes(self, user, ip_addr, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Commits specified nodes to repo. Again.

        """

        user = User.guess_instance(user)

        scm_instance = repo.scm_instance_no_cache()

        message = safe_unicode(message)

        committer = user.full_contact

        author = safe_unicode(author) if author else committer

        imc_class = self._get_IMC_module(scm_instance.alias)

        imc = imc_class(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            filename = self._sanitize_path(data['filename'])

            old_filename = self._sanitize_path(_filename)

            content = data['content']

            filenode = FileNode(old_filename, content=content)

            op = data['op']

            if op == 'add':

                imc.add(filenode)

            elif op == 'del':

                imc.remove(filenode)

            elif op == 'mod':

                if filename != old_filename:

                    # TODO: handle renames, needs vcs lib changes

                    imc.remove(filenode)

                    imc.add(FileNode(filename, content=content))

                else:

                    imc.change(filenode)

        # commit changes

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

    def delete_nodes(self, user, ip_addr, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Deletes specified nodes from repo.

        :param user: Kallithea User object or user_id, the committer

        :param repo: Kallithea Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param author: author of commit, cna be different that committer only for git

        :param trigger_push_hook: trigger push hooks

        :returns: new committed changeset after deletion

        """

        user = User.guess_instance(user)

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

        for f_path in nodes:

            f_path = self._sanitize_path(f_path)

            # content can be empty but for compatibility it allows same dicts

        message = safe_unicode(message)

        committer = user.full_contact

        author = safe_unicode(author) if author else committer

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

            imc.remove(FileNode(path, content=content))

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

        return tip

    def get_unread_journal(self):

        return UserLog.query().count()

    def get_repo_landing_revs(self, repo=None):

        """

        Generates select option with tags branches and bookmarks (for hg only)

        grouped by type

        :param repo:

        """

        hist_l = []

        choices = []

        repo = self.__get_repo(repo)

        hist_l.append(['rev:tip', _('latest tip')])

        choices.append('rev:tip')

        if repo is None:

            return choices, hist_l

        repo = repo.scm_instance

        branches_group = ([(u'branch:%s' % k, k) for k, v in