##// END OF EJS Templates
i18n: enable translation defaults for pyramid views.
marcink -
r1303:4e6cc838 default
parent child Browse files
Show More
@@ -1,480 +1,483 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2017 RhodeCode GmbH
3 # Copyright (C) 2010-2017 RhodeCode GmbH
4 #
4 #
5 # This program is free software: you can redistribute it and/or modify
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Affero General Public License, version 3
6 # it under the terms of the GNU Affero General Public License, version 3
7 # (only), as published by the Free Software Foundation.
7 # (only), as published by the Free Software Foundation.
8 #
8 #
9 # This program is distributed in the hope that it will be useful,
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
12 # GNU General Public License for more details.
13 #
13 #
14 # You should have received a copy of the GNU Affero General Public License
14 # You should have received a copy of the GNU Affero General Public License
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 #
16 #
17 # This program is dual-licensed. If you wish to learn more about the
17 # This program is dual-licensed. If you wish to learn more about the
18 # RhodeCode Enterprise Edition, including its added features, Support services,
18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20
20
21 """
21 """
22 Pylons middleware initialization
22 Pylons middleware initialization
23 """
23 """
24 import logging
24 import logging
25 from collections import OrderedDict
25 from collections import OrderedDict
26
26
27 from paste.registry import RegistryManager
27 from paste.registry import RegistryManager
28 from paste.gzipper import make_gzip_middleware
28 from paste.gzipper import make_gzip_middleware
29 from pylons.wsgiapp import PylonsApp
29 from pylons.wsgiapp import PylonsApp
30 from pyramid.authorization import ACLAuthorizationPolicy
30 from pyramid.authorization import ACLAuthorizationPolicy
31 from pyramid.config import Configurator
31 from pyramid.config import Configurator
32 from pyramid.settings import asbool, aslist
32 from pyramid.settings import asbool, aslist
33 from pyramid.wsgi import wsgiapp
33 from pyramid.wsgi import wsgiapp
34 from pyramid.httpexceptions import (
34 from pyramid.httpexceptions import (
35 HTTPError, HTTPInternalServerError, HTTPFound)
35 HTTPError, HTTPInternalServerError, HTTPFound)
36 from pyramid.events import ApplicationCreated
36 from pyramid.events import ApplicationCreated
37 from pyramid.renderers import render_to_response
37 from pyramid.renderers import render_to_response
38 from routes.middleware import RoutesMiddleware
38 from routes.middleware import RoutesMiddleware
39 import routes.util
39 import routes.util
40
40
41 import rhodecode
41 import rhodecode
42 from rhodecode.model import meta
42 from rhodecode.model import meta
43 from rhodecode.config import patches
43 from rhodecode.config import patches
44 from rhodecode.config.routing import STATIC_FILE_PREFIX
44 from rhodecode.config.routing import STATIC_FILE_PREFIX
45 from rhodecode.config.environment import (
45 from rhodecode.config.environment import (
46 load_environment, load_pyramid_environment)
46 load_environment, load_pyramid_environment)
47 from rhodecode.lib.middleware import csrf
47 from rhodecode.lib.middleware import csrf
48 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
48 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
49 from rhodecode.lib.middleware.error_handling import (
49 from rhodecode.lib.middleware.error_handling import (
50 PylonsErrorHandlingMiddleware)
50 PylonsErrorHandlingMiddleware)
51 from rhodecode.lib.middleware.https_fixup import HttpsFixup
51 from rhodecode.lib.middleware.https_fixup import HttpsFixup
52 from rhodecode.lib.middleware.vcs import VCSMiddleware
52 from rhodecode.lib.middleware.vcs import VCSMiddleware
53 from rhodecode.lib.plugins.utils import register_rhodecode_plugin
53 from rhodecode.lib.plugins.utils import register_rhodecode_plugin
54 from rhodecode.lib.utils2 import aslist as rhodecode_aslist
54 from rhodecode.lib.utils2 import aslist as rhodecode_aslist
55 from rhodecode.subscribers import scan_repositories_if_enabled
55 from rhodecode.subscribers import scan_repositories_if_enabled
56
56
57
57
58 log = logging.getLogger(__name__)
58 log = logging.getLogger(__name__)
59
59
60
60
61 # this is used to avoid avoid the route lookup overhead in routesmiddleware
61 # this is used to avoid avoid the route lookup overhead in routesmiddleware
62 # for certain routes which won't go to pylons to - eg. static files, debugger
62 # for certain routes which won't go to pylons to - eg. static files, debugger
63 # it is only needed for the pylons migration and can be removed once complete
63 # it is only needed for the pylons migration and can be removed once complete
64 class SkippableRoutesMiddleware(RoutesMiddleware):
64 class SkippableRoutesMiddleware(RoutesMiddleware):
65 """ Routes middleware that allows you to skip prefixes """
65 """ Routes middleware that allows you to skip prefixes """
66
66
67 def __init__(self, *args, **kw):
67 def __init__(self, *args, **kw):
68 self.skip_prefixes = kw.pop('skip_prefixes', [])
68 self.skip_prefixes = kw.pop('skip_prefixes', [])
69 super(SkippableRoutesMiddleware, self).__init__(*args, **kw)
69 super(SkippableRoutesMiddleware, self).__init__(*args, **kw)
70
70
71 def __call__(self, environ, start_response):
71 def __call__(self, environ, start_response):
72 for prefix in self.skip_prefixes:
72 for prefix in self.skip_prefixes:
73 if environ['PATH_INFO'].startswith(prefix):
73 if environ['PATH_INFO'].startswith(prefix):
74 # added to avoid the case when a missing /_static route falls
74 # added to avoid the case when a missing /_static route falls
75 # through to pylons and causes an exception as pylons is
75 # through to pylons and causes an exception as pylons is
76 # expecting wsgiorg.routingargs to be set in the environ
76 # expecting wsgiorg.routingargs to be set in the environ
77 # by RoutesMiddleware.
77 # by RoutesMiddleware.
78 if 'wsgiorg.routing_args' not in environ:
78 if 'wsgiorg.routing_args' not in environ:
79 environ['wsgiorg.routing_args'] = (None, {})
79 environ['wsgiorg.routing_args'] = (None, {})
80 return self.app(environ, start_response)
80 return self.app(environ, start_response)
81
81
82 return super(SkippableRoutesMiddleware, self).__call__(
82 return super(SkippableRoutesMiddleware, self).__call__(
83 environ, start_response)
83 environ, start_response)
84
84
85
85
86 def make_app(global_conf, static_files=True, **app_conf):
86 def make_app(global_conf, static_files=True, **app_conf):
87 """Create a Pylons WSGI application and return it
87 """Create a Pylons WSGI application and return it
88
88
89 ``global_conf``
89 ``global_conf``
90 The inherited configuration for this application. Normally from
90 The inherited configuration for this application. Normally from
91 the [DEFAULT] section of the Paste ini file.
91 the [DEFAULT] section of the Paste ini file.
92
92
93 ``app_conf``
93 ``app_conf``
94 The application's local configuration. Normally specified in
94 The application's local configuration. Normally specified in
95 the [app:<name>] section of the Paste ini file (where <name>
95 the [app:<name>] section of the Paste ini file (where <name>
96 defaults to main).
96 defaults to main).
97
97
98 """
98 """
99 # Apply compatibility patches
99 # Apply compatibility patches
100 patches.kombu_1_5_1_python_2_7_11()
100 patches.kombu_1_5_1_python_2_7_11()
101 patches.inspect_getargspec()
101 patches.inspect_getargspec()
102
102
103 # Configure the Pylons environment
103 # Configure the Pylons environment
104 config = load_environment(global_conf, app_conf)
104 config = load_environment(global_conf, app_conf)
105
105
106 # The Pylons WSGI app
106 # The Pylons WSGI app
107 app = PylonsApp(config=config)
107 app = PylonsApp(config=config)
108 if rhodecode.is_test:
108 if rhodecode.is_test:
109 app = csrf.CSRFDetector(app)
109 app = csrf.CSRFDetector(app)
110
110
111 expected_origin = config.get('expected_origin')
111 expected_origin = config.get('expected_origin')
112 if expected_origin:
112 if expected_origin:
113 # The API can be accessed from other Origins.
113 # The API can be accessed from other Origins.
114 app = csrf.OriginChecker(app, expected_origin,
114 app = csrf.OriginChecker(app, expected_origin,
115 skip_urls=[routes.util.url_for('api')])
115 skip_urls=[routes.util.url_for('api')])
116
116
117 # Establish the Registry for this application
117 # Establish the Registry for this application
118 app = RegistryManager(app)
118 app = RegistryManager(app)
119
119
120 app.config = config
120 app.config = config
121
121
122 return app
122 return app
123
123
124
124
125 def make_pyramid_app(global_config, **settings):
125 def make_pyramid_app(global_config, **settings):
126 """
126 """
127 Constructs the WSGI application based on Pyramid and wraps the Pylons based
127 Constructs the WSGI application based on Pyramid and wraps the Pylons based
128 application.
128 application.
129
129
130 Specials:
130 Specials:
131
131
132 * We migrate from Pylons to Pyramid. While doing this, we keep both
132 * We migrate from Pylons to Pyramid. While doing this, we keep both
133 frameworks functional. This involves moving some WSGI middlewares around
133 frameworks functional. This involves moving some WSGI middlewares around
134 and providing access to some data internals, so that the old code is
134 and providing access to some data internals, so that the old code is
135 still functional.
135 still functional.
136
136
137 * The application can also be integrated like a plugin via the call to
137 * The application can also be integrated like a plugin via the call to
138 `includeme`. This is accompanied with the other utility functions which
138 `includeme`. This is accompanied with the other utility functions which
139 are called. Changing this should be done with great care to not break
139 are called. Changing this should be done with great care to not break
140 cases when these fragments are assembled from another place.
140 cases when these fragments are assembled from another place.
141
141
142 """
142 """
143 # The edition string should be available in pylons too, so we add it here
143 # The edition string should be available in pylons too, so we add it here
144 # before copying the settings.
144 # before copying the settings.
145 settings.setdefault('rhodecode.edition', 'Community Edition')
145 settings.setdefault('rhodecode.edition', 'Community Edition')
146
146
147 # As long as our Pylons application does expect "unprepared" settings, make
147 # As long as our Pylons application does expect "unprepared" settings, make
148 # sure that we keep an unmodified copy. This avoids unintentional change of
148 # sure that we keep an unmodified copy. This avoids unintentional change of
149 # behavior in the old application.
149 # behavior in the old application.
150 settings_pylons = settings.copy()
150 settings_pylons = settings.copy()
151
151
152 sanitize_settings_and_apply_defaults(settings)
152 sanitize_settings_and_apply_defaults(settings)
153 config = Configurator(settings=settings)
153 config = Configurator(settings=settings)
154 add_pylons_compat_data(config.registry, global_config, settings_pylons)
154 add_pylons_compat_data(config.registry, global_config, settings_pylons)
155
155
156 load_pyramid_environment(global_config, settings)
156 load_pyramid_environment(global_config, settings)
157
157
158 includeme_first(config)
158 includeme_first(config)
159 includeme(config)
159 includeme(config)
160 pyramid_app = config.make_wsgi_app()
160 pyramid_app = config.make_wsgi_app()
161 pyramid_app = wrap_app_in_wsgi_middlewares(pyramid_app, config)
161 pyramid_app = wrap_app_in_wsgi_middlewares(pyramid_app, config)
162 pyramid_app.config = config
162 pyramid_app.config = config
163
163
164 # creating the app uses a connection - return it after we are done
164 # creating the app uses a connection - return it after we are done
165 meta.Session.remove()
165 meta.Session.remove()
166
166
167 return pyramid_app
167 return pyramid_app
168
168
169
169
170 def make_not_found_view(config):
170 def make_not_found_view(config):
171 """
171 """
172 This creates the view which should be registered as not-found-view to
172 This creates the view which should be registered as not-found-view to
173 pyramid. Basically it contains of the old pylons app, converted to a view.
173 pyramid. Basically it contains of the old pylons app, converted to a view.
174 Additionally it is wrapped by some other middlewares.
174 Additionally it is wrapped by some other middlewares.
175 """
175 """
176 settings = config.registry.settings
176 settings = config.registry.settings
177 vcs_server_enabled = settings['vcs.server.enable']
177 vcs_server_enabled = settings['vcs.server.enable']
178
178
179 # Make pylons app from unprepared settings.
179 # Make pylons app from unprepared settings.
180 pylons_app = make_app(
180 pylons_app = make_app(
181 config.registry._pylons_compat_global_config,
181 config.registry._pylons_compat_global_config,
182 **config.registry._pylons_compat_settings)
182 **config.registry._pylons_compat_settings)
183 config.registry._pylons_compat_config = pylons_app.config
183 config.registry._pylons_compat_config = pylons_app.config
184
184
185 # Appenlight monitoring.
185 # Appenlight monitoring.
186 pylons_app, appenlight_client = wrap_in_appenlight_if_enabled(
186 pylons_app, appenlight_client = wrap_in_appenlight_if_enabled(
187 pylons_app, settings)
187 pylons_app, settings)
188
188
189 # The pylons app is executed inside of the pyramid 404 exception handler.
189 # The pylons app is executed inside of the pyramid 404 exception handler.
190 # Exceptions which are raised inside of it are not handled by pyramid
190 # Exceptions which are raised inside of it are not handled by pyramid
191 # again. Therefore we add a middleware that invokes the error handler in
191 # again. Therefore we add a middleware that invokes the error handler in
192 # case of an exception or error response. This way we return proper error
192 # case of an exception or error response. This way we return proper error
193 # HTML pages in case of an error.
193 # HTML pages in case of an error.
194 reraise = (settings.get('debugtoolbar.enabled', False) or
194 reraise = (settings.get('debugtoolbar.enabled', False) or
195 rhodecode.disable_error_handler)
195 rhodecode.disable_error_handler)
196 pylons_app = PylonsErrorHandlingMiddleware(
196 pylons_app = PylonsErrorHandlingMiddleware(
197 pylons_app, error_handler, reraise)
197 pylons_app, error_handler, reraise)
198
198
199 # The VCSMiddleware shall operate like a fallback if pyramid doesn't find a
199 # The VCSMiddleware shall operate like a fallback if pyramid doesn't find a
200 # view to handle the request. Therefore it is wrapped around the pylons
200 # view to handle the request. Therefore it is wrapped around the pylons
201 # app. It has to be outside of the error handling otherwise error responses
201 # app. It has to be outside of the error handling otherwise error responses
202 # from the vcsserver are converted to HTML error pages. This confuses the
202 # from the vcsserver are converted to HTML error pages. This confuses the
203 # command line tools and the user won't get a meaningful error message.
203 # command line tools and the user won't get a meaningful error message.
204 if vcs_server_enabled:
204 if vcs_server_enabled:
205 pylons_app = VCSMiddleware(
205 pylons_app = VCSMiddleware(
206 pylons_app, settings, appenlight_client, registry=config.registry)
206 pylons_app, settings, appenlight_client, registry=config.registry)
207
207
208 # Convert WSGI app to pyramid view and return it.
208 # Convert WSGI app to pyramid view and return it.
209 return wsgiapp(pylons_app)
209 return wsgiapp(pylons_app)
210
210
211
211
212 def add_pylons_compat_data(registry, global_config, settings):
212 def add_pylons_compat_data(registry, global_config, settings):
213 """
213 """
214 Attach data to the registry to support the Pylons integration.
214 Attach data to the registry to support the Pylons integration.
215 """
215 """
216 registry._pylons_compat_global_config = global_config
216 registry._pylons_compat_global_config = global_config
217 registry._pylons_compat_settings = settings
217 registry._pylons_compat_settings = settings
218
218
219
219
220 def error_handler(exception, request):
220 def error_handler(exception, request):
221 from rhodecode.model.settings import SettingsModel
221 from rhodecode.model.settings import SettingsModel
222 from rhodecode.lib.utils2 import AttributeDict
222 from rhodecode.lib.utils2 import AttributeDict
223
223
224 try:
224 try:
225 rc_config = SettingsModel().get_all_settings()
225 rc_config = SettingsModel().get_all_settings()
226 except Exception:
226 except Exception:
227 log.exception('failed to fetch settings')
227 log.exception('failed to fetch settings')
228 rc_config = {}
228 rc_config = {}
229
229
230 base_response = HTTPInternalServerError()
230 base_response = HTTPInternalServerError()
231 # prefer original exception for the response since it may have headers set
231 # prefer original exception for the response since it may have headers set
232 if isinstance(exception, HTTPError):
232 if isinstance(exception, HTTPError):
233 base_response = exception
233 base_response = exception
234
234
235 c = AttributeDict()
235 c = AttributeDict()
236 c.error_message = base_response.status
236 c.error_message = base_response.status
237 c.error_explanation = base_response.explanation or str(base_response)
237 c.error_explanation = base_response.explanation or str(base_response)
238 c.visual = AttributeDict()
238 c.visual = AttributeDict()
239
239
240 c.visual.rhodecode_support_url = (
240 c.visual.rhodecode_support_url = (
241 request.registry.settings.get('rhodecode_support_url') or
241 request.registry.settings.get('rhodecode_support_url') or
242 request.route_url('rhodecode_support')
242 request.route_url('rhodecode_support')
243 )
243 )
244 c.redirect_time = 0
244 c.redirect_time = 0
245 c.rhodecode_name = rc_config.get('rhodecode_title', '')
245 c.rhodecode_name = rc_config.get('rhodecode_title', '')
246 if not c.rhodecode_name:
246 if not c.rhodecode_name:
247 c.rhodecode_name = 'Rhodecode'
247 c.rhodecode_name = 'Rhodecode'
248
248
249 c.causes = []
249 c.causes = []
250 if hasattr(base_response, 'causes'):
250 if hasattr(base_response, 'causes'):
251 c.causes = base_response.causes
251 c.causes = base_response.causes
252
252
253 response = render_to_response(
253 response = render_to_response(
254 '/errors/error_document.mako', {'c': c}, request=request,
254 '/errors/error_document.mako', {'c': c}, request=request,
255 response=base_response)
255 response=base_response)
256
256
257 return response
257 return response
258
258
259
259
260 def includeme(config):
260 def includeme(config):
261 settings = config.registry.settings
261 settings = config.registry.settings
262
262
263 # plugin information
263 # plugin information
264 config.registry.rhodecode_plugins = OrderedDict()
264 config.registry.rhodecode_plugins = OrderedDict()
265
265
266 config.add_directive(
266 config.add_directive(
267 'register_rhodecode_plugin', register_rhodecode_plugin)
267 'register_rhodecode_plugin', register_rhodecode_plugin)
268
268
269 if asbool(settings.get('appenlight', 'false')):
269 if asbool(settings.get('appenlight', 'false')):
270 config.include('appenlight_client.ext.pyramid_tween')
270 config.include('appenlight_client.ext.pyramid_tween')
271
271
272 # Includes which are required. The application would fail without them.
272 # Includes which are required. The application would fail without them.
273 config.include('pyramid_mako')
273 config.include('pyramid_mako')
274 config.include('pyramid_beaker')
274 config.include('pyramid_beaker')
275 config.include('rhodecode.channelstream')
275 config.include('rhodecode.channelstream')
276 config.include('rhodecode.admin')
276 config.include('rhodecode.admin')
277 config.include('rhodecode.authentication')
277 config.include('rhodecode.authentication')
278 config.include('rhodecode.integrations')
278 config.include('rhodecode.integrations')
279 config.include('rhodecode.login')
279 config.include('rhodecode.login')
280 config.include('rhodecode.tweens')
280 config.include('rhodecode.tweens')
281 config.include('rhodecode.api')
281 config.include('rhodecode.api')
282 config.include('rhodecode.svn_support')
282 config.include('rhodecode.svn_support')
283 config.add_route(
283 config.add_route(
284 'rhodecode_support', 'https://rhodecode.com/help/', static=True)
284 'rhodecode_support', 'https://rhodecode.com/help/', static=True)
285
285
286 config.add_translation_dirs('rhodecode:i18n/')
287 settings['default_locale_name'] = settings.get('lang', 'en')
288
286 # Add subscribers.
289 # Add subscribers.
287 config.add_subscriber(scan_repositories_if_enabled, ApplicationCreated)
290 config.add_subscriber(scan_repositories_if_enabled, ApplicationCreated)
288
291
289 # Set the authorization policy.
292 # Set the authorization policy.
290 authz_policy = ACLAuthorizationPolicy()
293 authz_policy = ACLAuthorizationPolicy()
291 config.set_authorization_policy(authz_policy)
294 config.set_authorization_policy(authz_policy)
292
295
293 # Set the default renderer for HTML templates to mako.
296 # Set the default renderer for HTML templates to mako.
294 config.add_mako_renderer('.html')
297 config.add_mako_renderer('.html')
295
298
296 # include RhodeCode plugins
299 # include RhodeCode plugins
297 includes = aslist(settings.get('rhodecode.includes', []))
300 includes = aslist(settings.get('rhodecode.includes', []))
298 for inc in includes:
301 for inc in includes:
299 config.include(inc)
302 config.include(inc)
300
303
301 # This is the glue which allows us to migrate in chunks. By registering the
304 # This is the glue which allows us to migrate in chunks. By registering the
302 # pylons based application as the "Not Found" view in Pyramid, we will
305 # pylons based application as the "Not Found" view in Pyramid, we will
303 # fallback to the old application each time the new one does not yet know
306 # fallback to the old application each time the new one does not yet know
304 # how to handle a request.
307 # how to handle a request.
305 config.add_notfound_view(make_not_found_view(config))
308 config.add_notfound_view(make_not_found_view(config))
306
309
307 if not settings.get('debugtoolbar.enabled', False):
310 if not settings.get('debugtoolbar.enabled', False):
308 # if no toolbar, then any exception gets caught and rendered
311 # if no toolbar, then any exception gets caught and rendered
309 config.add_view(error_handler, context=Exception)
312 config.add_view(error_handler, context=Exception)
310
313
311 config.add_view(error_handler, context=HTTPError)
314 config.add_view(error_handler, context=HTTPError)
312
315
313
316
314 def includeme_first(config):
317 def includeme_first(config):
315 # redirect automatic browser favicon.ico requests to correct place
318 # redirect automatic browser favicon.ico requests to correct place
316 def favicon_redirect(context, request):
319 def favicon_redirect(context, request):
317 return HTTPFound(
320 return HTTPFound(
318 request.static_path('rhodecode:public/images/favicon.ico'))
321 request.static_path('rhodecode:public/images/favicon.ico'))
319
322
320 config.add_view(favicon_redirect, route_name='favicon')
323 config.add_view(favicon_redirect, route_name='favicon')
321 config.add_route('favicon', '/favicon.ico')
324 config.add_route('favicon', '/favicon.ico')
322
325
323 config.add_static_view(
326 config.add_static_view(
324 '_static/deform', 'deform:static')
327 '_static/deform', 'deform:static')
325 config.add_static_view(
328 config.add_static_view(
326 '_static/rhodecode', path='rhodecode:public', cache_max_age=3600 * 24)
329 '_static/rhodecode', path='rhodecode:public', cache_max_age=3600 * 24)
327
330
328
331
329 def wrap_app_in_wsgi_middlewares(pyramid_app, config):
332 def wrap_app_in_wsgi_middlewares(pyramid_app, config):
330 """
333 """
331 Apply outer WSGI middlewares around the application.
334 Apply outer WSGI middlewares around the application.
332
335
333 Part of this has been moved up from the Pylons layer, so that the
336 Part of this has been moved up from the Pylons layer, so that the
334 data is also available if old Pylons code is hit through an already ported
337 data is also available if old Pylons code is hit through an already ported
335 view.
338 view.
336 """
339 """
337 settings = config.registry.settings
340 settings = config.registry.settings
338
341
339 # enable https redirects based on HTTP_X_URL_SCHEME set by proxy
342 # enable https redirects based on HTTP_X_URL_SCHEME set by proxy
340 pyramid_app = HttpsFixup(pyramid_app, settings)
343 pyramid_app = HttpsFixup(pyramid_app, settings)
341
344
342 # Add RoutesMiddleware to support the pylons compatibility tween during
345 # Add RoutesMiddleware to support the pylons compatibility tween during
343 # migration to pyramid.
346 # migration to pyramid.
344 pyramid_app = SkippableRoutesMiddleware(
347 pyramid_app = SkippableRoutesMiddleware(
345 pyramid_app, config.registry._pylons_compat_config['routes.map'],
348 pyramid_app, config.registry._pylons_compat_config['routes.map'],
346 skip_prefixes=(STATIC_FILE_PREFIX, '/_debug_toolbar'))
349 skip_prefixes=(STATIC_FILE_PREFIX, '/_debug_toolbar'))
347
350
348 pyramid_app, _ = wrap_in_appenlight_if_enabled(pyramid_app, settings)
351 pyramid_app, _ = wrap_in_appenlight_if_enabled(pyramid_app, settings)
349
352
350 if settings['gzip_responses']:
353 if settings['gzip_responses']:
351 pyramid_app = make_gzip_middleware(
354 pyramid_app = make_gzip_middleware(
352 pyramid_app, settings, compress_level=1)
355 pyramid_app, settings, compress_level=1)
353
356
354
357
355 # this should be the outer most middleware in the wsgi stack since
358 # this should be the outer most middleware in the wsgi stack since
356 # middleware like Routes make database calls
359 # middleware like Routes make database calls
357 def pyramid_app_with_cleanup(environ, start_response):
360 def pyramid_app_with_cleanup(environ, start_response):
358 try:
361 try:
359 return pyramid_app(environ, start_response)
362 return pyramid_app(environ, start_response)
360 finally:
363 finally:
361 # Dispose current database session and rollback uncommitted
364 # Dispose current database session and rollback uncommitted
362 # transactions.
365 # transactions.
363 meta.Session.remove()
366 meta.Session.remove()
364
367
365 # In a single threaded mode server, on non sqlite db we should have
368 # In a single threaded mode server, on non sqlite db we should have
366 # '0 Current Checked out connections' at the end of a request,
369 # '0 Current Checked out connections' at the end of a request,
367 # if not, then something, somewhere is leaving a connection open
370 # if not, then something, somewhere is leaving a connection open
368 pool = meta.Base.metadata.bind.engine.pool
371 pool = meta.Base.metadata.bind.engine.pool
369 log.debug('sa pool status: %s', pool.status())
372 log.debug('sa pool status: %s', pool.status())
370
373
371
374
372 return pyramid_app_with_cleanup
375 return pyramid_app_with_cleanup
373
376
374
377
375 def sanitize_settings_and_apply_defaults(settings):
378 def sanitize_settings_and_apply_defaults(settings):
376 """
379 """
377 Applies settings defaults and does all type conversion.
380 Applies settings defaults and does all type conversion.
378
381
379 We would move all settings parsing and preparation into this place, so that
382 We would move all settings parsing and preparation into this place, so that
380 we have only one place left which deals with this part. The remaining parts
383 we have only one place left which deals with this part. The remaining parts
381 of the application would start to rely fully on well prepared settings.
384 of the application would start to rely fully on well prepared settings.
382
385
383 This piece would later be split up per topic to avoid a big fat monster
386 This piece would later be split up per topic to avoid a big fat monster
384 function.
387 function.
385 """
388 """
386
389
387 # Pyramid's mako renderer has to search in the templates folder so that the
390 # Pyramid's mako renderer has to search in the templates folder so that the
388 # old templates still work. Ported and new templates are expected to use
391 # old templates still work. Ported and new templates are expected to use
389 # real asset specifications for the includes.
392 # real asset specifications for the includes.
390 mako_directories = settings.setdefault('mako.directories', [
393 mako_directories = settings.setdefault('mako.directories', [
391 # Base templates of the original Pylons application
394 # Base templates of the original Pylons application
392 'rhodecode:templates',
395 'rhodecode:templates',
393 ])
396 ])
394 log.debug(
397 log.debug(
395 "Using the following Mako template directories: %s",
398 "Using the following Mako template directories: %s",
396 mako_directories)
399 mako_directories)
397
400
398 # Default includes, possible to change as a user
401 # Default includes, possible to change as a user
399 pyramid_includes = settings.setdefault('pyramid.includes', [
402 pyramid_includes = settings.setdefault('pyramid.includes', [
400 'rhodecode.lib.middleware.request_wrapper',
403 'rhodecode.lib.middleware.request_wrapper',
401 ])
404 ])
402 log.debug(
405 log.debug(
403 "Using the following pyramid.includes: %s",
406 "Using the following pyramid.includes: %s",
404 pyramid_includes)
407 pyramid_includes)
405
408
406 # TODO: johbo: Re-think this, usually the call to config.include
409 # TODO: johbo: Re-think this, usually the call to config.include
407 # should allow to pass in a prefix.
410 # should allow to pass in a prefix.
408 settings.setdefault('rhodecode.api.url', '/_admin/api')
411 settings.setdefault('rhodecode.api.url', '/_admin/api')
409
412
410 # Sanitize generic settings.
413 # Sanitize generic settings.
411 _list_setting(settings, 'default_encoding', 'UTF-8')
414 _list_setting(settings, 'default_encoding', 'UTF-8')
412 _bool_setting(settings, 'is_test', 'false')
415 _bool_setting(settings, 'is_test', 'false')
413 _bool_setting(settings, 'gzip_responses', 'false')
416 _bool_setting(settings, 'gzip_responses', 'false')
414
417
415 # Call split out functions that sanitize settings for each topic.
418 # Call split out functions that sanitize settings for each topic.
416 _sanitize_appenlight_settings(settings)
419 _sanitize_appenlight_settings(settings)
417 _sanitize_vcs_settings(settings)
420 _sanitize_vcs_settings(settings)
418
421
419 return settings
422 return settings
420
423
421
424
422 def _sanitize_appenlight_settings(settings):
425 def _sanitize_appenlight_settings(settings):
423 _bool_setting(settings, 'appenlight', 'false')
426 _bool_setting(settings, 'appenlight', 'false')
424
427
425
428
426 def _sanitize_vcs_settings(settings):
429 def _sanitize_vcs_settings(settings):
427 """
430 """
428 Applies settings defaults and does type conversion for all VCS related
431 Applies settings defaults and does type conversion for all VCS related
429 settings.
432 settings.
430 """
433 """
431 _string_setting(settings, 'vcs.svn.compatible_version', '')
434 _string_setting(settings, 'vcs.svn.compatible_version', '')
432 _string_setting(settings, 'git_rev_filter', '--all')
435 _string_setting(settings, 'git_rev_filter', '--all')
433 _string_setting(settings, 'vcs.hooks.protocol', 'http')
436 _string_setting(settings, 'vcs.hooks.protocol', 'http')
434 _string_setting(settings, 'vcs.scm_app_implementation', 'http')
437 _string_setting(settings, 'vcs.scm_app_implementation', 'http')
435 _string_setting(settings, 'vcs.server', '')
438 _string_setting(settings, 'vcs.server', '')
436 _string_setting(settings, 'vcs.server.log_level', 'debug')
439 _string_setting(settings, 'vcs.server.log_level', 'debug')
437 _string_setting(settings, 'vcs.server.protocol', 'http')
440 _string_setting(settings, 'vcs.server.protocol', 'http')
438 _bool_setting(settings, 'startup.import_repos', 'false')
441 _bool_setting(settings, 'startup.import_repos', 'false')
439 _bool_setting(settings, 'vcs.hooks.direct_calls', 'false')
442 _bool_setting(settings, 'vcs.hooks.direct_calls', 'false')
440 _bool_setting(settings, 'vcs.server.enable', 'true')
443 _bool_setting(settings, 'vcs.server.enable', 'true')
441 _bool_setting(settings, 'vcs.start_server', 'false')
444 _bool_setting(settings, 'vcs.start_server', 'false')
442 _list_setting(settings, 'vcs.backends', 'hg, git, svn')
445 _list_setting(settings, 'vcs.backends', 'hg, git, svn')
443 _int_setting(settings, 'vcs.connection_timeout', 3600)
446 _int_setting(settings, 'vcs.connection_timeout', 3600)
444
447
445 # Support legacy values of vcs.scm_app_implementation. Legacy
448 # Support legacy values of vcs.scm_app_implementation. Legacy
446 # configurations may use 'rhodecode.lib.middleware.utils.scm_app_http'
449 # configurations may use 'rhodecode.lib.middleware.utils.scm_app_http'
447 # which is now mapped to 'http'.
450 # which is now mapped to 'http'.
448 scm_app_impl = settings['vcs.scm_app_implementation']
451 scm_app_impl = settings['vcs.scm_app_implementation']
449 if scm_app_impl == 'rhodecode.lib.middleware.utils.scm_app_http':
452 if scm_app_impl == 'rhodecode.lib.middleware.utils.scm_app_http':
450 settings['vcs.scm_app_implementation'] = 'http'
453 settings['vcs.scm_app_implementation'] = 'http'
451
454
452
455
453 def _int_setting(settings, name, default):
456 def _int_setting(settings, name, default):
454 settings[name] = int(settings.get(name, default))
457 settings[name] = int(settings.get(name, default))
455
458
456
459
457 def _bool_setting(settings, name, default):
460 def _bool_setting(settings, name, default):
458 input = settings.get(name, default)
461 input = settings.get(name, default)
459 if isinstance(input, unicode):
462 if isinstance(input, unicode):
460 input = input.encode('utf8')
463 input = input.encode('utf8')
461 settings[name] = asbool(input)
464 settings[name] = asbool(input)
462
465
463
466
464 def _list_setting(settings, name, default):
467 def _list_setting(settings, name, default):
465 raw_value = settings.get(name, default)
468 raw_value = settings.get(name, default)
466
469
467 old_separator = ','
470 old_separator = ','
468 if old_separator in raw_value:
471 if old_separator in raw_value:
469 # If we get a comma separated list, pass it to our own function.
472 # If we get a comma separated list, pass it to our own function.
470 settings[name] = rhodecode_aslist(raw_value, sep=old_separator)
473 settings[name] = rhodecode_aslist(raw_value, sep=old_separator)
471 else:
474 else:
472 # Otherwise we assume it uses pyramids space/newline separation.
475 # Otherwise we assume it uses pyramids space/newline separation.
473 settings[name] = aslist(raw_value)
476 settings[name] = aslist(raw_value)
474
477
475
478
476 def _string_setting(settings, name, default, lower=True):
479 def _string_setting(settings, name, default, lower=True):
477 value = settings.get(name, default)
480 value = settings.get(name, default)
478 if lower:
481 if lower:
479 value = value.lower()
482 value = value.lower()
480 settings[name] = value
483 settings[name] = value
General Comments 0
You need to be logged in to leave comments. Login now