Esempio n. 1
0
def repo_update_metadata(repositories):
    """
    Update repository metadata in database from repository content.

    In normal operation, Kallithea will keep caches up-to-date
    automatically. However, if repositories are externally modified, e.g. by
    a direct push via the filesystem rather than via a Kallithea URL,
    Kallithea is not aware of it. In this case, you should manually run this
    command to update the repository cache.

    If no repositories are specified, the caches of all repositories are
    updated.
    """
    if not repositories:
        repo_list = Repository.query().all()
    else:
        repo_names = [n.strip() for n in repositories]
        repo_list = list(Repository.query().filter(
            Repository.repo_name.in_(repo_names)))

    for repo in repo_list:
        # update latest revision metadata in database
        repo.update_changeset_cache()
        # invalidate in-memory VCS object cache... will be repopulated on
        # first access
        repo.set_invalidate()

    Session().commit()

    click.echo(
        'Updated database with information about latest change in the following %s repositories:'
        % (len(repo_list)))
    click.echo('\n'.join(repo.repo_name for repo in repo_list))
Esempio n. 2
0
    def test_push_invalidates_cache(self, webserver, testfork, vt):
        pre_cached_tip = [
            repo.get_api_data()['last_changeset']['short_id']
            for repo in Repository.query().filter(
                Repository.repo_name == testfork[vt.repo_type])
        ]

        dest_dir = _get_tmp_dir()
        clone_url = vt.repo_url_param(webserver, testfork[vt.repo_type])
        stdout, stderr = Command(base.TESTS_TMP_PATH).execute(
            vt.repo_type, 'clone', clone_url, dest_dir)

        stdout, stderr = _add_files_and_push(webserver,
                                             vt,
                                             dest_dir,
                                             files_no=1,
                                             clone_url=clone_url)

        Session().commit(
        )  # expire test session to make sure SA fetch new Repository instances after last_changeset has been updated server side hook in other process

        if vt.repo_type == 'git':
            _check_proper_git_push(stdout, stderr)

        post_cached_tip = [
            repo.get_api_data()['last_changeset']['short_id']
            for repo in Repository.query().filter(
                Repository.repo_name == testfork[vt.repo_type])
        ]
        assert pre_cached_tip != post_cached_tip
Esempio n. 3
0
        def _c():
            log.debug('generating switcher repo/groups list')
            all_repos = Repository.query().order_by(Repository.repo_name).all()
            repo_iter = self.scm_model.get_repos(all_repos)
            all_groups = RepoGroup.query().order_by(RepoGroup.group_name).all()
            repo_groups_iter = self.scm_model.get_repo_groups(all_groups)

            res = [{
                    'text': _('Groups'),
                    'children': [
                       {'id': obj.group_name,
                        'text': obj.group_name,
                        'type': 'group',
                        'obj': {}}
                       for obj in repo_groups_iter
                    ],
                   },
                   {
                    'text': _('Repositories'),
                    'children': [
                       {'id': obj.repo_name,
                        'text': obj.repo_name,
                        'type': 'repo',
                        'obj': obj.get_dict()}
                       for obj in repo_iter
                    ],
                   }]

            data = {
                'more': False,
                'results': res,
            }
            return data
Esempio n. 4
0
    def edit_advanced(self, repo_name):
        """GET /repo_name/settings: Form to edit an existing item"""
        # url('edit_repo', repo_name=ID)
        c.repo_info = self._load_repo(repo_name)
        c.default_user_id = User.get_default_user().user_id
        c.in_public_journal = UserFollowing.query()\
            .filter(UserFollowing.user_id == c.default_user_id)\
            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        _repos = Repository.query().order_by(Repository.repo_name).all()
        read_access_repos = RepoList(_repos)
        c.repos_list = [(None, _('-- Not a fork --'))]
        c.repos_list += [(x.repo_id, x.repo_name) for x in read_access_repos
                         if x.repo_id != c.repo_info.repo_id]

        defaults = {
            'id_fork_of': c.repo_info.fork.repo_id if c.repo_info.fork else ''
        }

        c.active = 'advanced'
        if request.POST:
            return redirect(url('repo_edit_advanced'))
        return htmlfill.render(render('admin/repos/repo_edit.html'),
                               defaults=defaults,
                               encoding="UTF-8",
                               force_defaults=False)
