Package cherrypy :: Module _cpdispatch
[hide private]
[frames] | no frames]

Module _cpdispatch

source code

CherryPy dispatchers.

A 'dispatcher' is the object which looks up the 'page handler' callable and collects config for the current request based on the path_info, other request attributes, and the application architecture. The core calls the dispatcher as early as possible, passing it a 'path_info' argument.

The default dispatcher discovers the page handler by matching path_info to a hierarchical arrangement of objects, starting at request.app.root.

Classes [hide private]
  PageHandler
Callable which sets response.body.
  LateParamPageHandler
When passing cherrypy.request.params to the page handler, we do not want to capture that dict too early; we want to give tools like the decoding tool a chance to modify the params dict in-between the lookup of the handler and the actual calling of the handler.
  Dispatcher
CherryPy Dispatcher which walks a tree of objects to find a handler.
  MethodDispatcher
Additional dispatch based on cherrypy.request.method.upper().
  RoutesDispatcher
A Routes based dispatcher for CherryPy.
Functions [hide private]
 
test_callable_spec(callable, callable_args, callable_kwargs)
Inspect callable and test to see if the given args are suitable for it.
source code
 
XMLRPCDispatcher(next_dispatcher=Dispatcher()) source code
 
VirtualHost(next_dispatcher=Dispatcher(), use_x_forwarded_host=True, **domains)
Select a different handler based on the Host header.
source code
Variables [hide private]
  __package__ = 'cherrypy'
Function Details [hide private]

test_callable_spec(callable, callable_args, callable_kwargs)

source code 

Inspect callable and test to see if the given args are suitable for it.

When an error occurs during the handler's invoking stage there are 2
erroneous cases:
1.  Too many parameters passed to a function which doesn't define
    one of *args or **kwargs.
2.  Too little parameters are passed to the function.

There are 3 sources of parameters to a cherrypy handler.
1.  query string parameters are passed as keyword parameters to the handler.
2.  body parameters are also passed as keyword parameters.
3.  when partial matching occurs, the final path atoms are passed as
    positional args.
Both the query string and path atoms are part of the URI.  If they are
incorrect, then a 404 Not Found should be raised. Conversely the body
parameters are part of the request; if they are invalid a 400 Bad Request.

VirtualHost(next_dispatcher=Dispatcher(), use_x_forwarded_host=True, **domains)

source code 
Select a different handler based on the Host header.

This can be useful when running multiple sites within one CP server.
It allows several domains to point to different parts of a single
website structure. For example:

    http://www.domain.example  ->  root
    http://www.domain2.example  ->  root/domain2/
    http://www.domain2.example:443  ->  root/secure

can be accomplished via the following config:

    [/]
    request.dispatch = cherrypy.dispatch.VirtualHost(
        **{'www.domain2.example': '/domain2',
           'www.domain2.example:443': '/secure',
          })

next_dispatcher: the next dispatcher object in the dispatch chain.
    The VirtualHost dispatcher adds a prefix to the URL and calls
    another dispatcher. Defaults to cherrypy.dispatch.Dispatcher().

use_x_forwarded_host: if True (the default), any "X-Forwarded-Host"
    request header will be used instead of the "Host" header. This
    is commonly added by HTTP servers (such as Apache) when proxying.

**domains: a dict of {host header value: virtual prefix} pairs.
    The incoming "Host" request header is looked up in this dict,
    and, if a match is found, the corresponding "virtual prefix"
    value will be prepended to the URL path before calling the
    next dispatcher. Note that you often need separate entries
    for "example.com" and "www.example.com". In addition, "Host"
    headers may contain the port number.