settings: use invalidate after updating settings.

rhodecode/controllers/admin/settings.py

@@ -1,852 +1,854 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.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'))
         c.navlist = navigation.get_navlist(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')
         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'
 
         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_hg_use_rebase_for_merging',
         type='bool',
         group=lazy_ugettext('Mercurial server-side merge'),
         label=lazy_ugettext('Use rebase instead of creating a merge commit when merging via web interface'),
         help=''  # Do not translate the empty string!
     ),
     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/')
     ),
 ]
 
 
 NavListEntry = collections.namedtuple('NavListEntry', ['key', 'name', 'url'])
 
 
 class NavEntry(object):
 
     def __init__(self, key, name, view_name, pyramid=False):
         self.key = key
         self.name = name
         self.view_name = view_name
         self.pyramid = pyramid
 
     def generate_url(self, request):
         if self.pyramid:
             if hasattr(request, 'route_path'):
                 return request.route_path(self.view_name)
             else:
                 # TODO: johbo: Remove this after migrating to pyramid.
                 # We need the pyramid request here to generate URLs to pyramid
                 # views from within pylons views.
                 from pyramid.threadlocal import get_current_request
                 pyramid_request = get_current_request()
                 return pyramid_request.route_path(self.view_name)
         else:
             return url(self.view_name)
 
 
 class NavigationRegistry(object):
 
     _base_entries = [
         NavEntry('global', lazy_ugettext('Global'), 'admin_settings_global'),
         NavEntry('vcs', lazy_ugettext('VCS'), 'admin_settings_vcs'),
         NavEntry('visual', lazy_ugettext('Visual'), 'admin_settings_visual'),
         NavEntry('mapping', lazy_ugettext('Remap and Rescan'),
                  'admin_settings_mapping'),
         NavEntry('issuetracker', lazy_ugettext('Issue Tracker'),
                  'admin_settings_issuetracker'),
         NavEntry('email', lazy_ugettext('Email'), 'admin_settings_email'),
         NavEntry('hooks', lazy_ugettext('Hooks'), 'admin_settings_hooks'),
         NavEntry('search', lazy_ugettext('Full Text Search'),
                  'admin_settings_search'),
         NavEntry('system', lazy_ugettext('System Info'),
                  'admin_settings_system'),
         NavEntry('open_source', lazy_ugettext('Open Source Licenses'),
                  'admin_settings_open_source', pyramid=True),
         # TODO: marcink: we disable supervisor now until the supervisor stats
         # page is fixed in the nix configuration
         # NavEntry('supervisor', lazy_ugettext('Supervisor'),
         #          'admin_settings_supervisor'),
     ]
 
     def __init__(self):
         self._registered_entries = collections.OrderedDict([
             (item.key, item) for item in self.__class__._base_entries
         ])
 
         # Add the labs entry when it's activated.
         labs_active = str2bool(
             rhodecode.CONFIG.get('labs_settings_active', 'false'))
         if labs_active:
             self.add_entry(
                 NavEntry('labs', lazy_ugettext('Labs'), 'admin_settings_labs'))
 
     def add_entry(self, entry):
         self._registered_entries[entry.key] = entry
 
     def get_navlist(self, request):
         navlist = [NavListEntry(i.key, i.name, i.generate_url(request))
                    for i in self._registered_entries.values()]
         return navlist
 
 navigation = NavigationRegistry()

rhodecode/lib/caches.py

