pyramid: removed pylons reference from apps.

- this can be completly removed from those views as they are pyramid only.

rhodecode/apps/admin/views/open_source_licenses.py

@@ -1,48 +1,54 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017  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 collections
 import logging
 
-from pylons import tmpl_context as c
+
 from pyramid.view import view_config
 
 from rhodecode.apps._base import BaseAppView
 from rhodecode.apps.admin.navigation import navigation_list
 from rhodecode.lib.auth import (LoginRequired, HasPermissionAllDecorator)
 from rhodecode.lib.utils import read_opensource_licenses
 
 log = logging.getLogger(__name__)
 
 
 class OpenSourceLicensesAdminSettingsView(BaseAppView):
 
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        self._register_global_c(c)
+        return c
+
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_open_source', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def open_source_licenses(self):
+        c = self.load_default_context()
         c.active = 'open_source'
         c.navlist = navigation_list(self.request)
         c.opensource_licenses = collections.OrderedDict(
             sorted(read_opensource_licenses().items(), key=lambda t: t[0]))
 
-        return {}
+        return self._get_template_context(c)

rhodecode/apps/admin/views/sessions.py

@@ -1,96 +1,102 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017  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 logging
 
-from pylons import tmpl_context as c
 from pyramid.view import view_config
 from pyramid.httpexceptions import HTTPFound
 
 from rhodecode.apps._base import BaseAppView
 from rhodecode.apps.admin.navigation import navigation_list
 from rhodecode.lib.auth import (
     LoginRequired, HasPermissionAllDecorator, CSRFRequired)
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.lib import system_info
 from rhodecode.lib import user_sessions
 
 
 log = logging.getLogger(__name__)
 
 
 class AdminSessionSettingsView(BaseAppView):
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+
+        self._register_global_c(c)
+        return c
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_sessions', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_sessions(self):
+        c = self.load_default_context()
+
         c.active = 'sessions'
         c.navlist = navigation_list(self.request)
 
         c.cleanup_older_days = 60
         older_than_seconds = 60 * 60 * 24 * c.cleanup_older_days
 
         config = system_info.rhodecode_config().get_value()['value']['config']
         c.session_model = user_sessions.get_session_handler(
             config.get('beaker.session.type', 'memory'))(config)
 
         c.session_conf = c.session_model.config
         c.session_count = c.session_model.get_count()
         c.session_expired_count = c.session_model.get_expired_count(
             older_than_seconds)
 
-        return {}
+        return self._get_template_context(c)
 
     @LoginRequired()
     @CSRFRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_sessions_cleanup', request_method='POST')
     def settings_sessions_cleanup(self):
         _ = self.request.translate
         expire_days = safe_int(self.request.params.get('expire_days'))
 
         if expire_days is None:
             expire_days = 60
 
         older_than_seconds = 60 * 60 * 24 * expire_days
 
         config = system_info.rhodecode_config().get_value()['value']['config']
         session_model = user_sessions.get_session_handler(
             config.get('beaker.session.type', 'memory'))(config)
 
         try:
             session_model.clean_sessions(
                 older_than_seconds=older_than_seconds)
             self.request.session.flash(
                 _('Cleaned up old sessions'), queue='success')
         except user_sessions.CleanupCommand as msg:
             self.request.session.flash(msg.message, queue='warning')
         except Exception as e:
             log.exception('Failed session cleanup')
             self.request.session.flash(
                 _('Failed to cleanup up old sessions'), queue='error')
 
         redirect_to = self.request.resource_path(
             self.context, route_name='admin_settings_sessions')
         return HTTPFound(redirect_to)

rhodecode/apps/admin/views/system_info.py

@@ -1,204 +1,209 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017  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 logging
 import urllib2
 import packaging.version
 
-from pylons import tmpl_context as c
 from pyramid.view import view_config
 
 import rhodecode
 from rhodecode.apps._base import BaseAppView
 from rhodecode.apps.admin.navigation import navigation_list
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (LoginRequired, HasPermissionAllDecorator)
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.lib import system_info
 from rhodecode.lib.ext_json import json
 from rhodecode.model.settings import SettingsModel
 
 log = logging.getLogger(__name__)
 
 
 class AdminSystemInfoSettingsView(BaseAppView):
+    def load_default_context(self):
+        c = self._get_local_tmpl_context()
+        self._register_global_c(c)
+        return c
 
     @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
 
     def get_update_url(self):
         settings = SettingsModel().get_all_settings()
         return settings.get('rhodecode_update_url')
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_system', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings.mako')
     def settings_system_info(self):
         _ = self.request.translate
+        c = self.load_default_context()
 
         c.active = 'system'
         c.navlist = navigation_list(self.request)
 
         # TODO(marcink), figure out how to allow only selected users to do this
         c.allowed_to_snapshot = self._rhodecode_user.admin
 
         snapshot = str2bool(self.request.params.get('snapshot'))
 
         c.rhodecode_update_url = self.get_update_url()
         server_info = system_info.get_system_info(self.request.environ)
 
         for key, val in server_info.items():
             setattr(c, key, val)
 
         def val(name, subkey='human_value'):
             return server_info[name][subkey]
 
         def state(name):
             return server_info[name]['state']
 
         def val2(name):
             val = server_info[name]['human_value']
             state = server_info[name]['state']
             return val, state
 
         update_info_msg = _('Note: please make sure this server can '
                             'access `${url}` for the update link to work',
                             mapping=dict(url=c.rhodecode_update_url))
         c.data_items = [
             # update info
             (_('Update info'), h.literal(
                 '<span class="link" id="check_for_update" >%s.</span>' % (
                 _('Check for updates')) +
                 '<br/> <span >%s.</span>' % (update_info_msg)
             ), ''),
 
             # RhodeCode specific
             (_('RhodeCode Version'), val('rhodecode_app')['text'], state('rhodecode_app')),
             (_('RhodeCode Server IP'), val('server')['server_ip'], state('server')),
             (_('RhodeCode Server ID'), val('server')['server_id'], state('server')),
             (_('RhodeCode Configuration'), val('rhodecode_config')['path'], state('rhodecode_config')),
             (_('RhodeCode Certificate'), val('rhodecode_config')['cert_path'], state('rhodecode_config')),
             (_('Workers'), val('rhodecode_config')['config']['server:main'].get('workers', '?'), state('rhodecode_config')),
             (_('Worker Type'), val('rhodecode_config')['config']['server:main'].get('worker_class', 'sync'), state('rhodecode_config')),
             ('', '', ''),  # spacer
 
             # Database
             (_('Database'), val('database')['url'], state('database')),
             (_('Database version'), val('database')['version'], state('database')),
             ('', '', ''),  # spacer
 
             # Platform/Python
             (_('Platform'), val('platform')['name'], state('platform')),
             (_('Platform UUID'), val('platform')['uuid'], state('platform')),
             (_('Python version'), val('python')['version'], state('python')),
             (_('Python path'), val('python')['executable'], state('python')),
             ('', '', ''),  # spacer
 
             # Systems stats
             (_('CPU'), val('cpu')['text'], state('cpu')),
             (_('Load'), val('load')['text'], state('load')),
             (_('Memory'), val('memory')['text'], state('memory')),
             (_('Uptime'), val('uptime')['text'], state('uptime')),
             ('', '', ''),  # spacer
 
             # Repo storage
             (_('Storage location'), val('storage')['path'], state('storage')),
             (_('Storage info'), val('storage')['text'], state('storage')),
             (_('Storage inodes'), val('storage_inodes')['text'], state('storage_inodes')),
 
             (_('Gist storage location'), val('storage_gist')['path'], state('storage_gist')),
             (_('Gist storage info'), val('storage_gist')['text'], state('storage_gist')),
 
             (_('Archive cache storage location'), val('storage_archive')['path'], state('storage_archive')),
             (_('Archive cache info'), val('storage_archive')['text'], state('storage_archive')),
 
             (_('Temp storage location'), val('storage_temp')['path'], state('storage_temp')),
             (_('Temp storage info'), val('storage_temp')['text'], state('storage_temp')),
 
             (_('Search info'), val('search')['text'], state('search')),
             (_('Search location'), val('search')['location'], state('search')),
             ('', '', ''),  # spacer
 
             # VCS specific
             (_('VCS Backends'), val('vcs_backends'), state('vcs_backends')),
             (_('VCS Server'), val('vcs_server')['text'], state('vcs_server')),
             (_('GIT'), val('git'), state('git')),
             (_('HG'), val('hg'), state('hg')),
             (_('SVN'), val('svn'), state('svn')),
 
         ]
 
         if snapshot:
             if c.allowed_to_snapshot:
                 c.data_items.pop(0)  # remove server info
                 self.request.override_renderer = 'admin/settings/settings_system_snapshot.mako'
             else:
                 self.request.session.flash(
                     'You are not allowed to do this', queue='warning')
-        return {}
+        return self._get_template_context(c)
 
     @LoginRequired()
     @HasPermissionAllDecorator('hg.admin')
     @view_config(
         route_name='admin_settings_system_update', request_method='GET',
         renderer='rhodecode:templates/admin/settings/settings_system_update.mako')
     def settings_system_info_check_update(self):
         _ = self.request.translate
+        c = self.load_default_context()
 
         update_url = self.get_update_url()
 
         _err = lambda s: '<div style="color:#ff8888; padding:4px 0px">{}</div>'.format(s)
         try:
             data = self.get_update_data(update_url)
         except urllib2.URLError as e:
             log.exception("Exception contacting upgrade server")
             self.request.override_renderer = 'string'
             return _err('Failed to contact upgrade server: %r' % e)
         except ValueError as e:
             log.exception("Bad data sent from update server")
             self.request.override_renderer = 'string'
             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 {}
+        return self._get_template_context(c)

rhodecode/apps/channelstream/views.py