Esempio n. 5
0
        def _c():
            log.debug('generating switcher repo/groups list')
            all_repos = Repository.query(sorted=True).all()
            repo_iter = self.scm_model.get_repos(all_repos)
            all_groups = RepoGroup.query(sorted=True).all()
            repo_groups_iter = self.scm_model.get_repo_groups(all_groups)

            res = [{
                    'text': _('Groups'),
                    'children': [
                       {'id': obj.group_name,
                        'text': obj.group_name,
                        'type': 'group',
                        'obj': {}}
                       for obj in repo_groups_iter
                    ],
                   },
                   {
                    'text': _('Repositories'),
                    'children': [
                       {'id': obj.repo_name,
                        'text': obj.repo_name,
                        'type': 'repo',
                        'obj': obj.get_dict()}
                       for obj in repo_iter
                    ],
                   }]

            data = {
                'more': False,
                'results': res,
            }
            return data
Esempio n. 6
0
    def show(self, group_name):
        """GET /repo_groups/group_name: Show a specific item"""
        # url('repos_group', group_name=GROUP_NAME)
        c.active = 'settings'

        c.group = c.repo_group = RepoGroupModel()._get_repo_group(group_name)
        c.group_repos = c.group.repositories.all()

        #overwrite our cached list with current filter
        c.repo_cnt = 0

        groups = RepoGroup.query().order_by(RepoGroup.group_name)\
            .filter(RepoGroup.group_parent_id == c.group.group_id).all()
        c.groups = self.scm_model.get_repo_groups(groups)

        c.repos_list = Repository.query()\
                        .filter(Repository.group_id == c.group.group_id)\
                        .order_by(func.lower(Repository.repo_name))\
                        .all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
                                                   admin=False)
        #json used to render the grid
        c.data = json.dumps(repos_data)

        return render('admin/repo_groups/repo_group_show.html')
Esempio n. 7
0
    def edit_advanced(self, repo_name):
        c.repo_info = self._load_repo()
        c.default_user_id = User.get_default_user().user_id
        c.in_public_journal = UserFollowing.query() \
            .filter(UserFollowing.user_id == c.default_user_id) \
            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        _repos = Repository.query(sorted=True).all()
        read_access_repos = RepoList(_repos, perm_level='read')
        c.repos_list = [(None, _('-- Not a fork --'))]
        c.repos_list += [(x.repo_id, x.repo_name)
                         for x in read_access_repos
                         if x.repo_id != c.repo_info.repo_id]

        defaults = {
            'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else ''
        }

        c.active = 'advanced'
        if request.POST:
            raise HTTPFound(location=url('repo_edit_advanced'))
        return htmlfill.render(
            render('admin/repos/repo_edit.html'),
            defaults=defaults,
            encoding="UTF-8",
            force_defaults=False)
Esempio n. 8
0
    def edit_advanced(self, repo_name):
        """GET /repo_name/settings: Form to edit an existing item"""
        # url('edit_repo', repo_name=ID)
        c.repo_info = self._load_repo(repo_name)
        c.default_user_id = User.get_default_user().user_id
        c.in_public_journal = UserFollowing.query()\
            .filter(UserFollowing.user_id == c.default_user_id)\
            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        _repos = Repository.query().order_by(Repository.repo_name).all()
        read_access_repos = RepoList(_repos)
        c.repos_list = [(None, _('-- Not a fork --'))]
        c.repos_list += [(x.repo_id, x.repo_name)
                         for x in read_access_repos
                         if x.repo_id != c.repo_info.repo_id]

        defaults = {
            'id_fork_of': c.repo_info.fork.repo_id if c.repo_info.fork else ''
        }

        c.active = 'advanced'
        if request.POST:
            return redirect(url('repo_edit_advanced'))
        return htmlfill.render(
            render('admin/repos/repo_edit.html'),
            defaults=defaults,
            encoding="UTF-8",
            force_defaults=False)
Esempio n. 9
0
 def test_my_account_my_repos(self):
     self.log_user()
     response = self.app.get(url('my_account_repos'))
     cnt = Repository.query().filter(
         Repository.user == User.get_by_username(
             TEST_USER_ADMIN_LOGIN)).count()
     response.mustcontain('"totalRecords": %s' % cnt)
Esempio n. 10
0
    def index(self):
        # Return a rendered template
        p = safe_int(request.GET.get('page'), 1)
        c.user = User.get(request.authuser.user_id)
        c.following = UserFollowing.query() \
            .filter(UserFollowing.user_id == request.authuser.user_id) \
            .options(joinedload(UserFollowing.follows_repository)) \
            .all()

        journal = self._get_journal_data(c.following)

        def url_generator(**kw):
            return url.current(filter=c.search_term, **kw)

        c.journal_pager = Page(journal, page=p, items_per_page=20, url=url_generator)
        c.journal_day_aggregate = self._get_daily_aggregate(c.journal_pager)

        if request.environ.get('HTTP_X_PARTIAL_XHR'):
            return render('journal/journal_data.html')

        repos_list = Repository.query(sorted=True) \
            .filter_by(owner_id=request.authuser.user_id).all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,
                                                   admin=True)
        #data used to render the grid
        c.data = repos_data

        return render('journal/journal.html')