@@ -1,220 +1,226 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2015-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/
 
 
 import beaker
 import logging
 
 from beaker.cache import _cache_decorate, cache_regions, region_invalidate
 
 from rhodecode.lib.utils import safe_str, md5
 from rhodecode.model.db import Session, CacheKey, IntegrityError
 
 log = logging.getLogger(__name__)
 
 FILE_TREE = 'cache_file_tree'
 FILE_TREE_META = 'cache_file_tree_metadata'
 FILE_SEARCH_TREE_META = 'cache_file_search_metadata'
 SUMMARY_STATS = 'cache_summary_stats'
 
 # This list of caches gets purged when invalidation happens
 USED_REPO_CACHES = (FILE_TREE, FILE_TREE_META, FILE_TREE_META)
 
 DEFAULT_CACHE_MANAGER_CONFIG = {
     'type': 'memorylru_base',
     'max_items': 10240,
     'key_length': 256,
     'enabled': True
 }
 
 
 def configure_cache_region(
         region_name, region_kw, default_cache_kw, default_expire=60):
     default_type = default_cache_kw.get('type', 'memory')
     default_lock_dir = default_cache_kw.get('lock_dir')
     default_data_dir = default_cache_kw.get('data_dir')
 
     region_kw['lock_dir'] = region_kw.get('lock_dir', default_lock_dir)
     region_kw['data_dir'] = region_kw.get('data_dir', default_data_dir)
     region_kw['type'] = region_kw.get('type', default_type)
     region_kw['expire'] = int(region_kw.get('expire', default_expire))
 
     beaker.cache.cache_regions[region_name] = region_kw
 
 
 def get_cache_manager(region_name, cache_name, custom_ttl=None):
     """
     Creates a Beaker cache manager. Such instance can be used like that::
 
     _namespace = caches.get_repo_namespace_key(caches.XXX, repo_name)
     cache_manager = caches.get_cache_manager('repo_cache_long', _namespace)
     _cache_key = caches.compute_key_from_params(repo_name, commit.raw_id)
     def heavy_compute():
         ...
     result = cache_manager.get(_cache_key, createfunc=heavy_compute)
 
     :param region_name: region from ini file
     :param cache_name: custom cache name, usually prefix+repo_name. eg
         file_switcher_repo1
     :param custom_ttl: override .ini file timeout on this cache
     :return: instance of cache manager
     """
 
     cache_config = cache_regions.get(region_name, DEFAULT_CACHE_MANAGER_CONFIG)
     if custom_ttl:
         log.debug('Updating region %s with custom ttl: %s',
                   region_name, custom_ttl)
         cache_config.update({'expire': custom_ttl})
 
     return beaker.cache.Cache._get_cache(cache_name, cache_config)
 
 
 def clear_cache_manager(cache_manager):
+    """
+    namespace = 'foobar'
+    cache_manager = get_cache_manager('repo_cache_long', namespace)
+    clear_cache_manager(cache_manager)
+    """
+
     log.debug('Clearing all values for cache manager %s', cache_manager)
     cache_manager.clear()
 
 
 def clear_repo_caches(repo_name):
     # invalidate cache manager for this repo
     for prefix in USED_REPO_CACHES:
         namespace = get_repo_namespace_key(prefix, repo_name)
         cache_manager = get_cache_manager('repo_cache_long', namespace)
         clear_cache_manager(cache_manager)
 
 
 def compute_key_from_params(*args):
     """
     Helper to compute key from given params to be used in cache manager
     """
     return md5("_".join(map(safe_str, args)))
 
 
 def get_repo_namespace_key(prefix, repo_name):
     return '{0}_{1}'.format(prefix, compute_key_from_params(repo_name))
 
 
 def conditional_cache(region, prefix, condition, func):
     """
     Conditional caching function use like::
         def _c(arg):
             # heavy computation function
             return data
 
         # depending on the condition the compute is wrapped in cache or not
         compute = conditional_cache('short_term', 'cache_desc',
                                     condition=True, func=func)
         return compute(arg)
 
     :param region: name of cache region
     :param prefix: cache region prefix
     :param condition: condition for cache to be triggered, and
         return data cached
     :param func: wrapped heavy function to compute
 
     """
     wrapped = func
     if condition:
         log.debug('conditional_cache: True, wrapping call of '
                   'func: %s into %s region cache', region, func)
         cached_region = _cache_decorate((prefix,), None, None, region)
         wrapped = cached_region(func)
     return wrapped
 
 
 class ActiveRegionCache(object):
     def __init__(self, context):
         self.context = context
 
     def invalidate(self, *args, **kwargs):
         return False
 
     def compute(self):
         log.debug('Context cache: getting obj %s from cache', self.context)
         return self.context.compute_func(self.context.cache_key)
 
 
 class FreshRegionCache(ActiveRegionCache):
     def invalidate(self):
         log.debug('Context cache: invalidating cache for %s', self.context)
         region_invalidate(
             self.context.compute_func, None, self.context.cache_key)
         return True
 
 
 class InvalidationContext(object):
     def __repr__(self):
         return '<InvalidationContext:{}[{}]>'.format(
             self.repo_name, self.cache_type)
 
     def __init__(self, compute_func, repo_name, cache_type,
                  raise_exception=False):
         self.compute_func = compute_func
         self.repo_name = repo_name
         self.cache_type = cache_type
         self.cache_key = compute_key_from_params(
             repo_name, cache_type)
         self.raise_exception = raise_exception
 
     def get_cache_obj(self):
         cache_key = CacheKey.get_cache_key(
             self.repo_name, self.cache_type)
         cache_obj = CacheKey.get_active_cache(cache_key)
         if not cache_obj:
             cache_obj = CacheKey(cache_key, self.repo_name)
         return cache_obj
 
     def __enter__(self):
         """
         Test if current object is valid, and return CacheRegion function
         that does invalidation and calculation
         """
 
         self.cache_obj = self.get_cache_obj()
         if self.cache_obj.cache_active:
             # means our cache obj is existing and marked as it's
             # cache is not outdated, we return BaseInvalidator
             self.skip_cache_active_change = True
             return ActiveRegionCache(self)
 
         # the key is either not existing or set to False, we return
         # the real invalidator which re-computes value. We additionally set
         # the flag to actually update the Database objects
         self.skip_cache_active_change = False
         return FreshRegionCache(self)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
 
         if self.skip_cache_active_change:
             return
 
         try:
             self.cache_obj.cache_active = True
             Session().add(self.cache_obj)
             Session().commit()
         except IntegrityError:
             # if we catch integrity error, it means we inserted this object
             # assumption is that's really an edge race-condition case and
             # it's safe is to skip it
             Session().rollback()
         except Exception:
             log.exception('Failed to commit on cache key update')
             Session().rollback()
             if self.raise_exception:
                 raise

