diff --git a/addons/web/controllers/main.py b/addons/web/controllers/main.py
index 87355d075f3..708600fdb99 100644
--- a/addons/web/controllers/main.py
+++ b/addons/web/controllers/main.py
@@ -34,9 +34,9 @@ import openerp.modules.registry
 from openerp.tools.translate import _
 
 from .. import http
-openerpweb = http
+http = http
 
-from openerp.addons.web.http import request as req, noauth, nodb
+from openerp.addons.web.http import request, nodb, noauth
 
 #----------------------------------------------------------
 # OpenERP Web helpers
@@ -87,9 +87,9 @@ def rjsmin(script):
     return result
 
 def db_list():
-    proxy = req.session.proxy("db")
+    proxy = request.session.proxy("db")
     dbs = proxy.list()
-    h = req.httprequest.environ['HTTP_HOST'].split(':')[0]
+    h = request.httprequest.environ['HTTP_HOST'].split(':')[0]
     d = h.split('.')[0]
     r = openerp.tools.config['dbfilter'].replace('%h', h).replace('%d', d)
     dbs = [i for i in dbs if re.match(r, i)]
@@ -100,7 +100,7 @@ def db_monodb_redirect():
     redirect = False
 
     # 1 try the db in the url
-    db_url = req.params.get('db')
+    db_url = request.params.get('db')
     if db_url:
         return (db_url, False)
 
@@ -111,7 +111,7 @@ def db_monodb_redirect():
         dbs = []
 
     # 2 use the database from the cookie if it's listable and still listed
-    cookie_db = req.httprequest.cookies.get('last_used_database')
+    cookie_db = request.httprequest.cookies.get('last_used_database')
     if cookie_db in dbs:
         db = cookie_db
 
@@ -121,9 +121,9 @@ def db_monodb_redirect():
 
     # redirect to the chosen db if multiple are available
     if db and len(dbs) > 1:
-        query = dict(urlparse.parse_qsl(req.httprequest.query_string, keep_blank_values=True))
+        query = dict(urlparse.parse_qsl(request.httprequest.query_string, keep_blank_values=True))
         query.update({ 'db': db })
-        redirect = req.httprequest.path + '?' + urllib.urlencode(query)
+        redirect = request.httprequest.path + '?' + urllib.urlencode(query)
     return (db, redirect)
 
 def db_monodb():
@@ -131,9 +131,9 @@ def db_monodb():
     return db_monodb_redirect()[0]
 
 def redirect_with_hash(url, code=303):
-    if req.httprequest.user_agent.browser == 'msie':
+    if request.httprequest.user_agent.browser == 'msie':
         try:
-            version = float(req.httprequest.user_agent.version)
+            version = float(request.httprequest.user_agent.version)
             if version < 10:
                 return "<html><head><script>window.location = '%s#' + location.hash;</script></head></html>" % url
         except Exception:
@@ -186,18 +186,18 @@ def module_topological_sort(modules):
 
 def module_installed():
     # Candidates module the current heuristic is the /static dir
-    loadable = openerpweb.addons_manifest.keys()
+    loadable = http.addons_manifest.keys()
     modules = {}
 
     # Retrieve database installed modules
     # TODO The following code should move to ir.module.module.list_installed_modules()
-    Modules = req.session.model('ir.module.module')
+    Modules = request.session.model('ir.module.module')
     domain = [('state','=','installed'), ('name','in', loadable)]
     for module in Modules.search_read(domain, ['name', 'dependencies_id']):
         modules[module['name']] = []
         deps = module.get('dependencies_id')
         if deps:
-            deps_read = req.session.model('ir.module.module.dependency').read(deps, ['name'])
+            deps_read = request.session.model('ir.module.module.dependency').read(deps, ['name'])
             dependencies = [i['name'] for i in deps_read]
             modules[module['name']] = dependencies
 
@@ -205,7 +205,7 @@ def module_installed():
     return sorted_modules
 
 def module_installed_bypass_session(dbname):
-    loadable = openerpweb.addons_manifest.keys()
+    loadable = http.addons_manifest.keys()
     modules = {}
     try:
         registry = openerp.modules.registry.RegistryManager.get(dbname)
@@ -231,7 +231,7 @@ def module_boot(db=None):
     serverside = []
     dbside = []
     for i in server_wide_modules:
-        if i in openerpweb.addons_manifest:
+        if i in http.addons_manifest:
             serverside.append(i)
     monodb = db or db_monodb()
     if monodb:
@@ -317,7 +317,7 @@ def manifest_glob(extension, addons=None, db=None, include_remotes=False):
         addons = addons.split(',')
     r = []
     for addon in addons:
-        manifest = openerpweb.addons_manifest.get(addon, None)
+        manifest = http.addons_manifest.get(addon, None)
         if not manifest:
             continue
         # ensure does not ends with /
