source file: /Library/Python/2.3/site-packages/CherryPy-3.0.1-py2.3.egg/cherrypy/_cprequest.py
file stats: 519 lines, 290 executed: 55.9% covered
   1. 
   2. import Cookie
   3. import os
   4. import sys
   5. import time
   6. import types
   7. 
   8. import cherrypy
   9. from cherrypy import _cpcgifs, _cpconfig
  10. from cherrypy._cperror import format_exc, bare_error
  11. from cherrypy.lib import http
  12. 
  13. 
  14. class Hook(object):
  15.     """A callback and its metadata: failsafe, priority, and kwargs."""
  16. 
  17.     __metaclass__ = cherrypy._AttributeDocstrings
  18. 
  19.     callback = None
  20.     callback__doc = """
  21.     The bare callable that this Hook object is wrapping, which will
  22.     be called when the Hook is called."""
  23. 
  24.     failsafe = False
  25.     failsafe__doc = """
  26.     If True, the callback is guaranteed to run even if other callbacks
  27.     from the same call point raise exceptions."""
  28. 
  29.     priority = 50
  30.     priority__doc = """
  31.     Defines the order of execution for a list of Hooks. Priority numbers
  32.     should be limited to the closed interval [0, 100], but values outside
  33.     this range are acceptable, as are fractional values."""
  34. 
  35.     kwargs = {}
  36.     kwargs__doc = """
  37.     A set of keyword arguments that will be passed to the
  38.     callable on each call."""
  39. 
  40.     def __init__(self, callback, failsafe=None, priority=None, **kwargs):
  41.         self.callback = callback
  42. 
  43.         if failsafe is None:
  44.             failsafe = getattr(callback, "failsafe", False)
  45.         self.failsafe = failsafe
  46. 
  47.         if priority is None:
  48.             priority = getattr(callback, "priority", 50)
  49.         self.priority = priority
  50. 
  51.         self.kwargs = kwargs
  52. 
  53.     def __cmp__(self, other):
  54.         return cmp(self.priority, other.priority)
  55. 
  56.     def __call__(self):
  57.         """Run self.callback(**self.kwargs)."""
  58.         return self.callback(**self.kwargs)
  59. 
  60. 
  61. class HookMap(dict):
  62.     """A map of call points to lists of callbacks (Hook objects)."""
  63. 
  64.     def __new__(cls, points=None):
  65.         d = dict.__new__(cls)
  66.         for p in points or []:
  67.             d[p] = []
  68.         return d
  69. 
  70.     def __init__(self, *a, **kw):
  71.         pass
  72. 
  73.     def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
  74.         """Append a new Hook made from the supplied arguments."""
  75.         self[point].append(Hook(callback, failsafe, priority, **kwargs))
  76. 
  77.     def run(self, point):
  78.         """Execute all registered Hooks (callbacks) for the given point."""
  79.         exc = None
  80.         hooks = self[point]
  81.         hooks.sort()
  82.         for hook in hooks:
  83.             # Some hooks are guaranteed to run even if others at
  84.             # the same hookpoint fail. We will still log the failure,
  85.             # but proceed on to the next hook. The only way
  86.             # to stop all processing from one of these hooks is
  87.             # to raise SystemExit and stop the whole server.
  88.             if exc is None or hook.failsafe:
  89.                 try:
  90.                     hook()
  91.                 except (KeyboardInterrupt, SystemExit):
  92.                     raise
  93.                 except (cherrypy.HTTPError, cherrypy.HTTPRedirect,
  94.                         cherrypy.InternalRedirect):
  95.                     exc = sys.exc_info()[1]
  96.                 except:
  97.                     exc = sys.exc_info()[1]
  98.                     cherrypy.log(traceback=True)
  99.         if exc:
 100.             raise
 101. 
 102.     def __copy__(self):
 103.         newmap = self.__class__()
 104.         # We can't just use 'update' because we want copies of the
 105.         # mutable values (each is a list) as well.
 106.         for k, v in self.iteritems():
 107.             newmap[k] = v[:]
 108.         return newmap
 109.     copy = __copy__
 110. 
 111.     def __repr__(self):
 112.         cls = self.__class__
 113.         return "%s.%s(points=%r)" % (cls.__module__, cls.__name__, self.keys())
 114. 
 115. 
 116. # Config namespace handlers
 117. 
 118. def hooks_namespace(k, v):
 119.     """Attach bare hooks declared in config."""
 120.     # Use split again to allow multiple hooks for a single
 121.     # hookpoint per path (e.g. "hooks.before_handler.1").
 122.     # Little-known fact you only get from reading source ;)
 123.     hookpoint = k.split(".", 1)[0]
 124.     if isinstance(v, basestring):
 125.         v = cherrypy.lib.attributes(v)
 126.     if not isinstance(v, Hook):
 127.         v = Hook(v)
 128.     cherrypy.request.hooks[hookpoint].append(v)
 129. 
 130. def request_namespace(k, v):
 131.     """Attach request attributes declared in config."""
 132.     setattr(cherrypy.request, k, v)
 133. 
 134. def response_namespace(k, v):
 135.     """Attach response attributes declared in config."""
 136.     setattr(cherrypy.response, k, v)
 137. 
 138. def error_page_namespace(k, v):
 139.     """Attach error pages declared in config."""
 140.     cherrypy.request.error_page[int(k)] = v
 141. 
 142. 
 143. hookpoints = ['on_start_resource', 'before_request_body',
 144.               'before_handler', 'before_finalize',
 145.               'on_end_resource', 'on_end_request',
 146.               'before_error_response', 'after_error_response']
 147. 
 148. 
 149. class Request(object):
 150.     """An HTTP request.
 151. 
 152.     This object represents the metadata of an HTTP request message;
 153.     that is, it contains attributes which describe the environment
 154.     in which the request URL, headers, and body were sent (if you
 155.     want tools to interpret the headers and body, those are elsewhere,
 156.     mostly in Tools). This 'metadata' consists of socket data,
 157.     transport characteristics, and the Request-Line. This object
 158.     also contains data regarding the configuration in effect for
 159.     the given URL, and the execution plan for generating a response.
 160.     """
 161. 
 162.     __metaclass__ = cherrypy._AttributeDocstrings
 163. 
 164.     prev = None
 165.     prev__doc = """
 166.     The previous Request object (if any). This should be None
 167.     unless we are processing an InternalRedirect."""
 168. 
 169.     # Conversation/connection attributes
 170.     local = http.Host("localhost", 80)
 171.     local__doc = \
 172.         "An http.Host(ip, port, hostname) object for the server socket."
 173. 
 174.     remote = http.Host("localhost", 1111)
 175.     remote__doc = \
 176.         "An http.Host(ip, port, hostname) object for the client socket."
 177. 
 178.     scheme = "http"
 179.     scheme__doc = """
 180.     The protocol used between client and server. In most cases,
 181.     this will be either 'http' or 'https'."""
 182. 
 183.     server_protocol = "HTTP/1.1"
 184.     server_protocol__doc = """
 185.     The HTTP version for which the HTTP server is at least
 186.     conditionally compliant."""
 187. 
 188.     base = ""
 189.     base__doc = """The (scheme://host) portion of the requested URL."""
 190. 
 191.     # Request-Line attributes
 192.     request_line = ""
 193.     request_line__doc = """
 194.     The complete Request-Line received from the client. This is a
 195.     single string consisting of the request method, URI, and protocol
 196.     version (joined by spaces). Any final CRLF is removed."""
 197. 
 198.     method = "GET"
 199.     method__doc = """
 200.     Indicates the HTTP method to be performed on the resource identified
 201.     by the Request-URI. Common methods include GET, HEAD, POST, PUT, and
 202.     DELETE. CherryPy allows any extension method; however, various HTTP
 203.     servers and gateways may restrict the set of allowable methods.
 204.     CherryPy applications SHOULD restrict the set (on a per-URI basis)."""
 205. 
 206.     query_string = ""
 207.     query_string__doc = """
 208.     The query component of the Request-URI, a string of information to be
 209.     interpreted by the resource. The query portion of a URI follows the
 210.     path component, and is separated by a '?'. For example, the URI
 211.     'http://www.cherrypy.org/wiki?a=3&b=4' has the query component,
 212.     'a=3&b=4'."""
 213. 
 214.     protocol = (1, 1)
 215.     protocol__doc = """The HTTP protocol version corresponding to the set
 216.         of features which should be allowed in the response. If BOTH
 217.         the client's request message AND the server's level of HTTP
 218.         compliance is HTTP/1.1, this attribute will be the tuple (1, 1).
 219.         If either is 1.0, this attribute will be the tuple (1, 0).
 220.         Lower HTTP protocol versions are not explicitly supported."""
 221. 
 222.     params = {}
 223.     params__doc = """
 224.     A dict which combines query string (GET) and request entity (POST)
 225.     variables. This is populated in two stages: GET params are added
 226.     before the 'on_start_resource' hook, and POST params are added
 227.     between the 'before_request_body' and 'before_handler' hooks."""
 228. 
 229.     # Message attributes
 230.     header_list = []
 231.     header_list__doc = """
 232.     A list of the HTTP request headers as (name, value) tuples.
 233.     In general, you should use request.headers (a dict) instead."""
 234. 
 235.     headers = http.HeaderMap()
 236.     headers__doc = """
 237.     A dict-like object containing the request headers. Keys are header
 238.     names (in Title-Case format); however, you may get and set them in
 239.     a case-insensitive manner. That is, headers['Content-Type'] and
 240.     headers['content-type'] refer to the same value. Values are header
 241.     values (decoded according to RFC 2047 if necessary). See also:
 242.     http.HeaderMap, http.HeaderElement."""
 243. 
 244.     cookie = Cookie.SimpleCookie()
 245.     cookie__doc = """See help(Cookie)."""
 246. 
 247.     rfile = None
 248.     rfile__doc = """
 249.     If the request included an entity (body), it will be available
 250.     as a stream in this attribute. However, the rfile will normally
 251.     be read for you between the 'before_request_body' hook and the
 252.     'before_handler' hook, and the resulting string is placed into
 253.     either request.params or the request.body attribute.
 254. 
 255.     You may disable the automatic consumption of the rfile by setting
 256.     request.process_request_body to False, either in config for the desired
 257.     path, or in an 'on_start_resource' or 'before_request_body' hook.
 258. 
 259.     WARNING: In almost every case, you should not attempt to read from the
 260.     rfile stream after CherryPy's automatic mechanism has read it. If you
 261.     turn off the automatic parsing of rfile, you should read exactly the
 262.     number of bytes specified in request.headers['Content-Length'].
 263.     Ignoring either of these warnings may result in a hung request thread
 264.     or in corruption of the next (pipelined) request.
 265.     """
 266. 
 267.     process_request_body = True
 268.     process_request_body__doc = """
 269.     If True, the rfile (if any) is automatically read and parsed,
 270.     and the result placed into request.params or request.body."""
 271. 
 272.     methods_with_bodies = ("POST", "PUT")
 273.     methods_with_bodies__doc = """
 274.     A sequence of HTTP methods for which CherryPy will automatically
 275.     attempt to read a body from the rfile."""
 276. 
 277.     body = None
 278.     body__doc = """
 279.     If the request Content-Type is 'application/x-www-form-urlencoded'
 280.     or multipart, this will be None. Otherwise, this will contain the
 281.     request entity body as a string; this value is set between the
 282.     'before_request_body' and 'before_handler' hooks (assuming that
 283.     process_request_body is True)."""
 284. 
 285.     # Dispatch attributes
 286.     dispatch = cherrypy.dispatch.Dispatcher()
 287.     dispatch__doc = """
 288.     The object which looks up the 'page handler' callable and collects
 289.     config for the current request based on the path_info, other
 290.     request attributes, and the application architecture. The core
 291.     calls the dispatcher as early as possible, passing it a 'path_info'
 292.     argument.
 293. 
 294.     The default dispatcher discovers the page handler by matching path_info
 295.     to a hierarchical arrangement of objects, starting at request.app.root.
 296.     See help(cherrypy.dispatch) for more information."""
 297. 
 298.     script_name = ""
 299.     script_name__doc = """
 300.     The 'mount point' of the application which is handling this request."""
 301. 
 302.     path_info = "/"
 303.     path_info__doc = """
 304.     The 'relative path' portion of the Request-URI. This is relative
 305.     to the script_name ('mount point') of the application which is
 306.     handling this request."""
 307. 
 308.     login = None
 309.     login__doc = """
 310.     When authentication is used during the request processing this is
 311.     set to 'False' if it failed and to the 'username' value if it succeeded.
 312.     The default 'None' implies that no authentication happened."""
 313. 
 314.     app = None
 315.     app__doc = \
 316.         """The cherrypy.Application object which is handling this request."""
 317. 
 318.     handler = None
 319.     handler__doc = """
 320.     The function, method, or other callable which CherryPy will call to
 321.     produce the response. The discovery of the handler and the arguments
 322.     it will receive are determined by the request.dispatch object.
 323.     By default, the handler is discovered by walking a tree of objects
 324.     starting at request.app.root, and is then passed all HTTP params
 325.     (from the query string and POST body) as keyword arguments."""
 326. 
 327.     toolmaps = {}
 328.     toolmaps__doc = """
 329.     A nested dict of all Toolboxes and Tools in effect for this request,
 330.     of the form: {Toolbox.namespace: {Tool.name: config dict}}."""
 331. 
 332.     config = None
 333.     config__doc = """
 334.     A flat dict of all configuration entries which apply to the
 335.     current request. These entries are collected from global config,
 336.     application config (based on request.path_info), and from handler
 337.     config (exactly how is governed by the request.dispatch object in
 338.     effect for this request; by default, handler config can be attached
 339.     anywhere in the tree between request.app.root and the final handler,
 340.     and inherits downward)."""
 341. 
 342.     is_index = None
 343.     is_index__doc = """
 344.     This will be True if the current request is mapped to an 'index'
 345.     resource handler (also, a 'default' handler if path_info ends with
 346.     a slash). The value may be used to automatically redirect the
 347.     user-agent to a 'more canonical' URL which either adds or removes
 348.     the trailing slash. See cherrypy.tools.trailing_slash."""
 349. 
 350.     hooks = HookMap(hookpoints)
 351.     hooks__doc = """
 352.     A HookMap (dict-like object) of the form: {hookpoint: [hook, ...]}.
 353.     Each key is a str naming the hook point, and each value is a list
 354.     of hooks which will be called at that hook point during this request.
 355.     The list of hooks is generally populated as early as possible (mostly
 356.     from Tools specified in config), but may be extended at any time.
 357.     See also: _cprequest.Hook, _cprequest.HookMap, and cherrypy.tools."""
 358. 
 359.     error_response = cherrypy.HTTPError(500).set_response
 360.     error_response__doc = """
 361.     The no-arg callable which will handle unexpected, untrapped errors
 362.     during request processing. This is not used for expected exceptions
 363.     (like NotFound, HTTPError, or HTTPRedirect) which are raised in
 364.     response to expected conditions (those should be customized either
 365.     via request.error_page or by overriding HTTPError.set_response).
 366.     By default, error_response uses HTTPError(500) to return a generic
 367.     error response to the user-agent."""
 368. 
 369.     error_page = {}
 370.     error_page__doc = """
 371.     A dict of {error code: response filename} pairs. The named response
 372.     files should be Python string-formatting templates, and can expect by
 373.     default to receive the format values with the mapping keys 'status',
 374.     'message', 'traceback', and 'version'. The set of format mappings
 375.     can be extended by overriding HTTPError.set_response."""
 376. 
 377.     show_tracebacks = True
 378.     show_tracebacks__doc = """
 379.     If True, unexpected errors encountered during request processing will
 380.     include a traceback in the response body."""
 381. 
 382.     throws = (KeyboardInterrupt, SystemExit, cherrypy.InternalRedirect)
 383.     throws__doc = \
 384.         """The sequence of exceptions which Request.run does not trap."""
 385. 
 386.     throw_errors = False
 387.     throw_errors__doc = """
 388.     If True, Request.run will not trap any errors (except HTTPRedirect and
 389.     HTTPError, which are more properly called 'exceptions', not errors)."""
 390. 
 391.     namespaces = _cpconfig.NamespaceSet(
 392.         **{"hooks": hooks_namespace,
 393.            "request": request_namespace,
 394.            "response": response_namespace,
 395.            "error_page": error_page_namespace,
 396.            # "tools": See _cptools.Toolbox
 397.            })
 398. 
 399.     def __init__(self, local_host, remote_host, scheme="http",
 400.                  server_protocol="HTTP/1.1"):
 401.         """Populate a new Request object.
 402. 
 403.         local_host should be an http.Host object with the server info.
 404.         remote_host should be an http.Host object with the client info.
 405.         scheme should be a string, either "http" or "https".
 406.         """
 407.         self.local = local_host
 408.         self.remote = remote_host
 409.         self.scheme = scheme
 410.         self.server_protocol = server_protocol
 411. 
 412.         self.closed = False
 413. 
 414.         # Put a *copy* of the class error_page into self.
 415.         self.error_page = self.error_page.copy()
 416. 
 417.         # Put a *copy* of the class namespaces into self.
 418.         self.namespaces = self.namespaces.copy()
 419. 
 420.     def close(self):
 421.         """Run cleanup code and remove self from globals. (Core)"""
 422.         if not self.closed:
 423.             self.closed = True
 424.             self.hooks.run('on_end_request')
 425. 
 426.     def run(self, method, path, query_string, req_protocol, headers, rfile):
 427.         """Process the Request. (Core)
 428. 
 429.         method, path, query_string, and req_protocol should be pulled directly
 430.             from the Request-Line (e.g. "GET /path?key=val HTTP/1.0").
 431.         path should be %XX-unquoted, but query_string should not be.
 432.         headers should be a list of (name, value) tuples.
 433.         rfile should be a file-like object containing the HTTP request entity.
 434. 
 435.         When run() is done, the returned object should have 3 attributes:
 436.           status, e.g. "200 OK"
 437.           header_list, a list of (name, value) tuples
 438.           body, an iterable yielding strings
 439. 
 440.         Consumer code (HTTP servers) should then access these response
 441.         attributes to build the outbound stream.
 442. 
 443.         """
 444. 
 445.         try:
 446.             self.error_response = cherrypy.HTTPError(500).set_response
 447. 
 448.             self.method = method
 449.             path = path or "/"
 450.             self.query_string = query_string or ''
 451. 
 452.             # Compare request and server HTTP protocol versions, in case our
 453.             # server does not support the requested protocol. Limit our output
 454.             # to min(req, server). We want the following output:
 455.             #     request    server     actual written   supported response
 456.             #     protocol   protocol  response protocol    feature set
 457.             # a     1.0        1.0           1.0                1.0
 458.             # b     1.0        1.1           1.1                1.0
 459.             # c     1.1        1.0           1.0                1.0
 460.             # d     1.1        1.1           1.1                1.1
 461.             # Notice that, in (b), the response will be "HTTP/1.1" even though
 462.             # the client only understands 1.0. RFC 2616 10.5.6 says we should
 463.             # only return 505 if the _major_ version is different.
 464.             rp = int(req_protocol[5]), int(req_protocol[7])
 465.             sp = int(self.server_protocol[5]), int(self.server_protocol[7])
 466.             self.protocol = min(rp, sp)
 467. 
 468.             # Rebuild first line of the request (e.g. "GET /path HTTP/1.0").
 469.             url = path
 470.             if query_string:
 471.                 url += '?' + query_string
 472.             self.request_line = '%s %s %s' % (method, url, req_protocol)
 473. 
 474.             self.header_list = list(headers)
 475.             self.rfile = rfile
 476.             self.headers = http.HeaderMap()
 477.             self.cookie = Cookie.SimpleCookie()
 478.             self.handler = None
 479. 
 480.             # path_info should be the path from the
 481.             # app root (script_name) to the handler.
 482.             self.script_name = self.app.script_name
 483.             self.path_info = pi = path[len(self.script_name.rstrip("/")):]
 484. 
 485.             self.respond(pi)
 486. 
 487.         except self.throws:
 488.             raise
 489.         except:
 490.             if self.throw_errors:
 491.                 raise
 492.             else:
 493.                 # Failure in setup, error handler or finalize. Bypass them.
 494.                 # Can't use handle_error because we may not have hooks yet.
 495.                 cherrypy.log(traceback=True)
 496.                 if self.show_tracebacks:
 497.                     body = format_exc()
 498.                 else:
 499.                     body = ""
 500.                 r = bare_error(body)
 501.                 response = cherrypy.response
 502.                 response.status, response.header_list, response.body = r
 503. 
 504.         if self.method == "HEAD":
 505.             # HEAD requests MUST NOT return a message-body in the response.
 506.             cherrypy.response.body = []
 507. 
 508.         cherrypy.log.access()
 509. 
 510.         if cherrypy.response.timed_out:
 511.             raise cherrypy.TimeoutError()
 512. 
 513.         return cherrypy.response
 514. 
 515.     def respond(self, path_info):
 516.         """Generate a response for the resource at self.path_info. (Core)"""
 517.         try:
 518.             try:
 519.                 try:
 520.                     if self.app is None:
 521.                         raise cherrypy.NotFound()
 522. 
 523.                     # Get the 'Host' header, so we can HTTPRedirect properly.
 524.                     self.process_headers()
 525. 
 526.                     # Make a copy of the class hooks
 527.                     self.hooks = self.__class__.hooks.copy()
 528.                     self.toolmaps = {}
 529.                     self.get_resource(path_info)
 530.                     self.namespaces(self.config)
 531. 
 532.                     self.hooks.run('on_start_resource')
 533. 
 534.                     if self.process_request_body:
 535.                         if self.method not in self.methods_with_bodies:
 536.                             self.process_request_body = False
 537. 
 538.                         if self.process_request_body:
 539.                             # Prepare the SizeCheckWrapper for the req body
 540.                             mbs = getattr(cherrypy.server,
 541.                                           "max_request_body_size", 0)
 542.                             if mbs > 0:
 543.                                 self.rfile = http.SizeCheckWrapper(self.rfile, mbs)
 544. 
 545.                     self.hooks.run('before_request_body')
 546.                     if self.process_request_body:
 547.                         self.process_body()
 548. 
 549.                     self.hooks.run('before_handler')
 550.                     if self.handler:
 551.                         cherrypy.response.body = self.handler()
 552.                     self.hooks.run('before_finalize')
 553.                     cherrypy.response.finalize()
 554.                 except (cherrypy.HTTPRedirect, cherrypy.HTTPError), inst:
 555.                     inst.set_response()
 556.                     self.hooks.run('before_finalize')
 557.                     cherrypy.response.finalize()
 558.             finally:
 559.                 self.hooks.run('on_end_resource')
 560.         except self.throws:
 561.             raise
 562.         except:
 563.             if self.throw_errors:
 564.                 raise
 565.             self.handle_error(sys.exc_info())
 566. 
 567.     def process_headers(self):
 568.         """Parse HTTP header data into Python structures. (Core)"""
 569.         self.params = http.parse_query_string(self.query_string)
 570. 
 571.         # Process the headers into self.headers
 572.         headers = self.headers
 573.         for name, value in self.header_list:
 574.             # Call title() now (and use dict.__method__(headers))
 575.             # so title doesn't have to be called twice.
 576.             name = name.title()
 577.             value = value.strip()
 578. 
 579.             # Warning: if there is more than one header entry for cookies (AFAIK,
 580.             # only Konqueror does that), only the last one will remain in headers
 581.             # (but they will be correctly stored in request.cookie).
 582.             if "=?" in value:
 583.                 dict.__setitem__(headers, name, http.decode_TEXT(value))
 584.             else:
 585.                 dict.__setitem__(headers, name, value)
 586. 
 587.             # Handle cookies differently because on Konqueror, multiple
 588.             # cookies come on different lines with the same key
 589.             if name == 'Cookie':
 590.                 self.cookie.load(value)
 591. 
 592.         if not dict.__contains__(headers, 'Host'):
 593.             # All Internet-based HTTP/1.1 servers MUST respond with a 400
 594.             # (Bad Request) status code to any HTTP/1.1 request message
 595.             # which lacks a Host header field.
 596.             if self.protocol >= (1, 1):
 597.                 msg = "HTTP/1.1 requires a 'Host' request header."
 598.                 raise cherrypy.HTTPError(400, msg)
 599.         host = dict.__getitem__(headers, 'Host')
 600.         if not host:
 601.             host = self.local.name or self.local.ip
 602.         self.base = "%s://%s" % (self.scheme, host)
 603. 
 604.     def get_resource(self, path):
 605.         """Call a dispatcher (which sets self.handler and .config). (Core)"""
 606.         dispatch = self.dispatch
 607.         # First, see if there is a custom dispatch at this URI. Custom
 608.         # dispatchers can only be specified in app.config, not in _cp_config
 609.         # (since custom dispatchers may not even have an app.root).
 610.         trail = path
 611.         while trail:
 612.             nodeconf = self.app.config.get(trail, {})
 613. 
 614.             d = nodeconf.get("request.dispatch")
 615.             if d:
 616.                 dispatch = d
 617.                 break
 618. 
 619.             lastslash = trail.rfind("/")
 620.             if lastslash == -1:
 621.                 break
 622.             elif lastslash == 0 and trail != "/":
 623.                 trail = "/"
 624.             else:
 625.                 trail = trail[:lastslash]
 626. 
 627.         # dispatch() should set self.handler and self.config
 628.         dispatch(path)
 629. 
 630.     def process_body(self):
 631.         """Convert request.rfile into request.params (or request.body). (Core)"""
 632.         if not self.headers.get("Content-Length", ""):
 633.             # No Content-Length header supplied (or it's 0).
 634.             # If we went ahead and called cgi.FieldStorage, it would hang,
 635.             # since it cannot determine when to stop reading from the socket.
 636.             # See http://www.cherrypy.org/ticket/493.
 637.             # See also http://www.cherrypy.org/ticket/650.
 638.             # Note also that we expect any HTTP server to have decoded
 639.             # any message-body that had a transfer-coding, and we expect
 640.             # the HTTP server to have supplied a Content-Length header
 641.             # which is valid for the decoded entity-body.
 642.             return
 643. 
 644.         # FieldStorage only recognizes POST, so fake it.
 645.         methenv = {'REQUEST_METHOD': "POST"}
 646.         try:
 647.             forms = _cpcgifs.FieldStorage(fp=self.rfile,
 648.                                           headers=self.headers,
 649.                                           environ=methenv,
 650.                                           keep_blank_values=1)
 651.         except http.MaxSizeExceeded:
 652.             # Post data is too big
 653.             raise cherrypy.HTTPError(413)
 654. 
 655.         # Note that, if headers['Content-Type'] is multipart/*,
 656.         # then forms.file will not exist; instead, each form[key]
 657.         # item will be its own file object, and will be handled
 658.         # by params_from_CGI_form.
 659.         if forms.file:
 660.             # request body was a content-type other than form params.
 661.             self.body = forms.file
 662.         else:
 663.             self.params.update(http.params_from_CGI_form(forms))
 664. 
 665.     def handle_error(self, exc):
 666.         """Handle the last exception. (Core)"""
 667.         try:
 668.             self.hooks.run("before_error_response")
 669.             if self.error_response:
 670.                 self.error_response()
 671.             self.hooks.run("after_error_response")
 672.             cherrypy.response.finalize()
 673.         except cherrypy.HTTPRedirect, inst:
 674.             inst.set_response()
 675.             cherrypy.response.finalize()
 676. 
 677. 
 678. def file_generator(input, chunkSize=65536):
 679.     """Yield the given input (a file object) in chunks (default 64k). (Core)"""
 680.     chunk = input.read(chunkSize)
 681.     while chunk:
 682.         yield chunk
 683.         chunk = input.read(chunkSize)
 684.     input.close()
 685. 
 686. 
 687. class Body(object):
 688.     """The body of the HTTP response (the response entity)."""
 689. 
 690.     def __get__(self, obj, objclass=None):
 691.         if obj is None:
 692.             # When calling on the class instead of an instance...
 693.             return self
 694.         else:
 695.             return obj._body
 696. 
 697.     def __set__(self, obj, value):
 698.         # Convert the given value to an iterable object.
 699.         if isinstance(value, basestring):
 700.             # strings get wrapped in a list because iterating over a single
 701.             # item list is much faster than iterating over every character
 702.             # in a long string.
 703.             if value:
 704.                 value = [value]
 705.             else:
 706.                 # [''] doesn't evaluate to False, so replace it with [].
 707.                 value = []
 708.         elif isinstance(value, types.FileType):
 709.             value = file_generator(value)
 710.         elif value is None:
 711.             value = []
 712.         obj._body = value
 713. 
 714. 
 715. class Response(object):
 716.     """An HTTP Response, including status, headers, and body.
 717. 
 718.     Application developers should use Response.headers (a dict) to
 719.     set or modify HTTP response headers. When the response is finalized,
 720.     Response.headers is transformed into Response.header_list as
 721.     (key, value) tuples.
 722.     """
 723. 
 724.     __metaclass__ = cherrypy._AttributeDocstrings
 725. 
 726.     # Class attributes for dev-time introspection.
 727.     status = ""
 728.     status__doc = """The HTTP Status-Code and Reason-Phrase."""
 729. 
 730.     header_list = []
 731.     header_list__doc = """
 732.     A list of the HTTP response headers as (name, value) tuples.
 733.     In general, you should use response.headers (a dict) instead."""
 734. 
 735.     headers = http.HeaderMap()
 736.     headers__doc = """
 737.     A dict-like object containing the response headers. Keys are header
 738.     names (in Title-Case format); however, you may get and set them in
 739.     a case-insensitive manner. That is, headers['Content-Type'] and
 740.     headers['content-type'] refer to the same value. Values are header
 741.     values (decoded according to RFC 2047 if necessary). See also:
 742.     http.HeaderMap, http.HeaderElement."""
 743. 
 744.     cookie = Cookie.SimpleCookie()
 745.     cookie__doc = """See help(Cookie)."""
 746. 
 747.     body = Body()
 748.     body__doc = """The body (entity) of the HTTP response."""
 749. 
 750.     time = None
 751.     time__doc = """The value of time.time() when created. Use in HTTP dates."""
 752. 
 753.     timeout = 300
 754.     timeout__doc = """Seconds after which the response will be aborted."""
 755. 
 756.     timed_out = False
 757.     timed_out__doc = """
 758.     Flag to indicate the response should be aborted, because it has
 759.     exceeded its timeout."""
 760. 
 761.     stream = False
 762.     stream__doc = """If False, buffer the response body."""
 763. 
 764.     def __init__(self):
 765.         self.status = None
 766.         self.header_list = None
 767.         self._body = []
 768.         self.time = time.time()
 769. 
 770.         self.headers = http.HeaderMap()
 771.         # Since we know all our keys are titled strings, we can
 772.         # bypass HeaderMap.update and get a big speed boost.
 773.         dict.update(self.headers, {
 774.             "Content-Type": 'text/html',
 775.             "Server": "CherryPy/" + cherrypy.__version__,
 776.             "Date": http.HTTPDate(self.time),
 777.         })
 778.         self.cookie = Cookie.SimpleCookie()
 779. 
 780.     def collapse_body(self):
 781.         """Iterate over self.body, replacing it with and returning the result."""
 782.         newbody = ''.join([chunk for chunk in self.body])
 783.         self.body = newbody
 784.         return newbody
 785. 
 786.     def finalize(self):
 787.         """Transform headers (and cookies) into self.header_list. (Core)"""
 788.         try:
 789.             code, reason, _ = http.valid_status(self.status)
 790.         except ValueError, x:
 791.             raise cherrypy.HTTPError(500, x.args[0])
 792. 
 793.         self.status = "%s %s" % (code, reason)
 794. 
 795.         headers = self.headers
 796.         if self.stream:
 797.             if dict.get(headers, 'Content-Length') is None:
 798.                 dict.pop(headers, 'Content-Length', None)
 799.         elif code < 200 or code in (204, 205, 304):
 800.             # "All 1xx (informational), 204 (no content),
 801.             # and 304 (not modified) responses MUST NOT
 802.             # include a message-body."
 803.             dict.pop(headers, 'Content-Length', None)
 804.             self.body = ""
 805.         else:
 806.             # Responses which are not streamed should have a Content-Length,
 807.             # but allow user code to set Content-Length if desired.
 808.             if dict.get(headers, 'Content-Length') is None:
 809.                 content = self.collapse_body()
 810.                 dict.__setitem__(headers, 'Content-Length', len(content))
 811. 
 812.         # Transform our header dict into a list of tuples.
 813.         self.header_list = h = headers.output(cherrypy.request.protocol)
 814. 
 815.         cookie = self.cookie.output()
 816.         if cookie:
 817.             for line in cookie.split("\n"):
 818.                 name, value = line.split(": ", 1)
 819.                 h.append((name, value))
 820. 
 821.     def check_timeout(self):
 822.         """If now > self.time + self.timeout, set self.timed_out.
 823. 
 824.         This purposefully sets a flag, rather than raising an error,
 825.         so that a monitor thread can interrupt the Response thread.
 826.         """
 827.         if time.time() > self.time + self.timeout:
 828.             self.timed_out = True
 829. 
 830.