314 lines
11 KiB
Python
314 lines
11 KiB
Python
#!/usr/bin/python
|
|
import datetime
|
|
import urllib
|
|
import dateutil.relativedelta
|
|
import functools
|
|
import logging
|
|
import optparse
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import traceback
|
|
import uuid
|
|
import xmlrpclib
|
|
|
|
import cherrypy
|
|
import cherrypy.lib.static
|
|
import simplejson
|
|
|
|
import nonliterals
|
|
# TODO if from openerpserver use backendlocal
|
|
# from backendlocal import *
|
|
from backendrpc import *
|
|
|
|
#-----------------------------------------------------------
|
|
# Globals
|
|
#-----------------------------------------------------------
|
|
|
|
import __main__
|
|
|
|
path_root = __main__.path_root
|
|
path_addons = __main__.path_addons
|
|
cherrypy_root = None
|
|
|
|
#-----------------------------------------------------------
|
|
# Per Database Globals (might move into a pool if needed)
|
|
#-----------------------------------------------------------
|
|
|
|
applicationsession = {}
|
|
addons_module = {}
|
|
addons_manifest = {}
|
|
controllers_class = {}
|
|
controllers_object = {}
|
|
controllers_path = {}
|
|
|
|
#----------------------------------------------------------
|
|
# OpenERP Web RequestHandler
|
|
#----------------------------------------------------------
|
|
class CherryPyRequest(object):
|
|
""" CherryPy request handling
|
|
"""
|
|
def init(self,params):
|
|
self.params = params
|
|
# Move cherrypy thread local objects to attributes
|
|
self.applicationsession = applicationsession
|
|
self.httprequest = cherrypy.request
|
|
self.httpresponse = cherrypy.response
|
|
self.httpsession = cherrypy.session
|
|
self.httpsession_id = "cookieid"
|
|
# OpenERP session setup
|
|
self.session_id = self.params.pop("session_id", None) or uuid.uuid4().hex
|
|
host = cherrypy.config['openerp.server.host']
|
|
port = cherrypy.config['openerp.server.port']
|
|
self.session = self.httpsession.setdefault(self.session_id, OpenERPSession(host, port))
|
|
# Request attributes
|
|
self.context = self.params.pop('context', None)
|
|
self.debug = self.params.pop('debug',False) != False
|
|
|
|
class JsonRequest(CherryPyRequest):
|
|
""" JSON-RPC2 over HTTP.
|
|
|
|
Sucessful request::
|
|
|
|
--> {"jsonrpc": "2.0",
|
|
"method": "call",
|
|
"params": {"session_id": "SID",
|
|
"context": {},
|
|
"arg1": "val1" },
|
|
"id": null}
|
|
|
|
<-- {"jsonrpc": "2.0",
|
|
"result": { "res1": "val1" },
|
|
"id": null}
|
|
|
|
Request producing a error::
|
|
|
|
--> {"jsonrpc": "2.0",
|
|
"method": "call",
|
|
"params": {"session_id": "SID",
|
|
"context": {},
|
|
"arg1": "val1" },
|
|
"id": null}
|
|
|
|
<-- {"jsonrpc": "2.0",
|
|
"error": {"code": 1,
|
|
"message": "End user error message.",
|
|
"data": {"code": "codestring",
|
|
"debug": "traceback" } },
|
|
"id": null}
|
|
|
|
"""
|
|
|
|
def dispatch(self, controller, method, requestf=None, request=None):
|
|
""" Calls the method asked for by the JSON-RPC2 request
|
|
|
|
:param controller: the instance of the controller which received the request
|
|
:param method: the method which received the request
|
|
:param requestf: a file-like object containing an encoded JSON-RPC2 request
|
|
:param request: a JSON-RPC2 request
|
|
|
|
:returns: an utf8 encoded JSON-RPC2 reply
|
|
"""
|
|
response = {"jsonrpc": "2.0" }
|
|
error = None
|
|
try:
|
|
# Read POST content or POST Form Data named "request"
|
|
if requestf:
|
|
self.jsonrequest = simplejson.load(requestf, object_hook=nonliterals.non_literal_decoder)
|
|
else:
|
|
self.jsonrequest = simplejson.loads(request, object_hook=nonliterals.non_literal_decoder)
|
|
self.init(self.jsonrequest.get("params", {}))
|
|
if self.debug or 1:
|
|
print "--> %s.%s %s" % (controller.__class__.__name__, method.__name__, self.jsonrequest)
|
|
response['id'] = self.jsonrequest.get('id')
|
|
response["result"] = method(controller, self, **self.params)
|
|
except OpenERPUnboundException:
|
|
error = {
|
|
'code': 100,
|
|
'message': "OpenERP Session Invalid",
|
|
'data': {
|
|
'type': 'session_invalid',
|
|
'debug': traceback.format_exc()
|
|
}
|
|
}
|
|
except xmlrpclib.Fault, e:
|
|
error = {
|
|
'code': 200,
|
|
'message': "OpenERP Server Error",
|
|
'data': {
|
|
'type': 'server_exception',
|
|
'fault_code': e.faultCode,
|
|
'debug': "Client %s\nServer %s" % (
|
|
"".join(traceback.format_exception("", None, sys.exc_traceback)), e.faultString)
|
|
}
|
|
}
|
|
except Exception:
|
|
cherrypy.log("An error occured while handling a json request",
|
|
severity=logging.ERROR, traceback=True)
|
|
error = {
|
|
'code': 300,
|
|
'message': "OpenERP WebClient Error",
|
|
'data': {
|
|
'type': 'client_exception',
|
|
'debug': "Client %s" % traceback.format_exc()
|
|
}
|
|
}
|
|
if error:
|
|
response["error"] = error
|
|
|
|
if self.debug or 1:
|
|
print "<--", response
|
|
print
|
|
|
|
content = simplejson.dumps(response, cls=nonliterals.NonLiteralEncoder)
|
|
cherrypy.response.headers['Content-Type'] = 'application/json'
|
|
cherrypy.response.headers['Content-Length'] = len(content)
|
|
return content
|
|
|
|
def jsonrequest(f):
|
|
@cherrypy.expose
|
|
@functools.wraps(f)
|
|
def json_handler(controller):
|
|
return JsonRequest().dispatch(controller, f, requestf=cherrypy.request.body)
|
|
return json_handler
|
|
|
|
class HttpRequest(CherryPyRequest):
|
|
""" Regular GET/POST request
|
|
"""
|
|
def dispatch(self, controller, method, **kw):
|
|
self.init(kw)
|
|
akw = {}
|
|
for key in kw.keys():
|
|
if isinstance(kw[key], basestring) and len(kw[key]) < 1024:
|
|
akw[key] = kw[key]
|
|
else:
|
|
akw[key] = type(kw[key])
|
|
if self.debug or 1:
|
|
print "%s --> %s.%s %r" % (self.httprequest.method, controller.__class__.__name__, method.__name__, akw)
|
|
r = method(controller, self, **kw)
|
|
if self.debug or 1:
|
|
print "<--", 'size:', len(r)
|
|
print
|
|
return r
|
|
|
|
def httprequest(f):
|
|
# check cleaner wrapping:
|
|
# functools.wraps(f)(lambda x: JsonRequest().dispatch(x, f))
|
|
def http_handler(controller,*l, **kw):
|
|
return HttpRequest().dispatch(controller, f, **kw)
|
|
http_handler.exposed = 1
|
|
return http_handler
|
|
|
|
#-----------------------------------------------------------
|
|
# Cherrypy stuff
|
|
#-----------------------------------------------------------
|
|
|
|
class ControllerType(type):
|
|
def __init__(cls, name, bases, attrs):
|
|
super(ControllerType, cls).__init__(name, bases, attrs)
|
|
controllers_class["%s.%s" % (cls.__module__, cls.__name__)] = cls
|
|
|
|
class Controller(object):
|
|
__metaclass__ = ControllerType
|
|
|
|
class Root(object):
|
|
def __init__(self):
|
|
self.addons = {}
|
|
self._load_addons()
|
|
|
|
def _load_addons(self):
|
|
if path_addons not in sys.path:
|
|
sys.path.insert(0, path_addons)
|
|
for i in os.listdir(path_addons):
|
|
if i not in addons_module:
|
|
manifest_path = os.path.join(path_addons, i, '__openerp__.py')
|
|
if os.path.isfile(manifest_path):
|
|
manifest = eval(open(manifest_path).read())
|
|
print "Loading", i
|
|
m = __import__(i)
|
|
addons_module[i] = m
|
|
addons_manifest[i] = manifest
|
|
for k, v in controllers_class.items():
|
|
if k not in controllers_object:
|
|
o = v()
|
|
controllers_object[k] = o
|
|
if hasattr(o, '_cp_path'):
|
|
controllers_path[o._cp_path] = o
|
|
|
|
def default(self, *l, **kw):
|
|
print "default",l,kw
|
|
# handle static files
|
|
if len(l) > 2 and l[1] == 'static':
|
|
# sanitize path
|
|
p = os.path.normpath(os.path.join(*l))
|
|
p2 = os.path.join(path_addons, p)
|
|
print "p",p
|
|
print "p2",p2
|
|
|
|
return cherrypy.lib.static.serve_file(p2)
|
|
elif len(l) > 1:
|
|
for i in range(len(l), 1, -1):
|
|
ps = "/" + "/".join(l[0:i])
|
|
if ps in controllers_path:
|
|
c = controllers_path[ps]
|
|
rest = l[i:] or ['index']
|
|
meth = rest[0]
|
|
m = getattr(c, meth)
|
|
if getattr(m, 'exposed', 0):
|
|
print "Calling", ps, c, meth, m
|
|
return m(**kw)
|
|
raise cherrypy.NotFound('/' + '/'.join(l))
|
|
elif l and l[0] == 'mobile':
|
|
#for the mobile web client we are supposed to use a different url to just add '/mobile'
|
|
raise cherrypy.HTTPRedirect('/web_mobile/static/src/web_mobile.html', 301)
|
|
else:
|
|
if kw:
|
|
qs = '?' + urllib.urlencode(kw)
|
|
else:
|
|
qs = ''
|
|
raise cherrypy.HTTPRedirect('/base/webclient/home' + qs, 301)
|
|
default.exposed = True
|
|
|
|
def main(argv):
|
|
# change the timezone of the program to the OpenERP server's assumed timezone
|
|
os.environ["TZ"] = "UTC"
|
|
|
|
DEFAULT_CONFIG = {
|
|
'server.socket_host': '0.0.0.0',
|
|
'tools.sessions.on': True,
|
|
'tools.sessions.storage_type': 'file',
|
|
'tools.sessions.timeout': 60
|
|
}
|
|
|
|
# Parse config
|
|
op = optparse.OptionParser()
|
|
op.add_option("-p", "--port", dest="server.socket_port", default=8002, help="listening port", type="int", metavar="NUMBER")
|
|
op.add_option("-s", "--session-path", dest="tools.sessions.storage_path", default=os.path.join(tempfile.gettempdir(), "cpsessions"), help="directory used for session storage", metavar="DIR")
|
|
op.add_option("--server-host", dest="openerp.server.host", default='127.0.0.1', help="OpenERP server hostname", metavar="HOST")
|
|
op.add_option("--server-port", dest="openerp.server.port", default=8069, help="OpenERP server port", type="int", metavar="NUMBER")
|
|
op.add_option("--db-filter", dest="openerp.dbfilter", default='.*', help="Filter listed database", metavar="REGEXP")
|
|
(o, args) = op.parse_args(argv[1:])
|
|
o = vars(o)
|
|
for k in o.keys():
|
|
if o[k] is None:
|
|
del(o[k])
|
|
|
|
# Setup and run cherrypy
|
|
cherrypy.tree.mount(Root())
|
|
|
|
cherrypy.config.update(config=DEFAULT_CONFIG)
|
|
if os.path.exists(os.path.join(path_root,'openerp-web.cfg')):
|
|
cherrypy.config.update(os.path.join(path_root,'openerp-web.cfg'))
|
|
if os.path.exists(os.path.expanduser('~/.openerp_webrc')):
|
|
cherrypy.config.update(os.path.expanduser('~/.openerp_webrc'))
|
|
cherrypy.config.update(o)
|
|
|
|
if not os.path.exists(cherrypy.config['tools.sessions.storage_path']):
|
|
os.makedirs(cherrypy.config['tools.sessions.storage_path'], 0700)
|
|
|
|
cherrypy.server.subscribe()
|
|
cherrypy.engine.start()
|
|
cherrypy.engine.block()
|
|
|