@@ -338,7 +338,7 @@ def manifest_list(extension, mods=None, db=None):
     db: a database name (return all installed modules in that database)
     """
     files = manifest_glob(extension, addons=mods, db=db, include_remotes=True)
-    if not req.debug:
+    if not request.debug:
         path = '/web/webclient/' + extension
         if mods is not None:
             path += '?' + urllib.urlencode({'mods': mods})
@@ -383,28 +383,28 @@ def make_conditional(response, last_modified=None, etag=None):
         response.last_modified = last_modified
     if etag:
         response.set_etag(etag)
-    return response.make_conditional(req.httprequest)
+    return response.make_conditional(request.httprequest)
 
 def login_and_redirect(db, login, key, redirect_url='/'):
-    wsgienv = req.httprequest.environ
+    wsgienv = request.httprequest.environ
     env = dict(
-        base_location=req.httprequest.url_root.rstrip('/'),
+        base_location=request.httprequest.url_root.rstrip('/'),
         HTTP_HOST=wsgienv['HTTP_HOST'],
         REMOTE_ADDR=wsgienv['REMOTE_ADDR'],
     )
-    req.session.authenticate(db, login, key, env)
+    request.session.authenticate(db, login, key, env)
     return set_cookie_and_redirect(redirect_url)
 
 def set_cookie_and_redirect(redirect_url):
     redirect = werkzeug.utils.redirect(redirect_url, 303)
     redirect.autocorrect_location_header = False
-    cookie_val = urllib2.quote(simplejson.dumps(req.session_id))
+    cookie_val = urllib2.quote(simplejson.dumps(request.session_id))
     redirect.set_cookie('instance0|session_id', cookie_val)
     return redirect
 
 def load_actions_from_ir_values(key, key2, models, meta):
-    Values = req.session.model('ir.values')
-    actions = Values.get(key, key2, models, meta, req.context)
+    Values = request.session.model('ir.values')
+    actions = Values.get(key, key2, models, meta, request.context)
 
     return [(id, name, clean_action(action))
             for id, name, action in actions]
@@ -530,8 +530,8 @@ def xml2json_from_elementtree(el, preserve_whitespaces=False):
 def content_disposition(filename):
     filename = filename.encode('utf8')
     escaped = urllib2.quote(filename)
-    browser = req.httprequest.user_agent.browser
-    version = int((req.httprequest.user_agent.version or '0').split('.')[0])
+    browser = request.httprequest.user_agent.browser
+    version = int((request.httprequest.user_agent.version or '0').split('.')[0])
     if browser == 'msie' and version < 9:
         return "attachment; filename=%s" % escaped
     elif browser == 'safari':
@@ -570,10 +570,10 @@ html_template = """<!DOCTYPE html>
 </html>
 """
 
-class Home(openerpweb.Controller):
+class Home(http.Controller):
     _cp_path = '/'
 
-    @openerpweb.httprequest
+    @http.httprequest
     @nodb
     def index(self, s_action=None, db=None, **kw):
         db, redir = db_monodb_redirect()
@@ -591,40 +591,40 @@ class Home(openerpweb.Controller):
         }
         return r
 
-    @openerpweb.httprequest
+    @http.httprequest
     def login(self, db, login, key):
         return login_and_redirect(db, login, key)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def jsonrpc(self, service, method, args):
         """ Method used by client APIs to contact OpenERP. """
         return openerp.netsvc.dispatch_rpc(service, method, args)
 
-class WebClient(openerpweb.Controller):
+class WebClient(http.Controller):
     _cp_path = "/web/webclient"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def csslist(self, mods=None):
         return manifest_list('css', mods=mods)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def jslist(self, mods=None):
         return manifest_list('js', mods=mods)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def qweblist(self, mods=None):
         return manifest_list('qweb', mods=mods)
 
-    @openerpweb.httprequest
+    @http.httprequest
     @nodb
     def css(self, mods=None, db=None):
         files = list(manifest_glob('css', addons=mods, db=db))
         last_modified = get_last_modified(f[0] for f in files)
-        if req.httprequest.if_modified_since and req.httprequest.if_modified_since >= last_modified:
+        if request.httprequest.if_modified_since and request.httprequest.if_modified_since >= last_modified:
             return werkzeug.wrappers.Response(status=304)
 
         file_map = dict(files)
@@ -668,38 +668,38 @@ class WebClient(openerpweb.Controller):
         content = '\n'.join(matches)
 
         return make_conditional(
-            req.make_response(content, [('Content-Type', 'text/css')]),
+            request.make_response(content, [('Content-Type', 'text/css')]),
             last_modified, checksum)
 
-    @openerpweb.httprequest
+    @http.httprequest
     @nodb
     def js(self, mods=None, db=None):
         files = [f[0] for f in manifest_glob('js', addons=mods, db=db)]
         last_modified = get_last_modified(files)
-        if req.httprequest.if_modified_since and req.httprequest.if_modified_since >= last_modified:
+        if request.httprequest.if_modified_since and request.httprequest.if_modified_since >= last_modified:
             return werkzeug.wrappers.Response(status=304)
 
         content, checksum = concat_js(files)
 
         return make_conditional(
-            req.make_response(content, [('Content-Type', 'application/javascript')]),
+            request.make_response(content, [('Content-Type', 'application/javascript')]),
             last_modified, checksum)
 
-    @openerpweb.httprequest
+    @http.httprequest
     @nodb
     def qweb(self, mods=None, db=None):
         files = [f[0] for f in manifest_glob('qweb', addons=mods, db=db)]
         last_modified = get_last_modified(files)
-        if req.httprequest.if_modified_since and req.httprequest.if_modified_since >= last_modified:
+        if request.httprequest.if_modified_since and request.httprequest.if_modified_since >= last_modified:
             return werkzeug.wrappers.Response(status=304)
 
         content, checksum = concat_xml(files)
 
         return make_conditional(
-            req.make_response(content, [('Content-Type', 'text/xml')]),
+            request.make_response(content, [('Content-Type', 'text/xml')]),
             last_modified, checksum)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def bootstrap_translations(self, mods):
         """ Load local translations from *.po files, as a temporary solution
@@ -709,12 +709,12 @@ class WebClient(openerpweb.Controller):
         # For performance reasons we only load a single translation, so for
         # sub-languages (that should only be partially translated) we load the
         # main language PO instead - that should be enough for the login screen.
-        lang = req.lang.split('_')[0]
+        lang = request.lang.split('_')[0]
 
         translations_per_module = {}
         for addon_name in mods:
-            if openerpweb.addons_manifest[addon_name].get('bootstrap'):
-                addons_path = openerpweb.addons_manifest[addon_name]['addons_path']
+            if http.addons_manifest[addon_name].get('bootstrap'):
+                addons_path = http.addons_manifest[addon_name]['addons_path']
                 f_name = os.path.join(addons_path, addon_name, "i18n", lang + ".po")
                 if not os.path.exists(f_name):
                     continue
@@ -723,9 +723,9 @@ class WebClient(openerpweb.Controller):
         return {"modules": translations_per_module,
                 "lang_parameters": None}
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def translations(self, mods, lang):
-        res_lang = req.session.model('res.lang')
+        res_lang = request.session.model('res.lang')
         ids = res_lang.search([("code", "=", lang)])
         lang_params = None
         if ids:
@@ -734,7 +734,7 @@ class WebClient(openerpweb.Controller):
 
         # Regional languages (ll_CC) must inherit/override their parent lang (ll), but this is
         # done server-side when the language is loaded, so we only need to load the user's lang.