Esempio n. 11
0
    def edit_advanced(self, repo_name):
        c.repo_info = self._load_repo()
        c.default_user_id = kallithea.DEFAULT_USER_ID
        c.in_public_journal = UserFollowing.query() \
            .filter(UserFollowing.user_id == c.default_user_id) \
            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        _repos = Repository.query(sorted=True).all()
        read_access_repos = RepoList(_repos, perm_level='read')
        c.repos_list = [(None, _('-- Not a fork --'))]
        c.repos_list += [(x.repo_id, x.repo_name) for x in read_access_repos
                         if x.repo_id != c.repo_info.repo_id
                         and x.repo_type == c.repo_info.repo_type]

        defaults = {
            'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else ''
        }

        c.active = 'advanced'
        if request.POST:
            raise HTTPFound(location=url('repo_edit_advanced'))
        return htmlfill.render(render('admin/repos/repo_edit.html'),
                               defaults=defaults,
                               encoding="UTF-8",
                               force_defaults=False)
Esempio n. 12
0
    def test_index(self):
        self.log_user()
        response = self.app.get(url(controller='home', action='index'))
        #if global permission is set
        response.mustcontain('Add Repository')

        response.mustcontain('<span class="repotag">git')

        # html in javascript variable:
        response.mustcontain('var data = ({"totalRecords": %s' %
                             Repository.query().count())
        response.mustcontain(r'href=\"/%s\"' % HG_REPO)

        response.mustcontain(r'\x3ci class=\"icon-globe\"')

        response.mustcontain(
            r'\"fixes issue with having custom format for git-log\n\"')
        response.mustcontain(
            r'\"/%s/changeset/5f2c6ee195929b0be80749243c18121c9864a3b3\"' %
            GIT_REPO)

        response.mustcontain(
            r'\"disable security checks on hg clone for travis\"')
        response.mustcontain(
            r'\"/%s/changeset/96507bd11ecc815ebc6270fdf6db110928c09c1e\"' %
            HG_REPO)
Esempio n. 13
0
    def show(self, group_name):
        """GET /repo_groups/group_name: Show a specific item"""
        # url('repos_group', group_name=GROUP_NAME)
        c.active = 'settings'

        c.group = c.repo_group = RepoGroupModel()._get_repo_group(group_name)
        c.group_repos = c.group.repositories.all()

        #overwrite our cached list with current filter
        c.repo_cnt = 0

        groups = RepoGroup.query().order_by(RepoGroup.group_name)\
            .filter(RepoGroup.group_parent_id == c.group.group_id).all()
        c.groups = self.scm_model.get_repo_groups(groups)

        c.repos_list = Repository.query()\
                        .filter(Repository.group_id == c.group.group_id)\
                        .order_by(func.lower(Repository.repo_name))\
                        .all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
                                                   admin=False)
        #json used to render the grid
        c.data = json.dumps(repos_data)

        return render('admin/repo_groups/repo_group_show.html')
Esempio n. 14
0
    def get_by_repo_name(self, repo_name, cache=False):
        repo = Repository.query() \
            .filter(Repository.repo_name == repo_name)

        if cache:
            repo = repo.options(FromCache("sql_cache_short",
                                          "get_repo_%s" % repo_name))
        return repo.scalar()
Esempio n. 15
0
    def get_by_repo_name(self, repo_name, cache=False):
        repo = Repository.query() \
            .filter(Repository.repo_name == repo_name)

        if cache:
            repo = repo.options(
                FromCache("sql_cache_short", "get_repo_%s" % repo_name))
        return repo.scalar()
Esempio n. 16
0
 def test_my_account_my_repos(self):
     self.log_user()
     response = self.app.get(base.url('my_account_repos'))
     cnt = Repository.query().filter(
         Repository.owner == User.get_by_username(
             base.TEST_USER_ADMIN_LOGIN)).count()
     response.mustcontain('"raw_name": "%s"' % base.HG_REPO)
     response.mustcontain('"just_name": "%s"' % base.GIT_REPO)
Esempio n. 17
0
    def index(self, format='html'):
        repos_list = RepoList(Repository.query(sorted=True).all(),
                              perm_level='admin')
        # the repo list will be filtered to only show repos where the user has read permissions
        repos_data = RepoModel().get_repos_as_dict(repos_list, admin=True)
        # data used to render the grid
        c.data = repos_data

        return render('admin/repos/repos.html')
Esempio n. 18
0
    def is_following_repo(self, repo_name, user_id, cache=False):
        r = Repository.query() \
            .filter(Repository.repo_name == repo_name).scalar()

        f = UserFollowing.query() \
            .filter(UserFollowing.follows_repository == r) \
            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None
Esempio n. 19
0
    def take_action(self, args):
        if args.repo_update_list is None:
            repo_list = Repository.query().all()
        else:
            repo_names = [safe_unicode(n.strip())
                          for n in args.repo_update_list.split(',')]
            repo_list = list(Repository.query()
                .filter(Repository.repo_name.in_(repo_names)))
        for repo in repo_list:
            repo.update_changeset_cache()
        Session().commit()

        if args.invalidate_cache:
            for r in repo_list:
                r.set_invalidate()
            print 'Updated repo info and invalidated cache for %s repositories' % (len(repo_list))
        else:
            print 'Updated repo info for %s repositories' % (len(repo_list))
Esempio n. 20
0
    def index(self):
        c.group = None

        repo_groups_list = self.scm_model.get_repo_groups()
        repos_list = Repository.query(sorted=True).filter_by(group=None).all()

        c.data = RepoModel().get_repos_as_dict(
            repos_list, repo_groups_list=repo_groups_list, short_name=True)

        return render('/index.html')
    def test_push_new_file_git(self, webserver):
        DEST = _get_tmp_dir()
        clone_url = webserver.repo_url(GIT_REPO)
        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, DEST)

        # commit some stuff into this repo
        fork_name = '%s_fork%s' % (GIT_REPO, _RandomNameSequence().next())
        fixture.create_fork(GIT_REPO, fork_name)
        clone_url = webserver.repo_url(fork_name)
        stdout, stderr = _add_files_and_push(webserver, 'git', DEST, clone_url=clone_url)
        print [(x.repo_full_path,x.repo_path) for x in Repository.query()] # TODO: what is this for
Esempio n. 22
0
    def index(self, format='html'):
        _list = Repository.query(sorted=True).all()

        c.repos_list = RepoList(_list, perm_level='admin')
        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
                                                   admin=True,
                                                   super_user_actions=True)
        #data used to render the grid
        c.data = repos_data

        return render('admin/repos/repos.html')
Esempio n. 23
0
    def index(self, format='html'):
        _list = Repository.query(sorted=True).all()

        c.repos_list = RepoList(_list, perm_level='admin')
        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
                                                   admin=True,
                                                   super_user_actions=True)
        #data used to render the grid
        c.data = repos_data

        return render('admin/repos/repos.html')
Esempio n. 24
0
    def take_action(self, args):
        if args.repo_update_list is None:
            repo_list = Repository.query().all()
        else:
            repo_names = [
                safe_unicode(n.strip())
                for n in args.repo_update_list.split(',')
            ]
            repo_list = list(Repository.query().filter(
                Repository.repo_name.in_(repo_names)))
        for repo in repo_list:
            repo.update_changeset_cache()
        Session().commit()

        if args.invalidate_cache:
            for r in repo_list:
                r.set_invalidate()
            print 'Updated repo info and invalidated cache for %s repositories' % (
                len(repo_list))
        else:
            print 'Updated repo info for %s repositories' % (len(repo_list))
Esempio n. 25
0
    def index(self):
        c.groups = self.scm_model.get_repo_groups()
        c.group = None

        repos_list = Repository.query(sorted=True).filter_by(group=None).all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,
                                                   admin=False, short_name=True)
        #data used to render the grid
        c.data = repos_data

        return render('/index.html')
Esempio n. 26
0
    def get_all_user_repos(self, user):
        """
        Gets all repositories that user have at least read access

        :param user:
        """
        from kallithea.lib.auth import AuthUser
        user = User.guess_instance(user)
        repos = AuthUser(dbuser=user).permissions['repositories']
        access_check = lambda r: r[
            1] in ['repository.read', 'repository.write', 'repository.admin']
        repos = [x[0] for x in filter(access_check, repos.items())]
        return Repository.query().filter(Repository.repo_name.in_(repos))
Esempio n. 27
0
    def get_all_user_repos(self, user):
        """
        Gets all repositories that user have at least read access

        :param user:
        """
        from kallithea.lib.auth import AuthUser
        user = self._get_user(user)
        repos = AuthUser(user_id=user.user_id).permissions['repositories']
        access_check = lambda r: r[1] in ['repository.read',
                                          'repository.write',
                                          'repository.admin']
        repos = [x[0] for x in filter(access_check, repos.items())]
        return Repository.query().filter(Repository.repo_name.in_(repos))