rhodecode/model/settings.py

@@ -1,690 +1,696 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/
 
 import hashlib
 import logging
 from collections import namedtuple
 from functools import wraps
 
 from rhodecode.lib import caches
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.utils2 import (
     Optional, AttributeDict, safe_str, remove_prefix, str2bool)
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi, RhodeCodeSetting)
 from rhodecode.model.meta import Session
 
 
 log = logging.getLogger(__name__)
 
 
 UiSetting = namedtuple(
     'UiSetting', ['section', 'key', 'value', 'active'])
 
 SOCIAL_PLUGINS_LIST = ['github', 'bitbucket', 'twitter', 'google']
 
 
 class SettingNotFound(Exception):
     def __init__(self):
         super(SettingNotFound, self).__init__('Setting is not found')
 
 
 class SettingsModel(BaseModel):
     BUILTIN_HOOKS = (
         RhodeCodeUi.HOOK_REPO_SIZE, RhodeCodeUi.HOOK_PUSH,
         RhodeCodeUi.HOOK_PRE_PUSH, RhodeCodeUi.HOOK_PULL,
         RhodeCodeUi.HOOK_PRE_PULL)
     HOOKS_SECTION = 'hooks'
 
     def __init__(self, sa=None, repo=None):
         self.repo = repo
         self.UiDbModel = RepoRhodeCodeUi if repo else RhodeCodeUi
         self.SettingsDbModel = (
             RepoRhodeCodeSetting if repo else RhodeCodeSetting)
         super(SettingsModel, self).__init__(sa)
 
     def get_ui_by_key(self, key):
         q = self.UiDbModel.query()
         q = q.filter(self.UiDbModel.ui_key == key)
         q = self._filter_by_repo(RepoRhodeCodeUi, q)
         return q.scalar()
 
     def get_ui_by_section(self, section):
         q = self.UiDbModel.query()
         q = q.filter(self.UiDbModel.ui_section == section)
         q = self._filter_by_repo(RepoRhodeCodeUi, q)
         return q.all()
 
     def get_ui_by_section_and_key(self, section, key):
         q = self.UiDbModel.query()
         q = q.filter(self.UiDbModel.ui_section == section)
         q = q.filter(self.UiDbModel.ui_key == key)
         q = self._filter_by_repo(RepoRhodeCodeUi, q)
         return q.scalar()
 
     def get_ui(self, section=None, key=None):
         q = self.UiDbModel.query()
         q = self._filter_by_repo(RepoRhodeCodeUi, q)
 
         if section:
             q = q.filter(self.UiDbModel.ui_section == section)
         if key:
             q = q.filter(self.UiDbModel.ui_key == key)
 
         # TODO: mikhail: add caching
         result = [
             UiSetting(
                 section=safe_str(r.ui_section), key=safe_str(r.ui_key),
                 value=safe_str(r.ui_value), active=r.ui_active
             )
             for r in q.all()
         ]
         return result
 
     def get_builtin_hooks(self):
         q = self.UiDbModel.query()
         q = q.filter(self.UiDbModel.ui_key.in_(self.BUILTIN_HOOKS))
         return self._get_hooks(q)
 
     def get_custom_hooks(self):
         q = self.UiDbModel.query()
         q = q.filter(~self.UiDbModel.ui_key.in_(self.BUILTIN_HOOKS))
         return self._get_hooks(q)
 
     def create_ui_section_value(self, section, val, key=None, active=True):
         new_ui = self.UiDbModel()
         new_ui.ui_section = section
         new_ui.ui_value = val
         new_ui.ui_active = active
 
         if self.repo:
             repo = self._get_repo(self.repo)
             repository_id = repo.repo_id
             new_ui.repository_id = repository_id
 
         if not key:
             # keys are unique so they need appended info
             if self.repo:
                 key = hashlib.sha1(
                     '{}{}{}'.format(section, val, repository_id)).hexdigest()
             else:
                 key = hashlib.sha1('{}{}'.format(section, val)).hexdigest()
 
         new_ui.ui_key = key
 
         Session().add(new_ui)
         return new_ui
 
     def create_or_update_hook(self, key, value):
         ui = (
             self.get_ui_by_section_and_key(self.HOOKS_SECTION, key) or
             self.UiDbModel())
         ui.ui_section = self.HOOKS_SECTION
         ui.ui_active = True
         ui.ui_key = key
         ui.ui_value = value
 
         if self.repo:
             repo = self._get_repo(self.repo)
             repository_id = repo.repo_id
             ui.repository_id = repository_id
 
         Session().add(ui)
         return ui
 
     def delete_ui(self, id_):
         ui = self.UiDbModel.get(id_)
         if not ui:
             raise SettingNotFound()
         Session().delete(ui)
 
     def get_setting_by_name(self, name):
         q = self._get_settings_query()
         q = q.filter(self.SettingsDbModel.app_settings_name == name)
         return q.scalar()
 
     def create_or_update_setting(
             self, name, val=Optional(''), type_=Optional('unicode')):
         """
         Creates or updates RhodeCode setting. If updates is triggered it will
         only update parameters that are explicityl set Optional instance will
         be skipped
 
         :param name:
         :param val:
         :param type_:
         :return:
         """
 
         res = self.get_setting_by_name(name)
         repo = self._get_repo(self.repo) if self.repo else None
 
         if not res:
             val = Optional.extract(val)
             type_ = Optional.extract(type_)
 
             args = (
                 (repo.repo_id, name, val, type_)
                 if repo else (name, val, type_))
             res = self.SettingsDbModel(*args)
 
         else:
             if self.repo:
                 res.repository_id = repo.repo_id
 
             res.app_settings_name = name
             if not isinstance(type_, Optional):
                 # update if set
                 res.app_settings_type = type_
             if not isinstance(val, Optional):
                 # update if set
                 res.app_settings_value = val
 
         Session.add(res)
         return res
 
