##// END OF EJS Templates
core: optimize some calls to skip license/scm detection on them
milka -
r4655:009d312e default
parent child Browse files
Show More
@@ -1,267 +1,280 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2020 RhodeCode GmbH
3 # Copyright (C) 2010-2020 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 import gzip
21 import gzip
22 import shutil
22 import shutil
23 import logging
23 import logging
24 import tempfile
24 import tempfile
25 import urlparse
25 import urlparse
26
26
27 from webob.exc import HTTPNotFound
27 from webob.exc import HTTPNotFound
28
28
29 import rhodecode
29 import rhodecode
30 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
30 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
31 from rhodecode.lib.middleware.simplegit import SimpleGit, GIT_PROTO_PAT
31 from rhodecode.lib.middleware.simplegit import SimpleGit, GIT_PROTO_PAT
32 from rhodecode.lib.middleware.simplehg import SimpleHg
32 from rhodecode.lib.middleware.simplehg import SimpleHg
33 from rhodecode.lib.middleware.simplesvn import SimpleSvn
33 from rhodecode.lib.middleware.simplesvn import SimpleSvn
34 from rhodecode.model.settings import VcsSettingsModel
34 from rhodecode.model.settings import VcsSettingsModel
35
35
36 log = logging.getLogger(__name__)
36 log = logging.getLogger(__name__)
37
37
38 VCS_TYPE_KEY = '_rc_vcs_type'
38 VCS_TYPE_KEY = '_rc_vcs_type'
39 VCS_TYPE_SKIP = '_rc_vcs_skip'
39 VCS_TYPE_SKIP = '_rc_vcs_skip'
40
40
41
41
42 def is_git(environ):
42 def is_git(environ):
43 """
43 """
44 Returns True if requests should be handled by GIT wsgi middleware
44 Returns True if requests should be handled by GIT wsgi middleware
45 """
45 """
46 is_git_path = GIT_PROTO_PAT.match(environ['PATH_INFO'])
46 is_git_path = GIT_PROTO_PAT.match(environ['PATH_INFO'])
47 log.debug(
47 log.debug(
48 'request path: `%s` detected as GIT PROTOCOL %s', environ['PATH_INFO'],
48 'request path: `%s` detected as GIT PROTOCOL %s', environ['PATH_INFO'],
49 is_git_path is not None)
49 is_git_path is not None)
50
50
51 return is_git_path
51 return is_git_path
52
52
53
53
54 def is_hg(environ):
54 def is_hg(environ):
55 """
55 """
56 Returns True if requests target is mercurial server - header
56 Returns True if requests target is mercurial server - header
57 ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.
57 ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.
58 """
58 """
59 is_hg_path = False
59 is_hg_path = False
60
60
61 http_accept = environ.get('HTTP_ACCEPT')
61 http_accept = environ.get('HTTP_ACCEPT')
62
62
63 if http_accept and http_accept.startswith('application/mercurial'):
63 if http_accept and http_accept.startswith('application/mercurial'):
64 query = urlparse.parse_qs(environ['QUERY_STRING'])
64 query = urlparse.parse_qs(environ['QUERY_STRING'])
65 if 'cmd' in query:
65 if 'cmd' in query:
66 is_hg_path = True
66 is_hg_path = True
67
67
68 log.debug(
68 log.debug(
69 'request path: `%s` detected as HG PROTOCOL %s', environ['PATH_INFO'],
69 'request path: `%s` detected as HG PROTOCOL %s', environ['PATH_INFO'],
70 is_hg_path)
70 is_hg_path)
71
71
72 return is_hg_path
72 return is_hg_path
73
73
74
74
75 def is_svn(environ):
75 def is_svn(environ):
76 """
76 """
77 Returns True if requests target is Subversion server
77 Returns True if requests target is Subversion server
78 """
78 """
79
79
80 http_dav = environ.get('HTTP_DAV', '')
80 http_dav = environ.get('HTTP_DAV', '')
81 magic_path_segment = rhodecode.CONFIG.get(
81 magic_path_segment = rhodecode.CONFIG.get(
82 'rhodecode_subversion_magic_path', '/!svn')
82 'rhodecode_subversion_magic_path', '/!svn')
83 is_svn_path = (
83 is_svn_path = (
84 'subversion' in http_dav or
84 'subversion' in http_dav or
85 magic_path_segment in environ['PATH_INFO']
85 magic_path_segment in environ['PATH_INFO']
86 or environ['REQUEST_METHOD'] in ['PROPFIND', 'PROPPATCH']
86 or environ['REQUEST_METHOD'] in ['PROPFIND', 'PROPPATCH']
87 )
87 )
88 log.debug(
88 log.debug(
89 'request path: `%s` detected as SVN PROTOCOL %s', environ['PATH_INFO'],
89 'request path: `%s` detected as SVN PROTOCOL %s', environ['PATH_INFO'],
90 is_svn_path)
90 is_svn_path)
91
91
92 return is_svn_path
92 return is_svn_path
93
93
94
94
95 class GunzipMiddleware(object):
95 class GunzipMiddleware(object):
96 """
96 """
97 WSGI middleware that unzips gzip-encoded requests before
97 WSGI middleware that unzips gzip-encoded requests before
98 passing on to the underlying application.
98 passing on to the underlying application.
99 """
99 """
100
100
101 def __init__(self, application):
101 def __init__(self, application):
102 self.app = application
102 self.app = application
103
103
104 def __call__(self, environ, start_response):
104 def __call__(self, environ, start_response):
105 accepts_encoding_header = environ.get('HTTP_CONTENT_ENCODING', b'')
105 accepts_encoding_header = environ.get('HTTP_CONTENT_ENCODING', b'')
106
106
107 if b'gzip' in accepts_encoding_header:
107 if b'gzip' in accepts_encoding_header:
108 log.debug('gzip detected, now running gunzip wrapper')
108 log.debug('gzip detected, now running gunzip wrapper')
109 wsgi_input = environ['wsgi.input']
109 wsgi_input = environ['wsgi.input']
110
110
111 if not hasattr(environ['wsgi.input'], 'seek'):
111 if not hasattr(environ['wsgi.input'], 'seek'):
112 # The gzip implementation in the standard library of Python 2.x
112 # The gzip implementation in the standard library of Python 2.x
113 # requires the '.seek()' and '.tell()' methods to be available
113 # requires the '.seek()' and '.tell()' methods to be available
114 # on the input stream. Read the data into a temporary file to
114 # on the input stream. Read the data into a temporary file to
115 # work around this limitation.
115 # work around this limitation.
116
116
117 wsgi_input = tempfile.SpooledTemporaryFile(64 * 1024 * 1024)
117 wsgi_input = tempfile.SpooledTemporaryFile(64 * 1024 * 1024)
118 shutil.copyfileobj(environ['wsgi.input'], wsgi_input)
118 shutil.copyfileobj(environ['wsgi.input'], wsgi_input)
119 wsgi_input.seek(0)
119 wsgi_input.seek(0)
120
120
121 environ['wsgi.input'] = gzip.GzipFile(fileobj=wsgi_input, mode='r')
121 environ['wsgi.input'] = gzip.GzipFile(fileobj=wsgi_input, mode='r')
122 # since we "Ungzipped" the content we say now it's no longer gzip
122 # since we "Ungzipped" the content we say now it's no longer gzip
123 # content encoding
123 # content encoding
124 del environ['HTTP_CONTENT_ENCODING']
124 del environ['HTTP_CONTENT_ENCODING']
125
125
126 # content length has changes ? or i'm not sure
126 # content length has changes ? or i'm not sure
127 if 'CONTENT_LENGTH' in environ:
127 if 'CONTENT_LENGTH' in environ:
128 del environ['CONTENT_LENGTH']
128 del environ['CONTENT_LENGTH']
129 else:
129 else:
130 log.debug('content not gzipped, gzipMiddleware passing '
130 log.debug('content not gzipped, gzipMiddleware passing '
131 'request further')
131 'request further')
132 return self.app(environ, start_response)
132 return self.app(environ, start_response)
133
133
134
134
135 def is_vcs_call(environ):
135 def is_vcs_call(environ):
136 if VCS_TYPE_KEY in environ:
136 if VCS_TYPE_KEY in environ:
137 raw_type = environ[VCS_TYPE_KEY]
137 raw_type = environ[VCS_TYPE_KEY]
138 return raw_type and raw_type != VCS_TYPE_SKIP
138 return raw_type and raw_type != VCS_TYPE_SKIP
139 return False
139 return False
140
140
141
141
142 def get_path_elem(route_path):
142 def get_path_elem(route_path):
143 if not route_path:
143 if not route_path:
144 return None
144 return None
145
145
146 cleaned_route_path = route_path.lstrip('/')
146 cleaned_route_path = route_path.lstrip('/')
147 if cleaned_route_path:
147 if cleaned_route_path:
148 cleaned_route_path_elems = cleaned_route_path.split('/')
148 cleaned_route_path_elems = cleaned_route_path.split('/')
149 if cleaned_route_path_elems:
149 if cleaned_route_path_elems:
150 return cleaned_route_path_elems[0]
150 return cleaned_route_path_elems[0]
151 return None
151 return None
152
152
153
153
154 def detect_vcs_request(environ, backends):
154 def detect_vcs_request(environ, backends):
155 checks = {
155 checks = {
156 'hg': (is_hg, SimpleHg),
156 'hg': (is_hg, SimpleHg),
157 'git': (is_git, SimpleGit),
157 'git': (is_git, SimpleGit),
158 'svn': (is_svn, SimpleSvn),
158 'svn': (is_svn, SimpleSvn),
159 }
159 }
160 handler = None
160 handler = None
161 # List of path views first chunk we don't do any checks
161 # List of path views first chunk we don't do any checks
162 white_list = [
162 white_list = [
163 # e.g /_file_store/download
163 # e.g /_file_store/download
164 '_file_store'
164 '_file_store',
165
166 # static files no detection
167 '_static',
168
169 # full channelstream connect should be VCS skipped
170 '_admin/channelstream/connect',
165 ]
171 ]
166
172
167 path_info = environ['PATH_INFO']
173 path_info = environ['PATH_INFO']
168
174
169 if get_path_elem(path_info) in white_list:
175 path_elem = get_path_elem(path_info)
176
177 if path_elem in white_list:
170 log.debug('path `%s` in whitelist, skipping...', path_info)
178 log.debug('path `%s` in whitelist, skipping...', path_info)
171 return handler
179 return handler
172
180
181 path_url = path_info.lstrip('/')
182 if path_url in white_list:
183 log.debug('full url path `%s` in whitelist, skipping...', path_url)
184 return handler
185
173 if VCS_TYPE_KEY in environ:
186 if VCS_TYPE_KEY in environ:
174 raw_type = environ[VCS_TYPE_KEY]
187 raw_type = environ[VCS_TYPE_KEY]
175 if raw_type == VCS_TYPE_SKIP:
188 if raw_type == VCS_TYPE_SKIP:
176 log.debug('got `skip` marker for vcs detection, skipping...')
189 log.debug('got `skip` marker for vcs detection, skipping...')
177 return handler
190 return handler
178
191
179 _check, handler = checks.get(raw_type) or [None, None]
192 _check, handler = checks.get(raw_type) or [None, None]
180 if handler:
193 if handler:
181 log.debug('got handler:%s from environ', handler)
194 log.debug('got handler:%s from environ', handler)
182
195
183 if not handler:
196 if not handler:
184 log.debug('request start: checking if request is of VCS type in order: %s', backends)
197 log.debug('request start: checking if request for `%s` is of VCS type in order: %s', path_elem, backends)
185 for vcs_type in backends:
198 for vcs_type in backends:
186 vcs_check, _handler = checks[vcs_type]
199 vcs_check, _handler = checks[vcs_type]
187 if vcs_check(environ):
200 if vcs_check(environ):
188 log.debug('vcs handler found %s', _handler)
201 log.debug('vcs handler found %s', _handler)
189 handler = _handler
202 handler = _handler
190 break
203 break
191
204
192 return handler
205 return handler
193
206
194
207
195 class VCSMiddleware(object):
208 class VCSMiddleware(object):
196
209
197 def __init__(self, app, registry, config, appenlight_client):
210 def __init__(self, app, registry, config, appenlight_client):
198 self.application = app
211 self.application = app
199 self.registry = registry
212 self.registry = registry
200 self.config = config
213 self.config = config
201 self.appenlight_client = appenlight_client
214 self.appenlight_client = appenlight_client
202 self.use_gzip = True
215 self.use_gzip = True
203 # order in which we check the middlewares, based on vcs.backends config
216 # order in which we check the middlewares, based on vcs.backends config
204 self.check_middlewares = config['vcs.backends']
217 self.check_middlewares = config['vcs.backends']
205
218
206 def vcs_config(self, repo_name=None):
219 def vcs_config(self, repo_name=None):
207 """
220 """
208 returns serialized VcsSettings
221 returns serialized VcsSettings
209 """
222 """
210 try:
223 try:
211 return VcsSettingsModel(
224 return VcsSettingsModel(
212 repo=repo_name).get_ui_settings_as_config_obj()
225 repo=repo_name).get_ui_settings_as_config_obj()
213 except Exception:
226 except Exception:
214 pass
227 pass
215
228
216 def wrap_in_gzip_if_enabled(self, app, config):
229 def wrap_in_gzip_if_enabled(self, app, config):
217 if self.use_gzip:
230 if self.use_gzip:
218 app = GunzipMiddleware(app)
231 app = GunzipMiddleware(app)
219 return app
232 return app
220
233
221 def _get_handler_app(self, environ):
234 def _get_handler_app(self, environ):
222 app = None
235 app = None
223 log.debug('VCSMiddleware: detecting vcs type.')
236 log.debug('VCSMiddleware: detecting vcs type.')
224 handler = detect_vcs_request(environ, self.check_middlewares)
237 handler = detect_vcs_request(environ, self.check_middlewares)
225 if handler:
238 if handler:
226 app = handler(self.config, self.registry)
239 app = handler(self.config, self.registry)
227
240
228 return app
241 return app
229
242
230 def __call__(self, environ, start_response):
243 def __call__(self, environ, start_response):
231 # check if we handle one of interesting protocols, optionally extract
244 # check if we handle one of interesting protocols, optionally extract
232 # specific vcsSettings and allow changes of how things are wrapped
245 # specific vcsSettings and allow changes of how things are wrapped
233 vcs_handler = self._get_handler_app(environ)
246 vcs_handler = self._get_handler_app(environ)
234 if vcs_handler:
247 if vcs_handler:
235 # translate the _REPO_ID into real repo NAME for usage
248 # translate the _REPO_ID into real repo NAME for usage
236 # in middleware
249 # in middleware
237 environ['PATH_INFO'] = vcs_handler._get_by_id(environ['PATH_INFO'])
250 environ['PATH_INFO'] = vcs_handler._get_by_id(environ['PATH_INFO'])
238
251
239 # Set acl, url and vcs repo names.
252 # Set acl, url and vcs repo names.
240 vcs_handler.set_repo_names(environ)
253 vcs_handler.set_repo_names(environ)
241
254
242 # register repo config back to the handler
255 # register repo config back to the handler
243 vcs_conf = self.vcs_config(vcs_handler.acl_repo_name)
256 vcs_conf = self.vcs_config(vcs_handler.acl_repo_name)
244 # maybe damaged/non existent settings. We still want to
257 # maybe damaged/non existent settings. We still want to
245 # pass that point to validate on is_valid_and_existing_repo
258 # pass that point to validate on is_valid_and_existing_repo
246 # and return proper HTTP Code back to client
259 # and return proper HTTP Code back to client
247 if vcs_conf:
260 if vcs_conf:
248 vcs_handler.repo_vcs_config = vcs_conf
261 vcs_handler.repo_vcs_config = vcs_conf
249
262
250 # check for type, presence in database and on filesystem
263 # check for type, presence in database and on filesystem
251 if not vcs_handler.is_valid_and_existing_repo(
264 if not vcs_handler.is_valid_and_existing_repo(
252 vcs_handler.acl_repo_name,
265 vcs_handler.acl_repo_name,
253 vcs_handler.base_path,
266 vcs_handler.base_path,
254 vcs_handler.SCM):
267 vcs_handler.SCM):
255 return HTTPNotFound()(environ, start_response)
268 return HTTPNotFound()(environ, start_response)
256
269
257 environ['REPO_NAME'] = vcs_handler.url_repo_name
270 environ['REPO_NAME'] = vcs_handler.url_repo_name
258
271
259 # Wrap handler in middlewares if they are enabled.
272 # Wrap handler in middlewares if they are enabled.
260 vcs_handler = self.wrap_in_gzip_if_enabled(
273 vcs_handler = self.wrap_in_gzip_if_enabled(
261 vcs_handler, self.config)
274 vcs_handler, self.config)
262 vcs_handler, _ = wrap_in_appenlight_if_enabled(
275 vcs_handler, _ = wrap_in_appenlight_if_enabled(
263 vcs_handler, self.config, self.appenlight_client)
276 vcs_handler, self.config, self.appenlight_client)
264
277
265 return vcs_handler(environ, start_response)
278 return vcs_handler(environ, start_response)
266
279
267 return self.application(environ, start_response)
280 return self.application(environ, start_response)
General Comments 0
You need to be logged in to leave comments. Login now