Esempio n. 28
0
    def get_all_user_repos(self, user):
        """
        Gets all repositories that user have at least read access

        :param user:
        """
        from kallithea.lib.auth import AuthUser
        auth_user = AuthUser(dbuser=User.guess_instance(user))
        repos = [
            repo_name for repo_name, perm in
            auth_user.permissions['repositories'].items() if perm in
            ['repository.read', 'repository.write', 'repository.admin']
        ]
        return Repository.query().filter(Repository.repo_name.in_(repos))
Esempio n. 29
0
    def show(self, group_name):
        c.active = 'settings'

        c.group = c.repo_group = RepoGroup.guess_instance(group_name)

        groups = RepoGroup.query(sorted=True).filter_by(parent_group=c.group).all()
        repo_groups_list = self.scm_model.get_repo_groups(groups)

        repos_list = Repository.query(sorted=True).filter_by(group=c.group).all()
        c.data = RepoModel().get_repos_as_dict(repos_list,
                                               repo_groups_list=repo_groups_list,
                                               short_name=True)

        return render('admin/repo_groups/repo_group_show.html')
Esempio n. 30
0
    def show(self, group_name):
        c.active = 'settings'

        c.group = c.repo_group = RepoGroup.guess_instance(group_name)

        groups = RepoGroup.query(sorted=True).filter_by(parent_group=c.group).all()
        c.groups = self.scm_model.get_repo_groups(groups)

        repos_list = Repository.query(sorted=True).filter_by(group=c.group).all()
        repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,
                                                   admin=False, short_name=True)
        # data used to render the grid
        c.data = repos_data

        return render('admin/repo_groups/repo_group_show.html')
Esempio n. 31
0
    def index(self):
        c.groups = self.scm_model.get_repo_groups()
        c.group = None

        c.repos_list = Repository.query()\
                        .filter(Repository.group_id == None)\
                        .order_by(func.lower(Repository.repo_name))\
                        .all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
                                                   admin=False)
        #json used to render the grid
        c.data = json.dumps(repos_data)

        return render('/index.html')
Esempio n. 32
0
    def index(self, format='html'):
        """GET /repos: All items in the collection"""
        # url('repos')
        _list = Repository.query()\
                        .order_by(func.lower(Repository.repo_name))\
                        .all()

        c.repos_list = RepoList(_list, perm_set=['repository.admin'])
        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
                                                   admin=True,
                                                   super_user_actions=True)
        #json used to render the grid
        c.data = json.dumps(repos_data)

        return render('admin/repos/repos.html')
Esempio n. 33
0
    def index(self, format='html'):
        """GET /repos: All items in the collection"""
        # url('repos')
        _list = Repository.query()\
                        .order_by(func.lower(Repository.repo_name))\
                        .all()

        c.repos_list = RepoList(_list, perm_set=['repository.admin'])
        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
                                                   admin=True,
                                                   super_user_actions=True)
        #json used to render the grid
        c.data = json.dumps(repos_data)

        return render('admin/repos/repos.html')
Esempio n. 34
0
        def validate_python(self, value, state):
            # TODO WRITE VALIDATIONS
            group_name = value.get('group_name')
            group_parent_id = value.get('group_parent_id')

            # slugify repo group just in case :)
            slug = repo_name_slug(group_name)

            # check for parent of self
            parent_of_self = lambda: (old_data['group_id'] == int(
                group_parent_id) if group_parent_id else False)
            if edit and parent_of_self():
                msg = M(self, 'group_parent_id', state)
                raise formencode.Invalid(msg,
                                         value,
                                         state,
                                         error_dict=dict(group_parent_id=msg))

            old_gname = None
            if edit:
                old_gname = RepoGroup.get(old_data.get('group_id')).group_name

            if old_gname != group_name or not edit:

                # check group
                gr = RepoGroup.query()\
                      .filter(RepoGroup.group_name == slug)\
                      .filter(RepoGroup.group_parent_id == group_parent_id)\
                      .scalar()

                if gr:
                    msg = M(self, 'group_exists', state, group_name=slug)
                    raise formencode.Invalid(msg,
                                             value,
                                             state,
                                             error_dict=dict(group_name=msg))

                # check for same repo
                repo = Repository.query()\
                      .filter(Repository.repo_name == slug)\
                      .scalar()

                if repo:
                    msg = M(self, 'repo_exists', state, group_name=slug)
                    raise formencode.Invalid(msg,
                                             value,
                                             state,
                                             error_dict=dict(group_name=msg))