-        ir_translation = req.session.model('ir.translation')
+        ir_translation = request.session.model('ir.translation')
         translations_per_module = {}
         messages = ir_translation.search_read([('module','in',mods),('lang','=',lang),
                                                ('comments','like','openerp-web'),('value','!=',False),
@@ -748,15 +748,15 @@ class WebClient(openerpweb.Controller):
         return {"modules": translations_per_module,
                 "lang_parameters": lang_params}
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def version_info(self):
         return openerp.service.common.exp_version()
 
-class Proxy(openerpweb.Controller):
+class Proxy(http.Controller):
     _cp_path = '/web/proxy'
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def load(self, path):
         """ Proxies an HTTP request through a JSON request.
@@ -770,37 +770,37 @@ class Proxy(openerpweb.Controller):
         from werkzeug.test import Client
         from werkzeug.wrappers import BaseResponse
 
-        return Client(req.httprequest.app, BaseResponse).get(path).data
+        return Client(request.httprequest.app, BaseResponse).get(path).data
 
-class Database(openerpweb.Controller):
+class Database(http.Controller):
     _cp_path = "/web/database"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def get_list(self):
         return db_list()
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def create(self, fields):
         params = dict(map(operator.itemgetter('name', 'value'), fields))
-        return req.session.proxy("db").create_database(
+        return request.session.proxy("db").create_database(
             params['super_admin_pwd'],
             params['db_name'],
             bool(params.get('demo_data')),
             params['db_lang'],
             params['create_admin_pwd'])
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def duplicate(self, fields):
         params = dict(map(operator.itemgetter('name', 'value'), fields))
-        return req.session.proxy("db").duplicate_database(
+        return request.session.proxy("db").duplicate_database(
             params['super_admin_pwd'],
             params['db_original_name'],
             params['db_name'])
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def duplicate(self, fields):
         params = dict(map(operator.itemgetter('name', 'value'), fields))
@@ -810,9 +810,9 @@ class Database(openerpweb.Controller):
             params['db_name'],
         )
 
-        return req.session.proxy("db").duplicate_database(*duplicate_attrs)
+        return request.session.proxy("db").duplicate_database(*duplicate_attrs)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def drop(self, fields):
         password, db = operator.itemgetter(
@@ -820,24 +820,24 @@ class Database(openerpweb.Controller):
                 dict(map(operator.itemgetter('name', 'value'), fields)))
 
         try:
-            return req.session.proxy("db").drop(password, db)
+            return request.session.proxy("db").drop(password, db)
         except openerp.exceptions.AccessDenied:
             return {'error': 'AccessDenied', 'title': 'Drop Database'}
         except Exception:
             return {'error': _('Could not drop database !'), 'title': _('Drop Database')}
 
-    @openerpweb.httprequest
+    @http.httprequest
     @nodb
     def backup(self, backup_db, backup_pwd, token):
         try:
             db_dump = base64.b64decode(
-                req.session.proxy("db").dump(backup_pwd, backup_db))
+                request.session.proxy("db").dump(backup_pwd, backup_db))
             filename = "%(db)s_%(timestamp)s.dump" % {
                 'db': backup_db,
                 'timestamp': datetime.datetime.utcnow().strftime(
                     "%Y-%m-%d_%H-%M-%SZ")
             }
-            return req.make_response(db_dump,
+            return request.make_response(db_dump,
                [('Content-Type', 'application/octet-stream; charset=binary'),
                ('Content-Disposition', content_disposition(filename))],
                {'fileToken': int(token)}
@@ -845,63 +845,63 @@ class Database(openerpweb.Controller):
         except Exception, e:
             return simplejson.dumps([[],[{'error': openerp.tools.ustr(e), 'title': _('Backup Database')}]])
 
-    @openerpweb.httprequest
+    @http.httprequest
     @nodb
     def restore(self, db_file, restore_pwd, new_db):
         try:
             data = base64.b64encode(db_file.read())
-            req.session.proxy("db").restore(restore_pwd, new_db, data)
+            request.session.proxy("db").restore(restore_pwd, new_db, data)
             return ''
         except openerp.exceptions.AccessDenied, e:
             raise Exception("AccessDenied")
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def change_password(self, fields):
         old_password, new_password = operator.itemgetter(
             'old_pwd', 'new_pwd')(
                 dict(map(operator.itemgetter('name', 'value'), fields)))
         try:
-            return req.session.proxy("db").change_admin_password(old_password, new_password)
+            return request.session.proxy("db").change_admin_password(old_password, new_password)
         except openerp.exceptions.AccessDenied:
             return {'error': 'AccessDenied', 'title': _('Change Password')}
         except Exception:
             return {'error': _('Error, password not changed !'), 'title': _('Change Password')}
 
-class Session(openerpweb.Controller):
+class Session(http.Controller):
     _cp_path = "/web/session"
 
     def session_info(self):
-        req.session.ensure_valid()
+        request.session.ensure_valid()
         return {
-            "session_id": req.session_id,
-            "uid": req.session._uid,
-            "user_context": req.session.get_context() if req.session._uid else {},
-            "db": req.session._db,
-            "username": req.session._login,
+            "session_id": request.session_id,
+            "uid": request.session._uid,
+            "user_context": request.session.get_context() if request.session._uid else {},
+            "db": request.session._db,
+            "username": request.session._login,
         }
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def get_session_info(self):
-        req.uid = req.session._uid
-        req.db = req.session._db
+        request.uid = request.session._uid
+        request.db = request.session._db
         return self.session_info()
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def authenticate(self, db, login, password, base_location=None):
-        wsgienv = req.httprequest.environ
+        wsgienv = request.httprequest.environ
         env = dict(
             base_location=base_location,
             HTTP_HOST=wsgienv['HTTP_HOST'],
             REMOTE_ADDR=wsgienv['REMOTE_ADDR'],
         )
-        req.session.authenticate(db, login, password, env)
+        request.session.authenticate(db, login, password, env)
 
         return self.session_info()
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def change_password (self, fields):
         old_password, new_password,confirm_password = operator.itemgetter('old_pwd', 'new_password','confirm_pwd')(
                 dict(map(operator.itemgetter('name', 'value'), fields)))
@@ -910,32 +910,32 @@ class Session(openerpweb.Controller):
         if new_password != confirm_password:
             return {'error': _('The new password and its confirmation must be identical.'),'title': _('Change Password')}
         try:
-            if req.session.model('res.users').change_password(
+            if request.session.model('res.users').change_password(
                 old_password, new_password):
                 return {'new_password':new_password}
         except Exception:
             return {'error': _('The old password you provided is incorrect, your password was not changed.'), 'title': _('Change Password')}
         return {'error': _('Error, password not changed !'), 'title': _('Change Password')}
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def sc_list(self):
-        return req.session.model('ir.ui.view_sc').get_sc(
-            req.session._uid, "ir.ui.menu", req.context)
+        return request.session.model('ir.ui.view_sc').get_sc(
+            request.session._uid, "ir.ui.menu", request.context)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     @nodb
     def get_lang_list(self):
         try:
-            return req.session.proxy("db").list_lang() or []
+            return request.session.proxy("db").list_lang() or []
         except Exception, e:
             return {"error": e, "title": _("Languages")}
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def modules(self):
         # return all installed modules. Web client is smart enough to not load a module twice
         return module_installed()
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def save_session_action(self, the_action):
         """
         This method store an action object in the session object and returns an integer
@@ -947,10 +947,10 @@ class Session(openerpweb.Controller):
         :return: A key identifying the saved action.
         :rtype: integer
         """
-        saved_actions = req.httpsession.get('saved_actions')
+        saved_actions = request.httpsession.get('saved_actions')
         if not saved_actions:
             saved_actions = {"next":1, "actions":{}}
-            req.httpsession['saved_actions'] = saved_actions
+            request.httpsession['saved_actions'] = saved_actions
         # we don't allow more than 10 stored actions
         if len(saved_actions["actions"]) >= 10:
             del saved_actions["actions"][min(saved_actions["actions"])]
@@ -959,7 +959,7 @@ class Session(openerpweb.Controller):
         saved_actions["next"] = key + 1
         return key
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def get_session_action(self, key):
         """
         Gets back a previously saved action. This method can return None if the action
@@ -970,57 +970,57 @@ class Session(openerpweb.Controller):
         :return: The saved action or None.
         :rtype: anything
         """
-        saved_actions = req.httpsession.get('saved_actions')
+        saved_actions = request.httpsession.get('saved_actions')
         if not saved_actions:
             return None
         return saved_actions["actions"].get(key)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def check(self):
-        req.session.assert_valid()
+        request.session.assert_valid()
         return None
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def destroy(self):
-        req.session._suicide = True
+        request.session._suicide = True
 
-class Menu(openerpweb.Controller):
+class Menu(http.Controller):
     _cp_path = "/web/menu"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def get_user_roots(self):
         """ Return all root menu ids visible for the session user.
 
         :return: the root menu ids
         :rtype: list(int)
         """
-        s = req.session
+        s = request.session
         Menus = s.model('ir.ui.menu')
         # If a menu action is defined use its domain to get the root menu items
         user_menu_id = s.model('res.users').read([s._uid], ['menu_id'],
-                                                 req.context)[0]['menu_id']
+                                                 request.context)[0]['menu_id']
 
         menu_domain = [('parent_id', '=', False)]
         if user_menu_id:
             domain_string = s.model('ir.actions.act_window').read(
-                [user_menu_id[0]], ['domain'],req.context)[0]['domain']
+                [user_menu_id[0]], ['domain'],request.context)[0]['domain']
             if domain_string:
                 menu_domain = ast.literal_eval(domain_string)
 
-        return Menus.search(menu_domain, 0, False, False, req.context)
+        return Menus.search(menu_domain, 0, False, False, request.context)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def load(self):
         """ Loads all menu items (all applications and their sub-menus).
 
         :return: the menu root
         :rtype: dict('children': menu_nodes)
         """
-        Menus = req.session.model('ir.ui.menu')
+        Menus = request.session.model('ir.ui.menu')
 
         fields = ['name', 'sequence', 'parent_id', 'action']
         menu_root_ids = self.get_user_roots()
-        menu_roots = Menus.read(menu_root_ids, fields, req.context) if menu_root_ids else []
+        menu_roots = Menus.read(menu_root_ids, fields, request.context) if menu_root_ids else []
         menu_root = {
             'id': False,
             'name': 'root',
@@ -1033,8 +1033,8 @@ class Menu(openerpweb.Controller):
 
         # menus are loaded fully unlike a regular tree view, cause there are a
         # limited number of items (752 when all 6.1 addons are installed)
-        menu_ids = Menus.search([('id', 'child_of', menu_root_ids)], 0, False, False, req.context)
-        menu_items = Menus.read(menu_ids, fields, req.context)
+        menu_ids = Menus.search([('id', 'child_of', menu_root_ids)], 0, False, False, request.context)
+        menu_items = Menus.read(menu_ids, fields, request.context)
         # adds roots at the end of the sequence, so that they will overwrite
         # equivalent menu items from full menu read when put into id:item
         # mapping, resulting in children being correctly set on the roots.
@@ -1060,26 +1060,26 @@ class Menu(openerpweb.Controller):
 
         return menu_root
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def load_needaction(self, menu_ids):
         """ Loads needaction counters for specific menu ids.
 
             :return: needaction data
             :rtype: dict(menu_id: {'needaction_enabled': boolean, 'needaction_counter': int})
         """
-        return req.session.model('ir.ui.menu').get_needaction_data(menu_ids, req.context)
+        return request.session.model('ir.ui.menu').get_needaction_data(menu_ids, request.context)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def action(self, menu_id):
         # still used by web_shortcut
         actions = load_actions_from_ir_values('action', 'tree_but_open',
                                              [('ir.ui.menu', menu_id)], False)
         return {"action": actions}
 
-class DataSet(openerpweb.Controller):
+class DataSet(http.Controller):
     _cp_path = "/web/dataset"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def search_read(self, model, fields=False, offset=0, limit=False, domain=None, sort=None):
         return self.do_search_read(model, fields, offset, limit, domain, sort)
     def do_search_read(self, model, fields=False, offset=0, limit=False, domain=None
@@ -1099,12 +1099,12 @@ class DataSet(openerpweb.Controller):
                   matching fields selection set)
         :rtype: list
         """
-        Model = req.session.model(model)
+        Model = request.session.model(model)
 
         ids = Model.search(domain, offset or 0, limit or False, sort or False,
-                           req.context)
+                           request.context)
         if limit and len(ids) == limit:
-            length = Model.search_count(domain, req.context)
+            length = Model.search_count(domain, request.context)
         else:
             length = len(ids) + (offset or 0)
         if fields and fields == ['id']:
@@ -1114,18 +1114,18 @@ class DataSet(openerpweb.Controller):
                 'records': [{'id': id} for id in ids]
             }
 