@@ -1,178 +1,175 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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/
 
 """
 Channel Stream controller for rhodecode
 
 :created_on: Oct 10, 2015
 :author: marcinl
 :copyright: (c) 2013-2015 RhodeCode GmbH.
 :license: Commercial License, see LICENSE for more details.
 """
 
 import logging
 import uuid
 
-from pylons import tmpl_context as c
-from pyramid.settings import asbool
 from pyramid.view import view_config
 from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPBadGateway
 
 from rhodecode.lib.channelstream import (
     channelstream_request,
     ChannelstreamConnectionException,
     ChannelstreamPermissionException,
     check_channel_permissions,
     get_connection_validators,
     get_user_data,
     parse_channels_info,
     update_history_from_logs,
     STATE_PUBLIC_KEYS)
 from rhodecode.lib.auth import NotAnonymous
-from rhodecode.lib.utils2 import str2bool
 
 log = logging.getLogger(__name__)
 
 
 class ChannelstreamView(object):
     def __init__(self, context, request):
         self.context = context
         self.request = request
 
         # Some of the decorators rely on this attribute to be present
         # on the class of the decorated method.
         self._rhodecode_user = request.user
         registry = request.registry
         self.channelstream_config = registry.rhodecode_plugins['channelstream']
         if not self.channelstream_config.get('enabled'):
             log.error('Channelstream plugin is disabled')
             raise HTTPBadRequest()
 
     @NotAnonymous()
     @view_config(route_name='channelstream_connect', renderer='json')
     def connect(self):
         """ handle authorization of users trying to connect """
         try:
             json_body = self.request.json_body
         except Exception:
             log.exception('Failed to decode json from request')
             raise HTTPBadRequest()
         try:
             channels = check_channel_permissions(
                 json_body.get('channels'),
                 get_connection_validators(self.request.registry))
         except ChannelstreamPermissionException:
             log.error('Incorrect permissions for requested channels')
             raise HTTPForbidden()
 
-        user = c.rhodecode_user
+        user = self._rhodecode_user
         if user.user_id:
             user_data = get_user_data(user.user_id)
         else:
             user_data = {
                 'id': None,
                 'username': None,
                 'first_name': None,
                 'last_name': None,
                 'icon_link': None,
                 'display_name': None,
                 'display_link': None,
             }
-        user_data['permissions'] = c.rhodecode_user.permissions
+        user_data['permissions'] = self._rhodecode_user.permissions
         payload = {
             'username': user.username,
             'user_state': user_data,
             'conn_id': str(uuid.uuid4()),
             'channels': channels,
             'channel_configs': {},
             'state_public_keys': STATE_PUBLIC_KEYS,
             'info': {
                 'exclude_channels': ['broadcast']
             }
         }
         filtered_channels = [channel for channel in channels
                              if channel != 'broadcast']
         for channel in filtered_channels:
             payload['channel_configs'][channel] = {
                 'notify_presence': True,
                 'history_size': 100,
                 'store_history': True,
                 'broadcast_presence_with_user_lists': True
             }
         # connect user to server
         try:
             connect_result = channelstream_request(self.channelstream_config,
                                                    payload, '/connect')
         except ChannelstreamConnectionException:
             log.exception('Channelstream service is down')
             return HTTPBadGateway()
 
         connect_result['channels'] = channels
         connect_result['channels_info'] = parse_channels_info(
             connect_result['channels_info'],
             include_channel_info=filtered_channels)
         update_history_from_logs(self.channelstream_config,
                                  filtered_channels, connect_result)
         return connect_result
 
     @NotAnonymous()
     @view_config(route_name='channelstream_subscribe', renderer='json')
     def subscribe(self):
         """ can be used to subscribe specific connection to other channels """
         try:
             json_body = self.request.json_body
         except Exception:
             log.exception('Failed to decode json from request')
             raise HTTPBadRequest()
         try:
             channels = check_channel_permissions(
                 json_body.get('channels'),
                 get_connection_validators(self.request.registry))
         except ChannelstreamPermissionException:
             log.error('Incorrect permissions for requested channels')
             raise HTTPForbidden()
         payload = {'conn_id': json_body.get('conn_id', ''),
                    'channels': channels,
                    'channel_configs': {},
                    'info': {
                        'exclude_channels': ['broadcast']}
                    }
         filtered_channels = [chan for chan in channels if chan != 'broadcast']
         for channel in filtered_channels:
             payload['channel_configs'][channel] = {
                 'notify_presence': True,
                 'history_size': 100,
                 'store_history': True,
                 'broadcast_presence_with_user_lists': True
             }
         try:
             connect_result = channelstream_request(
                 self.channelstream_config, payload, '/subscribe')
         except ChannelstreamConnectionException:
             log.exception('Channelstream service is down')
             return HTTPBadGateway()
         # include_channel_info will limit history only to new channel
         # to not overwrite histories on other channels in client
         connect_result['channels_info'] = parse_channels_info(
             connect_result['channels_info'],
             include_channel_info=filtered_channels)
         update_history_from_logs(self.channelstream_config,
                                  filtered_channels, connect_result)
         return connect_result