Esempio n. 35
0
        def validate_python(self, value, state):
            # TODO WRITE VALIDATIONS
            group_name = value.get('group_name')
            group_parent_id = value.get('group_parent_id')

            # slugify repo group just in case :)
            slug = repo_name_slug(group_name)

            # check for parent of self
            parent_of_self = lambda: (
                old_data['group_id'] == group_parent_id
                if group_parent_id else False
            )
            if edit and parent_of_self():
                msg = M(self, 'group_parent_id', state)
                raise formencode.Invalid(msg, value, state,
                    error_dict=dict(group_parent_id=msg)
                )

            old_gname = None
            if edit:
                old_gname = RepoGroup.get(old_data.get('group_id')).group_name

            if old_gname != group_name or not edit:

                # check group
                gr = RepoGroup.query() \
                      .filter(RepoGroup.group_name == slug) \
                      .filter(RepoGroup.group_parent_id == group_parent_id) \
                      .scalar()

                if gr is not None:
                    msg = M(self, 'group_exists', state, group_name=slug)
                    raise formencode.Invalid(msg, value, state,
                            error_dict=dict(group_name=msg)
                    )

                # check for same repo
                repo = Repository.query() \
                      .filter(Repository.repo_name == slug) \
                      .scalar()

                if repo is not None:
                    msg = M(self, 'repo_exists', state, group_name=slug)
                    raise formencode.Invalid(msg, value, state,
                            error_dict=dict(group_name=msg)
                    )
    def test_push_new_file_git(self, webserver):
        DEST = _get_tmp_dir()
        clone_url = webserver.repo_url(GIT_REPO)
        stdout, stderr = Command(TESTS_TMP_PATH).execute(
            'git clone', clone_url, DEST)

        # commit some stuff into this repo
        fork_name = '%s_fork%s' % (GIT_REPO, _RandomNameSequence().next())
        fixture.create_fork(GIT_REPO, fork_name)
        clone_url = webserver.repo_url(fork_name)
        stdout, stderr = _add_files_and_push(webserver,
                                             'git',
                                             DEST,
                                             clone_url=clone_url)
        print[(x.repo_full_path, x.repo_path)
              for x in Repository.query()]  # TODO: what is this for
        _check_proper_git_push(stdout, stderr)
Esempio n. 37
0
    def test_zzz_fork_permission_page(self):
        usr = self.log_user(self.username, self.password)['user_id']
        repo_name = self.REPO

        forks = Repository.query()\
            .filter(Repository.repo_type == self.REPO_TYPE)\
            .filter(Repository.fork_id != None).all()
        self.assertEqual(1, len(forks))

        # set none
        RepoModel().grant_user_permission(repo=forks[0],
                                          user=usr, perm='repository.none')
        Session().commit()
        # fork shouldn't be there
        response = self.app.get(url(controller='forks', action='forks',
                                    repo_name=repo_name))
        response.mustcontain('There are no forks yet')
Esempio n. 38
0
    def test_zzz_fork_permission_page(self):
        usr = self.log_user(self.username, self.password)['user_id']
        repo_name = self.REPO

        forks = Repository.query() \
            .filter(Repository.repo_type == self.REPO_TYPE) \
            .filter(Repository.fork_id != None).all()
        assert 1 == len(forks)

        # set none
        RepoModel().grant_user_permission(repo=forks[0],
                                          user=usr, perm='repository.none')
        Session().commit()
        # fork shouldn't be there
        response = self.app.get(url(controller='forks', action='forks',
                                    repo_name=repo_name))
        response.mustcontain('There are no forks yet')
Esempio n. 39
0
    def settings_mapping(self):
        c.active = 'mapping'
        if request.POST:
            rm_obsolete = request.POST.get('destroy', False)
            install_git_hooks = request.POST.get('hooks', False)
            overwrite_git_hooks = request.POST.get('hooks_overwrite', False)
            invalidate_cache = request.POST.get('invalidate', False)
            log.debug('rescanning repo location with destroy obsolete=%s, '
                      'install git hooks=%s and '
                      'overwrite git hooks=%s' % (rm_obsolete, install_git_hooks, overwrite_git_hooks))

            filesystem_repos = ScmModel().repo_scan()
            added, removed = repo2db_mapper(filesystem_repos, rm_obsolete,
                                            install_git_hooks=install_git_hooks,
                                            user=request.authuser.username,
                                            overwrite_git_hooks=overwrite_git_hooks)
            added_msg = h.HTML(', ').join(
                h.link_to(safe_str(repo_name), h.url('summary_home', repo_name=repo_name)) for repo_name in added
            ) or '-'
            removed_msg = h.HTML(', ').join(
                safe_str(repo_name) for repo_name in removed
            ) or '-'
            h.flash(h.HTML(_('Repositories successfully rescanned. Added: %s. Removed: %s.')) %
                    (added_msg, removed_msg), category='success')

            if invalidate_cache:
                log.debug('invalidating all repositories cache')
                i = 0
                for repo in Repository.query():
                    try:
                        ScmModel().mark_for_invalidation(repo.repo_name)
                        i += 1
                    except VCSError as e:
                        log.warning('VCS error invalidating %s: %s', repo.repo_name, e)
                h.flash(_('Invalidated %s repositories') % i, category='success')

            raise HTTPFound(location=url('admin_settings_mapping'))

        defaults = Setting.get_app_settings()
        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(
            render('admin/settings/settings.html'),
            defaults=defaults,
            encoding="UTF-8",
            force_defaults=False)
Esempio n. 40
0
        def _validate_python(self, value, state):
            # TODO WRITE VALIDATIONS
            group_name = value.get('group_name')
            parent_group_id = value.get('parent_group_id')

            # slugify repo group just in case :)
            slug = repo_name_slug(group_name)

            # check for parent of self
            if edit and parent_group_id and old_data[
                    'group_id'] == parent_group_id:
                msg = self.message('parent_group_id', state)
                raise formencode.Invalid(msg,
                                         value,
                                         state,
                                         error_dict=dict(parent_group_id=msg))

            old_gname = None
            if edit:
                old_gname = RepoGroup.get(old_data.get('group_id')).group_name

            if old_gname != group_name or not edit:

                # check group
                gr = RepoGroup.query() \
                      .filter(func.lower(RepoGroup.group_name) == func.lower(slug)) \
                      .filter(RepoGroup.parent_group_id == parent_group_id) \
                      .scalar()
                if gr is not None:
                    msg = self.message('group_exists', state, group_name=slug)
                    raise formencode.Invalid(msg,
                                             value,
                                             state,
                                             error_dict=dict(group_name=msg))

                # check for same repo
                repo = Repository.query() \
                      .filter(func.lower(Repository.repo_name) == func.lower(slug)) \
                      .scalar()
                if repo is not None:
                    msg = self.message('repo_exists', state, group_name=slug)
                    raise formencode.Invalid(msg,
                                             value,
                                             state,
                                             error_dict=dict(group_name=msg))
Esempio n. 41
0
    def test_index(self):
        self.log_user()
        response = self.app.get(url(controller='home', action='index'))
        #if global permission is set
        response.mustcontain('Add Repository')

        response.mustcontain('<span class="repotag">git')

        # html in javascript variable:
        response.mustcontain('var data = ({"totalRecords": %s' % Repository.query().count())
        response.mustcontain(r'href=\"/%s\"' % HG_REPO)

        response.mustcontain(r'\x3ci class=\"icon-globe\"')

        response.mustcontain(r'\"fixes issue with having custom format for git-log\n\"')
        response.mustcontain(r'\"/%s/changeset/5f2c6ee195929b0be80749243c18121c9864a3b3\"' % GIT_REPO)

        response.mustcontain(r'\"disable security checks on hg clone for travis\"')
        response.mustcontain(r'\"/%s/changeset/96507bd11ecc815ebc6270fdf6db110928c09c1e\"' % HG_REPO)
Esempio n. 42
0
    def test_zz_fork_permission_page(self):
        usr = self.log_user(self.username, self.password)['user_id']
        repo_name = self.REPO

        forks = Repository.query() \
            .filter(Repository.repo_type == self.REPO_TYPE) \
            .filter(Repository.fork_id != None).all()
        assert 1 == len(forks)

        # set read permissions for this
        RepoModel().grant_user_permission(repo=forks[0],
                                          user=usr,
                                          perm='repository.read')
        Session().commit()

        response = self.app.get(
            url(controller='forks', action='forks', repo_name=repo_name))

        response.mustcontain('<div>fork of vcs test</div>')
Esempio n. 43
0
    def test_zz_fork_permission_page(self):
        usr = self.log_user(self.username, self.password)['user_id']
        repo_name = self.REPO

        forks = Repository.query() \
            .filter(Repository.repo_type == self.REPO_TYPE) \
            .filter(Repository.fork_id != None).all()
        assert 1 == len(forks)

        # set read permissions for this
        RepoModel().grant_user_permission(repo=forks[0],
                                          user=usr,
                                          perm='repository.read')
        Session().commit()

        response = self.app.get(url(controller='forks', action='forks',
                                    repo_name=repo_name))

        response.mustcontain('<div>fork of vcs test</div>')