-        records = Model.read(ids, fields or False, req.context)
+        records = Model.read(ids, fields or False, request.context)
         records.sort(key=lambda obj: ids.index(obj['id']))
         return {
             'length': length,
             'records': records
         }
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def load(self, model, id, fields):
-        m = req.session.model(model)
+        m = request.session.model(model)
         value = {}
-        r = m.read([id], False, req.context)
+        r = m.read([id], False, request.context)
         if r:
             value = r[0]
         return {'value': value}
@@ -1137,36 +1137,36 @@ class DataSet(openerpweb.Controller):
         # Temporary implements future display_name special field for model#read()
         if method == 'read' and kwargs.get('context', {}).get('future_display_name'):
             if 'display_name' in args[1]:
-                names = dict(req.session.model(model).name_get(args[0], **kwargs))
+                names = dict(request.session.model(model).name_get(args[0], **kwargs))
                 args[1].remove('display_name')
-                records = req.session.model(model).read(*args, **kwargs)
+                records = request.session.model(model).read(*args, **kwargs)
                 for record in records:
                     record['display_name'] = \
                         names.get(record['id']) or "%s#%d" % (model, (record['id']))
                 return records
 
-        return getattr(req.session.model(model), method)(*args, **kwargs)
+        return getattr(request.session.model(model), method)(*args, **kwargs)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def call(self, model, method, args, domain_id=None, context_id=None):
         return self._call_kw(model, method, args, {})
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def call_kw(self, model, method, args, kwargs):
         return self._call_kw(model, method, args, kwargs)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def call_button(self, model, method, args, domain_id=None, context_id=None):
         action = self._call_kw(model, method, args, {})
         if isinstance(action, dict) and action.get('type') != '':
             return clean_action(action)
         return False
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def exec_workflow(self, model, id, signal):
-        return req.session.exec_workflow(model, id, signal)
+        return request.session.exec_workflow(model, id, signal)
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def resequence(self, model, ids, field='sequence', offset=0):
         """ Re-sequences a number of records in the model, by their ids
 
@@ -1181,7 +1181,7 @@ class DataSet(openerpweb.Controller):
                            starting the resequencing from an arbitrary number,
                            defaults to ``0``
         """
