1 # -*- coding: utf-8 -*-
2 ##############################################################################
4 # OpenERP, Open Source Management Solution
5 # Copyright (C) 2011 OpenERP s.a. (<http://openerp.com>).
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU Affero General Public License as
9 # published by the Free Software Foundation, either version 3 of the
10 # License, or (at your option) any later version.
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU Affero General Public License for more details.
17 # You should have received a copy of the GNU Affero General Public License
18 # along with this program. If not, see <http://www.gnu.org/licenses/>.
20 ##############################################################################
22 """ WSGI stuffs (proof of concept for now)
24 This module offers a WSGI interface to OpenERP.
42 import openerp.modules
43 import openerp.tools.config as config
44 import service.websrv_lib as websrv_lib
46 # XML-RPC fault codes. Some care must be taken when changing these: the
47 # constants are also defined client-side and must remain in sync.
48 # User code must use the exceptions defined in ``openerp.exceptions`` (not
49 # create directly ``xmlrpclib.Fault`` objects).
50 XML_RPC_FAULT_CODE_APPLICATION_ERROR = 1
51 XML_RPC_FAULT_CODE_DEFERRED_APPLICATION_ERROR = 2
52 XML_RPC_FAULT_CODE_ACCESS_DENIED = 3
53 XML_RPC_FAULT_CODE_ACCESS_ERROR = 4
54 XML_RPC_FAULT_CODE_WARNING = 5
56 def xmlrpc_return(start_response, service, method, params):
58 Helper to call a service's method with some params, using a wsgi-supplied
59 ``start_response`` callback.
61 This is the place to look at to see the mapping between core exceptions
62 and XML-RPC fault codes.
64 # Map OpenERP core exceptions to XML-RPC fault codes. Specific exceptions
65 # defined in ``openerp.exceptions`` are mapped to specific fault codes;
66 # all the other exceptions are mapped to the generic
67 # XML_RPC_FAULT_CODE_APPLICATION_ERROR value.
68 # This also mimics SimpleXMLRPCDispatcher._marshaled_dispatch() for
71 result = openerp.netsvc.dispatch_rpc(service, method, params)
72 response = xmlrpclib.dumps((result,), methodresponse=1, allow_none=False, encoding=None)
73 except openerp.exceptions.Warning, e:
74 fault = xmlrpclib.Fault(XML_RPC_FAULT_CODE_WARNING, str(e))
75 response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
76 except openerp.exceptions.AccessError, e:
77 fault = xmlrpclib.Fault(XML_RPC_FAULT_CODE_ACCESS_ERROR, str(e))
78 response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
79 except openerp.exceptions.AccessDenied, e:
80 fault = xmlrpclib.Fault(XML_RPC_FAULT_CODE_ACCESS_DENIED, str(e))
81 response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
82 except openerp.exceptions.DeferredException, e:
84 # Which one is the best ?
85 formatted_info = "".join(traceback.format_exception(*info))
86 #formatted_info = openerp.tools.exception_to_unicode(e) + '\n' + info
87 fault = xmlrpclib.Fault(XML_RPC_FAULT_CODE_DEFERRED_APPLICATION_ERROR, formatted_info)
88 response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
91 # Which one is the best ?
92 formatted_info = "".join(traceback.format_exception(*info))
93 #formatted_info = openerp.tools.exception_to_unicode(e) + '\n' + info
94 fault = xmlrpclib.Fault(XML_RPC_FAULT_CODE_APPLICATION_ERROR, formatted_info)
95 response = xmlrpclib.dumps(fault, allow_none=None, encoding=None)
96 start_response("200 OK", [('Content-Type','text/xml'), ('Content-Length', str(len(response)))])
99 def wsgi_xmlrpc(environ, start_response):
100 """ The main OpenERP WSGI handler."""
101 if environ['REQUEST_METHOD'] == 'POST' and environ['PATH_INFO'].startswith('/openerp/6.1/xmlrpc'):
102 length = int(environ['CONTENT_LENGTH'])
103 data = environ['wsgi.input'].read(length)
105 params, method = xmlrpclib.loads(data)
107 path = environ['PATH_INFO'][len('/openerp/6.1/xmlrpc'):]
108 if path.startswith('/'): path = path[1:]
109 if path.endswith('/'): p = path[:-1]
110 path = path.split('/')
112 # All routes are hard-coded.
114 # No need for a db segment.
118 if service == 'common':
119 if method in ('server_version',):
121 return xmlrpc_return(start_response, service, method, params)
123 # A db segment must be given.
125 service, db_name = path
126 params = (db_name,) + params
128 if service == 'model':
130 return xmlrpc_return(start_response, service, method, params)
132 # TODO the body has been read, need to raise an exception (not return None).
134 def legacy_wsgi_xmlrpc(environ, start_response):
135 if environ['REQUEST_METHOD'] == 'POST' and environ['PATH_INFO'].startswith('/xmlrpc/'):
136 length = int(environ['CONTENT_LENGTH'])
137 data = environ['wsgi.input'].read(length)
138 path = environ['PATH_INFO'][len('/xmlrpc/'):] # expected to be one of db, object, ...
140 params, method = xmlrpclib.loads(data)
141 return xmlrpc_return(start_response, path, method, params)
143 def wsgi_jsonrpc(environ, start_response):
146 def wsgi_webdav(environ, start_response):
147 pi = environ['PATH_INFO']
148 if environ['REQUEST_METHOD'] == 'OPTIONS' and pi in ['*','/']:
149 return return_options(environ, start_response)
150 elif pi.startswith('/webdav'):
151 http_dir = websrv_lib.find_http_service(pi)
153 path = pi[len(http_dir.path):]
154 if path.startswith('/'):
155 environ['PATH_INFO'] = path
157 environ['PATH_INFO'] = '/' + path
158 return http_to_wsgi(http_dir)(environ, start_response)
160 def return_options(environ, start_response):
161 # Microsoft specific header, see
162 # http://www.ibm.com/developerworks/rational/library/2089.html
163 if 'Microsoft' in environ.get('User-Agent', ''):
164 option = [('MS-Author-Via', 'DAV')]
167 options += [('DAV', '1 2'), ('Allow', 'GET HEAD PROPFIND OPTIONS REPORT')]
168 start_response("200 OK", [('Content-Length', str(0))] + options)
171 def http_to_wsgi(http_dir):
173 Turn a BaseHTTPRequestHandler into a WSGI entry point.
175 Actually the argument is not a bare BaseHTTPRequestHandler but is wrapped
176 (as a class, so it needs to be instanciated) in a HTTPDir.
178 This code is adapted from wbsrv_lib.MultiHTTPHandler._handle_one_foreign().
179 It is a temporary solution: the HTTP sub-handlers (in particular the
180 document_webdav addon) have to be WSGIfied.
182 def wsgi_handler(environ, start_response):
184 # Extract from the WSGI environment the necessary data.
185 scheme = environ['wsgi.url_scheme']
188 for key, value in environ.items():
189 if key.startswith('HTTP_'):
190 key = key[5:].replace('_', '-').title()
192 if key == 'CONTENT_LENGTH':
193 key = key.replace('_', '-').title()
195 if environ.get('Content-Type'):
196 headers['Content-Type'] = environ['Content-Type']
198 path = urllib.quote(environ.get('PATH_INFO', ''))
199 if environ.get('QUERY_STRING'):
200 path += '?' + environ['QUERY_STRING']
202 request_version = 'HTTP/1.1' # TODO
203 request_line = "%s %s %s\n" % (environ['REQUEST_METHOD'], path, request_version)
208 # Let's pretend we have a server to hand to the handler.
210 server.server_name = environ['SERVER_NAME']
211 server.server_port = int(environ['SERVER_PORT'])
213 # Initialize the underlying handler and associated auth. provider.
214 con = openerp.service.websrv_lib.noconnection(environ['wsgi.input'])
215 handler = http_dir.instanciate_handler(con, environ['REMOTE_ADDR'], server)
217 # Populate the handler as if it is called by a regular HTTP server
218 # and the request is already parsed.
219 handler.wfile = StringIO.StringIO()
220 handler.rfile = environ['wsgi.input']
221 handler.headers = headers
222 handler.command = environ['REQUEST_METHOD']
224 handler.request_version = request_version
225 handler.close_connection = 1
226 handler.raw_requestline = request_line
227 handler.requestline = request_line
229 # Handle authentication if there is an auth. provider associated to
231 if hasattr(handler, 'auth_provider'):
233 handler.auth_provider.checkRequest(handler, path)
234 except websrv_lib.AuthRequiredExc, ae:
235 # Darwin 9.x.x webdav clients will report "HTTP/1.0" to us, while they support (and need) the
236 # authorisation features of HTTP/1.1
237 if request_version != 'HTTP/1.1' and ('Darwin/9.' not in handler.headers.get('User-Agent', '')):
238 start_response("403 Forbidden", [])
240 start_response("401 Authorization required", [
241 ('WWW-Authenticate', '%s realm="%s"' % (ae.atype,ae.realm)),
242 # ('Connection', 'keep-alive'),
243 ('Content-Type', 'text/html'),
244 ('Content-Length', 4), # len(self.auth_required_msg)
246 return ['Blah'] # self.auth_required_msg
247 except websrv_lib.AuthRejectedExc,e:
248 start_response("403 %s" % (e.args[0],), [])
251 method_name = 'do_' + handler.command
253 # Support the OPTIONS method even when not provided directly by the
254 # handler. TODO I would prefer to remove it and fix the handler if
256 if not hasattr(handler, method_name):
257 if handler.command == 'OPTIONS':
258 return return_options(environ, start_response)
259 start_response("501 Unsupported method (%r)" % handler.command, [])
262 # Finally, call the handler's method.
264 method = getattr(handler, method_name)
266 # The DAV handler buffers its output and provides a _flush()
268 getattr(handler, '_flush', lambda: None)()
269 response = parse_http_response(handler.wfile.getvalue())
270 response_headers = response.getheaders()
271 body = response.read()
272 start_response(str(response.status) + ' ' + response.reason, response_headers)
274 except (websrv_lib.AuthRejectedExc, websrv_lib.AuthRequiredExc):
277 start_response("500 Internal error", [])
282 def parse_http_response(s):
283 """ Turn a HTTP response string into a httplib.HTTPResponse object."""
284 class DummySocket(StringIO.StringIO):
286 This is used to provide a StringIO to httplib.HTTPResponse
287 which, instead of taking a file object, expects a socket and
288 uses its makefile() method.
290 def makefile(self, *args, **kw):
292 response = httplib.HTTPResponse(DummySocket(s))
296 # WSGI handlers registered through the register_wsgi_handler() function below.
299 def register_wsgi_handler(handler):
300 """ Register a WSGI handler.
302 Handlers are tried in the order they are added. We might provide a way to
303 register a handler for specific routes later.
305 module_handlers.append(handler)
307 def application(environ, start_response):
308 """ WSGI entry point."""
310 # Try all handlers until one returns some result (i.e. not None).
317 for handler in wsgi_handlers:
318 result = handler(environ, start_response)
323 # We never returned from the loop.
324 response = 'No handler found.\n'
325 start_response('404 Not Found', [('Content-Type', 'text/plain'), ('Content-Length', str(len(response)))])
328 # The WSGI server, started by start_server(), stopped by stop_server().
332 """ Serve HTTP requests via werkzeug development server.
334 If werkzeug can not be imported, we fall back to wsgiref's simple_server.
336 Calling this function is blocking, you might want to call it in its own
342 # TODO Change the xmlrpc_* options to http_*
343 interface = config['xmlrpc_interface'] or '0.0.0.0'
344 port = config['xmlrpc_port']
346 import werkzeug.serving
347 httpd = werkzeug.serving.make_server(interface, port, application, threaded=True)
348 logging.getLogger('wsgi').info('HTTP service (werkzeug) running on %s:%s', interface, port)
349 except ImportError, e:
350 import wsgiref.simple_server
351 logging.getLogger('wsgi').warn('Werkzeug module unavailable, falling back to wsgiref.')
352 httpd = wsgiref.simple_server.make_server(interface, port, application)
353 logging.getLogger('wsgi').info('HTTP service (wsgiref) running on %s:%s', interface, port)
355 httpd.serve_forever()
358 """ Call serve() in its own thread.
360 The WSGI server can be shutdown with stop_server() below.
362 threading.Thread(target=openerp.wsgi.serve).start()
365 """ Initiate the shutdown of the WSGI server.
367 The server is supposed to have been started by start_server() above.
372 # Master process id, can be used for signaling.
375 # Application setup before we can spawn any worker process.
376 # This is suitable for e.g. gunicorn's on_starting hook.
377 def on_starting(server):
379 arbiter_pid = os.getpid() # TODO check if this is true even after replacing the executable
380 config = openerp.tools.config
381 #openerp.tools.cache = kill_workers_cache
382 openerp.netsvc.init_logger()
383 openerp.osv.osv.start_object_proxy()
384 openerp.service.web_services.start_web_services()
386 # Install our own signal handler on the master process.
387 def when_ready(server):
388 # Hijack gunicorn's SIGWINCH handling; we can choose another one.
389 signal.signal(signal.SIGWINCH, make_winch_handler(server))
391 # Our signal handler will signal a SGIQUIT to all workers.
392 def make_winch_handler(server):
393 def handle_winch(sig, fram):
394 server.kill_workers(signal.SIGQUIT) # This is gunicorn specific.
397 # Kill gracefuly the workers (e.g. because we want to clear their cache).
398 # This is done by signaling a SIGWINCH to the master process, so it can be
399 # called by the workers themselves.
402 os.kill(arbiter_pid, signal.SIGWINCH)
404 if e.errno == errno.ESRCH: # no such pid
408 class kill_workers_cache(openerp.tools.ormcache):
409 def clear(self, dbname, *args, **kwargs):
412 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: