Merge lp:~openerp-dev/openerp-web/trunk-routedeco-chs into lp:openerp-web

[Antony Lesuisse (OpenERP)]

[lp:~openerp-dev/openerp-web/trunk-routedeco-chs]

3493. By Christophe Simonis (OpenERP) on 2013-04-15

merge upstream

3494. By Christophe Simonis (OpenERP) on 2013-05-02

merge upstream

Unmerged revisions

3494. By Christophe Simonis (OpenERP) on 2013-05-02

merge upstream

3493. By Christophe Simonis (OpenERP) on 2013-04-15

merge upstream

3492. By Christophe Simonis (OpenERP) on 2012-11-24

[FIX] do not reimport already imported modules

3491. By Christophe Simonis (OpenERP) on 2012-11-24

[FIX] correct logging of plain function

3490. By Christophe Simonis (OpenERP) on 2012-11-24

[FIX] allow multiple routes for a function

3489. By Christophe Simonis (OpenERP) on 2012-11-24

[FIX] host_matching

3488. By Christophe Simonis (OpenERP) on 2012-11-24

[FIX] deactivate host_matching for routes

3487. By Christophe Simonis (OpenERP) on 2012-11-24

[IMP] web: use werkzeug for routing

=== modified file 'addons/web/controllers/main.py'
--- addons/web/controllers/main.py	2013-04-24 10:20:25 +0000
+++ addons/web/controllers/main.py	2013-05-02 09:39:32 +0000
@@ -1129,6 +1129,7 @@
         return self._call_kw(req, model, method, args, {})
 
     @openerpweb.jsonrequest
+    @openerpweb.app.route(_cp_path + '/call_kw/<model>:<method>', json=True)    # for debug mode
     def call_kw(self, req, model, method, args, kwargs):
         return self._call_kw(req, model, method, args, kwargs)
 
@@ -1455,8 +1456,8 @@
         """
         return sorted([
             controller.fmt
-            for path, controller in openerpweb.controllers_path.iteritems()
-            if path.startswith(self._cp_path)
+            for controller in self.__class__.__subclasses__()
+            if controller._cp_path.startswith(self._cp_path)
             if hasattr(controller, 'fmt')
         ], key=operator.itemgetter("label"))
 
 
=== modified file 'addons/web/http.py'
--- addons/web/http.py	2013-04-24 10:20:25 +0000
+++ addons/web/http.py	2013-05-02 09:39:32 +0000
@@ -36,6 +36,12 @@
 
 _logger = logging.getLogger(__name__)
 
+
+def str_method(method):
+    if hasattr(method, 'im_class'):
+        return '{0.im_class.__name__}.{0.__name__}'.format(method)
+    return '{0.__module__}.{0.__name__}'.format(method)
+
 #----------------------------------------------------------
 # RequestHandler
 #----------------------------------------------------------
@@ -198,7 +204,7 @@
                 self.jsonrequest = simplejson.loads(request, object_hook=reject_nonliteral)
             self.init(self.jsonrequest.get("params", {}))
             if _logger.isEnabledFor(logging.DEBUG):
-                _logger.debug("--> %s.%s\n%s", method.im_class.__name__, method.__name__, pprint.pformat(self.jsonrequest))
+                _logger.debug("--> %s\n%s", str_method(method), pprint.pformat(self.jsonrequest))
             response['id'] = self.jsonrequest.get('id')
             response["result"] = method(self, **self.params)
         except session.AuthenticationError, e:
@@ -292,7 +298,7 @@
                 akw[key] = value
             else:
                 akw[key] = type(value)
-        _logger.debug("%s --> %s.%s %r", self.httprequest.method, method.im_class.__name__, method.__name__, akw)
+        _logger.debug("%s --> %s %r", self.httprequest.method, str_method(method), akw)
         try:
             r = method(self, **self.params)
         except Exception, e:
@@ -352,22 +358,40 @@
 #----------------------------------------------------------
 # Controller registration with a metaclass
 #----------------------------------------------------------
-addons_module = {}
 addons_manifest = {}
-controllers_class = []
-controllers_class_path = {}
-controllers_object = {}
-controllers_object_path = {}
-controllers_path = {}
+_loaded_modules = []
 
 class ControllerType(type):
     def __init__(cls, name, bases, attrs):
         super(ControllerType, cls).__init__(name, bases, attrs)
-        name_class = ("%s.%s" % (cls.__module__, cls.__name__), cls)
-        controllers_class.append(name_class)
-        path = attrs.get('_cp_path')
-        if path not in controllers_class_path:
-            controllers_class_path[path] = name_class
+
+        p = attrs.get('_cp_path', None)
+        if not p:
+            return
+
+        p = p.rstrip('/') + '/'
+
+        for k, v in attrs.items():
+
+            if hasattr(v, 'endpoint'):
+                # function decorated by @route
+                # convert func to method
+                func, json = app._endpoint_funcs[v.endpoint]
+                assert func == v
+                app._endpoint_funcs[v.endpoint] = ((cls, k), json)
+
+            e = getattr(v, 'exposed', None)
+            if e not in ['http', 'json']:
+                continue
+
+            endpoint = '{0.__module__}.{0.__name__}.{1}'.format(cls, k)
+
+            if endpoint in app._endpoint_funcs and app._endpoint_funcs[endpoint][0] != (cls, k):
+                raise RuntimeError('endpoint %r already defined as %r' % (endpoint, app._endpoint_funcs[endpoint]))
+
+            path = p + (k if k != 'index' else '')
+            app._url_map.add(werkzeug.routing.Rule(path, endpoint=endpoint, host="<__domain__>"))
+            app._endpoint_funcs[endpoint] = ((cls, k), e == 'json')
 
 class Controller(object):
     __metaclass__ = ControllerType
@@ -502,21 +526,41 @@
             raise
     return path
 
-class Root(object):
-    """Root WSGI application for the OpenERP Web Client.
+class App(object):
+    """Main WSGI application for the OpenERP Web Client.
     """
     def __init__(self):
         self.addons = {}
