def commit_change(self,
repo,
filename,
content,
message,
vcs_type,
parent=None,
newfile=False):
repo = Repository.get_by_repo_name(repo)
_cs = parent
if not parent:
_cs = EmptyChangeset(alias=vcs_type)
if newfile:
nodes = {filename: {'content': content}}
cs = ScmModel().create_nodes(
user=TEST_USER_ADMIN_LOGIN,
repo=repo,
message=message,
nodes=nodes,
parent_cs=_cs,
author=TEST_USER_ADMIN_LOGIN,
)
else:
cs = ScmModel().commit_change(repo=repo.scm_instance,
repo_name=repo.repo_name,
cs=parent,
user=TEST_USER_ADMIN_LOGIN,
author=TEST_USER_ADMIN_LOGIN,
message=message,
content=content,
f_path=filename)
return cs
def update(self, repo_name):
"""
PUT /repos/repo_name: Update an existing item"""
# Forms posted to this method should contain a hidden field:
# <input type="hidden" name="_method" value="PUT" />
# Or using helpers:
# h.form(url('repo', repo_name=ID),
# method='put')
# url('repo', repo_name=ID)
c.repo_info = self._load_repo(repo_name)
c.active = 'settings'
c.repo_fields = RepositoryField.query()\
.filter(RepositoryField.repository == c.repo_info).all()
self.__load_defaults(c.repo_info)
repo_model = RepoModel()
changed_name = repo_name
#override the choices with extracted revisions !
choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo_name)
c.landing_revs_choices = choices
repo = Repository.get_by_repo_name(repo_name)
old_data = {
'repo_name': repo_name,
'repo_group': repo.group.get_dict() if repo.group else {},
'repo_type': repo.repo_type,
}
_form = RepoForm(edit=True,
old_data=old_data,
repo_groups=c.repo_groups_choices,
landing_revs=c.landing_revs_choices)()
try:
form_result = _form.to_python(dict(request.POST))
repo = repo_model.update(repo_name, **form_result)
ScmModel().mark_for_invalidation(repo_name)
h.flash(_('Repository %s updated successfully') % repo_name,
category='success')
changed_name = repo.repo_name
action_logger(self.authuser, 'admin_updated_repo', changed_name,
self.ip_addr, self.sa)
Session().commit()
except formencode.Invalid, errors:
defaults = self.__load_data(repo_name)
defaults.update(errors.value)
return htmlfill.render(render('admin/repos/repo_edit.html'),
defaults=defaults,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
def _invalidate_cache(self, repo_name):
"""
Sets cache for this repository for invalidation on next access
:param repo_name: full repo name, also a cache key
"""
ScmModel().mark_for_invalidation(repo_name)
def edit_advanced_fork(self, repo_name):
"""
Mark given repository as a fork of another
:param repo_name:
"""
try:
fork_id = request.POST.get('id_fork_of')
repo = ScmModel().mark_as_fork(repo_name, fork_id,
request.authuser.username)
fork = repo.fork.repo_name if repo.fork else _('Nothing')
Session().commit()
h.flash(_('Marked repository %s as fork of %s') %
(repo_name, fork),
category='success')
except RepositoryError as e:
log.error(traceback.format_exc())
h.flash(e, category='error')
except Exception as e:
log.error(traceback.format_exc())
h.flash(_('An error occurred during this operation'),
category='error')
raise HTTPFound(
location=url('edit_repo_advanced', repo_name=repo_name))
def test_index_trending_git(self):
self.log_user()
# codes stats
self._enable_stats(base.GIT_REPO)
ScmModel().mark_for_invalidation(base.GIT_REPO)
# generate statistics first
response = self.app.get(
base.url(controller='summary',
action='statistics',
repo_name=base.GIT_REPO))
response = self.app.get(
base.url(controller='summary',
action='index',
repo_name=base.GIT_REPO))
response.mustcontain(
'[["py", {"count": 68, "desc": ["Python"]}], '
'["rst", {"count": 16, "desc": ["Rst"]}], '
'["css", {"count": 2, "desc": ["Css"]}], '
'["sh", {"count": 2, "desc": ["Bash"]}], '
'["bat", {"count": 1, "desc": ["Batch"]}], '
'["cfg", {"count": 1, "desc": ["Ini"]}], '
'["html", {"count": 1, "desc": ["EvoqueHtml", "Html"]}], '
'["ini", {"count": 1, "desc": ["Ini"]}], '
'["js", {"count": 1, "desc": ["Javascript"]}], '
'["makefile", {"count": 1, "desc": ["Makefile", "Makefile"]}]]', )
def test_index_statistics_git(self):
self.log_user()
#codes stats
self._enable_stats(GIT_REPO)
ScmModel().mark_for_invalidation(GIT_REPO)
response = self.app.get(
url(controller='summary', action='statistics', repo_name=GIT_REPO))
def nodelist(self, repo_name, revision, f_path):
if request.environ.get('HTTP_X_PARTIAL_XHR'):
cs = self.__get_cs(revision)
_d, _f = ScmModel().get_nodes(repo_name,
cs.raw_id,
f_path,
flat=False)
return {'nodes': _d + _f}
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 _before(self, *args, **kwargs):
"""
_before is called before controller methods and after __call__
"""
c.kallithea_version = __version__
rc_config = Setting.get_app_settings()
# Visual options
c.visual = AttributeDict({})
## DB stored
c.visual.show_public_icon = str2bool(rc_config.get('show_public_icon'))
c.visual.show_private_icon = str2bool(rc_config.get('show_private_icon'))
c.visual.stylify_metatags = str2bool(rc_config.get('stylify_metatags'))
c.visual.page_size = safe_int(rc_config.get('dashboard_items', 100))
c.visual.admin_grid_items = safe_int(rc_config.get('admin_grid_items', 100))
c.visual.repository_fields = str2bool(rc_config.get('repository_fields'))
c.visual.show_version = str2bool(rc_config.get('show_version'))
c.visual.use_gravatar = str2bool(rc_config.get('use_gravatar'))
c.visual.gravatar_url = rc_config.get('gravatar_url')
c.ga_code = rc_config.get('ga_code')
# TODO: replace undocumented backwards compatibility hack with db upgrade and rename ga_code
if c.ga_code and '<' not in c.ga_code:
c.ga_code = '''<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', '%s']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();
</script>''' % c.ga_code
c.site_name = rc_config.get('title')
c.clone_uri_tmpl = rc_config.get('clone_uri_tmpl')
## INI stored
c.visual.allow_repo_location_change = str2bool(config.get('allow_repo_location_change', True))
c.visual.allow_custom_hooks_settings = str2bool(config.get('allow_custom_hooks_settings', True))
c.instance_id = config.get('instance_id')
c.issues_url = config.get('bugtracker', url('issues_url'))
# END CONFIG VARS
c.repo_name = get_repo_slug(request) # can be empty
c.backends = BACKENDS.keys()
c.unread_notifications = NotificationModel() \
.get_unread_cnt_for_user(request.authuser.user_id)
self.cut_off_limit = safe_int(config.get('cut_off_limit'))
c.my_pr_count = PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()
self.scm_model = ScmModel()
def command(self):
#get SqlAlchemy session
self._init_session()
rm_obsolete = self.options.delete_obsolete
log.info('Now scanning root location for new repos...')
added, removed = repo2db_mapper(ScmModel().repo_scan(),
remove_obsolete=rm_obsolete)
added = ', '.join(added) or '-'
removed = ', '.join(removed) or '-'
log.info('Scan completed added: %s removed: %s' % (added, removed))
def update(self, gist, description, owner, gist_mapping, gist_type,
lifetime):
gist = self._get_gist(gist)
gist_repo = gist.scm_instance
lifetime = safe_int(lifetime, -1)
if lifetime == 0: # preserve old value
gist_expires = gist.gist_expires
else:
gist_expires = time.time() + (lifetime * 60) if lifetime != -1 else -1
#calculate operation type based on given data
gist_mapping_op = {}
for k, v in gist_mapping.items():
# add, mod, del
if not v['org_filename'] and v['filename']:
op = 'add'
elif v['org_filename'] and not v['filename']:
op = 'del'
else:
op = 'mod'
v['op'] = op
gist_mapping_op[k] = v
gist.gist_description = description
gist.gist_expires = gist_expires
gist.owner = owner
gist.gist_type = gist_type
self.sa.add(gist)
self.sa.flush()
message = 'updated file'
message += 's: ' if len(gist_mapping) > 1 else ': '
message += ', '.join([x for x in gist_mapping])
#fake Kallithea Repository object
fake_repo = AttributeDict(dict(
repo_name=gist_repo.path,
scm_instance_no_cache=lambda: gist_repo,
))
self._store_metadata(gist_repo, gist.gist_id, gist.gist_access_id,
owner.user_id, gist.gist_type, gist.gist_expires)
ScmModel().update_nodes(
user=owner.user_id,
repo=fake_repo,
message=message,
nodes=gist_mapping_op,
trigger_push_hook=False
)
return gist
def __load_defaults(self):
if HasPermissionAny('hg.create.write_on_repogroup.true')():
repo_group_perm_level = 'write'
else:
repo_group_perm_level = 'admin'
c.repo_groups = AvailableRepoGroupChoices(['hg.create.repository'],
repo_group_perm_level)
c.landing_revs_choices, c.landing_revs = ScmModel(
).get_repo_landing_revs()
c.can_update = Ui.get_by_key('hooks', Ui.HOOK_UPDATE).ui_active
def __init__(self,
indexname=IDX_NAME,
index_location=None,
repo_location=None,
sa=None,
repo_list=None,
repo_update_list=None):
self.indexname = indexname
self.index_location = index_location
if not index_location:
raise Exception('You have to provide index location')
self.repo_location = repo_location
if not repo_location:
raise Exception('You have to provide repositories location')
self.repo_paths = ScmModel(sa).repo_scan(self.repo_location)
#filter repo list
if repo_list:
#Fix non-ascii repo names to unicode
repo_list = map(safe_unicode, repo_list)
self.filtered_repo_paths = {}
for repo_name, repo in self.repo_paths.items():
if repo_name in repo_list:
self.filtered_repo_paths[repo_name] = repo
self.repo_paths = self.filtered_repo_paths
#filter update repo list
self.filtered_repo_update_paths = {}
if repo_update_list:
self.filtered_repo_update_paths = {}
for repo_name, repo in self.repo_paths.items():
if repo_name in repo_update_list:
self.filtered_repo_update_paths[repo_name] = repo
self.repo_paths = self.filtered_repo_update_paths
self.initial = True
if not os.path.isdir(self.index_location):
os.makedirs(self.index_location)
log.info('Cannot run incremental index since it does not '
'yet exist running full build')
elif not exists_in(self.index_location, IDX_NAME):
log.info('Running full index build as the file content '
'index does not exist')
elif not exists_in(self.index_location, CHGSET_IDX_NAME):
log.info('Running full index build as the changeset '
'index does not exist')
else:
self.initial = False
def test_hooks_created_if_missing(self):
"""
Tests if hooks are installed in repository if they are missing.
"""
for hook, hook_path in self.kallithea_hooks.items():
if os.path.exists(hook_path):
os.remove(hook_path)
ScmModel().install_git_hooks(repo=self.repo)
for hook, hook_path in self.kallithea_hooks.items():
assert os.path.exists(hook_path)
def take_action(self, args):
rm_obsolete = args.delete_obsolete
print 'Now scanning root location for new repos ...'
added, removed = repo2db_mapper(ScmModel().repo_scan(),
remove_obsolete=rm_obsolete)
added = ', '.join(added) or '-'
removed = ', '.join(removed) or '-'
print 'Scan completed.'
print 'Added: %s' % added
if rm_obsolete:
print 'Removed: %s' % removed
else:
print 'Missing: %s' % removed
def __load_defaults(self, repo=None):
top_perms = ['hg.create.repository']
if HasPermissionAny('hg.create.write_on_repogroup.true')():
repo_group_perm_level = 'write'
else:
repo_group_perm_level = 'admin'
extras = [] if repo is None else [repo.group]
c.repo_groups = AvailableRepoGroupChoices(top_perms,
repo_group_perm_level,
extras)
c.landing_revs_choices, c.landing_revs = ScmModel(
).get_repo_landing_revs(repo)
def test_custom_hooks_forced_update(self):
"""
Tests if hooks are forcefully updated even though they are custom hooks.
"""
for hook, hook_path in self.kallithea_hooks.items():
with open(hook_path, "w") as f:
f.write("#!/bin/bash\n#CUSTOM_HOOK")
ScmModel().install_git_hooks(repo=self.repo, force_create=True)
for hook, hook_path in self.kallithea_hooks.items():
with open(hook_path) as f:
assert "KALLITHEA_HOOK_VER" in f.read()
def test_kallithea_hooks_updated(self):
"""
Tests if hooks are updated if they are Kallithea hooks already.
"""
for hook, hook_path in self.kallithea_hooks.items():
with open(hook_path, "w") as f:
f.write("KALLITHEA_HOOK_VER=0.0.0\nJUST_BOGUS")
ScmModel().install_git_hooks(repo=self.repo)
for hook, hook_path in self.kallithea_hooks.items():
with open(hook_path) as f:
assert "JUST_BOGUS" not in f.read()
def test_custom_hooks_untouched(self):
"""
Tests if hooks are left untouched if they are not Kallithea hooks.
"""
for hook, hook_path in self.kallithea_hooks.items():
with open(hook_path, "w") as f:
f.write("#!/bin/bash\n#CUSTOM_HOOK")
ScmModel().install_git_hooks(repo=self.repo)
for hook, hook_path in self.kallithea_hooks.items():
with open(hook_path) as f:
assert "CUSTOM_HOOK" in f.read()
def __load_data(self, repo_name=None):
"""
Load defaults settings for edit, and update
:param repo_name:
"""
c.repo_info = self._load_repo(repo_name)
self.__load_defaults(c.repo_info)
##override defaults for exact repo info here git/hg etc
choices, c.landing_revs = ScmModel().get_repo_landing_revs(c.repo_info)
c.landing_revs_choices = choices
defaults = RepoModel()._get_defaults(repo_name)
return defaults
def edit_remote(self, repo_name):
c.repo_info = self._load_repo()
c.active = 'remote'
if request.POST:
try:
ScmModel().pull_changes(repo_name, request.authuser.username)
h.flash(_('Pulled from remote location'), category='success')
except Exception as e:
log.error(traceback.format_exc())
h.flash(
_('An error occurred during pull from remote location'),
category='error')
raise HTTPFound(
location=url('edit_repo_remote', repo_name=c.repo_name))
return render('admin/repos/repo_edit.html')
def edit_remote(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.active = 'remote'
if request.POST:
try:
ScmModel().pull_changes(repo_name, self.authuser.username)
h.flash(_('Pulled from remote location'), category='success')
except Exception, e:
log.error(traceback.format_exc())
h.flash(
_('An error occurred during pull from remote location'),
category='error')
return redirect(url('edit_repo_remote', repo_name=c.repo_name))
def edit_caches(self, repo_name):
c.repo_info = self._load_repo()
c.active = 'caches'
if request.POST:
try:
ScmModel().mark_for_invalidation(repo_name)
Session().commit()
h.flash(_('Cache invalidation successful'), category='success')
except Exception as e:
log.error(traceback.format_exc())
h.flash(_('An error occurred during cache invalidation'),
category='error')
raise HTTPFound(
location=url('edit_repo_caches', repo_name=c.repo_name))
return render('admin/repos/repo_edit.html')
def edit_caches(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.active = 'caches'
if request.POST:
try:
ScmModel().mark_for_invalidation(repo_name, delete=True)
Session().commit()
h.flash(_('Cache invalidation successful'), category='success')
except Exception, e:
log.error(traceback.format_exc())
h.flash(_('An error occurred during cache invalidation'),
category='error')
return redirect(url('edit_repo_caches', repo_name=c.repo_name))
def update(self, repo_name):
c.repo_info = self._load_repo()
self.__load_defaults(c.repo_info)
c.active = 'settings'
c.repo_fields = RepositoryField.query() \
.filter(RepositoryField.repository == c.repo_info).all()
repo_model = RepoModel()
changed_name = repo_name
repo = Repository.get_by_repo_name(repo_name)
old_data = {
'repo_name': repo_name,
'repo_group': repo.group.get_dict() if repo.group else {},
'repo_type': repo.repo_type,
}
_form = RepoForm(edit=True,
old_data=old_data,
repo_groups=c.repo_groups,
landing_revs=c.landing_revs_choices)()
try:
form_result = _form.to_python(dict(request.POST))
repo = repo_model.update(repo_name, **form_result)
ScmModel().mark_for_invalidation(repo_name)
h.flash(_('Repository %s updated successfully') % repo_name,
category='success')
changed_name = repo.repo_name
action_logger(request.authuser, 'admin_updated_repo', changed_name,
request.ip_addr)
Session().commit()
except formencode.Invalid as errors:
log.info(errors)
defaults = self.__load_data()
defaults.update(errors.value)
return htmlfill.render(render('admin/repos/repo_edit.html'),
defaults=defaults,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of repository %s') %
repo_name,
category='error')
raise HTTPFound(location=url('edit_repo', repo_name=changed_name))
def delete(self, repo_name):
"""
DELETE /repos/repo_name: Delete an existing item"""
# Forms posted to this method should contain a hidden field:
# <input type="hidden" name="_method" value="DELETE" />
# Or using helpers:
# h.form(url('repo', repo_name=ID),
# method='delete')
# url('repo', repo_name=ID)
repo_model = RepoModel()
repo = repo_model.get_by_repo_name(repo_name)
if not repo:
h.not_mapped_error(repo_name)
return redirect(url('repos'))
try:
_forks = repo.forks.count()
handle_forks = None
if _forks and request.POST.get('forks'):
do = request.POST['forks']
if do == 'detach_forks':
handle_forks = 'detach'
h.flash(_('Detached %s forks') % _forks,
category='success')
elif do == 'delete_forks':
handle_forks = 'delete'
h.flash(_('Deleted %s forks') % _forks, category='success')
repo_model.delete(repo, forks=handle_forks)
action_logger(self.authuser, 'admin_deleted_repo', repo_name,
self.ip_addr, self.sa)
ScmModel().mark_for_invalidation(repo_name)
h.flash(_('Deleted repository %s') % repo_name, category='success')
Session().commit()
except AttachedForksError:
h.flash(_('Cannot delete %s it still contains attached forks') %
repo_name,
category='warning')
except Exception:
log.error(traceback.format_exc())
h.flash(_('An error occurred during deletion of %s') % repo_name,
category='error')
if repo.group:
return redirect(
url('repos_group_home', group_name=repo.group.group_name))
return redirect(url('repos'))
def edit_advanced_fork(self, repo_name):
"""
Mark given repository as a fork of another
:param repo_name:
"""
try:
fork_id = request.POST.get('id_fork_of')
repo = ScmModel().mark_as_fork(repo_name, fork_id,
self.authuser.username)
fork = repo.fork.repo_name if repo.fork else _('Nothing')
Session().commit()
h.flash(_('Marked repo %s as fork of %s') % (repo_name, fork),
category='success')
except RepositoryError, e:
log.error(traceback.format_exc())
h.flash(str(e), category='error')
def create_repo(self, name, repo_group=None, **kwargs):
if 'skip_if_exists' in kwargs:
del kwargs['skip_if_exists']
r = Repository.get_by_repo_name(name)
if r:
return r
if isinstance(repo_group, RepoGroup):
repo_group = repo_group.group_id
form_data = self._get_repo_create_params(repo_name=name, **kwargs)
form_data[
'repo_group'] = repo_group # patch form dict so it can be used directly by model
cur_user = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
RepoModel().create(form_data, cur_user)
Session().commit()
ScmModel().mark_for_invalidation(name)
return Repository.get_by_repo_name(name)
def repo_scan(remove_missing):
"""Scan filesystem for repositories.
Search the configured repository root for new repositories and add them
into Kallithea.
Additionally, report repositories that were previously known to Kallithea
but are no longer present on the filesystem. If option --remove-missing is
given, remove the missing repositories from the Kallithea database.
"""
click.echo('Now scanning root location for new repos ...')
added, removed = repo2db_mapper(ScmModel().repo_scan(),
remove_obsolete=remove_missing)
click.echo('Scan completed.')
if added:
click.echo('Added: %s' % ', '.join(added))
if removed:
click.echo(
'%s: %s' %
('Removed' if remove_missing else 'Missing', ', '.join(removed)))
def create_fork(self, repo_to_fork, fork_name, **kwargs):
repo_to_fork = Repository.get_by_repo_name(repo_to_fork)
form_data = self._get_repo_create_params(
repo_name=fork_name,
fork_parent_id=repo_to_fork,
repo_type=repo_to_fork.repo_type,
**kwargs)
# patch form dict so it can be used directly by model
form_data['description'] = form_data['repo_description']
form_data['private'] = form_data['repo_private']
form_data['landing_rev'] = form_data['repo_landing_rev']
owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
RepoModel().create_fork(form_data, cur_user=owner)
Session().commit()
ScmModel().mark_for_invalidation(fork_name)
r = Repository.get_by_repo_name(fork_name)
assert r
return r