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))
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
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
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)
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
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')
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)
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)
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)
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')
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)
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)
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')
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()
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()
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)
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')
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
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))
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
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')
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')
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))
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')
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))
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))
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))
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')
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')
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')
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')
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')
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))
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)
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')
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')
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)
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))
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)
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>')
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>')
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)
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))
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))
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()
def update_repo_info(self):
for repo in Repository.query():
repo.update_changeset_cache()
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)
