import cherrypy
from cherrypy._cpdispatch import PageHandler, LateParamPageHandler
import routes
import logging
import yaml
REST_METHODS = ('GET','PUT','POST','DELETE')
def is_form_post(environ):
"""Determine whether the request is a POSTed html form"""
if environ['REQUEST_METHOD'] != 'POST':
return False
content_type = environ.get('CONTENT_TYPE', '').lower()
if ';' in content_type:
content_type = content_type.split(';', 1)[0]
return content_type in ('application/x-www-form-urlencoded','multipart/form-data')
class ResourceDispatcher(object):
"""
A Routes-based dispatcher for CherryPy that maps RESTful resources.
The dispatcher is meant to follow most of the conventions pioneers by the
Ruby on Rails framework's router. In particular, if you do not predefine the
keys for the controllers prior to configuring the routes, ResourceDispatcher.resource()
will try to add a CamelCase version of the given collection_name + the "Controller"
suffix. For example mapper.resource("item","items") will try to add
{"items": ItemsController()} to the controllers dict.
Otherwise the connect() and resource() methods are passed directly to routes.Mapper()
and work in the same manner.
"""
def __init__(self,controllers={}):
"""
Resource dispatcher
RESTful Routes-based dispatcher for CherryPy.
Provide a dict of {collection_name: Controller()} to
initialize the set of controllers available. Otherwise,
set the controllers attr to this hash after creation.
"""
import routes
self.controllers = controllers
self.mapper = routes.Mapper()
self.mapper.controller_scan = self.controllers.keys
def connect(self, *args, **kwargs):
"""Create and connect a new Route to the dispatcher."""
self.mapper.connect(*args, **kwargs)
def resource(self,member_name,collection_name):
"""Maps a resource, given the member_name and collection_name of that resource.
If the resource does not yet exist in the set of defined controllers, this method
will attempt the add it, following a standard naming convention pioneered by
Ruby on Rails, where the plural snake_cased collection name is turned to
CamelCase and suffixed with "Controller" for the class' name.
For example mapper.resource('blog_comment','blog_comments') would map to
the controller BlogCommentsController."""
if collection_name not in self.controllers.keys():
self.controllers[collection_name] = \
eval("%s()" % collection_name.title().replace("_",""))
self.mapper.resource(member_name,collection_name)
def redirect(self, url):
"""A wrapper for CherryPy's HTTPRedirect method"""
raise cherrypy.HTTPRedirect(url)
def __call__(self, path_info):
"""Set handler and config for the current request."""
func = self.find_handler(path_info)
if func:
cherrypy.response.headers['Allow'] = ", ".join(REST_METHODS)
cherrypy.request.handler = LateParamPageHandler(func)
else:
cherrypy.request.handler = cherrypy.NotFound()
def find_handler(self,path_info):
"""Find the right page handler, and set request.config."""
request = cherrypy.request
environ = cherrypy.request.wsgi_environ
# account for HTTP REQUEST_METHOD overrides
old_method = None
if '_method' in environ.get('QUERY_STRING', '') and \
request.params.get('_method','').upper() in REST_METHODS:
old_method = environ['REQUEST_METHOD']
environ['REQUEST_METHOD'] = request.params['_method'].upper()
logging.debug("_method found in QUERY_STRING, altering request"
" method to %s", environ['REQUEST_METHOD'])
elif is_form_post(environ):
# must parse the request body to get the method param
request.process_body()
m = request.params.get('_method',None)
if m is not None and m.upper() in REST_METHODS:
old_method = environ['REQUEST_METHOD']
environ['REQUEST_METHOD'] = m.upper()
logging.debug("_method found in POST data, altering request "
"method to %s", environ['REQUEST_METHOD'])
config = routes.request_config()
# Hook up the routes variables for this request
config.mapper = self.mapper
config.environ = environ
config.host = request.headers.get('Host',None)
config.protocol = request.scheme
config.redirect = self.redirect
result = self.mapper.match(path_info)
m = self.mapper.match(path_info)
config.mapper_dict = result
if old_method:
environ['REQUEST_METHOD'] = old_method
# also pop out the _method request param, if it exists
request.params.pop('_method', None)
params = {}
if result:
params = result.copy()
params.pop('controller', None)
params.pop('action', None)
request.params.update(params)
# Get config for the root object/path.
request.config = base = cherrypy.config.copy()
curpath = ""
def merge(nodeconf):
if 'tools.staticdir.dir' in nodeconf:
nodeconf['tools.staticdir.section'] = curpath or "/"
base.update(nodeconf)
app = request.app
root = app.root
if hasattr(root, "_cp_config"):
merge(root._cp_config)
if "/" in app.config:
merge(app.config["/"])
# Mix in values from app.config.
atoms = [x for x in path_info.split("/") if x]
if atoms:
last = atoms.pop()
else:
last = None
for atom in atoms:
curpath = "/".join((curpath, atom))
if curpath in app.config:
merge(app.config[curpath])
handler = None
if result:
controller = result.get('controller', None)
controller = self.controllers.get(controller)
if controller:
# Get config from the controller.
if hasattr(controller, "_cp_config"):
merge(controller._cp_config)
action = result.get('action', None)
if action is not None:
handler = getattr(controller, action, None)
# Get config from the handler
if hasattr(handler, "_cp_config"):
merge(handler._cp_config)
# Do the last path atom here so it can
# override the controller's _cp_config.
if last:
curpath = "/".join((curpath, last))
if curpath in app.config:
merge(app.config[curpath])
return handler
) is private.
