##// END OF EJS Templates
views: skip vcsdetection for ops view
super-admin -
r4721:6968978f default
parent child
Show More
@@ -1,280 +1,283
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
165
166 # static files no detection
166 # static files no detection
167 '_static',
167 '_static',
168
168
169 # skip ops ping
170 '_admin/ops/ping',
171
169 # full channelstream connect should be VCS skipped
172 # full channelstream connect should be VCS skipped
170 '_admin/channelstream/connect',
173 '_admin/channelstream/connect',
171 ]
174 ]
172
175
173 path_info = environ['PATH_INFO']
176 path_info = environ['PATH_INFO']
174
177
175 path_elem = get_path_elem(path_info)
178 path_elem = get_path_elem(path_info)
176
179
177 if path_elem in white_list:
180 if path_elem in white_list:
178 log.debug('path `%s` in whitelist, skipping...', path_info)
181 log.debug('path `%s` in whitelist, skipping...', path_info)
179 return handler
182 return handler
180
183
181 path_url = path_info.lstrip('/')
184 path_url = path_info.lstrip('/')
182 if path_url in white_list:
185 if path_url in white_list:
183 log.debug('full url path `%s` in whitelist, skipping...', path_url)
186 log.debug('full url path `%s` in whitelist, skipping...', path_url)
184 return handler
187 return handler
185
188
186 if VCS_TYPE_KEY in environ:
189 if VCS_TYPE_KEY in environ:
187 raw_type = environ[VCS_TYPE_KEY]
190 raw_type = environ[VCS_TYPE_KEY]
188 if raw_type == VCS_TYPE_SKIP:
191 if raw_type == VCS_TYPE_SKIP:
189 log.debug('got `skip` marker for vcs detection, skipping...')
192 log.debug('got `skip` marker for vcs detection, skipping...')
190 return handler
193 return handler
191
194
192 _check, handler = checks.get(raw_type) or [None, None]
195 _check, handler = checks.get(raw_type) or [None, None]
193 if handler:
196 if handler:
194 log.debug('got handler:%s from environ', handler)
197 log.debug('got handler:%s from environ', handler)
195
198
196 if not handler:
199 if not handler:
197 log.debug('request start: checking if request for `%s` is of VCS type in order: %s', path_elem, backends)
200 log.debug('request start: checking if request for `%s` is of VCS type in order: %s', path_elem, backends)
198 for vcs_type in backends:
201 for vcs_type in backends:
199 vcs_check, _handler = checks[vcs_type]
202 vcs_check, _handler = checks[vcs_type]
200 if vcs_check(environ):
203 if vcs_check(environ):
201 log.debug('vcs handler found %s', _handler)
204 log.debug('vcs handler found %s', _handler)
202 handler = _handler
205 handler = _handler
203 break
206 break
204
207
205 return handler
208 return handler
206
209
207
210
208 class VCSMiddleware(object):
211 class VCSMiddleware(object):
209
212
210 def __init__(self, app, registry, config, appenlight_client):
213 def __init__(self, app, registry, config, appenlight_client):
211 self.application = app
214 self.application = app
212 self.registry = registry
215 self.registry = registry
213 self.config = config
216 self.config = config
214 self.appenlight_client = appenlight_client
217 self.appenlight_client = appenlight_client
215 self.use_gzip = True
218 self.use_gzip = True
216 # order in which we check the middlewares, based on vcs.backends config
219 # order in which we check the middlewares, based on vcs.backends config
217 self.check_middlewares = config['vcs.backends']
220 self.check_middlewares = config['vcs.backends']
218
221
219 def vcs_config(self, repo_name=None):
222 def vcs_config(self, repo_name=None):
220 """
223 """
221 returns serialized VcsSettings
224 returns serialized VcsSettings
222 """
225 """
223 try:
226 try:
224 return VcsSettingsModel(
227 return VcsSettingsModel(
225 repo=repo_name).get_ui_settings_as_config_obj()
228 repo=repo_name).get_ui_settings_as_config_obj()
226 except Exception:
229 except Exception:
227 pass
230 pass
228
231
229 def wrap_in_gzip_if_enabled(self, app, config):
232 def wrap_in_gzip_if_enabled(self, app, config):
230 if self.use_gzip:
233 if self.use_gzip:
231 app = GunzipMiddleware(app)
234 app = GunzipMiddleware(app)
232 return app
235 return app
233
236
234 def _get_handler_app(self, environ):
237 def _get_handler_app(self, environ):
235 app = None
238 app = None
236 log.debug('VCSMiddleware: detecting vcs type.')
239 log.debug('VCSMiddleware: detecting vcs type.')
237 handler = detect_vcs_request(environ, self.check_middlewares)
240 handler = detect_vcs_request(environ, self.check_middlewares)
238 if handler:
241 if handler:
239 app = handler(self.config, self.registry)
242 app = handler(self.config, self.registry)
240
243
241 return app
244 return app
242
245
243 def __call__(self, environ, start_response):
246 def __call__(self, environ, start_response):
244 # check if we handle one of interesting protocols, optionally extract
247 # check if we handle one of interesting protocols, optionally extract
245 # specific vcsSettings and allow changes of how things are wrapped
248 # specific vcsSettings and allow changes of how things are wrapped
246 vcs_handler = self._get_handler_app(environ)
249 vcs_handler = self._get_handler_app(environ)
247 if vcs_handler:
250 if vcs_handler:
248 # translate the _REPO_ID into real repo NAME for usage
251 # translate the _REPO_ID into real repo NAME for usage
249 # in middleware
252 # in middleware
250 environ['PATH_INFO'] = vcs_handler._get_by_id(environ['PATH_INFO'])
253 environ['PATH_INFO'] = vcs_handler._get_by_id(environ['PATH_INFO'])
251
254
252 # Set acl, url and vcs repo names.
255 # Set acl, url and vcs repo names.
253 vcs_handler.set_repo_names(environ)
256 vcs_handler.set_repo_names(environ)
254
257
255 # register repo config back to the handler
258 # register repo config back to the handler
256 vcs_conf = self.vcs_config(vcs_handler.acl_repo_name)
259 vcs_conf = self.vcs_config(vcs_handler.acl_repo_name)
257 # maybe damaged/non existent settings. We still want to
260 # maybe damaged/non existent settings. We still want to
258 # pass that point to validate on is_valid_and_existing_repo
261 # pass that point to validate on is_valid_and_existing_repo
259 # and return proper HTTP Code back to client
262 # and return proper HTTP Code back to client
260 if vcs_conf:
263 if vcs_conf:
261 vcs_handler.repo_vcs_config = vcs_conf
264 vcs_handler.repo_vcs_config = vcs_conf
262
265
263 # check for type, presence in database and on filesystem
266 # check for type, presence in database and on filesystem
264 if not vcs_handler.is_valid_and_existing_repo(
267 if not vcs_handler.is_valid_and_existing_repo(
265 vcs_handler.acl_repo_name,
268 vcs_handler.acl_repo_name,
266 vcs_handler.base_path,
269 vcs_handler.base_path,
267 vcs_handler.SCM):
270 vcs_handler.SCM):
268 return HTTPNotFound()(environ, start_response)
271 return HTTPNotFound()(environ, start_response)
269
272
270 environ['REPO_NAME'] = vcs_handler.url_repo_name
273 environ['REPO_NAME'] = vcs_handler.url_repo_name
271
274
272 # Wrap handler in middlewares if they are enabled.
275 # Wrap handler in middlewares if they are enabled.
273 vcs_handler = self.wrap_in_gzip_if_enabled(
276 vcs_handler = self.wrap_in_gzip_if_enabled(
274 vcs_handler, self.config)
277 vcs_handler, self.config)
275 vcs_handler, _ = wrap_in_appenlight_if_enabled(
278 vcs_handler, _ = wrap_in_appenlight_if_enabled(
276 vcs_handler, self.config, self.appenlight_client)
279 vcs_handler, self.config, self.appenlight_client)
277
280
278 return vcs_handler(environ, start_response)
281 return vcs_handler(environ, start_response)
279
282
280 return self.application(environ, start_response)
283 return self.application(environ, start_response)
General Comments 0
You need to be logged in to leave comments. Login now