"""
-from wsgiref.simple_server import make_server
-from SimpleXMLRPCServer import SimpleXMLRPCDispatcher
+import httplib
+import urllib
import xmlrpclib
+import StringIO
+import logging
import os
import signal
import sys
+import threading
import time
import openerp
import openerp.tools.config as config
+import openerp.service.websrv_lib as websrv_lib
def xmlrpc_return(start_response, service, method, params):
""" Helper to call a service's method with some params, using a
wsgi-supplied ``start_response`` callback."""
- result = openerp.netsvc.ExportService.getService(service).dispatch(method, None, params)
- response = xmlrpclib.dumps((result,), methodresponse=1, allow_none=False, encoding=None)
+ # This mimics SimpleXMLRPCDispatcher._marshaled_dispatch() for exception
+ # handling.
+ try:
+ result = openerp.netsvc.dispatch_rpc(service, method, params, None) # TODO auth
+ response = xmlrpclib.dumps((result,), methodresponse=1, allow_none=False, encoding=None)
+ except openerp.netsvc.OpenERPDispatcherException, e:
+ fault = xmlrpclib.Fault(openerp.tools.exception_to_unicode(e.exception), e.traceback)
+ response = xmlrpclib.dumps(fault, allow_none=False, encoding=None)
+ except:
+ exc_type, exc_value, exc_tb = sys.exc_info()
+ fault = xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value))
+ response = xmlrpclib.dumps(fault, allow_none=None, encoding=None)
start_response("200 OK", [('Content-Type','text/xml'), ('Content-Length', str(len(response)))])
return [response]
length = int(environ['CONTENT_LENGTH'])
data = environ['wsgi.input'].read(length)
- # TODO see SimpleXMLRPCDispatcher._marshaled_dispatch() for some necessary handling.
- # TODO see OpenERPDispatcher for some othe handling (in particular, auth things).
params, method = xmlrpclib.loads(data)
path = environ['PATH_INFO'][len('/openerp/xmlrpc'):]
elif service == 'report':
return xmlrpc_return(start_response, 'report', method, params)
+ # TODO the body has been read, need to raise an exception (not return None).
+
def legacy_wsgi_xmlrpc(environ, start_response):
if environ['REQUEST_METHOD'] == 'POST' and environ['PATH_INFO'].startswith('/xmlrpc/'):
length = int(environ['CONTENT_LENGTH'])
data = environ['wsgi.input'].read(length)
path = environ['PATH_INFO'][len('/xmlrpc/'):] # expected to be one of db, object, ...
- # TODO see SimpleXMLRPCDispatcher._marshaled_dispatch() for some necessary handling.
- # TODO see OpenERPDispatcher for some othe handling (in particular, auth things).
params, method = xmlrpclib.loads(data)
return xmlrpc_return(start_response, path, method, params)
def wsgi_jsonrpc(environ, start_response):
pass
-def wsgi_modules(environ, start_response):
- """ WSGI handler dispatching to addons-provided entry points."""
- pass
+def wsgi_webdav(environ, start_response):
+ if environ['REQUEST_METHOD'] == 'OPTIONS' and environ['PATH_INFO'] == '*':
+ return return_options(environ, start_response)
+
+ http_dir = websrv_lib.find_http_service(environ['PATH_INFO'])
+ if http_dir:
+ path = environ['PATH_INFO'][len(http_dir.path):]
+ if path.startswith('/'):
+ environ['PATH_INFO'] = path
+ else:
+ environ['PATH_INFO'] = '/' + path
+ return http_to_wsgi(http_dir)(environ, start_response)
+
+def return_options(environ, start_response):
+ # Microsoft specific header, see
+ # http://www.ibm.com/developerworks/rational/library/2089.html
+ if 'Microsoft' in environ.get('User-Agent', ''):
+ option = [('MS-Author-Via', 'DAV')]
+ else:
+ option = []
+ options += [('DAV', '1 2'), ('Allow', 'GET HEAD PROPFIND OPTIONS REPORT')]
+ start_response("200 OK", [('Content-Length', str(0))] + options)
+ return []
+
+def http_to_wsgi(http_dir):
+ """
+ Turn a BaseHTTPRequestHandler into a WSGI entry point.
+
+ Actually the argument is not a bare BaseHTTPRequestHandler but is wrapped
+ (as a class, so it needs to be instanciated) in a HTTPDir.
-# WSGI handlers provided by modules loaded with the --load command-line option.
+ This code is adapted from wbsrv_lib.MultiHTTPHandler._handle_one_foreign().
+ It is a temporary solution: the HTTP sub-handlers (in particular the
+ document_webdav addon) have to be WSGIfied.
+ """
+ def wsgi_handler(environ, start_response):
+
+ # Extract from the WSGI environment the necessary data.
+ scheme = environ['wsgi.url_scheme']
+
+ headers = {}
+ for key, value in environ.items():
+ if key.startswith('HTTP_'):
+ key = key[5:].replace('_', '-').title()
+ headers[key] = value
+ if key == 'CONTENT_LENGTH':
+ key = key.replace('_', '-').title()
+ headers[key] = value
+ if environ.get('Content-Type'):
+ headers['Content-Type'] = environ['Content-Type']
+
+ path = urllib.quote(environ.get('PATH_INFO', ''))
+ if environ.get('QUERY_STRING'):
+ path += '?' + environ['QUERY_STRING']
+
+ request_version = 'HTTP/1.1' # TODO
+ request_line = "%s %s %s\n" % (environ['REQUEST_METHOD'], path, request_version)
+
+ class Dummy(object):
+ pass
+
+ # Let's pretend we have a server to hand to the handler.
+ server = Dummy()
+ server.server_name = environ['SERVER_NAME']
+ server.server_port = int(environ['SERVER_PORT'])
+
+ # Initialize the underlying handler and associated auth. provider.
+ con = openerp.service.websrv_lib.noconnection(environ['wsgi.input'])
+ handler = http_dir.instanciate_handler(con, environ['REMOTE_ADDR'], server)
+
+ # Populate the handler as if it is called by a regular HTTP server
+ # and the request is already parsed.
+ handler.wfile = StringIO.StringIO()
+ handler.rfile = environ['wsgi.input']
+ handler.headers = headers
+ handler.command = environ['REQUEST_METHOD']
+ handler.path = path
+ handler.request_version = request_version
+ handler.close_connection = 1
+ handler.raw_requestline = request_line
+ handler.requestline = request_line
+
+ # Handle authentication if there is an auth. provider associated to
+ # the handler.
+ if hasattr(handler, 'auth_provider'):
+ try:
+ handler.auth_provider.checkRequest(handler, path)
+ except websrv_lib.AuthRequiredExc, ae:
+ # Darwin 9.x.x webdav clients will report "HTTP/1.0" to us, while they support (and need) the
+ # authorisation features of HTTP/1.1
+ if request_version != 'HTTP/1.1' and ('Darwin/9.' not in handler.headers.get('User-Agent', '')):
+ start_response("403 Forbidden", [])
+ return []
+ start_response("401 Authorization required", [
+ ('WWW-Authenticate', '%s realm="%s"' % (ae.atype,ae.realm)),
+ # ('Connection', 'keep-alive'),
+ ('Content-Type', 'text/html'),
+ ('Content-Length', 4), # len(self.auth_required_msg)
+ ])
+ return ['Blah'] # self.auth_required_msg
+ except websrv_lib.AuthRejectedExc,e:
+ start_response("403 %s" % (e.args[0],), [])
+ return []
+
+ method_name = 'do_' + handler.command
+
+ # Support the OPTIONS method even when not provided directly by the
+ # handler. TODO I would prefer to remove it and fix the handler if
+ # needed.
+ if not hasattr(handler, method_name):
+ if handler.command == 'OPTIONS':
+ return return_options(environ, start_response)
+ start_response("501 Unsupported method (%r)" % handler.command, [])
+ return []
+
+ # Finally, call the handler's method.
+ try:
+ method = getattr(handler, method_name)
+ method()
+ # The DAV handler buffers its output and provides a _flush()
+ # method.
+ getattr(handler, '_flush', lambda: None)()
+ response = parse_http_response(handler.wfile.getvalue())
+ response_headers = response.getheaders()
+ body = response.read()
+ start_response(str(response.status) + ' ' + response.reason, response_headers)
+ return [body]
+ except (websrv_lib.AuthRejectedExc, websrv_lib.AuthRequiredExc):
+ raise
+ except Exception, e:
+ start_response("500 Internal error", [])
+ return []
+
+ return wsgi_handler
+
+def parse_http_response(s):
+ """ Turn a HTTP response string into a httplib.HTTPResponse object."""
+ class DummySocket(StringIO.StringIO):
+ """
+ This is used to provide a StringIO to httplib.HTTPResponse
+ which, instead of taking a file object, expects a socket and
+ uses its makefile() method.
+ """
+ def makefile(self, *args, **kw):
+ return self
+ response = httplib.HTTPResponse(DummySocket(s))
+ response.begin()
+ return response
+
+# WSGI handlers registered through the register_wsgi_handler() function below.
module_handlers = []
def register_wsgi_handler(handler):
wsgi_xmlrpc,
wsgi_jsonrpc,
legacy_wsgi_xmlrpc,
- wsgi_modules,
+ wsgi_webdav
] + module_handlers
for handler in wsgi_handlers:
result = handler(environ, start_response)
continue
return result
- # We never returned from the loop. Needs something else than 200 OK.
+ # We never returned from the loop.
response = 'No handler found.\n'
- start_response('200 OK', [('Content-Type', 'text/plain'), ('Content-Length', str(len(response)))])
+ start_response('404 Not Found', [('Content-Type', 'text/plain'), ('Content-Length', str(len(response)))])
return [response]
+# The WSGI server, started by start_server(), stopped by stop_server().
+httpd = None
+
def serve():
- """ Serve XMLRPC requests via wsgiref's simple_server.
+ """ Serve HTTP requests via werkzeug development server.
- Blocking, should probably be called in its own process.
+ If werkzeug can not be imported, we fall back to wsgiref's simple_server.
+
+ Calling this function is blocking, you might want to call it in its own
+ thread.
"""
- httpd = make_server('localhost', config['xmlrpc_port'], application)
+
+ global httpd
+
+ # TODO Change the xmlrpc_port option to http_port.
+ try:
+ import werkzeug.serving
+ httpd = werkzeug.serving.make_server('0.0.0.0', config['xmlrpc_port'], application, threaded=True)
+ except ImportError, e:
+ import wsgiref.simple_server
+ logging.getLogger('wsgi').warn('Can not import werkzeug, ' 'falling back to wsgiref.')
+ httpd = wsgiref.simple_server.make_server('0.0.0.0', config['xmlrpc_port'], application)
+
httpd.serve_forever()
+def start_server():
+ """ Call serve() in its own thread.
+
+ The WSGI server can be shutdown with stop_server() below.
+ """
+ threading.Thread(target=openerp.wsgi.serve).start()
+
+def stop_server():
+ """ Initiate the shutdown of the WSGI server.
+
+ The server is supposed to have been started by start_server() above.
+ """
+ if httpd:
+ httpd.shutdown()
+
# Master process id, can be used for signaling.
arbiter_pid = None
global arbiter_pid
arbiter_pid = os.getpid() # TODO check if this is true even after replacing the executable
config = openerp.tools.config
- config['addons_path'] = '/home/openerp/repos/addons/trunk-xmlrpc-no-osv-memory' # need a config file
#openerp.tools.cache = kill_workers_cache
openerp.netsvc.init_logger()
openerp.osv.osv.start_object_proxy()
projects / odoo / odoo.git / blobdiff