labs: enable by default. We want people to encourage using those

rhodecode/controllers/admin/repos.py

@@ -1,881 +1,881 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2013-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 """
 Repositories controller for RhodeCode
 """
 
 import logging
 import traceback
 
 import formencode
 from formencode import htmlfill
 from pylons import request, tmpl_context as c, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 from webob.exc import HTTPForbidden, HTTPNotFound, HTTPBadRequest
 
 import rhodecode
 from rhodecode.lib import auth, helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasPermissionAllDecorator,
     HasRepoPermissionAllDecorator, NotAnonymous, HasPermissionAny,
     HasRepoGroupPermissionAny, HasRepoPermissionAnyDecorator)
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.exceptions import AttachedForksError
 from rhodecode.lib.utils import action_logger, repo_name_slug, jsonify
 from rhodecode.lib.utils2 import safe_int, str2bool
 from rhodecode.lib.vcs import RepositoryError
 from rhodecode.model.db import (
     User, Repository, UserFollowing, RepoGroup, RepositoryField)
 from rhodecode.model.forms import (
     RepoForm, RepoFieldForm, RepoPermsForm, RepoVcsSettingsForm,
     IssueTrackerPatternsForm)
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel, RepoGroupList, RepoList
 from rhodecode.model.settings import (
     SettingsModel, IssueTrackerSettingsModel, VcsSettingsModel,
     SettingNotFound)
 
 log = logging.getLogger(__name__)
 
 
 class ReposController(BaseRepoController):
     """
     REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repo', 'repos')
 
     @LoginRequired()
     def __before__(self):
         super(ReposController, self).__before__()
 
     def _load_repo(self, repo_name):
         repo_obj = Repository.get_by_repo_name(repo_name)
 
         if repo_obj is None:
             h.not_mapped_error(repo_name)
             return redirect(url('repos'))
 
         return repo_obj
 
     def __load_defaults(self, repo=None):
         acl_groups = RepoGroupList(RepoGroup.query().all(),
                                perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
 
         # in case someone no longer have a group.write access to a repository
         # pre fill the list with this entry, we don't care if this is the same
         # but it will allow saving repo data properly.
 
         repo_group = None
         if repo:
             repo_group = repo.group
         if repo_group and unicode(repo_group.group_id) not in c.repo_groups_choices:
             c.repo_groups_choices.append(unicode(repo_group.group_id))
             c.repo_groups.append(RepoGroup._generate_choice(repo_group))
 
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
         c.landing_revs_choices = choices
 
     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
         if not c.repository_requirements_missing:
             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 _log_creation_exception(self, e, repo_name):
             reason = None
             if len(e.args) == 2:
                 reason = e.args[1]
 
             if reason == 'INVALID_CERTIFICATE':
                 log.exception(
                     'Exception creating a repository: invalid certificate')
                 msg = (_('Error creating repository %s: invalid certificate')
                        % repo_name)
             else:
                 log.exception("Exception creating a repository")
                 msg = (_('Error creating repository %s')
                        % repo_name)
 
             return msg
 
     @NotAnonymous()
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
 
         repo_list = Repository.get_all_repos()
         c.repo_list = RepoList(repo_list, perm_set=['repository.admin'])
         repos_data = RepoModel().get_repos_as_dict(
             repo_list=c.repo_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')
 
     # perms check inside
     @NotAnonymous()
     @auth.CSRFRequired()
     def create(self):
         """
         POST /repos: Create a new item"""
         # url('repos')
 
         self.__load_defaults()
         form_result = {}
         task_id = None
         try:
             # CanWriteToGroup validators checks permissions of this POST
             form_result = RepoForm(repo_groups=c.repo_groups_choices,
                                    landing_revs=c.landing_revs_choices)()\
                             .to_python(dict(request.POST))
 
             # create is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create(form_result, c.rhodecode_user.user_id)
             from celery.result import BaseAsyncResult
             if isinstance(task, BaseAsyncResult):
                 task_id = task.task_id
         except formencode.Invalid as errors:
             c.personal_repo_group = RepoGroup.get_by_group_name(
                 c.rhodecode_user.username)
             return htmlfill.render(
                 render('admin/repos/repo_add.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
 
         except Exception as e:
             msg = self._log_creation_exception(e, form_result.get('repo_name'))
             h.flash(msg, category='error')
             return redirect(url('home'))
 
         return redirect(h.url('repo_creating_home',
                               repo_name=form_result['repo_name_full'],
                               task_id=task_id))
 
     # perms check inside
     @NotAnonymous()
     def create_repository(self):
         """GET /_admin/create_repository: Form to create a new item"""
         new_repo = request.GET.get('repo', '')
         parent_group = request.GET.get('parent_group')
         if not HasPermissionAny('hg.admin', 'hg.create.repository')():
             # you're not super admin nor have global create permissions,
             # but maybe you have at least write permission to a parent group ?
             _gr = RepoGroup.get(parent_group)
             gr_name = _gr.group_name if _gr else None
             # create repositories with write permission on group is set to true
             create_on_write = HasPermissionAny('hg.create.write_on_repogroup.true')()
             group_admin = HasRepoGroupPermissionAny('group.admin')(group_name=gr_name)
             group_write = HasRepoGroupPermissionAny('group.write')(group_name=gr_name)
             if not (group_admin or (group_write and create_on_write)):
                 raise HTTPForbidden
 
         acl_groups = RepoGroupList(RepoGroup.query().all(),
                                perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
         choices, c.landing_revs = ScmModel().get_repo_landing_revs()
         c.personal_repo_group = RepoGroup.get_by_group_name(c.rhodecode_user.username)
         c.new_repo = repo_name_slug(new_repo)
 
         ## apply the defaults from defaults page
         defaults = SettingsModel().get_default_repo_settings(strip_prefix=True)
         # set checkbox to autochecked
         defaults['repo_copy_permissions'] = True
         if parent_group:
             defaults.update({'repo_group': parent_group})
 
         return htmlfill.render(
             render('admin/repos/repo_add.html'),
             defaults=defaults,
             errors={},
             prefix_error=False,
             encoding="UTF-8",
             force_defaults=False
         )
 
     @NotAnonymous()
     def repo_creating(self, repo_name):
         c.repo = repo_name
         c.task_id = request.GET.get('task_id')
         if not c.repo:
             raise HTTPNotFound()
         return render('admin/repos/repo_creating.html')
 
     @NotAnonymous()
     @jsonify
     def repo_check(self, repo_name):
         c.repo = repo_name
         task_id = request.GET.get('task_id')
 
         if task_id and task_id not in ['None']:
             import rhodecode
             from celery.result import AsyncResult
             if rhodecode.CELERY_ENABLED:
                 task = AsyncResult(task_id)
                 if task.failed():
                     msg = self._log_creation_exception(task.result, c.repo)
                     h.flash(msg, category='error')
                     return redirect(url('home'), code=501)
 
         repo = Repository.get_by_repo_name(repo_name)
         if repo and repo.repo_state == Repository.STATE_CREATED:
             if repo.clone_uri:
                 clone_uri = repo.clone_uri_hidden
                 h.flash(_('Created repository %s from %s')
                         % (repo.repo_name, clone_uri), category='success')
             else:
                 repo_url = h.link_to(repo.repo_name,
                                      h.url('summary_home',
                                            repo_name=repo.repo_name))
                 fork = repo.fork
                 if fork:
                     fork_name = fork.repo_name
                     h.flash(h.literal(_('Forked repository %s as %s')
                             % (fork_name, repo_url)), category='success')
                 else:
                     h.flash(h.literal(_('Created repository %s') % repo_url),
                             category='success')
             return {'result': True}
         return {'result': False}
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     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)
 
         self.__load_data(repo_name)
         c.active = 'settings'
         c.repo_fields = RepositoryField.query()\
             .filter(RepositoryField.repository == c.repo_info).all()
 
         repo_model = RepoModel()
         changed_name = repo_name
 
         # override the choices with extracted revisions !
         c.personal_repo_group = RepoGroup.get_by_group_name(
             c.rhodecode_user.username)
         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, allow_disabled=True)()
 
         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(c.rhodecode_user, 'admin_updated_repo',
                               changed_name, self.ip_addr, self.sa)
             Session().commit()
         except formencode.Invalid as 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)
 
         except Exception:
             log.exception("Exception during update of repository")
             h.flash(_('Error occurred during update of repository %s') \
                     % repo_name, category='error')
         return redirect(url('edit_repo', repo_name=changed_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     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(c.rhodecode_user, '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.exception("Exception during deletion of repository")
             h.flash(_('An error occurred during deletion of %s') % repo_name,
                     category='error')
 
         return redirect(url('repos'))
 
     @HasPermissionAllDecorator('hg.admin')
     def show(self, repo_name, format='html'):
         """GET /repos/repo_name: Show a specific item"""
         # url('repo', repo_name=ID)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit(self, repo_name):
         """GET /repo_name/settings: Form to edit an existing item"""
         # url('edit_repo', repo_name=ID)
         defaults = self.__load_data(repo_name)
         if 'clone_uri' in defaults:
             del defaults['clone_uri']
 
         c.repo_fields = RepositoryField.query()\
             .filter(RepositoryField.repository == c.repo_info).all()
         c.personal_repo_group = RepoGroup.get_by_group_name(
             c.rhodecode_user.username)
         c.active = 'settings'
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_permissions(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 = 'permissions'
         defaults = RepoModel()._get_defaults(repo_name)
 
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_permissions_update(self, repo_name):
         form = RepoPermsForm()().to_python(request.POST)
         RepoModel().update_permissions(repo_name,
             form['perm_additions'], form['perm_updates'], form['perm_deletions'])
 
         #TODO: implement this
         #action_logger(c.rhodecode_user, 'admin_changed_repo_permissions',
         #              repo_name, self.ip_addr, self.sa)
         Session().commit()
         h.flash(_('Repository permissions updated'), category='success')
         return redirect(url('edit_repo_perms', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_fields(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.repo_fields = RepositoryField.query()\
             .filter(RepositoryField.repository == c.repo_info).all()
         c.active = 'fields'
         if request.POST:
 
             return redirect(url('repo_edit_fields'))
         return render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def create_repo_field(self, repo_name):
         try:
             form_result = RepoFieldForm()().to_python(dict(request.POST))
             RepoModel().add_repo_field(
                 repo_name, form_result['new_field_key'],
                 field_type=form_result['new_field_type'],
                 field_value=form_result['new_field_value'],
                 field_label=form_result['new_field_label'],
                 field_desc=form_result['new_field_desc'])
 
             Session().commit()
         except Exception as e:
             log.exception("Exception creating field")
             msg = _('An error occurred during creation of field')
             if isinstance(e, formencode.Invalid):
                 msg += ". " + e.msg
             h.flash(msg, category='error')
         return redirect(url('edit_repo_fields', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def delete_repo_field(self, repo_name, field_id):
         field = RepositoryField.get_or_404(field_id)
         try:
             RepoModel().delete_repo_field(repo_name, field.field_key)
             Session().commit()
         except Exception as e:
             log.exception("Exception during removal of field")
             msg = _('An error occurred during removal of field')
             h.flash(msg, category='error')
         return redirect(url('edit_repo_fields', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     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()
 
         c.active = 'advanced'
         c.has_origin_repo_read_perm = False
         if c.repo_info.fork:
             c.has_origin_repo_read_perm = h.HasRepoPermissionAny(
                 'repository.write', 'repository.read', 'repository.admin')(
                 c.repo_info.fork.repo_name, 'repo set as fork page')
 
         if request.POST:
             return redirect(url('repo_edit_advanced'))
         return render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_advanced_journal(self, repo_name):
         """
         Set's this repository to be visible in public journal,
         in other words assing default user to follow this repo
 
         :param repo_name:
         """
 
         try:
             repo_id = Repository.get_by_repo_name(repo_name).repo_id
             user_id = User.get_default_user().user_id
             self.scm_model.toggle_following_repo(repo_id, user_id)
             h.flash(_('Updated repository visibility in public journal'),
                     category='success')
             Session().commit()
         except Exception:
             h.flash(_('An error occurred during setting this'
                       ' repository in public journal'),
                     category='error')
 
         return redirect(url('edit_repo_advanced', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_advanced_fork(self, repo_name):
         """
         Mark given repository as a fork of another
 
         :param repo_name:
         """
 
         new_fork_id = request.POST.get('id_fork_of')
         try:
 
             if new_fork_id and not new_fork_id.isdigit():
                 log.error('Given fork id %s is not an INT', new_fork_id)
 
             fork_id = safe_int(new_fork_id)
             repo = ScmModel().mark_as_fork(repo_name, fork_id,
                                            c.rhodecode_user.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 as e:
             log.exception("Repository Error occurred")
             h.flash(str(e), category='error')
         except Exception as e:
             log.exception("Exception while editing fork")
             h.flash(_('An error occurred during this operation'),
                     category='error')
 
         return redirect(url('edit_repo_advanced', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_advanced_locking(self, repo_name):
         """
         Unlock repository when it is locked !
 
         :param repo_name:
         """
         try:
             repo = Repository.get_by_repo_name(repo_name)
             if request.POST.get('set_lock'):
                 Repository.lock(repo, c.rhodecode_user.user_id,
                                 lock_reason=Repository.LOCK_WEB)
                 h.flash(_('Locked repository'), category='success')
             elif request.POST.get('set_unlock'):
                 Repository.unlock(repo)
                 h.flash(_('Unlocked repository'), category='success')
         except Exception as e:
             log.exception("Exception during unlocking")
             h.flash(_('An error occurred during unlocking'),
                     category='error')
         return redirect(url('edit_repo_advanced', repo_name=repo_name))
 
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @auth.CSRFRequired()
     def toggle_locking(self, repo_name):
         """
         Toggle locking of repository by simple GET call to url
 
         :param repo_name:
         """
 
         try:
             repo = Repository.get_by_repo_name(repo_name)
 
             if repo.enable_locking:
                 if repo.locked[0]:
                     Repository.unlock(repo)
                     action = _('Unlocked')
                 else:
                     Repository.lock(repo, c.rhodecode_user.user_id,
                                     lock_reason=Repository.LOCK_WEB)
                     action = _('Locked')
 
                 h.flash(_('Repository has been %s') % action,
                         category='success')
         except Exception:
             log.exception("Exception during unlocking")
             h.flash(_('An error occurred during unlocking'),
                     category='error')
         return redirect(url('summary_home', repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_caches(self, repo_name):
         """PUT /{repo_name}/settings/caches: invalidate the repo caches."""
         try:
             ScmModel().mark_for_invalidation(repo_name, delete=True)
             Session().commit()
             h.flash(_('Cache invalidation successful'),
                     category='success')
         except Exception:
             log.exception("Exception during cache invalidation")
             h.flash(_('An error occurred during cache invalidation'),
                     category='error')
 
         return redirect(url('edit_repo_caches', repo_name=c.repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_caches_form(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'
 
         return render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_remote(self, repo_name):
         """PUT /{repo_name}/settings/remote: edit the repo remote."""
         try:
             ScmModel().pull_changes(repo_name, c.rhodecode_user.username)
             h.flash(_('Pulled from remote location'), category='success')
         except Exception:
             log.exception("Exception during pull from remote")
             h.flash(_('An error occurred during pull from remote location'),
                     category='error')
         return redirect(url('edit_repo_remote', repo_name=c.repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_remote_form(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'
 
         return render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def edit_statistics(self, repo_name):
         """PUT /{repo_name}/settings/statistics: reset the repo statistics."""
         try:
             RepoModel().delete_stats(repo_name)
             Session().commit()
         except Exception as e:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of repository stats'),
                     category='error')
         return redirect(url('edit_repo_statistics', repo_name=c.repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def edit_statistics_form(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)
         repo = c.repo_info.scm_instance()
 
         if c.repo_info.stats:
             # this is on what revision we ended up so we add +1 for count
             last_rev = c.repo_info.stats.stat_on_revision + 1
         else:
             last_rev = 0
         c.stats_revision = last_rev
 
         c.repo_last_rev = repo.count()
 
         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)
 
         c.active = 'statistics'
 
         return render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_issuetracker_test(self, repo_name):
         if request.is_xhr:
             return h.urlify_commit_message(
                 request.POST.get('test_text', ''),
                 repo_name)
         else:
             raise HTTPBadRequest()
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_issuetracker_delete(self, repo_name):
         uid = request.POST.get('uid')
         repo_settings = IssueTrackerSettingsModel(repo=repo_name)
         try:
             repo_settings.delete_entries(uid)
         except Exception:
             h.flash(_('Error occurred during deleting issue tracker entry'),
                     category='error')
         else:
             h.flash(_('Removed issue tracker entry'), category='success')
         return redirect(url('repo_settings_issuetracker',
                         repo_name=repo_name))
 
     def _update_patterns(self, form, repo_settings):
         for uid in form['delete_patterns']:
             repo_settings.delete_entries(uid)
 
         for pattern in form['patterns']:
             for setting, value, type_ in pattern:
                 sett = repo_settings.create_or_update_setting(
                     setting, value, type_)
                 Session().add(sett)
 
             Session().commit()
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_issuetracker_save(self, repo_name):
         # Save inheritance
         repo_settings = IssueTrackerSettingsModel(repo=repo_name)
         inherited = (request.POST.get('inherit_global_issuetracker')
                      == "inherited")
         repo_settings.inherit_global_settings = inherited
         Session().commit()
 
         form = IssueTrackerPatternsForm()().to_python(request.POST)
         if form:
             self._update_patterns(form, repo_settings)
 
         h.flash(_('Updated issue tracker entries'), category='success')
         return redirect(url('repo_settings_issuetracker',
                         repo_name=repo_name))
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def repo_issuetracker(self, repo_name):
         """GET /admin/settings/issue-tracker: All items in the collection"""
         c.active = 'issuetracker'
         c.data = 'data'
         c.repo_info = self._load_repo(repo_name)
 
         repo = Repository.get_by_repo_name(repo_name)
         c.settings_model = IssueTrackerSettingsModel(repo=repo)
         c.global_patterns = c.settings_model.get_global_settings()
         c.repo_patterns = c.settings_model.get_repo_settings()
 
         return render('admin/repos/repo_edit.html')
 
     @HasRepoPermissionAllDecorator('repository.admin')
     def repo_settings_vcs(self, repo_name):
         """GET /{repo_name}/settings/vcs/: All items in the collection"""
 
         model = VcsSettingsModel(repo=repo_name)
 
         c.active = 'vcs'
         c.global_svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.global_svn_tag_patterns = model.get_global_svn_tag_patterns()
         c.svn_branch_patterns = model.get_repo_svn_branch_patterns()
         c.svn_tag_patterns = model.get_repo_svn_tag_patterns()
         c.repo_info = self._load_repo(repo_name)
         defaults = self._vcs_form_defaults(repo_name)
         c.inherit_global_settings = defaults['inherit_global_settings']
         c.labs_active = str2bool(
-            rhodecode.CONFIG.get('labs_settings_active', 'false'))
+            rhodecode.CONFIG.get('labs_settings_active', 'true'))
 
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     def repo_settings_vcs_update(self, repo_name):
         """POST /{repo_name}/settings/vcs/: All items in the collection"""
         c.active = 'vcs'
 
         model = VcsSettingsModel(repo=repo_name)
         c.global_svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.global_svn_tag_patterns = model.get_global_svn_tag_patterns()
         c.svn_branch_patterns = model.get_repo_svn_branch_patterns()
         c.svn_tag_patterns = model.get_repo_svn_tag_patterns()
         c.repo_info = self._load_repo(repo_name)
         defaults = self._vcs_form_defaults(repo_name)
         c.inherit_global_settings = defaults['inherit_global_settings']
 
         application_form = RepoVcsSettingsForm(repo_name)()
         try:
             form_result = application_form.to_python(dict(request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             return htmlfill.render(
                 render('admin/repos/repo_edit.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
 
         try:
             inherit_global_settings = form_result['inherit_global_settings']
             model.create_or_update_repo_settings(
                 form_result, inherit_global_settings=inherit_global_settings)
         except Exception:
             log.exception("Exception while updating settings")
             h.flash(
                 _('Error occurred during updating repository VCS settings'),
                 category='error')
         else:
             Session().commit()
             h.flash(_('Updated VCS settings'), category='success')
             return redirect(url('repo_vcs_settings', repo_name=repo_name))
 
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=self._vcs_form_defaults(repo_name),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasRepoPermissionAllDecorator('repository.admin')
     @auth.CSRFRequired()
     @jsonify
     def repo_delete_svn_pattern(self, repo_name):
         if not request.is_xhr:
             return False
 
         delete_pattern_id = request.POST.get('delete_svn_pattern')
         model = VcsSettingsModel(repo=repo_name)
         try:
             model.delete_repo_svn_pattern(delete_pattern_id)
         except SettingNotFound:
             raise HTTPBadRequest()
 
         Session().commit()
         return True
 
     def _vcs_form_defaults(self, repo_name):
         model = VcsSettingsModel(repo=repo_name)
         global_defaults = model.get_global_settings()
 
         repo_defaults = {}
         repo_defaults.update(global_defaults)
         repo_defaults.update(model.get_repo_settings())
 
         global_defaults = {
             '{}_inherited'.format(k): global_defaults[k]
             for k in global_defaults}
 
         defaults = {
             'inherit_global_settings': model.inherit_global_settings
         }
         defaults.update(global_defaults)
         defaults.update(repo_defaults)
         defaults.update({
             'new_svn_branch': '',
             'new_svn_tag': '',
         })
         return defaults

rhodecode/controllers/admin/settings.py

@@ -1,806 +1,806 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 """
 settings controller for rhodecode admin
 """
 
 import collections
 import logging
 import urllib2
 
 import datetime
 import formencode
 from formencode import htmlfill
 import packaging.version
 from pylons import request, tmpl_context as c, url, config
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _, lazy_ugettext
 from webob.exc import HTTPBadRequest
 
 import rhodecode
 from rhodecode.admin.navigation import navigation_list
 from rhodecode.lib import auth
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.celerylib import tasks, run_task
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.utils2 import (
     str2bool, safe_unicode, AttributeDict, safe_int)
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils import jsonify
 
 from rhodecode.model.db import RhodeCodeUi, Repository
 from rhodecode.model.forms import ApplicationSettingsForm, \
     ApplicationUiSettingsForm, ApplicationVisualisationForm, \
     LabsSettingsForm, IssueTrackerPatternsForm
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.notification import EmailNotificationModel
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import (
     IssueTrackerSettingsModel, VcsSettingsModel, SettingNotFound,
     SettingsModel)
 
 from rhodecode.model.supervisor import SupervisorModel, SUPERVISOR_MASTER
 
 
 log = logging.getLogger(__name__)
 
 
 class SettingsController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('setting', 'settings', controller='admin/settings',
     #         path_prefix='/admin', name_prefix='admin_')
 
     @LoginRequired()
     def __before__(self):
         super(SettingsController, self).__before__()
         c.labs_active = str2bool(
-            rhodecode.CONFIG.get('labs_settings_active', 'false'))
+            rhodecode.CONFIG.get('labs_settings_active', 'true'))
         c.navlist = navigation_list(request)
 
     def _get_hg_ui_settings(self):
         ret = RhodeCodeUi.query().all()
 
         if not ret:
             raise Exception('Could not get application ui settings !')
         settings = {}
         for each in ret:
             k = each.ui_key
             v = each.ui_value
             if k == '/':
                 k = 'root_path'
 
             if k in ['push_ssl', 'publish']:
                 v = str2bool(v)
 
             if k.find('.') != -1:
                 k = k.replace('.', '_')
 
             if each.ui_section in ['hooks', 'extensions']:
                 v = each.ui_active
 
             settings[each.ui_section + '_' + k] = v
         return settings
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     @jsonify
     def delete_svn_pattern(self):
         if not request.is_xhr:
             raise HTTPBadRequest()
 
         delete_pattern_id = request.POST.get('delete_svn_pattern')
         model = VcsSettingsModel()
         try:
             model.delete_global_svn_pattern(delete_pattern_id)
         except SettingNotFound:
             raise HTTPBadRequest()
 
         Session().commit()
         return True
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_vcs_update(self):
         """POST /admin/settings: All items in the collection"""
         # url('admin_settings_vcs')
         c.active = 'vcs'
 
         model = VcsSettingsModel()
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
 
         application_form = ApplicationUiSettingsForm()()
         try:
             form_result = application_form.to_python(dict(request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _("Some form inputs contain invalid data."),
                 category='error')
             return htmlfill.render(
                 render('admin/settings/settings.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
 
         try:
             model.update_global_ssl_setting(form_result['web_push_ssl'])
             if c.visual.allow_repo_location_change:
                 model.update_global_path_setting(
                     form_result['paths_root_path'])
             model.update_global_hook_settings(form_result)
             model.create_global_svn_settings(form_result)
             model.create_or_update_global_hg_settings(form_result)
             model.create_or_update_global_pr_settings(form_result)
         except Exception:
             log.exception("Exception while updating settings")
             h.flash(_('Error occurred during updating '
                       'application settings'), category='error')
         else:
             Session().commit()
             h.flash(_('Updated VCS settings'), category='success')
             return redirect(url('admin_settings_vcs'))
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_vcs(self):
         """GET /admin/settings: All items in the collection"""
         # url('admin_settings_vcs')
         c.active = 'vcs'
         model = VcsSettingsModel()
         c.svn_branch_patterns = model.get_global_svn_branch_patterns()
         c.svn_tag_patterns = model.get_global_svn_tag_patterns()
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_mapping_update(self):
         """POST /admin/settings/mapping: All items in the collection"""
         # url('admin_settings_mapping')
         c.active = 'mapping'
         rm_obsolete = request.POST.get('destroy', False)
         invalidate_cache = request.POST.get('invalidate', False)
         log.debug(
             'rescanning repo location with destroy obsolete=%s', rm_obsolete)
 
         if invalidate_cache:
             log.debug('invalidating all repositories cache')
             for repo in Repository.get_all():
                 ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
 
         filesystem_repos = ScmModel().repo_scan()
         added, removed = repo2db_mapper(filesystem_repos, rm_obsolete)
         _repr = lambda l: ', '.join(map(safe_unicode, l)) or '-'
         h.flash(_('Repositories successfully '
                   'rescanned added: %s ; removed: %s') %
                 (_repr(added), _repr(removed)),
                 category='success')
         return redirect(url('admin_settings_mapping'))
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_mapping(self):
         """GET /admin/settings/mapping: All items in the collection"""
         # url('admin_settings_mapping')
         c.active = 'mapping'
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_global_update(self):
         """POST /admin/settings/global: All items in the collection"""
         # url('admin_settings_global')
         c.active = 'global'
         application_form = ApplicationSettingsForm()()
         try:
             form_result = application_form.to_python(dict(request.POST))
         except formencode.Invalid as errors:
             return htmlfill.render(
                 render('admin/settings/settings.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False)
 
         try:
             settings = [
                 ('title', 'rhodecode_title'),
                 ('realm', 'rhodecode_realm'),
                 ('pre_code', 'rhodecode_pre_code'),
                 ('post_code', 'rhodecode_post_code'),
                 ('captcha_public_key', 'rhodecode_captcha_public_key'),
                 ('captcha_private_key', 'rhodecode_captcha_private_key'),
             ]
             for setting, form_key in settings:
                 sett = SettingsModel().create_or_update_setting(
                     setting, form_result[form_key])
                 Session().add(sett)
 
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated application settings'), category='success')
         except Exception:
             log.exception("Exception while updating application settings")
             h.flash(
                 _('Error occurred during updating application settings'),
                 category='error')
 
         return redirect(url('admin_settings_global'))
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_global(self):
         """GET /admin/settings/global: All items in the collection"""
         # url('admin_settings_global')
         c.active = 'global'
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_visual_update(self):
         """POST /admin/settings/visual: All items in the collection"""
         # url('admin_settings_visual')
         c.active = 'visual'
         application_form = ApplicationVisualisationForm()()
         try:
             form_result = application_form.to_python(dict(request.POST))
         except formencode.Invalid as errors:
             return htmlfill.render(
                 render('admin/settings/settings.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
 
         try:
             settings = [
                 ('show_public_icon', 'rhodecode_show_public_icon', 'bool'),
                 ('show_private_icon', 'rhodecode_show_private_icon', 'bool'),
                 ('stylify_metatags', 'rhodecode_stylify_metatags', 'bool'),
                 ('repository_fields', 'rhodecode_repository_fields', 'bool'),
                 ('dashboard_items', 'rhodecode_dashboard_items', 'int'),
                 ('admin_grid_items', 'rhodecode_admin_grid_items', 'int'),
                 ('show_version', 'rhodecode_show_version', 'bool'),
                 ('use_gravatar', 'rhodecode_use_gravatar', 'bool'),
                 ('markup_renderer', 'rhodecode_markup_renderer', 'unicode'),
                 ('gravatar_url', 'rhodecode_gravatar_url', 'unicode'),
                 ('clone_uri_tmpl', 'rhodecode_clone_uri_tmpl', 'unicode'),
                 ('support_url', 'rhodecode_support_url', 'unicode'),
                 ('show_revision_number', 'rhodecode_show_revision_number', 'bool'),
                 ('show_sha_length', 'rhodecode_show_sha_length', 'int'),
             ]
             for setting, form_key, type_ in settings:
                 sett = SettingsModel().create_or_update_setting(
                     setting, form_result[form_key], type_)
                 Session().add(sett)
 
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated visualisation settings'), category='success')
         except Exception:
             log.exception("Exception updating visualization settings")
             h.flash(_('Error occurred during updating '
                       'visualisation settings'),
                     category='error')
 
         return redirect(url('admin_settings_visual'))
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_visual(self):
         """GET /admin/settings/visual: All items in the collection"""
         # url('admin_settings_visual')
         c.active = 'visual'
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_issuetracker_test(self):
         if request.is_xhr:
             return h.urlify_commit_message(
                 request.POST.get('test_text', ''),
                 'repo_group/test_repo1')
         else:
             raise HTTPBadRequest()
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_issuetracker_delete(self):
         uid = request.POST.get('uid')
         IssueTrackerSettingsModel().delete_entries(uid)
         h.flash(_('Removed issue tracker entry'), category='success')
         return redirect(url('admin_settings_issuetracker'))
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_issuetracker(self):
         """GET /admin/settings/issue-tracker: All items in the collection"""
         # url('admin_settings_issuetracker')
         c.active = 'issuetracker'
         defaults = SettingsModel().get_all_settings()
 
         entry_key = 'rhodecode_issuetracker_pat_'
 
         c.issuetracker_entries = {}
         for k, v in defaults.items():
             if k.startswith(entry_key):
                 uid = k[len(entry_key):]
                 c.issuetracker_entries[uid] = None
 
         for uid in c.issuetracker_entries:
             c.issuetracker_entries[uid] = AttributeDict({
                 'pat': defaults.get('rhodecode_issuetracker_pat_' + uid),
                 'url': defaults.get('rhodecode_issuetracker_url_' + uid),
                 'pref': defaults.get('rhodecode_issuetracker_pref_' + uid),
                 'desc': defaults.get('rhodecode_issuetracker_desc_' + uid),
             })
 
         return render('admin/settings/settings.html')
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_issuetracker_save(self):
         settings_model = IssueTrackerSettingsModel()
 
         form = IssueTrackerPatternsForm()().to_python(request.POST)
         for uid in form['delete_patterns']:
             settings_model.delete_entries(uid)
 
         for pattern in form['patterns']:
             for setting, value, type_ in pattern:
                 sett = settings_model.create_or_update_setting(
                     setting, value, type_)
                 Session().add(sett)
 
             Session().commit()
 
         SettingsModel().invalidate_settings_cache()
         h.flash(_('Updated issue tracker entries'), category='success')
         return redirect(url('admin_settings_issuetracker'))
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_email_update(self):
         """POST /admin/settings/email: All items in the collection"""
         # url('admin_settings_email')
         c.active = 'email'
 
         test_email = request.POST.get('test_email')
 
         if not test_email:
             h.flash(_('Please enter email address'), category='error')
             return redirect(url('admin_settings_email'))
 
         email_kwargs = {
             'date': datetime.datetime.now(),
             'user': c.rhodecode_user,
             'rhodecode_version': c.rhodecode_version
         }
 
         (subject, headers, email_body,
          email_body_plaintext) = EmailNotificationModel().render_email(
             EmailNotificationModel.TYPE_EMAIL_TEST, **email_kwargs)
 
         recipients = [test_email] if test_email else None
 
         run_task(tasks.send_email, recipients, subject,
                  email_body_plaintext, email_body)
 
         h.flash(_('Send email task created'), category='success')
         return redirect(url('admin_settings_email'))
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_email(self):
         """GET /admin/settings/email: All items in the collection"""
         # url('admin_settings_email')
         c.active = 'email'
         c.rhodecode_ini = rhodecode.CONFIG
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_hooks_update(self):
         """POST or DELETE /admin/settings/hooks: All items in the collection"""
         # url('admin_settings_hooks')
         c.active = 'hooks'
         if c.visual.allow_custom_hooks_settings:
             ui_key = request.POST.get('new_hook_ui_key')
             ui_value = request.POST.get('new_hook_ui_value')
 
             hook_id = request.POST.get('hook_id')
             new_hook = False
 
             model = SettingsModel()
             try:
                 if ui_value and ui_key:
                     model.create_or_update_hook(ui_key, ui_value)
                     h.flash(_('Added new hook'), category='success')
                     new_hook = True
                 elif hook_id:
                     RhodeCodeUi.delete(hook_id)
                     Session().commit()
 
                 # check for edits
                 update = False
                 _d = request.POST.dict_of_lists()
                 for k, v in zip(_d.get('hook_ui_key', []),
                                 _d.get('hook_ui_value_new', [])):
                     model.create_or_update_hook(k, v)
                     update = True
 
                 if update and not new_hook:
                     h.flash(_('Updated hooks'), category='success')
                 Session().commit()
             except Exception:
                 log.exception("Exception during hook creation")
                 h.flash(_('Error occurred during hook creation'),
                         category='error')
 
         return redirect(url('admin_settings_hooks'))
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_hooks(self):
         """GET /admin/settings/hooks: All items in the collection"""
         # url('admin_settings_hooks')
         c.active = 'hooks'
 
         model = SettingsModel()
         c.hooks = model.get_builtin_hooks()
         c.custom_hooks = model.get_custom_hooks()
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding="UTF-8",
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_search(self):
         """GET /admin/settings/search: All items in the collection"""
         # url('admin_settings_search')
         c.active = 'search'
 
         from rhodecode.lib.index import searcher_from_config
         searcher = searcher_from_config(config)
         c.statistics = searcher.statistics()
 
         return render('admin/settings/settings.html')
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_system(self):
         """GET /admin/settings/system: All items in the collection"""
         # url('admin_settings_system')
         snapshot = str2bool(request.GET.get('snapshot'))
         c.active = 'system'
 
         defaults = self._form_defaults()
         c.rhodecode_ini = rhodecode.CONFIG
         c.rhodecode_update_url = defaults.get('rhodecode_update_url')
         server_info = ScmModel().get_server_info(request.environ)
         for key, val in server_info.iteritems():
             setattr(c, key, val)
 
         if c.disk['percent'] > 90:
             h.flash(h.literal(_(
                 'Critical: your disk space is very low <b>%s%%</b> used' %
                 c.disk['percent'])), 'error')
         elif c.disk['percent'] > 70:
             h.flash(h.literal(_(
                 'Warning: your disk space is running low <b>%s%%</b> used' %
                 c.disk['percent'])), 'warning')
 
         try:
             c.uptime_age = h._age(
                 h.time_to_datetime(c.boot_time), False, show_suffix=False)
         except TypeError:
             c.uptime_age = c.boot_time
 
         try:
             c.system_memory = '%s/%s, %s%% (%s%%) used%s' % (
                 h.format_byte_size_binary(c.memory['used']),
                 h.format_byte_size_binary(c.memory['total']),
                 c.memory['percent2'],
                 c.memory['percent'],
                 ' %s' % c.memory['error'] if 'error' in c.memory else '')
         except TypeError:
             c.system_memory = 'NOT AVAILABLE'
 
         rhodecode_ini_safe = rhodecode.CONFIG.copy()
         blacklist = [
             'rhodecode_license_key',
             'routes.map',
             'pylons.h',
             'pylons.app_globals',
             'pylons.environ_config',
             'sqlalchemy.db1.url',
             ('app_conf', 'sqlalchemy.db1.url')
         ]
         for k in blacklist:
             if isinstance(k, tuple):
                 section, key = k
                 if section in rhodecode_ini_safe:
                     rhodecode_ini_safe[section].pop(key, None)
             else:
                 rhodecode_ini_safe.pop(k, None)
 
         c.rhodecode_ini_safe = rhodecode_ini_safe
 
         # TODO: marcink, figure out how to allow only selected users to do this
         c.allowed_to_snapshot = False
 
         if snapshot:
             if c.allowed_to_snapshot:
                 return render('admin/settings/settings_system_snapshot.html')
             else:
                 h.flash('You are not allowed to do this', category='warning')
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False)
 
     @staticmethod
     def get_update_data(update_url):
         """Return the JSON update data."""
         ver = rhodecode.__version__
         log.debug('Checking for upgrade on `%s` server', update_url)
         opener = urllib2.build_opener()
         opener.addheaders = [('User-agent', 'RhodeCode-SCM/%s' % ver)]
         response = opener.open(update_url)
         response_data = response.read()
         data = json.loads(response_data)
 
         return data
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_system_update(self):
         """GET /admin/settings/system/updates: All items in the collection"""
         # url('admin_settings_system_update')
         defaults = self._form_defaults()
         update_url = defaults.get('rhodecode_update_url', '')
 
         _err = lambda s: '<div style="color:#ff8888; padding:4px 0px">%s</div>' % (s)
         try:
             data = self.get_update_data(update_url)
         except urllib2.URLError as e:
             log.exception("Exception contacting upgrade server")
             return _err('Failed to contact upgrade server: %r' % e)
         except ValueError as e:
             log.exception("Bad data sent from update server")
             return _err('Bad data sent from update server')
 
         latest = data['versions'][0]
 
         c.update_url = update_url
         c.latest_data = latest
         c.latest_ver = latest['version']
         c.cur_ver = rhodecode.__version__
         c.should_upgrade = False
 
         if (packaging.version.Version(c.latest_ver) >
                 packaging.version.Version(c.cur_ver)):
             c.should_upgrade = True
         c.important_notices = latest['general']
 
         return render('admin/settings/settings_system_update.html')
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_supervisor(self):
         c.rhodecode_ini = rhodecode.CONFIG
         c.active = 'supervisor'
 
         c.supervisor_procs = OrderedDict([
             (SUPERVISOR_MASTER, {}),
         ])
 
         c.log_size = 10240
         supervisor = SupervisorModel()
 
         _connection = supervisor.get_connection(
             c.rhodecode_ini.get('supervisor.uri'))
         c.connection_error = None
         try:
             _connection.supervisor.getAllProcessInfo()
         except Exception as e:
             c.connection_error = str(e)
             log.exception("Exception reading supervisor data")
             return render('admin/settings/settings.html')
 
         groupid = c.rhodecode_ini.get('supervisor.group_id')
 
         # feed our group processes to the main
         for proc in supervisor.get_group_processes(_connection, groupid):
             c.supervisor_procs[proc['name']] = {}
 
         for k in c.supervisor_procs.keys():
             try:
                 # master process info
                 if k == SUPERVISOR_MASTER:
                     _data = supervisor.get_master_state(_connection)
                     _data['name'] = 'supervisor master'
                     _data['description'] = 'pid %s, id: %s, ver: %s' % (
                         _data['pid'], _data['id'], _data['ver'])
                     c.supervisor_procs[k] = _data
                 else:
                     procid = groupid + ":" + k
                     c.supervisor_procs[k] = supervisor.get_process_info(_connection, procid)
             except Exception as e:
                 log.exception("Exception reading supervisor data")
                 c.supervisor_procs[k] = {'_rhodecode_error': str(e)}
 
         return render('admin/settings/settings.html')
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_supervisor_log(self, procid):
         import rhodecode
         c.rhodecode_ini = rhodecode.CONFIG
         c.active = 'supervisor_tail'
 
         supervisor = SupervisorModel()
         _connection = supervisor.get_connection(c.rhodecode_ini.get('supervisor.uri'))
         groupid = c.rhodecode_ini.get('supervisor.group_id')
         procid = groupid + ":" + procid if procid != SUPERVISOR_MASTER else procid
 
         c.log_size = 10240
         offset = abs(safe_int(request.GET.get('offset', c.log_size))) * -1
         c.log = supervisor.read_process_log(_connection, procid, offset, 0)
 
         return render('admin/settings/settings.html')
 
     @HasPermissionAllDecorator('hg.admin')
     @auth.CSRFRequired()
     def settings_labs_update(self):
         """POST /admin/settings/labs: All items in the collection"""
         # url('admin_settings/labs', method={'POST'})
         c.active = 'labs'
 
         application_form = LabsSettingsForm()()
         try:
             form_result = application_form.to_python(dict(request.POST))
         except formencode.Invalid as errors:
             h.flash(
                 _('Some form inputs contain invalid data.'),
                 category='error')
             return htmlfill.render(
                 render('admin/settings/settings.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding='UTF-8',
                 force_defaults=False
             )
 
         try:
             session = Session()
             for setting in _LAB_SETTINGS:
                 setting_name = setting.key[len('rhodecode_'):]
                 sett = SettingsModel().create_or_update_setting(
                     setting_name, form_result[setting.key], setting.type)
                 session.add(sett)
 
         except Exception:
             log.exception('Exception while updating lab settings')
             h.flash(_('Error occurred during updating labs settings'),
                     category='error')
         else:
             Session().commit()
             SettingsModel().invalidate_settings_cache()
             h.flash(_('Updated Labs settings'), category='success')
             return redirect(url('admin_settings_labs'))
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding='UTF-8',
             force_defaults=False)
 
     @HasPermissionAllDecorator('hg.admin')
     def settings_labs(self):
         """GET /admin/settings/labs: All items in the collection"""
         # url('admin_settings_labs')
         if not c.labs_active:
             redirect(url('admin_settings'))
 
         c.active = 'labs'
         c.lab_settings = _LAB_SETTINGS
 
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=self._form_defaults(),
             encoding='UTF-8',
             force_defaults=False)
 
     def _form_defaults(self):
         defaults = SettingsModel().get_all_settings()
         defaults.update(self._get_hg_ui_settings())
         defaults.update({
             'new_svn_branch': '',
             'new_svn_tag': '',
         })
         return defaults
 
 
 # :param key: name of the setting including the 'rhodecode_' prefix
 # :param type: the RhodeCodeSetting type to use.
 # :param group: the i18ned group in which we should dispaly this setting
 # :param label: the i18ned label we should display for this setting
 # :param help: the i18ned help we should dispaly for this setting
 LabSetting = collections.namedtuple(
     'LabSetting', ('key', 'type', 'group', 'label', 'help'))
 
 
 # This list has to be kept in sync with the form
 # rhodecode.model.forms.LabsSettingsForm.
 _LAB_SETTINGS = [
     LabSetting(
         key='rhodecode_proxy_subversion_http_requests',
         type='bool',
         group=lazy_ugettext('Subversion HTTP Support'),
         label=lazy_ugettext('Proxy subversion HTTP requests'),
         help=''  # Do not translate the empty string!
     ),
     LabSetting(
         key='rhodecode_subversion_http_server_url',
         type='str',
         group=lazy_ugettext('Subversion HTTP Server URL'),
         label='',  # Do not translate the empty string!
         help=lazy_ugettext('e.g. http://localhost:8080/')
     ),
 ]