-        m = req.session.model(model)
+        m = request.session.model(model)
         if not m.fields_get([field]):
             return False
         # python 2.6 has no start parameter
@@ -1189,51 +1189,51 @@ class DataSet(openerpweb.Controller):
             m.write(id, { field: i + offset })
         return True
 
-class View(openerpweb.Controller):
+class View(http.Controller):
     _cp_path = "/web/view"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def add_custom(self, view_id, arch):
-        CustomView = req.session.model('ir.ui.view.custom')
+        CustomView = request.session.model('ir.ui.view.custom')
         CustomView.create({
-            'user_id': req.session._uid,
+            'user_id': request.session._uid,
             'ref_id': view_id,
             'arch': arch
-        }, req.context)
+        }, request.context)
         return {'result': True}
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def undo_custom(self, view_id, reset=False):
-        CustomView = req.session.model('ir.ui.view.custom')
-        vcustom = CustomView.search([('user_id', '=', req.session._uid), ('ref_id' ,'=', view_id)],
-                                    0, False, False, req.context)
+        CustomView = request.session.model('ir.ui.view.custom')
+        vcustom = CustomView.search([('user_id', '=', request.session._uid), ('ref_id' ,'=', view_id)],
+                                    0, False, False, request.context)
         if vcustom:
             if reset:
-                CustomView.unlink(vcustom, req.context)
+                CustomView.unlink(vcustom, request.context)
             else:
-                CustomView.unlink([vcustom[0]], req.context)
+                CustomView.unlink([vcustom[0]], request.context)
             return {'result': True}
         return {'result': False}
 
 class TreeView(View):
     _cp_path = "/web/treeview"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def action(self, model, id):
         return load_actions_from_ir_values(
             'action', 'tree_but_open',[(model, id)],
             False)
 
-class Binary(openerpweb.Controller):
+class Binary(http.Controller):
     _cp_path = "/web/binary"
 
-    @openerpweb.httprequest
+    @http.httprequest
     def image(self, model, id, field, **kw):
         last_update = '__last_update'
-        Model = req.session.model(model)
+        Model = request.session.model(model)
         headers = [('Content-Type', 'image/png')]
-        etag = req.httprequest.headers.get('If-None-Match')
-        hashed_session = hashlib.md5(req.session_id).hexdigest()
+        etag = request.httprequest.headers.get('If-None-Match')
+        hashed_session = hashlib.md5(request.session_id).hexdigest()
         retag = hashed_session
         id = None if not id else simplejson.loads(id)
         if type(id) is list:
@@ -1243,15 +1243,15 @@ class Binary(openerpweb.Controller):
                 if not id and hashed_session == etag:
                     return werkzeug.wrappers.Response(status=304)
                 else:
-                    date = Model.read([id], [last_update], req.context)[0].get(last_update)
+                    date = Model.read([id], [last_update], request.context)[0].get(last_update)
                     if hashlib.md5(date).hexdigest() == etag:
                         return werkzeug.wrappers.Response(status=304)
 
             if not id:
-                res = Model.default_get([field], req.context).get(field)
+                res = Model.default_get([field], request.context).get(field)
                 image_base64 = res
             else:
-                res = Model.read([id], [last_update, field], req.context)[0]
+                res = Model.read([id], [last_update, field], request.context)[0]
                 retag = hashlib.md5(res.get(last_update)).hexdigest()
                 image_base64 = res.get(field)
 
@@ -1276,13 +1276,13 @@ class Binary(openerpweb.Controller):
             headers.append(('Cache-Control', 'no-cache' if ncache == 0 else 'max-age=%s' % (ncache)))
         except:
             pass
-        return req.make_response(image_data, headers)
+        return request.make_response(image_data, headers)
 
     def placeholder(self, image='placeholder.png'):
-        addons_path = openerpweb.addons_manifest['web']['addons_path']
+        addons_path = http.addons_manifest['web']['addons_path']
         return open(os.path.join(addons_path, 'web', 'static', 'src', 'img', image), 'rb').read()
 