-        self.statics = {}
-
-        self.load_addons()
-
-        # Setup http sessions
+        self._url_map = werkzeug.routing.Map(host_matching=True)
+        self._endpoint_funcs = {}
+
         path = session_path()
         self.session_store = werkzeug.contrib.sessions.FilesystemSessionStore(path)
         self.session_lock = threading.Lock()
         _logger.debug('HTTP sessions stored in: %s', path)
 
+    def setup(self):
+        static_dirs = self.load_addons()
+        app = werkzeug.wsgi.SharedDataMiddleware(self.dispatch, static_dirs)
+        self.dispatch = DisableCacheMiddleware(app)
+
+    def route(self, path_pattern, endpoint=None, defaults=None, host=None, json=False):
+        """register a route for current app"""
+        def decorator(func):
+            _endpoint = endpoint
+            if _endpoint is None:
+                _endpoint = '{0.__module__}.{0.__name__}'.format(func)
+
+            if _endpoint in self._endpoint_funcs and self._endpoint_funcs[_endpoint][0] != func:
+                raise RuntimeError('endpoint %r already defined as %r' % (_endpoint, self._endpoint_funcs[_endpoint]))
+
+            _host = host if host else "<__domain__>"
+            self._url_map.add(werkzeug.routing.Rule(path_pattern, endpoint=_endpoint, defaults=defaults, host=_host))
+            self._endpoint_funcs[_endpoint] = (func, json)
+            func.endpoint = _endpoint
+            return func
+        return decorator
+
     def __call__(self, environ, start_response):
         """ Handle a WSGI request
         """
@@ -533,28 +577,35 @@
         request.parameter_storage_class = werkzeug.datastructures.ImmutableDict
         request.app = self
 
-        handler = self.find_handler(*(request.path.split('/')[1:]))
-
-        if not handler:
-            response = werkzeug.exceptions.NotFound()
-        else:
-            sid = request.cookies.get('sid')
-            if not sid:
-                sid = request.args.get('sid')
-
-            session_gc(self.session_store)
-
-            with session_context(request, self.session_store, self.session_lock, sid) as session:
-                result = handler(request)
-
-                if isinstance(result, basestring):
-                    headers=[('Content-Type', 'text/html; charset=utf-8'), ('Content-Length', len(result))]
-                    response = werkzeug.wrappers.Response(result, headers=headers)
-                else:
-                    response = result
-
-                if hasattr(response, 'set_cookie'):
-                    response.set_cookie('sid', session.sid)
+        urls = self._url_map.bind_to_environ(environ)
+
+        def dispatcher(endpoint, values):
+            func, isjson = self._endpoint_funcs[endpoint]
+            builder = [HttpRequest, JsonRequest][bool(isjson)]
+            if isinstance(func, tuple):
+                cls, mth = func
+                func = getattr(cls(), mth)
+            req = builder(request)
+            req.route_values = values
+            return req.dispatch(func)
+
+        sid = request.cookies.get('sid')
+        if not sid:
+            sid = request.args.get('sid')
+
+        session_gc(self.session_store)
+
+        with session_context(request, self.session_store, self.session_lock, sid) as session:
+            result = urls.dispatch(dispatcher, catch_http_exceptions=True)
+
+            if isinstance(result, basestring):
+                headers = [('Content-Type', 'text/html; charset=utf-8'), ('Content-Length', len(result))]
+                response = werkzeug.wrappers.Response(result, headers=headers)
+            else:
+                response = result
+
+            if hasattr(response, 'set_cookie'):
+                response.set_cookie('sid', session.sid)
 
         return response(environ, start_response)
 
@@ -564,62 +615,26 @@
 
         for addons_path in openerp.modules.module.ad_paths:
             for module in sorted(os.listdir(addons_path)):
-                if module not in addons_module:
+                fqn = 'openerp.addons.' + module
+                if fqn not in _loaded_modules:
                     manifest_path = os.path.join(addons_path, module, '__openerp__.py')
                     path_static = os.path.join(addons_path, module, 'static')
                     if os.path.isfile(manifest_path) and os.path.isdir(path_static):
                         manifest = ast.literal_eval(open(manifest_path).read())
                         manifest['addons_path'] = addons_path
-                        _logger.debug("Loading %s", module)
-                        if 'openerp.addons' in sys.modules:
-                            m = __import__('openerp.addons.' + module)
-                        else:
-                            m = __import__(module)
-                        addons_module[module] = m
+                        if fqn not in sys.modules:
+                            __import__(fqn)
                         addons_manifest[module] = manifest
-                        self.statics['/%s/static' % module] = path_static
-
-        for k, v in controllers_class_path.items():
-            if k not in controllers_object_path and hasattr(v[1], '_cp_path'):
-                o = v[1]()
-                controllers_object[v[0]] = o
+                        _loaded_modules.append(fqn)
+                        statics['/%s/static' % module] = path_static
                 controllers_object_path[k] = o
-                if hasattr(o, '_cp_path'):
-                    controllers_path[o._cp_path] = o
-
-        app = werkzeug.wsgi.SharedDataMiddleware(self.dispatch, self.statics)
-        self.dispatch = DisableCacheMiddleware(app)
-
-    def find_handler(self, *l):
-        """
-        Tries to discover the controller handling the request for the path
-        specified by the provided parameters
-
-        :param l: path sections to a controller or controller method
-        :returns: a callable matching the path sections, or ``None``
-        :rtype: ``Controller | None``
-        """
-        if l:
-            ps = '/' + '/'.join(filter(None, l))
-            method_name = 'index'
-            while ps:
-                c = controllers_path.get(ps)
-                if c:
-                    method = getattr(c, method_name, None)
-                    if method:
-                        exposed = getattr(method, 'exposed', False)
-                        if exposed == 'json':
-                            _logger.debug("Dispatch json to %s %s %s", ps, c, method_name)
-                            return lambda request: JsonRequest(request).dispatch(method)
-                        elif exposed == 'http':
-                            _logger.debug("Dispatch http to %s %s %s", ps, c, method_name)
-                            return lambda request: HttpRequest(request).dispatch(method)
-                ps, _slash, method_name = ps.rpartition('/')
-                if not ps and method_name:
-                    ps = '/'
-        return None
+
+        return statics
+
+app = App()
 
 def wsgi_postload():
-    openerp.wsgi.register_wsgi_handler(Root())
+    app.setup()
+    openerp.wsgi.register_wsgi_handler(app)
 
 # vim:et:ts=4:sw=4: