##// END OF EJS Templates
vcs: Use response header to decide if error handling is needed.
Martin Bornhold -
r609:24f4767a default
parent child Browse files
Show More
@@ -1,468 +1,470 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2016 RhodeCode GmbH
3 # Copyright (C) 2010-2016 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 HTTPError, HTTPInternalServerError
34 from pyramid.httpexceptions import HTTPError, HTTPInternalServerError
35 from pylons.controllers.util import redirect
35 from pylons.controllers.util import redirect
36 from pyramid.events import ApplicationCreated
36 from pyramid.events import ApplicationCreated
37 import pyramid.httpexceptions as httpexceptions
37 import pyramid.httpexceptions as httpexceptions
38 from pyramid.renderers import render_to_response
38 from pyramid.renderers import render_to_response
39 from routes.middleware import RoutesMiddleware
39 from routes.middleware import RoutesMiddleware
40 import routes.util
40 import routes.util
41
41
42 import rhodecode
42 import rhodecode
43 import rhodecode.integrations # do not remove this as it registers celery tasks
43 import rhodecode.integrations # do not remove this as it registers celery tasks
44 from rhodecode.config import patches
44 from rhodecode.config import patches
45 from rhodecode.config.routing import STATIC_FILE_PREFIX
45 from rhodecode.config.routing import STATIC_FILE_PREFIX
46 from rhodecode.config.environment import (
46 from rhodecode.config.environment import (
47 load_environment, load_pyramid_environment)
47 load_environment, load_pyramid_environment)
48 from rhodecode.lib.middleware import csrf
48 from rhodecode.lib.middleware import csrf
49 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
49 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
50 from rhodecode.lib.middleware.disable_vcs import DisableVCSPagesWrapper
50 from rhodecode.lib.middleware.disable_vcs import DisableVCSPagesWrapper
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 return pyramid_app
162 return pyramid_app
163
163
164
164
165 def make_not_found_view(config):
165 def make_not_found_view(config):
166 """
166 """
167 This creates the view which should be registered as not-found-view to
167 This creates the view which should be registered as not-found-view to
168 pyramid. Basically it contains of the old pylons app, converted to a view.
168 pyramid. Basically it contains of the old pylons app, converted to a view.
169 Additionally it is wrapped by some other middlewares.
169 Additionally it is wrapped by some other middlewares.
170 """
170 """
171 settings = config.registry.settings
171 settings = config.registry.settings
172 vcs_server_enabled = settings['vcs.server.enable']
172 vcs_server_enabled = settings['vcs.server.enable']
173
173
174 # Make pylons app from unprepared settings.
174 # Make pylons app from unprepared settings.
175 pylons_app = make_app(
175 pylons_app = make_app(
176 config.registry._pylons_compat_global_config,
176 config.registry._pylons_compat_global_config,
177 **config.registry._pylons_compat_settings)
177 **config.registry._pylons_compat_settings)
178 config.registry._pylons_compat_config = pylons_app.config
178 config.registry._pylons_compat_config = pylons_app.config
179
179
180 # Appenlight monitoring.
180 # Appenlight monitoring.
181 pylons_app, appenlight_client = wrap_in_appenlight_if_enabled(
181 pylons_app, appenlight_client = wrap_in_appenlight_if_enabled(
182 pylons_app, settings)
182 pylons_app, settings)
183
183
184 # The VCSMiddleware shall operate like a fallback if pyramid doesn't find
184 # The VCSMiddleware shall operate like a fallback if pyramid doesn't find
185 # a view to handle the request. Therefore we wrap it around the pylons app.
185 # a view to handle the request. Therefore we wrap it around the pylons app.
186 if vcs_server_enabled:
186 if vcs_server_enabled:
187 pylons_app = VCSMiddleware(
187 pylons_app = VCSMiddleware(
188 pylons_app, settings, appenlight_client, registry=config.registry)
188 pylons_app, settings, appenlight_client, registry=config.registry)
189
189
190 pylons_app_as_view = wsgiapp(pylons_app)
190 pylons_app_as_view = wsgiapp(pylons_app)
191
191
192 # Protect from VCS Server error related pages when server is not available
192 # Protect from VCS Server error related pages when server is not available
193 if not vcs_server_enabled:
193 if not vcs_server_enabled:
194 pylons_app_as_view = DisableVCSPagesWrapper(pylons_app_as_view)
194 pylons_app_as_view = DisableVCSPagesWrapper(pylons_app_as_view)
195
195
196 def pylons_app_with_error_handler(context, request):
196 def pylons_app_with_error_handler(context, request):
197 """
197 """
198 Handle exceptions from rc pylons app:
198 Handle exceptions from rc pylons app:
199
199
200 - old webob type exceptions get converted to pyramid exceptions
200 - old webob type exceptions get converted to pyramid exceptions
201 - pyramid exceptions are passed to the error handler view
201 - pyramid exceptions are passed to the error handler view
202 """
202 """
203 def is_vcs_request(request):
203 def is_vcs_response(response):
204 return True == request.environ.get(
204 return 'X-RhodeCode-Backend' in response.headers
205 'rhodecode.vcs.skip_error_handling')
206
205
207 def is_webob_error(response):
206 def is_http_error(response):
208 # webob type error responses
207 # webob type error responses
209 return (400 <= response.status_int <= 599)
208 return (400 <= response.status_int <= 599)
210
209
210 def is_error_handling_needed(response):
211 return is_http_error(response) and not is_vcs_response(response)
212
211 try:
213 try:
212 response = pylons_app_as_view(context, request)
214 response = pylons_app_as_view(context, request)
213 if is_webob_error(response) and not is_vcs_request(request):
215 if is_error_handling_needed(response):
214 return error_handler(
216 response = webob_to_pyramid_http_response(response)
215 webob_to_pyramid_http_response(response), request)
217 return error_handler(response, request)
216 except HTTPError as e: # pyramid type exceptions
218 except HTTPError as e: # pyramid type exceptions
217 return error_handler(e, request)
219 return error_handler(e, request)
218 except Exception:
220 except Exception:
219 if settings.get('debugtoolbar.enabled', False):
221 if settings.get('debugtoolbar.enabled', False):
220 raise
222 raise
221 return error_handler(HTTPInternalServerError(), request)
223 return error_handler(HTTPInternalServerError(), request)
222 return response
224 return response
223
225
224 return pylons_app_with_error_handler
226 return pylons_app_with_error_handler
225
227
226
228
227 def add_pylons_compat_data(registry, global_config, settings):
229 def add_pylons_compat_data(registry, global_config, settings):
228 """
230 """
229 Attach data to the registry to support the Pylons integration.
231 Attach data to the registry to support the Pylons integration.
230 """
232 """
231 registry._pylons_compat_global_config = global_config
233 registry._pylons_compat_global_config = global_config
232 registry._pylons_compat_settings = settings
234 registry._pylons_compat_settings = settings
233
235
234
236
235 def webob_to_pyramid_http_response(webob_response):
237 def webob_to_pyramid_http_response(webob_response):
236 ResponseClass = httpexceptions.status_map[webob_response.status_int]
238 ResponseClass = httpexceptions.status_map[webob_response.status_int]
237 pyramid_response = ResponseClass(webob_response.status)
239 pyramid_response = ResponseClass(webob_response.status)
238 pyramid_response.status = webob_response.status
240 pyramid_response.status = webob_response.status
239 pyramid_response.headers.update(webob_response.headers)
241 pyramid_response.headers.update(webob_response.headers)
240 if pyramid_response.headers['content-type'] == 'text/html':
242 if pyramid_response.headers['content-type'] == 'text/html':
241 pyramid_response.headers['content-type'] = 'text/html; charset=UTF-8'
243 pyramid_response.headers['content-type'] = 'text/html; charset=UTF-8'
242 return pyramid_response
244 return pyramid_response
243
245
244
246
245 def error_handler(exception, request):
247 def error_handler(exception, request):
246 # TODO: dan: replace the old pylons error controller with this
248 # TODO: dan: replace the old pylons error controller with this
247 from rhodecode.model.settings import SettingsModel
249 from rhodecode.model.settings import SettingsModel
248 from rhodecode.lib.utils2 import AttributeDict
250 from rhodecode.lib.utils2 import AttributeDict
249
251
250 try:
252 try:
251 rc_config = SettingsModel().get_all_settings()
253 rc_config = SettingsModel().get_all_settings()
252 except Exception:
254 except Exception:
253 log.exception('failed to fetch settings')
255 log.exception('failed to fetch settings')
254 rc_config = {}
256 rc_config = {}
255
257
256 base_response = HTTPInternalServerError()
258 base_response = HTTPInternalServerError()
257 # prefer original exception for the response since it may have headers set
259 # prefer original exception for the response since it may have headers set
258 if isinstance(exception, HTTPError):
260 if isinstance(exception, HTTPError):
259 base_response = exception
261 base_response = exception
260
262
261 c = AttributeDict()
263 c = AttributeDict()
262 c.error_message = base_response.status
264 c.error_message = base_response.status
263 c.error_explanation = base_response.explanation or str(base_response)
265 c.error_explanation = base_response.explanation or str(base_response)
264 c.visual = AttributeDict()
266 c.visual = AttributeDict()
265
267
266 c.visual.rhodecode_support_url = (
268 c.visual.rhodecode_support_url = (
267 request.registry.settings.get('rhodecode_support_url') or
269 request.registry.settings.get('rhodecode_support_url') or
268 request.route_url('rhodecode_support')
270 request.route_url('rhodecode_support')
269 )
271 )
270 c.redirect_time = 0
272 c.redirect_time = 0
271 c.rhodecode_name = rc_config.get('rhodecode_title', '')
273 c.rhodecode_name = rc_config.get('rhodecode_title', '')
272 if not c.rhodecode_name:
274 if not c.rhodecode_name:
273 c.rhodecode_name = 'Rhodecode'
275 c.rhodecode_name = 'Rhodecode'
274
276
275 response = render_to_response(
277 response = render_to_response(
276 '/errors/error_document.html', {'c': c}, request=request,
278 '/errors/error_document.html', {'c': c}, request=request,
277 response=base_response)
279 response=base_response)
278
280
279 return response
281 return response
280
282
281
283
282 def includeme(config):
284 def includeme(config):
283 settings = config.registry.settings
285 settings = config.registry.settings
284
286
285 # plugin information
287 # plugin information
286 config.registry.rhodecode_plugins = OrderedDict()
288 config.registry.rhodecode_plugins = OrderedDict()
287
289
288 config.add_directive(
290 config.add_directive(
289 'register_rhodecode_plugin', register_rhodecode_plugin)
291 'register_rhodecode_plugin', register_rhodecode_plugin)
290
292
291 if asbool(settings.get('appenlight', 'false')):
293 if asbool(settings.get('appenlight', 'false')):
292 config.include('appenlight_client.ext.pyramid_tween')
294 config.include('appenlight_client.ext.pyramid_tween')
293
295
294 # Includes which are required. The application would fail without them.
296 # Includes which are required. The application would fail without them.
295 config.include('pyramid_mako')
297 config.include('pyramid_mako')
296 config.include('pyramid_beaker')
298 config.include('pyramid_beaker')
297 config.include('rhodecode.channelstream')
299 config.include('rhodecode.channelstream')
298 config.include('rhodecode.admin')
300 config.include('rhodecode.admin')
299 config.include('rhodecode.authentication')
301 config.include('rhodecode.authentication')
300 config.include('rhodecode.integrations')
302 config.include('rhodecode.integrations')
301 config.include('rhodecode.login')
303 config.include('rhodecode.login')
302 config.include('rhodecode.tweens')
304 config.include('rhodecode.tweens')
303 config.include('rhodecode.api')
305 config.include('rhodecode.api')
304 config.include('rhodecode.svn_support')
306 config.include('rhodecode.svn_support')
305 config.add_route(
307 config.add_route(
306 'rhodecode_support', 'https://rhodecode.com/help/', static=True)
308 'rhodecode_support', 'https://rhodecode.com/help/', static=True)
307
309
308 # Add subscribers.
310 # Add subscribers.
309 config.add_subscriber(scan_repositories_if_enabled, ApplicationCreated)
311 config.add_subscriber(scan_repositories_if_enabled, ApplicationCreated)
310
312
311 # Set the authorization policy.
313 # Set the authorization policy.
312 authz_policy = ACLAuthorizationPolicy()
314 authz_policy = ACLAuthorizationPolicy()
313 config.set_authorization_policy(authz_policy)
315 config.set_authorization_policy(authz_policy)
314
316
315 # Set the default renderer for HTML templates to mako.
317 # Set the default renderer for HTML templates to mako.
316 config.add_mako_renderer('.html')
318 config.add_mako_renderer('.html')
317
319
318 # include RhodeCode plugins
320 # include RhodeCode plugins
319 includes = aslist(settings.get('rhodecode.includes', []))
321 includes = aslist(settings.get('rhodecode.includes', []))
320 for inc in includes:
322 for inc in includes:
321 config.include(inc)
323 config.include(inc)
322
324
323 # This is the glue which allows us to migrate in chunks. By registering the
325 # This is the glue which allows us to migrate in chunks. By registering the
324 # pylons based application as the "Not Found" view in Pyramid, we will
326 # pylons based application as the "Not Found" view in Pyramid, we will
325 # fallback to the old application each time the new one does not yet know
327 # fallback to the old application each time the new one does not yet know
326 # how to handle a request.
328 # how to handle a request.
327 config.add_notfound_view(make_not_found_view(config))
329 config.add_notfound_view(make_not_found_view(config))
328
330
329 if not settings.get('debugtoolbar.enabled', False):
331 if not settings.get('debugtoolbar.enabled', False):
330 # if no toolbar, then any exception gets caught and rendered
332 # if no toolbar, then any exception gets caught and rendered
331 config.add_view(error_handler, context=Exception)
333 config.add_view(error_handler, context=Exception)
332
334
333 config.add_view(error_handler, context=HTTPError)
335 config.add_view(error_handler, context=HTTPError)
334
336
335
337
336 def includeme_first(config):
338 def includeme_first(config):
337 # redirect automatic browser favicon.ico requests to correct place
339 # redirect automatic browser favicon.ico requests to correct place
338 def favicon_redirect(context, request):
340 def favicon_redirect(context, request):
339 return redirect(
341 return redirect(
340 request.static_path('rhodecode:public/images/favicon.ico'))
342 request.static_path('rhodecode:public/images/favicon.ico'))
341
343
342 config.add_view(favicon_redirect, route_name='favicon')
344 config.add_view(favicon_redirect, route_name='favicon')
343 config.add_route('favicon', '/favicon.ico')
345 config.add_route('favicon', '/favicon.ico')
344
346
345 config.add_static_view(
347 config.add_static_view(
346 '_static/deform', 'deform:static')
348 '_static/deform', 'deform:static')
347 config.add_static_view(
349 config.add_static_view(
348 '_static/rhodecode', path='rhodecode:public', cache_max_age=3600 * 24)
350 '_static/rhodecode', path='rhodecode:public', cache_max_age=3600 * 24)
349
351
350
352
351 def wrap_app_in_wsgi_middlewares(pyramid_app, config):
353 def wrap_app_in_wsgi_middlewares(pyramid_app, config):
352 """
354 """
353 Apply outer WSGI middlewares around the application.
355 Apply outer WSGI middlewares around the application.
354
356
355 Part of this has been moved up from the Pylons layer, so that the
357 Part of this has been moved up from the Pylons layer, so that the
356 data is also available if old Pylons code is hit through an already ported
358 data is also available if old Pylons code is hit through an already ported
357 view.
359 view.
358 """
360 """
359 settings = config.registry.settings
361 settings = config.registry.settings
360
362
361 # enable https redirects based on HTTP_X_URL_SCHEME set by proxy
363 # enable https redirects based on HTTP_X_URL_SCHEME set by proxy
362 pyramid_app = HttpsFixup(pyramid_app, settings)
364 pyramid_app = HttpsFixup(pyramid_app, settings)
363
365
364 # Add RoutesMiddleware to support the pylons compatibility tween during
366 # Add RoutesMiddleware to support the pylons compatibility tween during
365 # migration to pyramid.
367 # migration to pyramid.
366 pyramid_app = SkippableRoutesMiddleware(
368 pyramid_app = SkippableRoutesMiddleware(
367 pyramid_app, config.registry._pylons_compat_config['routes.map'],
369 pyramid_app, config.registry._pylons_compat_config['routes.map'],
368 skip_prefixes=(STATIC_FILE_PREFIX, '/_debug_toolbar'))
370 skip_prefixes=(STATIC_FILE_PREFIX, '/_debug_toolbar'))
369
371
370 pyramid_app, _ = wrap_in_appenlight_if_enabled(pyramid_app, settings)
372 pyramid_app, _ = wrap_in_appenlight_if_enabled(pyramid_app, settings)
371
373
372 if settings['gzip_responses']:
374 if settings['gzip_responses']:
373 pyramid_app = make_gzip_middleware(
375 pyramid_app = make_gzip_middleware(
374 pyramid_app, settings, compress_level=1)
376 pyramid_app, settings, compress_level=1)
375
377
376 return pyramid_app
378 return pyramid_app
377
379
378
380
379 def sanitize_settings_and_apply_defaults(settings):
381 def sanitize_settings_and_apply_defaults(settings):
380 """
382 """
381 Applies settings defaults and does all type conversion.
383 Applies settings defaults and does all type conversion.
382
384
383 We would move all settings parsing and preparation into this place, so that
385 We would move all settings parsing and preparation into this place, so that
384 we have only one place left which deals with this part. The remaining parts
386 we have only one place left which deals with this part. The remaining parts
385 of the application would start to rely fully on well prepared settings.
387 of the application would start to rely fully on well prepared settings.
386
388
387 This piece would later be split up per topic to avoid a big fat monster
389 This piece would later be split up per topic to avoid a big fat monster
388 function.
390 function.
389 """
391 """
390
392
391 # Pyramid's mako renderer has to search in the templates folder so that the
393 # Pyramid's mako renderer has to search in the templates folder so that the
392 # old templates still work. Ported and new templates are expected to use
394 # old templates still work. Ported and new templates are expected to use
393 # real asset specifications for the includes.
395 # real asset specifications for the includes.
394 mako_directories = settings.setdefault('mako.directories', [
396 mako_directories = settings.setdefault('mako.directories', [
395 # Base templates of the original Pylons application
397 # Base templates of the original Pylons application
396 'rhodecode:templates',
398 'rhodecode:templates',
397 ])
399 ])
398 log.debug(
400 log.debug(
399 "Using the following Mako template directories: %s",
401 "Using the following Mako template directories: %s",
400 mako_directories)
402 mako_directories)
401
403
402 # Default includes, possible to change as a user
404 # Default includes, possible to change as a user
403 pyramid_includes = settings.setdefault('pyramid.includes', [
405 pyramid_includes = settings.setdefault('pyramid.includes', [
404 'rhodecode.lib.middleware.request_wrapper',
406 'rhodecode.lib.middleware.request_wrapper',
405 ])
407 ])
406 log.debug(
408 log.debug(
407 "Using the following pyramid.includes: %s",
409 "Using the following pyramid.includes: %s",
408 pyramid_includes)
410 pyramid_includes)
409
411
410 # TODO: johbo: Re-think this, usually the call to config.include
412 # TODO: johbo: Re-think this, usually the call to config.include
411 # should allow to pass in a prefix.
413 # should allow to pass in a prefix.
412 settings.setdefault('rhodecode.api.url', '/_admin/api')
414 settings.setdefault('rhodecode.api.url', '/_admin/api')
413
415
414 # Sanitize generic settings.
416 # Sanitize generic settings.
415 _list_setting(settings, 'default_encoding', 'UTF-8')
417 _list_setting(settings, 'default_encoding', 'UTF-8')
416 _bool_setting(settings, 'is_test', 'false')
418 _bool_setting(settings, 'is_test', 'false')
417 _bool_setting(settings, 'gzip_responses', 'false')
419 _bool_setting(settings, 'gzip_responses', 'false')
418
420
419 # Call split out functions that sanitize settings for each topic.
421 # Call split out functions that sanitize settings for each topic.
420 _sanitize_appenlight_settings(settings)
422 _sanitize_appenlight_settings(settings)
421 _sanitize_vcs_settings(settings)
423 _sanitize_vcs_settings(settings)
422
424
423 return settings
425 return settings
424
426
425
427
426 def _sanitize_appenlight_settings(settings):
428 def _sanitize_appenlight_settings(settings):
427 _bool_setting(settings, 'appenlight', 'false')
429 _bool_setting(settings, 'appenlight', 'false')
428
430
429
431
430 def _sanitize_vcs_settings(settings):
432 def _sanitize_vcs_settings(settings):
431 """
433 """
432 Applies settings defaults and does type conversion for all VCS related
434 Applies settings defaults and does type conversion for all VCS related
433 settings.
435 settings.
434 """
436 """
435 _string_setting(settings, 'vcs.svn.compatible_version', '')
437 _string_setting(settings, 'vcs.svn.compatible_version', '')
436 _string_setting(settings, 'git_rev_filter', '--all')
438 _string_setting(settings, 'git_rev_filter', '--all')
437 _string_setting(settings, 'vcs.hooks.protocol', 'pyro4')
439 _string_setting(settings, 'vcs.hooks.protocol', 'pyro4')
438 _string_setting(settings, 'vcs.server', '')
440 _string_setting(settings, 'vcs.server', '')
439 _string_setting(settings, 'vcs.server.log_level', 'debug')
441 _string_setting(settings, 'vcs.server.log_level', 'debug')
440 _string_setting(settings, 'vcs.server.protocol', 'pyro4')
442 _string_setting(settings, 'vcs.server.protocol', 'pyro4')
441 _bool_setting(settings, 'startup.import_repos', 'false')
443 _bool_setting(settings, 'startup.import_repos', 'false')
442 _bool_setting(settings, 'vcs.hooks.direct_calls', 'false')
444 _bool_setting(settings, 'vcs.hooks.direct_calls', 'false')
443 _bool_setting(settings, 'vcs.server.enable', 'true')
445 _bool_setting(settings, 'vcs.server.enable', 'true')
444 _bool_setting(settings, 'vcs.start_server', 'false')
446 _bool_setting(settings, 'vcs.start_server', 'false')
445 _list_setting(settings, 'vcs.backends', 'hg, git, svn')
447 _list_setting(settings, 'vcs.backends', 'hg, git, svn')
446
448
447
449
448 def _bool_setting(settings, name, default):
450 def _bool_setting(settings, name, default):
449 input = settings.get(name, default)
451 input = settings.get(name, default)
450 if isinstance(input, unicode):
452 if isinstance(input, unicode):
451 input = input.encode('utf8')
453 input = input.encode('utf8')
452 settings[name] = asbool(input)
454 settings[name] = asbool(input)
453
455
454
456
455 def _list_setting(settings, name, default):
457 def _list_setting(settings, name, default):
456 raw_value = settings.get(name, default)
458 raw_value = settings.get(name, default)
457
459
458 old_separator = ','
460 old_separator = ','
459 if old_separator in raw_value:
461 if old_separator in raw_value:
460 # If we get a comma separated list, pass it to our own function.
462 # If we get a comma separated list, pass it to our own function.
461 settings[name] = rhodecode_aslist(raw_value, sep=old_separator)
463 settings[name] = rhodecode_aslist(raw_value, sep=old_separator)
462 else:
464 else:
463 # Otherwise we assume it uses pyramids space/newline separation.
465 # Otherwise we assume it uses pyramids space/newline separation.
464 settings[name] = aslist(raw_value)
466 settings[name] = aslist(raw_value)
465
467
466
468
467 def _string_setting(settings, name, default):
469 def _string_setting(settings, name, default):
468 settings[name] = settings.get(name, default).lower()
470 settings[name] = settings.get(name, default).lower()
General Comments 0
You need to be logged in to leave comments. Login now