-    @openerpweb.httprequest
+    @http.httprequest
     def saveas(self, model, field, id=None, filename_field=None, **kw):
         """ Download link for files stored as binary fields.
 
@@ -1296,26 +1296,26 @@ class Binary(openerpweb.Controller):
         :param str filename_field: field holding the file's name, if any
         :returns: :class:`werkzeug.wrappers.Response`
         """
-        Model = req.session.model(model)
+        Model = request.session.model(model)
         fields = [field]
         if filename_field:
             fields.append(filename_field)
         if id:
-            res = Model.read([int(id)], fields, req.context)[0]
+            res = Model.read([int(id)], fields, request.context)[0]
         else:
-            res = Model.default_get(fields, req.context)
+            res = Model.default_get(fields, request.context)
         filecontent = base64.b64decode(res.get(field, ''))
         if not filecontent:
-            return req.not_found()
+            return request.not_found()
         else:
             filename = '%s_%s' % (model.replace('.', '_'), id)
             if filename_field:
                 filename = res.get(filename_field, '') or filename
-            return req.make_response(filecontent,
+            return request.make_response(filecontent,
                 [('Content-Type', 'application/octet-stream'),
                  ('Content-Disposition', content_disposition(filename))])
 
-    @openerpweb.httprequest
+    @http.httprequest
     def saveas_ajax(self, data, token):
         jdata = simplejson.loads(data)
         model = jdata['model']
@@ -1325,7 +1325,7 @@ class Binary(openerpweb.Controller):
         filename_field = jdata.get('filename_field', None)
         context = jdata.get('context', {})
 
-        Model = req.session.model(model)
+        Model = request.session.model(model)
         fields = [field]
         if filename_field:
             fields.append(filename_field)
@@ -1343,12 +1343,12 @@ class Binary(openerpweb.Controller):
             filename = '%s_%s' % (model.replace('.', '_'), id)
             if filename_field:
                 filename = res.get(filename_field, '') or filename
-            return req.make_response(filecontent,
+            return request.make_response(filecontent,
                 headers=[('Content-Type', 'application/octet-stream'),
                         ('Content-Disposition', content_disposition(filename))],
                 cookies={'fileToken': int(token)})
 
-    @openerpweb.httprequest
+    @http.httprequest
     def upload(self, callback, ufile):
         # TODO: might be useful to have a configuration flag for max-length file uploads
         out = """<script language="javascript" type="text/javascript">
@@ -1363,9 +1363,9 @@ class Binary(openerpweb.Controller):
             args = [False, e.message]
         return out % (simplejson.dumps(callback), simplejson.dumps(args))
 
-    @openerpweb.httprequest
+    @http.httprequest
     def upload_attachment(self, callback, model, id, ufile):
-        Model = req.session.model('ir.attachment')
+        Model = request.session.model('ir.attachment')
         out = """<script language="javascript" type="text/javascript">
                     var win = window.top.window;
                     win.jQuery(win).trigger(%s, %s);
@@ -1377,7 +1377,7 @@ class Binary(openerpweb.Controller):
                 'datas_fname': ufile.filename,
                 'res_model': model,
                 'res_id': int(id)
-            }, req.context)
+            }, request.context)
             args = {
                 'filename': ufile.filename,
                 'id':  attachment_id
@@ -1386,14 +1386,14 @@ class Binary(openerpweb.Controller):
             args = {'error': "Something horrible happened"}
         return out % (simplejson.dumps(callback), simplejson.dumps(args))
 
-    @openerpweb.httprequest
+    @http.httprequest
     @nodb
     def company_logo(self, dbname=None):
         # TODO add etag, refactor to use /image code for etag
         uid = None
-        if req.session._db:
-            dbname = req.session._db
-            uid = req.session._uid
+        if request.session._db:
+            dbname = request.session._db
+            uid = request.session._uid
         elif dbname is None:
             dbname = db_monodb()
 
@@ -1425,50 +1425,50 @@ class Binary(openerpweb.Controller):
             ('Content-Type', 'image/png'),
             ('Content-Length', len(image_data)),
         ]
-        return req.make_response(image_data, headers)
+        return request.make_response(image_data, headers)
 
-class Action(openerpweb.Controller):
+class Action(http.Controller):
     _cp_path = "/web/action"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def load(self, action_id, do_not_eval=False):
-        Actions = req.session.model('ir.actions.actions')
+        Actions = request.session.model('ir.actions.actions')
         value = False
         try:
             action_id = int(action_id)
         except ValueError:
             try:
                 module, xmlid = action_id.split('.', 1)
-                model, action_id = req.session.model('ir.model.data').get_object_reference(module, xmlid)
+                model, action_id = request.session.model('ir.model.data').get_object_reference(module, xmlid)
                 assert model.startswith('ir.actions.')
             except Exception:
                 action_id = 0   # force failed read
 
-        base_action = Actions.read([action_id], ['type'], req.context)
+        base_action = Actions.read([action_id], ['type'], request.context)
         if base_action:
             ctx = {}
             action_type = base_action[0]['type']
             if action_type == 'ir.actions.report.xml':
                 ctx.update({'bin_size': True})
-            ctx.update(req.context)
-            action = req.session.model(action_type).read([action_id], False, ctx)
+            ctx.update(request.context)
+            action = request.session.model(action_type).read([action_id], False, ctx)
             if action:
                 value = clean_action(action[0])
         return value
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def run(self, action_id):
-        return_action = req.session.model('ir.actions.server').run(
-            [action_id], req.context)
+        return_action = request.session.model('ir.actions.server').run(
+            [action_id], request.context)
         if return_action:
             return clean_action(return_action)
         else:
             return False
 
-class Export(openerpweb.Controller):
+class Export(http.Controller):
     _cp_path = "/web/export"
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def formats(self):
         """ Returns all valid export formats
 
@@ -1477,17 +1477,17 @@ class Export(openerpweb.Controller):
         """
         return sorted([
             controller.fmt
-            for controller in openerpweb.controllers_object.itervalues()
+            for controller in http.controllers_object.itervalues()
             if (controller._cp_path or "").startswith(self._cp_path)
             if hasattr(controller, 'fmt')
         ], key=operator.itemgetter("label"))
 
     def fields_get(self, model):