+    def invalidate_settings_cache(self):
+        namespace = 'rhodecode_settings'
+        cache_manager = caches.get_cache_manager('sql_cache_short', namespace)
+        caches.clear_cache_manager(cache_manager)
+
     def get_all_settings(self, cache=False):
         def _compute():
             q = self._get_settings_query()
             if not q:
                 raise Exception('Could not get application settings !')
 
             settings = {
                 'rhodecode_' + result.app_settings_name: result.app_settings_value
                 for result in q
             }
             return settings
 
         if cache:
+            log.debug('Fetching app settings using cache')
             repo = self._get_repo(self.repo) if self.repo else None
             namespace = 'rhodecode_settings'
             cache_manager = caches.get_cache_manager(
                 'sql_cache_short', namespace)
             _cache_key = (
                 "get_repo_{}_settings".format(repo.repo_id)
                 if repo else "get_app_settings")
 
             return cache_manager.get(_cache_key, createfunc=_compute)
 
         else:
             return _compute()
 
     def get_auth_settings(self):
         q = self._get_settings_query()
         q = q.filter(
             self.SettingsDbModel.app_settings_name.startswith('auth_'))
         rows = q.all()
         auth_settings = {
             row.app_settings_name: row.app_settings_value for row in rows}
         return auth_settings
 
     def get_auth_plugins(self):
         auth_plugins = self.get_setting_by_name("auth_plugins")
         return auth_plugins.app_settings_value
 
     def get_default_repo_settings(self, strip_prefix=False):
         q = self._get_settings_query()
         q = q.filter(
             self.SettingsDbModel.app_settings_name.startswith('default_'))
         rows = q.all()
 
         result = {}
         for row in rows:
             key = row.app_settings_name
             if strip_prefix:
                 key = remove_prefix(key, prefix='default_')
             result.update({key: row.app_settings_value})
         return result
 
     def get_repo(self):
         repo = self._get_repo(self.repo)
         if not repo:
             raise Exception(
                 'Repository {} cannot be found'.format(self.repo))
         return repo
 
     def _filter_by_repo(self, model, query):
         if self.repo:
             repo = self.get_repo()
             query = query.filter(model.repository_id == repo.repo_id)
         return query
 
     def _get_hooks(self, query):
         query = query.filter(self.UiDbModel.ui_section == self.HOOKS_SECTION)
         query = self._filter_by_repo(RepoRhodeCodeUi, query)
         return query.all()
 
     def _get_settings_query(self):
         q = self.SettingsDbModel.query()
         return self._filter_by_repo(RepoRhodeCodeSetting, q)
 
     def list_enabled_social_plugins(self, settings):
         enabled = []
         for plug in SOCIAL_PLUGINS_LIST:
             if str2bool(settings.get('rhodecode_auth_{}_enabled'.format(plug)
                                      )):
                 enabled.append(plug)
         return enabled
 
 
 def assert_repo_settings(func):
     @wraps(func)
     def _wrapper(self, *args, **kwargs):
         if not self.repo_settings:
             raise Exception('Repository is not specified')
         return func(self, *args, **kwargs)
     return _wrapper
 
 
 class IssueTrackerSettingsModel(object):
     INHERIT_SETTINGS = 'inherit_issue_tracker_settings'
     SETTINGS_PREFIX = 'issuetracker_'
 
     def __init__(self, sa=None, repo=None):
         self.global_settings = SettingsModel(sa=sa)
         self.repo_settings = SettingsModel(sa=sa, repo=repo) if repo else None
 
     @property
     def inherit_global_settings(self):
         if not self.repo_settings:
             return True
         setting = self.repo_settings.get_setting_by_name(self.INHERIT_SETTINGS)
         return setting.app_settings_value if setting else True
 
     @inherit_global_settings.setter
     def inherit_global_settings(self, value):
         if self.repo_settings:
             settings = self.repo_settings.create_or_update_setting(
                 self.INHERIT_SETTINGS, value, type_='bool')
             Session().add(settings)
 
     def _get_keyname(self, key, uid, prefix=''):
         return '{0}{1}{2}_{3}'.format(
             prefix, self.SETTINGS_PREFIX, key, uid)
 
     def _make_dict_for_settings(self, qs):
         prefix_match = self._get_keyname('pat', '', 'rhodecode_')
 
         issuetracker_entries = {}
         # create keys
         for k, v in qs.items():
             if k.startswith(prefix_match):
                 uid = k[len(prefix_match):]
                 issuetracker_entries[uid] = None
 
         # populate
         for uid in issuetracker_entries:
             issuetracker_entries[uid] = AttributeDict({
                 'pat': qs.get(self._get_keyname('pat', uid, 'rhodecode_')),
                 'url': qs.get(self._get_keyname('url', uid, 'rhodecode_')),
                 'pref': qs.get(self._get_keyname('pref', uid, 'rhodecode_')),
                 'desc': qs.get(self._get_keyname('desc', uid, 'rhodecode_')),
             })
         return issuetracker_entries
 
     def get_global_settings(self, cache=False):
         """
         Returns list of global issue tracker settings
         """
         defaults = self.global_settings.get_all_settings(cache=cache)
         settings = self._make_dict_for_settings(defaults)
         return settings
 
     def get_repo_settings(self, cache=False):
         """
         Returns list of issue tracker settings per repository
         """
         if not self.repo_settings:
             raise Exception('Repository is not specified')
         all_settings = self.repo_settings.get_all_settings(cache=cache)
         settings = self._make_dict_for_settings(all_settings)
         return settings
 
     def get_settings(self, cache=False):
         if self.inherit_global_settings:
             return self.get_global_settings(cache=cache)
         else:
             return self.get_repo_settings(cache=cache)
 
     def delete_entries(self, uid):
         if self.repo_settings:
             all_patterns = self.get_repo_settings()
             settings_model = self.repo_settings
         else:
             all_patterns = self.get_global_settings()
             settings_model = self.global_settings
         entries = all_patterns.get(uid)
 
         for del_key in entries:
             setting_name = self._get_keyname(del_key, uid)
             entry = settings_model.get_setting_by_name(setting_name)
             if entry:
                 Session().delete(entry)
 
         Session().commit()
 
     def create_or_update_setting(
             self, name, val=Optional(''), type_=Optional('unicode')):
         if self.repo_settings:
             setting = self.repo_settings.create_or_update_setting(
                 name, val, type_)
         else:
             setting = self.global_settings.create_or_update_setting(
                 name, val, type_)
         return setting
 
 
 class VcsSettingsModel(object):
 
     INHERIT_SETTINGS = 'inherit_vcs_settings'
     GENERAL_SETTINGS = ('use_outdated_comments', 'pr_merge_enabled')
     HOOKS_SETTINGS = (
         ('hooks', 'changegroup.repo_size'),
         ('hooks', 'changegroup.push_logger'),
         ('hooks', 'outgoing.pull_logger'))
     HG_SETTINGS = (
         ('extensions', 'largefiles'), ('phases', 'publish'))
     GLOBAL_HG_SETTINGS = HG_SETTINGS + (('extensions', 'hgsubversion'), )
     SVN_BRANCH_SECTION = 'vcs_svn_branch'
     SVN_TAG_SECTION = 'vcs_svn_tag'
     SSL_SETTING = ('web', 'push_ssl')
     PATH_SETTING = ('paths', '/')
 
     def __init__(self, sa=None, repo=None):
         self.global_settings = SettingsModel(sa=sa)
         self.repo_settings = SettingsModel(sa=sa, repo=repo) if repo else None
         self._ui_settings = self.HG_SETTINGS + self.HOOKS_SETTINGS
         self._svn_sections = (self.SVN_BRANCH_SECTION, self.SVN_TAG_SECTION)
 
     @property
     @assert_repo_settings
     def inherit_global_settings(self):
         setting = self.repo_settings.get_setting_by_name(self.INHERIT_SETTINGS)
         return setting.app_settings_value if setting else True
 
     @inherit_global_settings.setter
     @assert_repo_settings
     def inherit_global_settings(self, value):
         self.repo_settings.create_or_update_setting(
             self.INHERIT_SETTINGS, value, type_='bool')
 
     def get_global_svn_branch_patterns(self):
         return self.global_settings.get_ui_by_section(self.SVN_BRANCH_SECTION)
 
     @assert_repo_settings
     def get_repo_svn_branch_patterns(self):
         return self.repo_settings.get_ui_by_section(self.SVN_BRANCH_SECTION)
 
     def get_global_svn_tag_patterns(self):
         return self.global_settings.get_ui_by_section(self.SVN_TAG_SECTION)
 
     @assert_repo_settings
     def get_repo_svn_tag_patterns(self):
         return self.repo_settings.get_ui_by_section(self.SVN_TAG_SECTION)
 
     def get_global_settings(self):
         return self._collect_all_settings(global_=True)
 
     @assert_repo_settings
     def get_repo_settings(self):
         return self._collect_all_settings(global_=False)
 
     @assert_repo_settings
     def create_or_update_repo_settings(
             self, data, inherit_global_settings=False):
         from rhodecode.model.scm import ScmModel
 
         self.inherit_global_settings = inherit_global_settings
 
         repo = self.repo_settings.get_repo()
         if not inherit_global_settings:
             if repo.repo_type == 'svn':
                 self.create_repo_svn_settings(data)
             else:
                 self.create_or_update_repo_hook_settings(data)
                 self.create_or_update_repo_pr_settings(data)
 
             if repo.repo_type == 'hg':
                 self.create_or_update_repo_hg_settings(data)
 
         ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
 
     @assert_repo_settings
     def create_or_update_repo_hook_settings(self, data):
         for section, key in self.HOOKS_SETTINGS:
             data_key = self._get_form_ui_key(section, key)
             if data_key not in data:
                 raise ValueError(
                     'The given data does not contain {} key'.format(data_key))
 
             active = data.get(data_key)
             repo_setting = self.repo_settings.get_ui_by_section_and_key(
                 section, key)
             if not repo_setting:
                 global_setting = self.global_settings.\
                     get_ui_by_section_and_key(section, key)
                 self.repo_settings.create_ui_section_value(
                     section, global_setting.ui_value, key=key, active=active)
             else:
                 repo_setting.ui_active = active
                 Session().add(repo_setting)
 
     def update_global_hook_settings(self, data):
         for section, key in self.HOOKS_SETTINGS:
             data_key = self._get_form_ui_key(section, key)
             if data_key not in data:
                 raise ValueError(
                     'The given data does not contain {} key'.format(data_key))
             active = data.get(data_key)
             repo_setting = self.global_settings.get_ui_by_section_and_key(
                 section, key)
             repo_setting.ui_active = active
             Session().add(repo_setting)
 
     @assert_repo_settings
     def create_or_update_repo_pr_settings(self, data):
         return self._create_or_update_general_settings(
             self.repo_settings, data)
 
     def create_or_update_global_pr_settings(self, data):
         return self._create_or_update_general_settings(
             self.global_settings, data)
 
     @assert_repo_settings
     def create_repo_svn_settings(self, data):
         return self._create_svn_settings(self.repo_settings, data)
 
     def create_global_svn_settings(self, data):
         return self._create_svn_settings(self.global_settings, data)
 
     @assert_repo_settings
     def create_or_update_repo_hg_settings(self, data):
         largefiles, phases = self.HG_SETTINGS
         largefiles_key, phases_key = self._get_hg_settings(
             self.HG_SETTINGS, data)
         self._create_or_update_ui(
             self.repo_settings, *largefiles, value='',
             active=data[largefiles_key])
         self._create_or_update_ui(
             self.repo_settings, *phases, value=safe_str(data[phases_key]))
 
     def create_or_update_global_hg_settings(self, data):
         largefiles, phases, subversion = self.GLOBAL_HG_SETTINGS
         largefiles_key, phases_key, subversion_key = self._get_hg_settings(
             self.GLOBAL_HG_SETTINGS, data)
         self._create_or_update_ui(
             self.global_settings, *largefiles, value='',
             active=data[largefiles_key])
         self._create_or_update_ui(
             self.global_settings, *phases, value=safe_str(data[phases_key]))
         self._create_or_update_ui(
             self.global_settings, *subversion, active=data[subversion_key])
 
     def update_global_ssl_setting(self, value):
         self._create_or_update_ui(
             self.global_settings, *self.SSL_SETTING, value=value)
 
     def update_global_path_setting(self, value):
         self._create_or_update_ui(
             self.global_settings, *self.PATH_SETTING, value=value)
 
     @assert_repo_settings
     def delete_repo_svn_pattern(self, id_):
         self.repo_settings.delete_ui(id_)
 
     def delete_global_svn_pattern(self, id_):
         self.global_settings.delete_ui(id_)
 
     @assert_repo_settings
     def get_repo_ui_settings(self, section=None, key=None):
         global_uis = self.global_settings.get_ui(section, key)
         repo_uis = self.repo_settings.get_ui(section, key)
         filtered_repo_uis = self._filter_ui_settings(repo_uis)
         filtered_repo_uis_keys = [
             (s.section, s.key) for s in filtered_repo_uis]
 
         def _is_global_ui_filtered(ui):
             return (
                 (ui.section, ui.key) in filtered_repo_uis_keys
                 or ui.section in self._svn_sections)
 
         filtered_global_uis = [
             ui for ui in global_uis if not _is_global_ui_filtered(ui)]
 
         return filtered_global_uis + filtered_repo_uis
 
     def get_global_ui_settings(self, section=None, key=None):
         return self.global_settings.get_ui(section, key)
 
     def get_ui_settings(self, section=None, key=None):
         if not self.repo_settings or self.inherit_global_settings:
             return self.get_global_ui_settings(section, key)
         else:
             return self.get_repo_ui_settings(section, key)
 
     def get_svn_patterns(self, section=None):
         if not self.repo_settings:
             return self.get_global_ui_settings(section)
         else:
             return self.get_repo_ui_settings(section)
 
     @assert_repo_settings
     def get_repo_general_settings(self):
         global_settings = self.global_settings.get_all_settings()
         repo_settings = self.repo_settings.get_all_settings()
         filtered_repo_settings = self._filter_general_settings(repo_settings)
         global_settings.update(filtered_repo_settings)
         return global_settings
 
     def get_global_general_settings(self):
         return self.global_settings.get_all_settings()
 
     def get_general_settings(self):
         if not self.repo_settings or self.inherit_global_settings:
             return self.get_global_general_settings()
         else:
             return self.get_repo_general_settings()
 
     def get_repos_location(self):
         return self.global_settings.get_ui_by_key('/').ui_value
 
     def _filter_ui_settings(self, settings):
         filtered_settings = [
             s for s in settings if self._should_keep_setting(s)]
         return filtered_settings
 
     def _should_keep_setting(self, setting):
         keep = (
             (setting.section, setting.key) in self._ui_settings or
             setting.section in self._svn_sections)
         return keep
 
     def _filter_general_settings(self, settings):
         keys = ['rhodecode_{}'.format(key) for key in self.GENERAL_SETTINGS]
         return {
             k: settings[k]
             for k in settings if k in keys}
 
     def _collect_all_settings(self, global_=False):
         settings = self.global_settings if global_ else self.repo_settings
         result = {}
 
         for section, key in self._ui_settings:
             ui = settings.get_ui_by_section_and_key(section, key)
             result_key = self._get_form_ui_key(section, key)
             if ui:
                 if section in ('hooks', 'extensions'):
                     result[result_key] = ui.ui_active
                 else:
                     result[result_key] = ui.ui_value
 
         for name in self.GENERAL_SETTINGS:
             setting = settings.get_setting_by_name(name)
             if setting:
                 result_key = 'rhodecode_{}'.format(name)
                 result[result_key] = setting.app_settings_value
 
         return result
 
     def _get_form_ui_key(self, section, key):
         return '{section}_{key}'.format(
             section=section, key=key.replace('.', '_'))
 
     def _create_or_update_ui(
             self, settings, section, key, value=None, active=None):
         ui = settings.get_ui_by_section_and_key(section, key)
         if not ui:
             active = True if active is None else active
             settings.create_ui_section_value(
                 section, value, key=key, active=active)
         else:
             if active is not None:
                 ui.ui_active = active
             if value is not None:
                 ui.ui_value = value
             Session().add(ui)
 
     def _create_svn_settings(self, settings, data):
         svn_settings = {
             'new_svn_branch': self.SVN_BRANCH_SECTION,
             'new_svn_tag': self.SVN_TAG_SECTION
         }
         for key in svn_settings:
             if data.get(key):
                 settings.create_ui_section_value(svn_settings[key], data[key])
 
     def _create_or_update_general_settings(self, settings, data):
         for name in self.GENERAL_SETTINGS:
             data_key = 'rhodecode_{}'.format(name)
             if data_key not in data:
                 raise ValueError(
                     'The given data does not contain {} key'.format(data_key))
             setting = settings.create_or_update_setting(
                 name, data[data_key], 'bool')
             Session().add(setting)
 
     def _get_hg_settings(self, settings, data):
         data_keys = [self._get_form_ui_key(*s) for s in settings]
         for data_key in data_keys:
             if data_key not in data:
                 raise ValueError(
                     'The given data does not contain {} key'.format(data_key))
         return data_keys