Esempio n. 44
0
    def settings_mapping(self):
        c.active = 'mapping'
        if request.POST:
            rm_obsolete = request.POST.get('destroy', False)
            install_git_hooks = request.POST.get('hooks', False)
            overwrite_git_hooks = request.POST.get('hooks_overwrite', False);
            invalidate_cache = request.POST.get('invalidate', False)
            log.debug('rescanning repo location with destroy obsolete=%s, '
                      'install git hooks=%s and '
                      'overwrite git hooks=%s' % (rm_obsolete, install_git_hooks, overwrite_git_hooks))

            filesystem_repos = ScmModel().repo_scan()
            added, removed = repo2db_mapper(filesystem_repos, rm_obsolete,
                                            install_git_hooks=install_git_hooks,
                                            user=request.authuser.username,
                                            overwrite_git_hooks=overwrite_git_hooks)
            h.flash(h.literal(_('Repositories successfully rescanned. Added: %s. Removed: %s.') %
                (', '.join(h.link_to(safe_unicode(repo_name), h.url('summary_home', repo_name=repo_name))
                 for repo_name in added) or '-',
                 ', '.join(h.escape(safe_unicode(repo_name)) for repo_name in removed) or '-')),
                category='success')

            if invalidate_cache:
                log.debug('invalidating all repositories cache')
                i = 0
                for repo in Repository.query():
                    try:
                        ScmModel().mark_for_invalidation(repo.repo_name)
                        i += 1
                    except VCSError as e:
                        log.warning('VCS error invalidating %s: %s', repo.repo_name, e)
                h.flash(_('Invalidated %s repositories') % i, category='success')

            raise HTTPFound(location=url('admin_settings_mapping'))

        defaults = Setting.get_app_settings()
        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(
            render('admin/settings/settings.html'),
            defaults=defaults,
            encoding="UTF-8",
            force_defaults=False)
Esempio n. 45
0
    def command(self):
        #get SqlAlchemy session
        self._init_session()

        repo_update_list = map(string.strip,
                               self.options.repo_update_list.split(',')) \
                               if self.options.repo_update_list else None

        if repo_update_list:
            repo_list = list(Repository.query()\
                .filter(Repository.repo_name.in_(repo_update_list)))
        else:
            repo_list = Repository.getAll()
        RepoModel.update_repoinfo(repositories=repo_list)
        Session().commit()

        if self.options.invalidate_cache:
            for r in repo_list:
                r.set_invalidate()
        print 'Updated cache for %s repositories' % (len(repo_list))
Esempio n. 46
0
    def command(self):
        #get SqlAlchemy session
        self._init_session()

        repo_update_list = map(string.strip,
                               self.options.repo_update_list.split(',')) \
                               if self.options.repo_update_list else None

        if repo_update_list:
            repo_list = list(Repository.query()\
                .filter(Repository.repo_name.in_(repo_update_list)))
        else:
            repo_list = Repository.getAll()
        RepoModel.update_repoinfo(repositories=repo_list)
        Session().commit()

        if self.options.invalidate_cache:
            for r in repo_list:
                r.set_invalidate()
        print 'Updated cache for %s repositories' % (len(repo_list))
Esempio n. 47
0
    def repo_switcher_data(self):
        if request.is_xhr:
            all_repos = Repository.query(sorted=True).all()
            repo_iter = self.scm_model.get_repos(all_repos)
            all_groups = RepoGroup.query(sorted=True).all()
            repo_groups_iter = self.scm_model.get_repo_groups(all_groups)

            res = [{
                'text':
                _('Groups'),
                'children': [{
                    'id': obj.group_name,
                    'text': obj.group_name,
                    'type': 'group',
                    'obj': {}
                } for obj in repo_groups_iter],
            }, {
                'text':
                _('Repositories'),
                'children': [{
                    'id': obj.repo_name,
                    'text': obj.repo_name,
                    'type': 'repo',
                    'obj': obj.get_dict()
                } for obj in repo_iter],
            }]

            for res_dict in res:
                for child in (res_dict['children']):
                    child['obj'].pop(
                        '_changeset_cache', None
                    )  # bytes cannot be encoded in json ... but this value isn't relevant on client side at all ...

            data = {
                'more': False,
                'results': res,
            }
            return data

        else:
            raise HTTPBadRequest()
Esempio n. 48
0
 def update_repo_info(self):
     for repo in Repository.query():
         repo.update_changeset_cache()
Esempio n. 49
0
 def test_my_account_my_repos(self):
     self.log_user()
     response = self.app.get(url('my_account_repos'))
     cnt = Repository.query().filter(Repository.owner ==
                        User.get_by_username(TEST_USER_ADMIN_LOGIN)).count()
     response.mustcontain('"totalRecords": %s' % cnt)