-        Model = req.session.model(model)
-        fields = Model.fields_get(False, req.context)
+        Model = request.session.model(model)
+        fields = Model.fields_get(False, request.context)
         return fields
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def get_fields(self, model, prefix='', parent_name= '',
                    import_compat=True, parent_field_type=None,
                    exclude=None):
@@ -1536,11 +1536,11 @@ class Export(openerpweb.Controller):
 
         return records
 
-    @openerpweb.jsonrequest
+    @http.jsonrequest
     def namelist(self, model, export_id):
         # TODO: namelist really has no reason to be in Python (although itertools.groupby helps)
-        export = req.session.model("ir.exports").read([export_id])[0]
-        export_fields_list = req.session.model("ir.exports.line").read(
+        export = request.session.model("ir.exports").read([export_id])[0]
+        export_fields_list = request.session.model("ir.exports.line").read(
             export['export_fields'])
 
         fields_data = self.fields_info(
@@ -1629,18 +1629,18 @@ class ExportFormat(object):
         """
         raise NotImplementedError()
 
-    @openerpweb.httprequest
+    @http.httprequest
     def index(self, data, token):
         model, fields, ids, domain, import_compat = \
             operator.itemgetter('model', 'fields', 'ids', 'domain',
                                 'import_compat')(
                 simplejson.loads(data))
 
-        Model = req.session.model(model)
-        ids = ids or Model.search(domain, 0, False, False, req.context)
+        Model = request.session.model(model)
+        ids = ids or Model.search(domain, 0, False, False, request.context)
 
         field_names = map(operator.itemgetter('name'), fields)
-        import_data = Model.export_data(ids, field_names, req.context).get('datas',[])
+        import_data = Model.export_data(ids, field_names, request.context).get('datas',[])
 
         if import_compat:
             columns_headers = field_names
@@ -1648,7 +1648,7 @@ class ExportFormat(object):
             columns_headers = [val['label'].strip() for val in fields]
 
 
-        return req.make_response(self.from_data(columns_headers, import_data),
+        return request.make_response(self.from_data(columns_headers, import_data),
             headers=[('Content-Disposition',
                             content_disposition(self.filename(model))),
                      ('Content-Type', self.content_type)],
@@ -1728,7 +1728,7 @@ class ExcelExport(ExportFormat, http.Controller):
         fp.close()
         return data
 
-class Reports(openerpweb.Controller):
+class Reports(http.Controller):
     _cp_path = "/web/report"
     POLLING_DELAY = 0.25
     TYPES_MAPPING = {
@@ -1740,12 +1740,12 @@ class Reports(openerpweb.Controller):
         'xls': 'application/vnd.ms-excel',
     }
 
-    @openerpweb.httprequest
+    @http.httprequest
     def index(self, action, token):
         action = simplejson.loads(action)
 
-        report_srv = req.session.proxy("report")
-        context = dict(req.context)
+        report_srv = request.session.proxy("report")
+        context = dict(request.context)
         context.update(action["context"])
 
         report_data = {}
@@ -1758,14 +1758,14 @@ class Reports(openerpweb.Controller):
             report_data.update(action['datas'])
 
         report_id = report_srv.report(
-            req.session._db, req.session._uid, req.session._password,
+            request.session._db, request.session._uid, request.session._password,
             action["report_name"], report_ids,
             report_data, context)
 
         report_struct = None
         while True:
             report_struct = report_srv.report_get(
-                req.session._db, req.session._uid, req.session._password, report_id)
+                request.session._db, request.session._uid, request.session._password, report_id)
             if report_struct["state"]:
                 break
 
@@ -1778,7 +1778,7 @@ class Reports(openerpweb.Controller):
             report_struct['format'], 'octet-stream')
         file_name = action.get('name', 'report')
         if 'name' not in action:
-            reports = req.session.model('ir.actions.report.xml')
+            reports = request.session.model('ir.actions.report.xml')
             res_id = reports.search([('report_name', '=', action['report_name']),],
                                     0, False, False, context)
             if len(res_id) > 0:
@@ -1787,7 +1787,7 @@ class Reports(openerpweb.Controller):
                 file_name = action['report_name']
         file_name = '%s.%s' % (file_name, report_struct['format'])
 
-        return req.make_response(report,
+        return request.make_response(report,
              headers=[
                  ('Content-Disposition', content_disposition(file_name)),
                  ('Content-Type', report_mimetype),
diff --git a/addons/web/controllers/testing.py b/addons/web/controllers/testing.py
index 8b89ab8ac9d..5e156dc410e 100644
--- a/addons/web/controllers/testing.py
+++ b/addons/web/controllers/testing.py
@@ -86,10 +86,8 @@ TESTING = Template(u"""<!DOCTYPE html>
 """, default_filters=['h'])
 
 class TestRunnerController(http.Controller):
-    _cp_path = '/web/tests'
 
-    @http.httprequest
-    @http.nodb
+    @http.route('/web/tests', type='http', authentication="nodb")
     def index(self, req, mod=None, **kwargs):
         ms = module.get_modules()
         manifests = dict(
diff --git a/addons/web/http.py b/addons/web/http.py
index 4f89dbf10bb..61a6a4e1250 100644
--- a/addons/web/http.py
+++ b/addons/web/http.py
@@ -88,12 +88,12 @@ class WebRequest(object):
     .. attribute:: db
 
         ``str``, the name of the database linked to the current request. Can be ``None``
-        if the current request uses the @nodb decorator.
+        if the current request uses the ``nodb`` authentication.
 
     .. attribute:: uid
 
         ``int``, the id of the user related to the current request. Can be ``None``
-        if the current request uses the @nodb or the @noauth decorator.
+        if the current request uses the ``nodb`` or the ``noauth`` authenticatoin.
     """
     def __init__(self, httprequest):
         self.httprequest = httprequest
@@ -171,14 +171,14 @@ class WebRequest(object):
     def registry(self):
         """
         The registry to the database linked to this request. Can be ``None`` if the current request uses the
-        @nodb decorator.
+        ``nodb'' authentication.
         """
         return openerp.modules.registry.RegistryManager.get(self.db) if self.db else None
 
     @property
     def cr(self):
         """
-        The cursor initialized for the current method call. If the current request uses the @nodb decorator
+        The cursor initialized for the current method call. If the current request uses the ``nodb`` authentication
         trying to access this property will raise an exception.
         """
         # some magic to lazy create the cr
@@ -211,22 +211,43 @@ class WebRequest(object):
             self.db = None
             self.uid = None
 
-
-def noauth(f):
+def route(route, type="http", authentication="auth"):
     """
+    Decorator marking the decorated method as being a handler for requests. The method must be part of a subclass
+    of ``Controller``.
+
     Decorator to put on a controller method to inform it does not require a user to be logged. When this decorator
     is used, ``request.uid`` will be ``None``. The request will still try to detect the database and an exception
     will be launched if there is no way to guess it.
+
+    :param route: string or array. The route part that will determine which http requests will match the decorated
+    method. Can be a single string or an array of strings. See werkzeug's routing documentation for the format of
+    route expression ( http://werkzeug.pocoo.org/docs/routing/ ).
+    :param type: The type of request, can be ``'http'`` or ``'json'``.
+    :param authentication: The type of authentication method, can on of the following:
+
+        * ``auth``: The user must be authenticated.
+        * ``noauth``: There is no need for the user to be authenticated but there must be a way to find the current
+        database.
+        * ``nodb``: The method is always active, even if there is no database. Mainly used by the framework and
+        authentication modules.
     """
+    def decorator(f):
+        if isinstance(route, list):
+            f.routes = route
+        else:
+            f.routes = [route]
+        f.exposed = type
+        if getattr(f, "auth", None) is None:
+            f.auth = authentication
+        return f
+    return decorator
+
+def noauth(f):
     f.auth = "noauth"
     return f
 
 def nodb(f):
-    """
-    Decorator to put on a controller method to inform it does not require authentication nor any link to a database.
-    When this decorator is used, ``request.uid`` and ``request.db`` will be ``None``. Trying to use ``request.cr``
-    will launch an exception.
-    """
     f.auth = "nodb"
     return f
 
@@ -398,8 +419,11 @@ def jsonrequest(f):
     the ``session_id``, ``context`` and ``debug`` keys (which are stripped out
     beforehand)
     """
-    f.exposed = 'json'
-    return f
+    f.combine = True
+    base = f.__name__
+    if f.__name__ == "index":
+        base = ""
+    return route([base, os.path.join(base, "<path:path>")], type="json", authentication="auth")(f)
 
 class HttpRequest(WebRequest):
     """ Regular GET/POST request
@@ -478,8 +502,11 @@ def httprequest(f):
     merged in the same dictionary), apart from the ``session_id``, ``context``
     and ``debug`` keys (which are stripped out beforehand)
     """
-    f.exposed = 'http'
-    return f
+    f.combine = True
+    base = f.__name__
+    if f.__name__ == "index":
+        base = ""
+    return route([base, os.path.join(base, "<path:path>")], type="http", authentication="auth")(f)
 
 #----------------------------------------------------------
 # Local storage of requests
@@ -526,8 +553,7 @@ class ControllerType(type):
         # store the controller in the controllers list
         name_class = ("%s.%s" % (cls.__module__, cls.__name__), cls)
         class_path = name_class[0].split(".")
-        path = attrs.get('_cp_path')
-        if not path or not class_path[:2] == ["openerp", "addons"]:
+        if not class_path[:2] == ["openerp", "addons"]:
             return
         module = class_path[2]
         controllers_per_module.setdefault(module, []).append(name_class)
@@ -535,13 +561,13 @@ class ControllerType(type):
 class Controller(object):
     __metaclass__ = ControllerType
 
-    def __new__(cls, *args, **kwargs):
-        subclasses = [c for c in cls.__subclasses__() if c._cp_path == cls._cp_path]
+    """def __new__(cls, *args, **kwargs):
+        subclasses = [c for c in cls.__subclasses__() if getattr(c, "_cp_path", None) == getattr(cls, "_cp_path", None)]
         if subclasses:
             name = "%s (extended by %s)" % (cls.__name__, ', '.join(sub.__name__ for sub in subclasses))
             cls = type(name, tuple(reversed(subclasses)), {})
 
-        return object.__new__(cls)
+        return object.__new__(cls)"""
 
     def get_wrapped_method(self, name):
         if name in self.__class__._methods_wrapper:
@@ -791,14 +817,14 @@ class Root(object):
                 for mk, mv in members:
                     if inspect.ismethod(mv) and getattr(mv, 'exposed', False) and getattr(mv, 'auth', None) == "nodb":
                         o = v[1]()
-                        if mk == "index":
-                            url = o._cp_path
-                        else:
-                            url = os.path.join(o._cp_path, mk)
                         function = (o.get_wrapped_method(mk), mv)
-                        routing_map.add(routing.Rule(url, endpoint=function))
-                        url = os.path.join(url, "<path:path>")
-                        routing_map.add(routing.Rule(url, endpoint=function))
+                        for url in mv.routes:
+                            if getattr(mv, "combine", False):
+                                url = os.path.join(o._cp_path, url)
+                                if url.endswith("/") and len(url) > 1:
+                                    url = url[: -1]
+                            print "<<<<<<<<<<<<<<<< nodb", url
+                            routing_map.add(routing.Rule(url, endpoint=function))
 
         if not db:
             return routing_map
@@ -817,14 +843,14 @@ class Root(object):
                 members = inspect.getmembers(o)
                 for mk, mv in members:
                     if inspect.ismethod(mv) and getattr(mv, 'exposed', False) and getattr(mv, 'auth', None) != "nodb":
-                        if mk == "index":
-                            url = o._cp_path
-                        else:
-                            url = os.path.join(o._cp_path, mk)
                         function = (o.get_wrapped_method(mk), mv)
-                        routing_map.add(routing.Rule(url, endpoint=function))
-                        url = os.path.join(url, "<path:path>")
-                        routing_map.add(routing.Rule(url, endpoint=function))
+                        for url in mv.routes:
+                            if getattr(mv, "combine", False):
+                                url = os.path.join(o._cp_path, url)
+                                if url.endswith("/") and len(url) > 1:
+                                    url = url[: -1]
+                            print "<<<<<<<<<<<<<<<< db", url
+                            routing_map.add(routing.Rule(url, endpoint=function))
         return routing_map
 
     def get_db_router(self, db):