repos.py
487 lines
| 18.3 KiB
| text/x-python
|
PythonLexer
r824 | # -*- coding: utf-8 -*- | |||
""" | ||||
rhodecode.controllers.admin.repos | ||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||||
r1203 | ||||
r1982 | Repositories controller for RhodeCode | |||
r1203 | ||||
r824 | :created_on: Apr 7, 2010 | |||
:author: marcink | ||||
r1824 | :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com> | |||
r824 | :license: GPLv3, see COPYING for more details. | |||
""" | ||||
r1206 | # This program is free software: you can redistribute it and/or modify | |||
# it under the terms of the GNU General Public License as published by | ||||
# the Free Software Foundation, either version 3 of the License, or | ||||
# (at your option) any later version. | ||||
r1203 | # | |||
r547 | # This program is distributed in the hope that it will be useful, | |||
# but WITHOUT ANY WARRANTY; without even the implied warranty of | ||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||||
# GNU General Public License for more details. | ||||
r1203 | # | |||
r547 | # You should have received a copy of the GNU General Public License | |||
r1206 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
r824 | ||||
import logging | ||||
import traceback | ||||
import formencode | ||||
r547 | from formencode import htmlfill | |||
r824 | ||||
r2242 | from webob.exc import HTTPInternalServerError | |||
r1722 | from pylons import request, session, tmpl_context as c, url | |||
from pylons.controllers.util import redirect | ||||
r547 | from pylons.i18n.translation import _ | |||
r1722 | from sqlalchemy.exc import IntegrityError | |||
r824 | ||||
r2664 | import rhodecode | |||
r547 | from rhodecode.lib import helpers as h | |||
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \ | ||||
r1828 | HasPermissionAnyDecorator, HasRepoPermissionAllDecorator | |||
r547 | from rhodecode.lib.base import BaseController, render | |||
r1022 | from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug | |||
r1085 | from rhodecode.lib.helpers import get_token | |||
r1722 | from rhodecode.model.meta import Session | |||
r1633 | from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup | |||
r547 | from rhodecode.model.forms import RepoForm | |||
r691 | from rhodecode.model.scm import ScmModel | |||
r629 | from rhodecode.model.repo import RepoModel | |||
r2664 | from rhodecode.lib.compat import json | |||
r824 | ||||
r547 | log = logging.getLogger(__name__) | |||
r1245 | ||||
r547 | class ReposController(BaseController): | |||
r1085 | """ | |||
REST Controller styled on the Atom Publishing Protocol""" | ||||
r547 | # To properly map this controller, ensure your config/routing.py | |||
# file has a resource setup: | ||||
# map.resource('repo', 'repos') | ||||
r636 | ||||
r547 | @LoginRequired() | |||
@HasPermissionAnyDecorator('hg.admin', 'hg.create.repository') | ||||
def __before__(self): | ||||
c.admin_user = session.get('admin_user') | ||||
c.admin_username = session.get('admin_username') | ||||
super(ReposController, self).__before__() | ||||
r636 | ||||
r1159 | def __load_defaults(self): | |||
r1633 | c.repo_groups = RepoGroup.groups_choices() | |||
r1547 | c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups) | |||
r1722 | ||||
r1159 | repo_model = RepoModel() | |||
c.users_array = repo_model.get_users_js() | ||||
c.users_groups_array = repo_model.get_users_groups_js() | ||||
r2460 | choices, c.landing_revs = ScmModel().get_repo_landing_revs() | |||
c.landing_revs_choices = choices | ||||
r1159 | ||||
def __load_data(self, repo_name=None): | ||||
r1112 | """ | |||
Load defaults settings for edit, and update | ||||
r1203 | ||||
r1112 | :param repo_name: | |||
""" | ||||
r1159 | self.__load_defaults() | |||
r1530 | c.repo_info = db_repo = Repository.get_by_repo_name(repo_name) | |||
r1561 | repo = db_repo.scm_instance | |||
r1112 | ||||
if c.repo_info is None: | ||||
h.flash(_('%s repository is not mapped to db perhaps' | ||||
' it was created or renamed from the filesystem' | ||||
' please run the application again' | ||||
' in order to rescan repositories') % repo_name, | ||||
category='error') | ||||
return redirect(url('repos')) | ||||
r2460 | choices, c.landing_revs = ScmModel().get_repo_landing_revs(c.repo_info) | |||
c.landing_revs_choices = choices | ||||
r1530 | c.default_user_id = User.get_by_username('default').user_id | |||
r1594 | c.in_public_journal = UserFollowing.query()\ | |||
r1112 | .filter(UserFollowing.user_id == c.default_user_id)\ | |||
.filter(UserFollowing.follows_repository == c.repo_info).scalar() | ||||
if c.repo_info.stats: | ||||
r1807 | # this is on what revision we ended up so we add +1 for count | |||
last_rev = c.repo_info.stats.stat_on_revision + 1 | ||||
r1112 | else: | |||
last_rev = 0 | ||||
c.stats_revision = last_rev | ||||
r1807 | c.repo_last_rev = repo.count() if repo.revisions else 0 | |||
r1112 | ||||
if last_rev == 0 or c.repo_last_rev == 0: | ||||
c.stats_percentage = 0 | ||||
else: | ||||
c.stats_percentage = '%.2f' % ((float((last_rev)) / | ||||
c.repo_last_rev) * 100) | ||||
r1594 | defaults = RepoModel()._get_defaults(repo_name) | |||
r1818 | ||||
r1755 | c.repos_list = [('', _('--REMOVE FORK--'))] | |||
c.repos_list += [(x.repo_id, x.repo_name) for x in | ||||
r2629 | Repository.query().order_by(Repository.repo_name).all() | |||
if x.repo_id != c.repo_info.repo_id] | ||||
r2459 | ||||
r2629 | defaults['id_fork_of'] = db_repo.fork.repo_id if db_repo.fork else '' | |||
r1112 | return defaults | |||
r636 | @HasPermissionAllDecorator('hg.admin') | |||
r547 | def index(self, format='html'): | |||
"""GET /repos: All items in the collection""" | ||||
# url('repos') | ||||
r1344 | ||||
r2664 | c.repos_list = Repository.query()\ | |||
.order_by(Repository.repo_name)\ | ||||
.all() | ||||
repos_data = [] | ||||
total_records = len(c.repos_list) | ||||
_tmpl_lookup = rhodecode.CONFIG['pylons.app_globals'].mako_lookup | ||||
template = _tmpl_lookup.get_template('data_table/_dt_elements.html') | ||||
quick_menu = lambda repo_name: (template.get_def("quick_menu") | ||||
r2674 | .render(repo_name, _=_, h=h, c=c)) | |||
r2664 | repo_lnk = lambda name, rtype, private, fork_of: ( | |||
template.get_def("repo_name") | ||||
r2674 | .render(name, rtype, private, fork_of, short_name=False, | |||
admin=True, _=_, h=h, c=c)) | ||||
r2664 | ||||
repo_actions = lambda repo_name: (template.get_def("repo_actions") | ||||
r2674 | .render(repo_name, _=_, h=h, c=c)) | |||
r2664 | ||||
for repo in c.repos_list: | ||||
repos_data.append({ | ||||
"menu": quick_menu(repo.repo_name), | ||||
"raw_name": repo.repo_name, | ||||
r2674 | "name": repo_lnk(repo.repo_name, repo.repo_type, | |||
repo.private, repo.fork), | ||||
r2664 | "desc": repo.description, | |||
"owner": repo.user.username, | ||||
"action": repo_actions(repo.repo_name), | ||||
}) | ||||
c.data = json.dumps({ | ||||
"totalRecords": total_records, | ||||
"startIndex": 0, | ||||
"sort": "name", | ||||
"dir": "asc", | ||||
"records": repos_data | ||||
}) | ||||
r547 | return render('admin/repos/repos.html') | |||
r636 | ||||
r547 | @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository') | |||
def create(self): | ||||
r1085 | """ | |||
POST /repos: Create a new item""" | ||||
r547 | # url('repos') | |||
r1722 | ||||
r1159 | self.__load_defaults() | |||
r547 | form_result = {} | |||
try: | ||||
r2460 | form_result = RepoForm(repo_groups=c.repo_groups_choices, | |||
landing_revs=c.landing_revs_choices)()\ | ||||
r1159 | .to_python(dict(request.POST)) | |||
r2660 | new_repo = RepoModel().create(form_result, | |||
self.rhodecode_user.user_id) | ||||
r1112 | if form_result['clone_uri']: | |||
h.flash(_('created repository %s from %s') \ | ||||
% (form_result['repo_name'], form_result['clone_uri']), | ||||
category='success') | ||||
else: | ||||
h.flash(_('created repository %s') % form_result['repo_name'], | ||||
r547 | category='success') | |||
if request.POST.get('user_created'): | ||||
r1722 | # created by regular non admin user | |||
r564 | action_logger(self.rhodecode_user, 'user_created_repo', | |||
r2375 | form_result['repo_name_full'], self.ip_addr, | |||
self.sa) | ||||
r547 | else: | |||
r564 | action_logger(self.rhodecode_user, 'admin_created_repo', | |||
r2375 | form_result['repo_name_full'], self.ip_addr, | |||
self.sa) | ||||
r2662 | Session().commit() | |||
r564 | except formencode.Invalid, errors: | |||
r1112 | ||||
r547 | c.new_repo = errors.value['repo_name'] | |||
r636 | ||||
r547 | if request.POST.get('user_created'): | |||
r = render('admin/repos/repo_add_create_repository.html') | ||||
r636 | else: | |||
r547 | r = render('admin/repos/repo_add.html') | |||
r636 | ||||
r547 | return htmlfill.render( | |||
r, | ||||
defaults=errors.value, | ||||
errors=errors.error_dict or {}, | ||||
prefix_error=False, | ||||
r636 | encoding="UTF-8") | |||
r547 | ||||
except Exception: | ||||
log.error(traceback.format_exc()) | ||||
r860 | msg = _('error occurred during creation of repository %s') \ | |||
r547 | % form_result.get('repo_name') | |||
h.flash(msg, category='error') | ||||
r2707 | return redirect(url('repos')) | |||
r2660 | #redirect to our new repo ! | |||
return redirect(url('summary_home', repo_name=new_repo.repo_name)) | ||||
r636 | ||||
r547 | @HasPermissionAllDecorator('hg.admin') | |||
def new(self, format='html'): | ||||
"""GET /repos/new: Form to create a new item""" | ||||
new_repo = request.GET.get('repo', '') | ||||
r1022 | c.new_repo = repo_name_slug(new_repo) | |||
r1159 | self.__load_defaults() | |||
r547 | return render('admin/repos/repo_add.html') | |||
r636 | ||||
r547 | @HasPermissionAllDecorator('hg.admin') | |||
def update(self, repo_name): | ||||
r1085 | """ | |||
PUT /repos/repo_name: Update an existing item""" | ||||
r547 | # 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) | ||||
r1159 | self.__load_defaults() | |||
r547 | repo_model = RepoModel() | |||
changed_name = repo_name | ||||
r2603 | #override the choices with extracted revisions ! | |||
choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo_name) | ||||
c.landing_revs_choices = choices | ||||
r1245 | _form = RepoForm(edit=True, old_data={'repo_name': repo_name}, | |||
r2460 | repo_groups=c.repo_groups_choices, | |||
landing_revs=c.landing_revs_choices)() | ||||
r547 | try: | |||
form_result = _form.to_python(dict(request.POST)) | ||||
r1539 | repo = repo_model.update(repo_name, form_result) | |||
r665 | invalidate_cache('get_repo_cached_%s' % repo_name) | |||
|
r2570 | h.flash(_('Repository %s updated successfully') % repo_name, | ||
r547 | category='success') | |||
r1539 | changed_name = repo.repo_name | |||
r660 | action_logger(self.rhodecode_user, 'admin_updated_repo', | |||
r2375 | changed_name, self.ip_addr, self.sa) | |||
r2662 | Session().commit() | |||
r564 | except formencode.Invalid, errors: | |||
r1112 | defaults = self.__load_data(repo_name) | |||
defaults.update(errors.value) | ||||
r547 | return htmlfill.render( | |||
render('admin/repos/repo_edit.html'), | ||||
r1112 | defaults=defaults, | |||
r547 | errors=errors.error_dict or {}, | |||
prefix_error=False, | ||||
encoding="UTF-8") | ||||
r636 | ||||
r547 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
r692 | h.flash(_('error occurred during update of repository %s') \ | |||
r547 | % repo_name, category='error') | |||
return redirect(url('edit_repo', repo_name=changed_name)) | ||||
r636 | ||||
r547 | @HasPermissionAllDecorator('hg.admin') | |||
def delete(self, repo_name): | ||||
r1085 | """ | |||
DELETE /repos/repo_name: Delete an existing item""" | ||||
r547 | # 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) | ||||
r636 | ||||
r547 | repo_model = RepoModel() | |||
r735 | repo = repo_model.get_by_repo_name(repo_name) | |||
r547 | if not repo: | |||
r636 | h.flash(_('%s repository is not mapped to db perhaps' | |||
r547 | ' it was moved or renamed from the filesystem' | |||
' please run the application again' | ||||
' in order to rescan repositories') % repo_name, | ||||
category='error') | ||||
r636 | ||||
r547 | return redirect(url('repos')) | |||
try: | ||||
r564 | action_logger(self.rhodecode_user, 'admin_deleted_repo', | |||
r2375 | repo_name, self.ip_addr, self.sa) | |||
r636 | repo_model.delete(repo) | |||
r665 | invalidate_cache('get_repo_cached_%s' % repo_name) | |||
r547 | h.flash(_('deleted repository %s') % repo_name, category='success') | |||
r2662 | Session().commit() | |||
r1361 | except IntegrityError, e: | |||
r1752 | if e.message.find('repositories_fork_id_fkey') != -1: | |||
r1361 | log.error(traceback.format_exc()) | |||
h.flash(_('Cannot delete %s it still contains attached ' | ||||
'forks') % repo_name, | ||||
category='warning') | ||||
else: | ||||
log.error(traceback.format_exc()) | ||||
h.flash(_('An error occurred during ' | ||||
'deletion of %s') % repo_name, | ||||
category='error') | ||||
r547 | except Exception, e: | |||
log.error(traceback.format_exc()) | ||||
r860 | h.flash(_('An error occurred during deletion of %s') % repo_name, | |||
r547 | category='error') | |||
r636 | ||||
r547 | return redirect(url('repos')) | |||
r636 | ||||
r1869 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r547 | def delete_perm_user(self, repo_name): | |||
r1085 | """ | |||
DELETE an existing repository permission user | ||||
r1203 | ||||
r604 | :param repo_name: | |||
r547 | """ | |||
try: | ||||
r1982 | RepoModel().revoke_user_permission(repo=repo_name, | |||
user=request.POST['user_id']) | ||||
r2662 | Session().commit() | |||
r1982 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
r860 | h.flash(_('An error occurred during deletion of repository user'), | |||
r547 | category='error') | |||
raise HTTPInternalServerError() | ||||
r636 | ||||
r1828 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r1015 | def delete_perm_users_group(self, repo_name): | |||
r1085 | """ | |||
DELETE an existing repository permission users group | ||||
r1203 | ||||
r1015 | :param repo_name: | |||
r708 | """ | |||
r1982 | ||||
r1015 | try: | |||
r1982 | RepoModel().revoke_users_group_permission( | |||
repo=repo_name, group_name=request.POST['users_group_id'] | ||||
) | ||||
r2662 | Session().commit() | |||
r1982 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
r1015 | h.flash(_('An error occurred during deletion of repository' | |||
' users groups'), | ||||
category='error') | ||||
raise HTTPInternalServerError() | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
def repo_stats(self, repo_name): | ||||
r1085 | """ | |||
DELETE an existing repository statistics | ||||
r1203 | ||||
r708 | :param repo_name: | |||
""" | ||||
try: | ||||
r1982 | RepoModel().delete_stats(repo_name) | |||
r2662 | Session().commit() | |||
r708 | except Exception, e: | |||
r860 | h.flash(_('An error occurred during deletion of repository stats'), | |||
r708 | category='error') | |||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
def repo_cache(self, repo_name): | ||||
r1085 | """ | |||
INVALIDATE existing repository cache | ||||
r1203 | ||||
r708 | :param repo_name: | |||
""" | ||||
try: | ||||
ScmModel().mark_for_invalidation(repo_name) | ||||
r2662 | Session().commit() | |||
r708 | except Exception, e: | |||
r711 | h.flash(_('An error occurred during cache invalidation'), | |||
r708 | category='error') | |||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
r1085 | def repo_public_journal(self, repo_name): | |||
""" | ||||
Set's this repository to be visible in public journal, | ||||
in other words assing default user to follow this repo | ||||
r1203 | ||||
r1085 | :param repo_name: | |||
""" | ||||
cur_token = request.POST.get('auth_token') | ||||
token = get_token() | ||||
if cur_token == token: | ||||
try: | ||||
r1530 | repo_id = Repository.get_by_repo_name(repo_name).repo_id | |||
user_id = User.get_by_username('default').user_id | ||||
r1085 | self.scm_model.toggle_following_repo(repo_id, user_id) | |||
h.flash(_('Updated repository visibility in public journal'), | ||||
category='success') | ||||
r2662 | Session().commit() | |||
r1085 | except: | |||
h.flash(_('An error occurred during setting this' | ||||
' repository in public journal'), | ||||
category='error') | ||||
else: | ||||
h.flash(_('Token mismatch'), category='error') | ||||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
r1114 | @HasPermissionAllDecorator('hg.admin') | |||
def repo_pull(self, repo_name): | ||||
""" | ||||
Runs task to update given repository with remote changes, | ||||
ie. make pull on remote location | ||||
r1203 | ||||
r1114 | :param repo_name: | |||
""" | ||||
try: | ||||
r1121 | ScmModel().pull_changes(repo_name, self.rhodecode_user.username) | |||
r1114 | h.flash(_('Pulled from remote location'), category='success') | |||
except Exception, e: | ||||
h.flash(_('An error occurred during pull from remote location'), | ||||
category='error') | ||||
r1085 | ||||
r1114 | return redirect(url('edit_repo', repo_name=repo_name)) | |||
r1085 | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
r1755 | def repo_as_fork(self, repo_name): | |||
""" | ||||
Mark given repository as a fork of another | ||||
r1818 | ||||
r1755 | :param repo_name: | |||
""" | ||||
try: | ||||
fork_id = request.POST.get('id_fork_of') | ||||
repo = ScmModel().mark_as_fork(repo_name, fork_id, | ||||
self.rhodecode_user.username) | ||||
fork = repo.fork.repo_name if repo.fork else _('Nothing') | ||||
r2629 | Session().commit() | |||
h.flash(_('Marked repo %s as fork of %s') % (repo_name, fork), | ||||
r1755 | category='success') | |||
except Exception, e: | ||||
r2629 | log.error(traceback.format_exc()) | |||
r1755 | h.flash(_('An error occurred during this operation'), | |||
category='error') | ||||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
r547 | def show(self, repo_name, format='html'): | |||
"""GET /repos/repo_name: Show a specific item""" | ||||
# url('repo', repo_name=ID) | ||||
r636 | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
r547 | def edit(self, repo_name, format='html'): | |||
"""GET /repos/repo_name/edit: Form to edit an existing item""" | ||||
# url('edit_repo', repo_name=ID) | ||||
r1112 | defaults = self.__load_data(repo_name) | |||
r636 | ||||
r547 | return htmlfill.render( | |||
render('admin/repos/repo_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
force_defaults=False | ||||
r636 | ) | |||