mirror of https://github.com/evilhero/mylar
974 lines
36 KiB
Python
Executable File
974 lines
36 KiB
Python
Executable File
|
|
import os
|
|
import sys
|
|
import time
|
|
import warnings
|
|
|
|
import cherrypy
|
|
from cherrypy._cpcompat import basestring, copykeys, ntob, unicodestr
|
|
from cherrypy._cpcompat import SimpleCookie, CookieError, py3k
|
|
from cherrypy import _cpreqbody, _cpconfig
|
|
from cherrypy._cperror import format_exc, bare_error
|
|
from cherrypy.lib import httputil, file_generator
|
|
|
|
|
|
class Hook(object):
|
|
|
|
"""A callback and its metadata: failsafe, priority, and kwargs."""
|
|
|
|
callback = None
|
|
"""
|
|
The bare callable that this Hook object is wrapping, which will
|
|
be called when the Hook is called."""
|
|
|
|
failsafe = False
|
|
"""
|
|
If True, the callback is guaranteed to run even if other callbacks
|
|
from the same call point raise exceptions."""
|
|
|
|
priority = 50
|
|
"""
|
|
Defines the order of execution for a list of Hooks. Priority numbers
|
|
should be limited to the closed interval [0, 100], but values outside
|
|
this range are acceptable, as are fractional values."""
|
|
|
|
kwargs = {}
|
|
"""
|
|
A set of keyword arguments that will be passed to the
|
|
callable on each call."""
|
|
|
|
def __init__(self, callback, failsafe=None, priority=None, **kwargs):
|
|
self.callback = callback
|
|
|
|
if failsafe is None:
|
|
failsafe = getattr(callback, "failsafe", False)
|
|
self.failsafe = failsafe
|
|
|
|
if priority is None:
|
|
priority = getattr(callback, "priority", 50)
|
|
self.priority = priority
|
|
|
|
self.kwargs = kwargs
|
|
|
|
def __lt__(self, other):
|
|
# Python 3
|
|
return self.priority < other.priority
|
|
|
|
def __cmp__(self, other):
|
|
# Python 2
|
|
return cmp(self.priority, other.priority)
|
|
|
|
def __call__(self):
|
|
"""Run self.callback(**self.kwargs)."""
|
|
return self.callback(**self.kwargs)
|
|
|
|
def __repr__(self):
|
|
cls = self.__class__
|
|
return ("%s.%s(callback=%r, failsafe=%r, priority=%r, %s)"
|
|
% (cls.__module__, cls.__name__, self.callback,
|
|
self.failsafe, self.priority,
|
|
", ".join(['%s=%r' % (k, v)
|
|
for k, v in self.kwargs.items()])))
|
|
|
|
|
|
class HookMap(dict):
|
|
|
|
"""A map of call points to lists of callbacks (Hook objects)."""
|
|
|
|
def __new__(cls, points=None):
|
|
d = dict.__new__(cls)
|
|
for p in points or []:
|
|
d[p] = []
|
|
return d
|
|
|
|
def __init__(self, *a, **kw):
|
|
pass
|
|
|
|
def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
|
|
"""Append a new Hook made from the supplied arguments."""
|
|
self[point].append(Hook(callback, failsafe, priority, **kwargs))
|
|
|
|
def run(self, point):
|
|
"""Execute all registered Hooks (callbacks) for the given point."""
|
|
exc = None
|
|
hooks = self[point]
|
|
hooks.sort()
|
|
for hook in hooks:
|
|
# Some hooks are guaranteed to run even if others at
|
|
# the same hookpoint fail. We will still log the failure,
|
|
# but proceed on to the next hook. The only way
|
|
# to stop all processing from one of these hooks is
|
|
# to raise SystemExit and stop the whole server.
|
|
if exc is None or hook.failsafe:
|
|
try:
|
|
hook()
|
|
except (KeyboardInterrupt, SystemExit):
|
|
raise
|
|
except (cherrypy.HTTPError, cherrypy.HTTPRedirect,
|
|
cherrypy.InternalRedirect):
|
|
exc = sys.exc_info()[1]
|
|
except:
|
|
exc = sys.exc_info()[1]
|
|
cherrypy.log(traceback=True, severity=40)
|
|
if exc:
|
|
raise exc
|
|
|
|
def __copy__(self):
|
|
newmap = self.__class__()
|
|
# We can't just use 'update' because we want copies of the
|
|
# mutable values (each is a list) as well.
|
|
for k, v in self.items():
|
|
newmap[k] = v[:]
|
|
return newmap
|
|
copy = __copy__
|
|
|
|
def __repr__(self):
|
|
cls = self.__class__
|
|
return "%s.%s(points=%r)" % (
|
|
cls.__module__,
|
|
cls.__name__,
|
|
copykeys(self)
|
|
)
|
|
|
|
|
|
# Config namespace handlers
|
|
|
|
def hooks_namespace(k, v):
|
|
"""Attach bare hooks declared in config."""
|
|
# Use split again to allow multiple hooks for a single
|
|
# hookpoint per path (e.g. "hooks.before_handler.1").
|
|
# Little-known fact you only get from reading source ;)
|
|
hookpoint = k.split(".", 1)[0]
|
|
if isinstance(v, basestring):
|
|
v = cherrypy.lib.attributes(v)
|
|
if not isinstance(v, Hook):
|
|
v = Hook(v)
|
|
cherrypy.serving.request.hooks[hookpoint].append(v)
|
|
|
|
|
|
def request_namespace(k, v):
|
|
"""Attach request attributes declared in config."""
|
|
# Provides config entries to set request.body attrs (like
|
|
# attempt_charsets).
|
|
if k[:5] == 'body.':
|
|
setattr(cherrypy.serving.request.body, k[5:], v)
|
|
else:
|
|
setattr(cherrypy.serving.request, k, v)
|
|
|
|
|
|
def response_namespace(k, v):
|
|
"""Attach response attributes declared in config."""
|
|
# Provides config entries to set default response headers
|
|
# http://cherrypy.org/ticket/889
|
|
if k[:8] == 'headers.':
|
|
cherrypy.serving.response.headers[k.split('.', 1)[1]] = v
|
|
else:
|
|
setattr(cherrypy.serving.response, k, v)
|
|
|
|
|
|
def error_page_namespace(k, v):
|
|
"""Attach error pages declared in config."""
|
|
if k != 'default':
|
|
k = int(k)
|
|
cherrypy.serving.request.error_page[k] = v
|
|
|
|
|
|
hookpoints = ['on_start_resource', 'before_request_body',
|
|
'before_handler', 'before_finalize',
|
|
'on_end_resource', 'on_end_request',
|
|
'before_error_response', 'after_error_response']
|
|
|
|
|
|
class Request(object):
|
|
|
|
"""An HTTP request.
|
|
|
|
This object represents the metadata of an HTTP request message;
|
|
that is, it contains attributes which describe the environment
|
|
in which the request URL, headers, and body were sent (if you
|
|
want tools to interpret the headers and body, those are elsewhere,
|
|
mostly in Tools). This 'metadata' consists of socket data,
|
|
transport characteristics, and the Request-Line. This object
|
|
also contains data regarding the configuration in effect for
|
|
the given URL, and the execution plan for generating a response.
|
|
"""
|
|
|
|
prev = None
|
|
"""
|
|
The previous Request object (if any). This should be None
|
|
unless we are processing an InternalRedirect."""
|
|
|
|
# Conversation/connection attributes
|
|
local = httputil.Host("127.0.0.1", 80)
|
|
"An httputil.Host(ip, port, hostname) object for the server socket."
|
|
|
|
remote = httputil.Host("127.0.0.1", 1111)
|
|
"An httputil.Host(ip, port, hostname) object for the client socket."
|
|
|
|
scheme = "http"
|
|
"""
|
|
The protocol used between client and server. In most cases,
|
|
this will be either 'http' or 'https'."""
|
|
|
|
server_protocol = "HTTP/1.1"
|
|
"""
|
|
The HTTP version for which the HTTP server is at least
|
|
conditionally compliant."""
|
|
|
|
base = ""
|
|
"""The (scheme://host) portion of the requested URL.
|
|
In some cases (e.g. when proxying via mod_rewrite), this may contain
|
|
path segments which cherrypy.url uses when constructing url's, but
|
|
which otherwise are ignored by CherryPy. Regardless, this value
|
|
MUST NOT end in a slash."""
|
|
|
|
# Request-Line attributes
|
|
request_line = ""
|
|
"""
|
|
The complete Request-Line received from the client. This is a
|
|
single string consisting of the request method, URI, and protocol
|
|
version (joined by spaces). Any final CRLF is removed."""
|
|
|
|
method = "GET"
|
|
"""
|
|
Indicates the HTTP method to be performed on the resource identified
|
|
by the Request-URI. Common methods include GET, HEAD, POST, PUT, and
|
|
DELETE. CherryPy allows any extension method; however, various HTTP
|
|
servers and gateways may restrict the set of allowable methods.
|
|
CherryPy applications SHOULD restrict the set (on a per-URI basis)."""
|
|
|
|
query_string = ""
|
|
"""
|
|
The query component of the Request-URI, a string of information to be
|
|
interpreted by the resource. The query portion of a URI follows the
|
|
path component, and is separated by a '?'. For example, the URI
|
|
'http://www.cherrypy.org/wiki?a=3&b=4' has the query component,
|
|
'a=3&b=4'."""
|
|
|
|
query_string_encoding = 'utf8'
|
|
"""
|
|
The encoding expected for query string arguments after % HEX HEX decoding).
|
|
If a query string is provided that cannot be decoded with this encoding,
|
|
404 is raised (since technically it's a different URI). If you want
|
|
arbitrary encodings to not error, set this to 'Latin-1'; you can then
|
|
encode back to bytes and re-decode to whatever encoding you like later.
|
|
"""
|
|
|
|
protocol = (1, 1)
|
|
"""The HTTP protocol version corresponding to the set
|
|
of features which should be allowed in the response. If BOTH
|
|
the client's request message AND the server's level of HTTP
|
|
compliance is HTTP/1.1, this attribute will be the tuple (1, 1).
|
|
If either is 1.0, this attribute will be the tuple (1, 0).
|
|
Lower HTTP protocol versions are not explicitly supported."""
|
|
|
|
params = {}
|
|
"""
|
|
A dict which combines query string (GET) and request entity (POST)
|
|
variables. This is populated in two stages: GET params are added
|
|
before the 'on_start_resource' hook, and POST params are added
|
|
between the 'before_request_body' and 'before_handler' hooks."""
|
|
|
|
# Message attributes
|
|
header_list = []
|
|
"""
|
|
A list of the HTTP request headers as (name, value) tuples.
|
|
In general, you should use request.headers (a dict) instead."""
|
|
|
|
headers = httputil.HeaderMap()
|
|
"""
|
|
A dict-like object containing the request headers. Keys are header
|
|
names (in Title-Case format); however, you may get and set them in
|
|
a case-insensitive manner. That is, headers['Content-Type'] and
|
|
headers['content-type'] refer to the same value. Values are header
|
|
values (decoded according to :rfc:`2047` if necessary). See also:
|
|
httputil.HeaderMap, httputil.HeaderElement."""
|
|
|
|
cookie = SimpleCookie()
|
|
"""See help(Cookie)."""
|
|
|
|
rfile = None
|
|
"""
|
|
If the request included an entity (body), it will be available
|
|
as a stream in this attribute. However, the rfile will normally
|
|
be read for you between the 'before_request_body' hook and the
|
|
'before_handler' hook, and the resulting string is placed into
|
|
either request.params or the request.body attribute.
|
|
|
|
You may disable the automatic consumption of the rfile by setting
|
|
request.process_request_body to False, either in config for the desired
|
|
path, or in an 'on_start_resource' or 'before_request_body' hook.
|
|
|
|
WARNING: In almost every case, you should not attempt to read from the
|
|
rfile stream after CherryPy's automatic mechanism has read it. If you
|
|
turn off the automatic parsing of rfile, you should read exactly the
|
|
number of bytes specified in request.headers['Content-Length'].
|
|
Ignoring either of these warnings may result in a hung request thread
|
|
or in corruption of the next (pipelined) request.
|
|
"""
|
|
|
|
process_request_body = True
|
|
"""
|
|
If True, the rfile (if any) is automatically read and parsed,
|
|
and the result placed into request.params or request.body."""
|
|
|
|
methods_with_bodies = ("POST", "PUT")
|
|
"""
|
|
A sequence of HTTP methods for which CherryPy will automatically
|
|
attempt to read a body from the rfile. If you are going to change
|
|
this property, modify it on the configuration (recommended)
|
|
or on the "hook point" `on_start_resource`.
|
|
"""
|
|
|
|
body = None
|
|
"""
|
|
If the request Content-Type is 'application/x-www-form-urlencoded'
|
|
or multipart, this will be None. Otherwise, this will be an instance
|
|
of :class:`RequestBody<cherrypy._cpreqbody.RequestBody>` (which you
|
|
can .read()); this value is set between the 'before_request_body' and
|
|
'before_handler' hooks (assuming that process_request_body is True)."""
|
|
|
|
# Dispatch attributes
|
|
dispatch = cherrypy.dispatch.Dispatcher()
|
|
"""
|
|
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.
|
|
See help(cherrypy.dispatch) for more information."""
|
|
|
|
script_name = ""
|
|
"""
|
|
The 'mount point' of the application which is handling this request.
|
|
|
|
This attribute MUST NOT end in a slash. If the script_name refers to
|
|
the root of the URI, it MUST be an empty string (not "/").
|
|
"""
|
|
|
|
path_info = "/"
|
|
"""
|
|
The 'relative path' portion of the Request-URI. This is relative
|
|
to the script_name ('mount point') of the application which is
|
|
handling this request."""
|
|
|
|
login = None
|
|
"""
|
|
When authentication is used during the request processing this is
|
|
set to 'False' if it failed and to the 'username' value if it succeeded.
|
|
The default 'None' implies that no authentication happened."""
|
|
|
|
# Note that cherrypy.url uses "if request.app:" to determine whether
|
|
# the call is during a real HTTP request or not. So leave this None.
|
|
app = None
|
|
"""The cherrypy.Application object which is handling this request."""
|
|
|
|
handler = None
|
|
"""
|
|
The function, method, or other callable which CherryPy will call to
|
|
produce the response. The discovery of the handler and the arguments
|
|
it will receive are determined by the request.dispatch object.
|
|
By default, the handler is discovered by walking a tree of objects
|
|
starting at request.app.root, and is then passed all HTTP params
|
|
(from the query string and POST body) as keyword arguments."""
|
|
|
|
toolmaps = {}
|
|
"""
|
|
A nested dict of all Toolboxes and Tools in effect for this request,
|
|
of the form: {Toolbox.namespace: {Tool.name: config dict}}."""
|
|
|
|
config = None
|
|
"""
|
|
A flat dict of all configuration entries which apply to the
|
|
current request. These entries are collected from global config,
|
|
application config (based on request.path_info), and from handler
|
|
config (exactly how is governed by the request.dispatch object in
|
|
effect for this request; by default, handler config can be attached
|
|
anywhere in the tree between request.app.root and the final handler,
|
|
and inherits downward)."""
|
|
|
|
is_index = None
|
|
"""
|
|
This will be True if the current request is mapped to an 'index'
|
|
resource handler (also, a 'default' handler if path_info ends with
|
|
a slash). The value may be used to automatically redirect the
|
|
user-agent to a 'more canonical' URL which either adds or removes
|
|
the trailing slash. See cherrypy.tools.trailing_slash."""
|
|
|
|
hooks = HookMap(hookpoints)
|
|
"""
|
|
A HookMap (dict-like object) of the form: {hookpoint: [hook, ...]}.
|
|
Each key is a str naming the hook point, and each value is a list
|
|
of hooks which will be called at that hook point during this request.
|
|
The list of hooks is generally populated as early as possible (mostly
|
|
from Tools specified in config), but may be extended at any time.
|
|
See also: _cprequest.Hook, _cprequest.HookMap, and cherrypy.tools."""
|
|
|
|
error_response = cherrypy.HTTPError(500).set_response
|
|
"""
|
|
The no-arg callable which will handle unexpected, untrapped errors
|
|
during request processing. This is not used for expected exceptions
|
|
(like NotFound, HTTPError, or HTTPRedirect) which are raised in
|
|
response to expected conditions (those should be customized either
|
|
via request.error_page or by overriding HTTPError.set_response).
|
|
By default, error_response uses HTTPError(500) to return a generic
|
|
error response to the user-agent."""
|
|
|
|
error_page = {}
|
|
"""
|
|
A dict of {error code: response filename or callable} pairs.
|
|
|
|
The error code must be an int representing a given HTTP error code,
|
|
or the string 'default', which will be used if no matching entry
|
|
is found for a given numeric code.
|
|
|
|
If a filename is provided, the file should contain a Python string-
|
|
formatting template, and can expect by default to receive format
|
|
values with the mapping keys %(status)s, %(message)s, %(traceback)s,
|
|
and %(version)s. The set of format mappings can be extended by
|
|
overriding HTTPError.set_response.
|
|
|
|
If a callable is provided, it will be called by default with keyword
|
|
arguments 'status', 'message', 'traceback', and 'version', as for a
|
|
string-formatting template. The callable must return a string or
|
|
iterable of strings which will be set to response.body. It may also
|
|
override headers or perform any other processing.
|
|
|
|
If no entry is given for an error code, and no 'default' entry exists,
|
|
a default template will be used.
|
|
"""
|
|
|
|
show_tracebacks = True
|
|
"""
|
|
If True, unexpected errors encountered during request processing will
|
|
include a traceback in the response body."""
|
|
|
|
show_mismatched_params = True
|
|
"""
|
|
If True, mismatched parameters encountered during PageHandler invocation
|
|
processing will be included in the response body."""
|
|
|
|
throws = (KeyboardInterrupt, SystemExit, cherrypy.InternalRedirect)
|
|
"""The sequence of exceptions which Request.run does not trap."""
|
|
|
|
throw_errors = False
|
|
"""
|
|
If True, Request.run will not trap any errors (except HTTPRedirect and
|
|
HTTPError, which are more properly called 'exceptions', not errors)."""
|
|
|
|
closed = False
|
|
"""True once the close method has been called, False otherwise."""
|
|
|
|
stage = None
|
|
"""
|
|
A string containing the stage reached in the request-handling process.
|
|
This is useful when debugging a live server with hung requests."""
|
|
|
|
namespaces = _cpconfig.NamespaceSet(
|
|
**{"hooks": hooks_namespace,
|
|
"request": request_namespace,
|
|
"response": response_namespace,
|
|
"error_page": error_page_namespace,
|
|
"tools": cherrypy.tools,
|
|
})
|
|
|
|
def __init__(self, local_host, remote_host, scheme="http",
|
|
server_protocol="HTTP/1.1"):
|
|
"""Populate a new Request object.
|
|
|
|
local_host should be an httputil.Host object with the server info.
|
|
remote_host should be an httputil.Host object with the client info.
|
|
scheme should be a string, either "http" or "https".
|
|
"""
|
|
self.local = local_host
|
|
self.remote = remote_host
|
|
self.scheme = scheme
|
|
self.server_protocol = server_protocol
|
|
|
|
self.closed = False
|
|
|
|
# Put a *copy* of the class error_page into self.
|
|
self.error_page = self.error_page.copy()
|
|
|
|
# Put a *copy* of the class namespaces into self.
|
|
self.namespaces = self.namespaces.copy()
|
|
|
|
self.stage = None
|
|
|
|
def close(self):
|
|
"""Run cleanup code. (Core)"""
|
|
if not self.closed:
|
|
self.closed = True
|
|
self.stage = 'on_end_request'
|
|
self.hooks.run('on_end_request')
|
|
self.stage = 'close'
|
|
|
|
def run(self, method, path, query_string, req_protocol, headers, rfile):
|
|
r"""Process the Request. (Core)
|
|
|
|
method, path, query_string, and req_protocol should be pulled directly
|
|
from the Request-Line (e.g. "GET /path?key=val HTTP/1.0").
|
|
|
|
path
|
|
This should be %XX-unquoted, but query_string should not be.
|
|
|
|
When using Python 2, they both MUST be byte strings,
|
|
not unicode strings.
|
|
|
|
When using Python 3, they both MUST be unicode strings,
|
|
not byte strings, and preferably not bytes \x00-\xFF
|
|
disguised as unicode.
|
|
|
|
headers
|
|
A list of (name, value) tuples.
|
|
|
|
rfile
|
|
A file-like object containing the HTTP request entity.
|
|
|
|
When run() is done, the returned object should have 3 attributes:
|
|
|
|
* status, e.g. "200 OK"
|
|
* header_list, a list of (name, value) tuples
|
|
* body, an iterable yielding strings
|
|
|
|
Consumer code (HTTP servers) should then access these response
|
|
attributes to build the outbound stream.
|
|
|
|
"""
|
|
response = cherrypy.serving.response
|
|
self.stage = 'run'
|
|
try:
|
|
self.error_response = cherrypy.HTTPError(500).set_response
|
|
|
|
self.method = method
|
|
path = path or "/"
|
|
self.query_string = query_string or ''
|
|
self.params = {}
|
|
|
|
# Compare request and server HTTP protocol versions, in case our
|
|
# server does not support the requested protocol. Limit our output
|
|
# to min(req, server). We want the following output:
|
|
# request server actual written supported response
|
|
# protocol protocol response protocol feature set
|
|
# a 1.0 1.0 1.0 1.0
|
|
# b 1.0 1.1 1.1 1.0
|
|
# c 1.1 1.0 1.0 1.0
|
|
# d 1.1 1.1 1.1 1.1
|
|
# Notice that, in (b), the response will be "HTTP/1.1" even though
|
|
# the client only understands 1.0. RFC 2616 10.5.6 says we should
|
|
# only return 505 if the _major_ version is different.
|
|
rp = int(req_protocol[5]), int(req_protocol[7])
|
|
sp = int(self.server_protocol[5]), int(self.server_protocol[7])
|
|
self.protocol = min(rp, sp)
|
|
response.headers.protocol = self.protocol
|
|
|
|
# Rebuild first line of the request (e.g. "GET /path HTTP/1.0").
|
|
url = path
|
|
if query_string:
|
|
url += '?' + query_string
|
|
self.request_line = '%s %s %s' % (method, url, req_protocol)
|
|
|
|
self.header_list = list(headers)
|
|
self.headers = httputil.HeaderMap()
|
|
|
|
self.rfile = rfile
|
|
self.body = None
|
|
|
|
self.cookie = SimpleCookie()
|
|
self.handler = None
|
|
|
|
# path_info should be the path from the
|
|
# app root (script_name) to the handler.
|
|
self.script_name = self.app.script_name
|
|
self.path_info = pi = path[len(self.script_name):]
|
|
|
|
self.stage = 'respond'
|
|
self.respond(pi)
|
|
|
|
except self.throws:
|
|
raise
|
|
except:
|
|
if self.throw_errors:
|
|
raise
|
|
else:
|
|
# Failure in setup, error handler or finalize. Bypass them.
|
|
# Can't use handle_error because we may not have hooks yet.
|
|
cherrypy.log(traceback=True, severity=40)
|
|
if self.show_tracebacks:
|
|
body = format_exc()
|
|
else:
|
|
body = ""
|
|
r = bare_error(body)
|
|
response.output_status, response.header_list, response.body = r
|
|
|
|
if self.method == "HEAD":
|
|
# HEAD requests MUST NOT return a message-body in the response.
|
|
response.body = []
|
|
|
|
try:
|
|
cherrypy.log.access()
|
|
except:
|
|
cherrypy.log.error(traceback=True)
|
|
|
|
if response.timed_out:
|
|
raise cherrypy.TimeoutError()
|
|
|
|
return response
|
|
|
|
# Uncomment for stage debugging
|
|
# stage = property(lambda self: self._stage, lambda self, v: print(v))
|
|
|
|
def respond(self, path_info):
|
|
"""Generate a response for the resource at self.path_info. (Core)"""
|
|
response = cherrypy.serving.response
|
|
try:
|
|
try:
|
|
try:
|
|
if self.app is None:
|
|
raise cherrypy.NotFound()
|
|
|
|
# Get the 'Host' header, so we can HTTPRedirect properly.
|
|
self.stage = 'process_headers'
|
|
self.process_headers()
|
|
|
|
# Make a copy of the class hooks
|
|
self.hooks = self.__class__.hooks.copy()
|
|
self.toolmaps = {}
|
|
|
|
self.stage = 'get_resource'
|
|
self.get_resource(path_info)
|
|
|
|
self.body = _cpreqbody.RequestBody(
|
|
self.rfile, self.headers, request_params=self.params)
|
|
|
|
self.namespaces(self.config)
|
|
|
|
self.stage = 'on_start_resource'
|
|
self.hooks.run('on_start_resource')
|
|
|
|
# Parse the querystring
|
|
self.stage = 'process_query_string'
|
|
self.process_query_string()
|
|
|
|
# Process the body
|
|
if self.process_request_body:
|
|
if self.method not in self.methods_with_bodies:
|
|
self.process_request_body = False
|
|
self.stage = 'before_request_body'
|
|
self.hooks.run('before_request_body')
|
|
if self.process_request_body:
|
|
self.body.process()
|
|
|
|
# Run the handler
|
|
self.stage = 'before_handler'
|
|
self.hooks.run('before_handler')
|
|
if self.handler:
|
|
self.stage = 'handler'
|
|
response.body = self.handler()
|
|
|
|
# Finalize
|
|
self.stage = 'before_finalize'
|
|
self.hooks.run('before_finalize')
|
|
response.finalize()
|
|
except (cherrypy.HTTPRedirect, cherrypy.HTTPError):
|
|
inst = sys.exc_info()[1]
|
|
inst.set_response()
|
|
self.stage = 'before_finalize (HTTPError)'
|
|
self.hooks.run('before_finalize')
|
|
response.finalize()
|
|
finally:
|
|
self.stage = 'on_end_resource'
|
|
self.hooks.run('on_end_resource')
|
|
except self.throws:
|
|
raise
|
|
except:
|
|
if self.throw_errors:
|
|
raise
|
|
self.handle_error()
|
|
|
|
def process_query_string(self):
|
|
"""Parse the query string into Python structures. (Core)"""
|
|
try:
|
|
p = httputil.parse_query_string(
|
|
self.query_string, encoding=self.query_string_encoding)
|
|
except UnicodeDecodeError:
|
|
raise cherrypy.HTTPError(
|
|
404, "The given query string could not be processed. Query "
|
|
"strings for this resource must be encoded with %r." %
|
|
self.query_string_encoding)
|
|
|
|
# Python 2 only: keyword arguments must be byte strings (type 'str').
|
|
if not py3k:
|
|
for key, value in p.items():
|
|
if isinstance(key, unicode):
|
|
del p[key]
|
|
p[key.encode(self.query_string_encoding)] = value
|
|
self.params.update(p)
|
|
|
|
def process_headers(self):
|
|
"""Parse HTTP header data into Python structures. (Core)"""
|
|
# Process the headers into self.headers
|
|
headers = self.headers
|
|
for name, value in self.header_list:
|
|
# Call title() now (and use dict.__method__(headers))
|
|
# so title doesn't have to be called twice.
|
|
name = name.title()
|
|
value = value.strip()
|
|
|
|
# Warning: if there is more than one header entry for cookies
|
|
# (AFAIK, only Konqueror does that), only the last one will
|
|
# remain in headers (but they will be correctly stored in
|
|
# request.cookie).
|
|
if "=?" in value:
|
|
dict.__setitem__(headers, name, httputil.decode_TEXT(value))
|
|
else:
|
|
dict.__setitem__(headers, name, value)
|
|
|
|
# Handle cookies differently because on Konqueror, multiple
|
|
# cookies come on different lines with the same key
|
|
if name == 'Cookie':
|
|
try:
|
|
self.cookie.load(value)
|
|
except CookieError:
|
|
msg = "Illegal cookie name %s" % value.split('=')[0]
|
|
raise cherrypy.HTTPError(400, msg)
|
|
|
|
if not dict.__contains__(headers, 'Host'):
|
|
# All Internet-based HTTP/1.1 servers MUST respond with a 400
|
|
# (Bad Request) status code to any HTTP/1.1 request message
|
|
# which lacks a Host header field.
|
|
if self.protocol >= (1, 1):
|
|
msg = "HTTP/1.1 requires a 'Host' request header."
|
|
raise cherrypy.HTTPError(400, msg)
|
|
host = dict.get(headers, 'Host')
|
|
if not host:
|
|
host = self.local.name or self.local.ip
|
|
self.base = "%s://%s" % (self.scheme, host)
|
|
|
|
def get_resource(self, path):
|
|
"""Call a dispatcher (which sets self.handler and .config). (Core)"""
|
|
# First, see if there is a custom dispatch at this URI. Custom
|
|
# dispatchers can only be specified in app.config, not in _cp_config
|
|
# (since custom dispatchers may not even have an app.root).
|
|
dispatch = self.app.find_config(
|
|
path, "request.dispatch", self.dispatch)
|
|
|
|
# dispatch() should set self.handler and self.config
|
|
dispatch(path)
|
|
|
|
def handle_error(self):
|
|
"""Handle the last unanticipated exception. (Core)"""
|
|
try:
|
|
self.hooks.run("before_error_response")
|
|
if self.error_response:
|
|
self.error_response()
|
|
self.hooks.run("after_error_response")
|
|
cherrypy.serving.response.finalize()
|
|
except cherrypy.HTTPRedirect:
|
|
inst = sys.exc_info()[1]
|
|
inst.set_response()
|
|
cherrypy.serving.response.finalize()
|
|
|
|
# ------------------------- Properties ------------------------- #
|
|
|
|
def _get_body_params(self):
|
|
warnings.warn(
|
|
"body_params is deprecated in CherryPy 3.2, will be removed in "
|
|
"CherryPy 3.3.",
|
|
DeprecationWarning
|
|
)
|
|
return self.body.params
|
|
body_params = property(_get_body_params,
|
|
doc="""
|
|
If the request Content-Type is 'application/x-www-form-urlencoded' or
|
|
multipart, this will be a dict of the params pulled from the entity
|
|
body; that is, it will be the portion of request.params that come
|
|
from the message body (sometimes called "POST params", although they
|
|
can be sent with various HTTP method verbs). This value is set between
|
|
the 'before_request_body' and 'before_handler' hooks (assuming that
|
|
process_request_body is True).
|
|
|
|
Deprecated in 3.2, will be removed for 3.3 in favor of
|
|
:attr:`request.body.params<cherrypy._cprequest.RequestBody.params>`.""")
|
|
|
|
|
|
class ResponseBody(object):
|
|
|
|
"""The body of the HTTP response (the response entity)."""
|
|
|
|
if py3k:
|
|
unicode_err = ("Page handlers MUST return bytes. Use tools.encode "
|
|
"if you wish to return unicode.")
|
|
|
|
def __get__(self, obj, objclass=None):
|
|
if obj is None:
|
|
# When calling on the class instead of an instance...
|
|
return self
|
|
else:
|
|
return obj._body
|
|
|
|
def __set__(self, obj, value):
|
|
# Convert the given value to an iterable object.
|
|
if py3k and isinstance(value, str):
|
|
raise ValueError(self.unicode_err)
|
|
|
|
if isinstance(value, basestring):
|
|
# strings get wrapped in a list because iterating over a single
|
|
# item list is much faster than iterating over every character
|
|
# in a long string.
|
|
if value:
|
|
value = [value]
|
|
else:
|
|
# [''] doesn't evaluate to False, so replace it with [].
|
|
value = []
|
|
elif py3k and isinstance(value, list):
|
|
# every item in a list must be bytes...
|
|
for i, item in enumerate(value):
|
|
if isinstance(item, str):
|
|
raise ValueError(self.unicode_err)
|
|
# Don't use isinstance here; io.IOBase which has an ABC takes
|
|
# 1000 times as long as, say, isinstance(value, str)
|
|
elif hasattr(value, 'read'):
|
|
value = file_generator(value)
|
|
elif value is None:
|
|
value = []
|
|
obj._body = value
|
|
|
|
|
|
class Response(object):
|
|
|
|
"""An HTTP Response, including status, headers, and body."""
|
|
|
|
status = ""
|
|
"""The HTTP Status-Code and Reason-Phrase."""
|
|
|
|
header_list = []
|
|
"""
|
|
A list of the HTTP response headers as (name, value) tuples.
|
|
In general, you should use response.headers (a dict) instead. This
|
|
attribute is generated from response.headers and is not valid until
|
|
after the finalize phase."""
|
|
|
|
headers = httputil.HeaderMap()
|
|
"""
|
|
A dict-like object containing the response headers. Keys are header
|
|
names (in Title-Case format); however, you may get and set them in
|
|
a case-insensitive manner. That is, headers['Content-Type'] and
|
|
headers['content-type'] refer to the same value. Values are header
|
|
values (decoded according to :rfc:`2047` if necessary).
|
|
|
|
.. seealso:: classes :class:`HeaderMap`, :class:`HeaderElement`
|
|
"""
|
|
|
|
cookie = SimpleCookie()
|
|
"""See help(Cookie)."""
|
|
|
|
body = ResponseBody()
|
|
"""The body (entity) of the HTTP response."""
|
|
|
|
time = None
|
|
"""The value of time.time() when created. Use in HTTP dates."""
|
|
|
|
timeout = 300
|
|
"""Seconds after which the response will be aborted."""
|
|
|
|
timed_out = False
|
|
"""
|
|
Flag to indicate the response should be aborted, because it has
|
|
exceeded its timeout."""
|
|
|
|
stream = False
|
|
"""If False, buffer the response body."""
|
|
|
|
def __init__(self):
|
|
self.status = None
|
|
self.header_list = None
|
|
self._body = []
|
|
self.time = time.time()
|
|
|
|
self.headers = httputil.HeaderMap()
|
|
# Since we know all our keys are titled strings, we can
|
|
# bypass HeaderMap.update and get a big speed boost.
|
|
dict.update(self.headers, {
|
|
"Content-Type": 'text/html',
|
|
"Server": "CherryPy/" + cherrypy.__version__,
|
|
"Date": httputil.HTTPDate(self.time),
|
|
})
|
|
self.cookie = SimpleCookie()
|
|
|
|
def collapse_body(self):
|
|
"""Collapse self.body to a single string; replace it and return it."""
|
|
if isinstance(self.body, basestring):
|
|
return self.body
|
|
|
|
newbody = []
|
|
for chunk in self.body:
|
|
if py3k and not isinstance(chunk, bytes):
|
|
raise TypeError("Chunk %s is not of type 'bytes'." %
|
|
repr(chunk))
|
|
newbody.append(chunk)
|
|
newbody = ntob('').join(newbody)
|
|
|
|
self.body = newbody
|
|
return newbody
|
|
|
|
def finalize(self):
|
|
"""Transform headers (and cookies) into self.header_list. (Core)"""
|
|
try:
|
|
code, reason, _ = httputil.valid_status(self.status)
|
|
except ValueError:
|
|
raise cherrypy.HTTPError(500, sys.exc_info()[1].args[0])
|
|
|
|
headers = self.headers
|
|
|
|
self.status = "%s %s" % (code, reason)
|
|
self.output_status = ntob(str(code), 'ascii') + \
|
|
ntob(" ") + headers.encode(reason)
|
|
|
|
if self.stream:
|
|
# The upshot: wsgiserver will chunk the response if
|
|
# you pop Content-Length (or set it explicitly to None).
|
|
# Note that lib.static sets C-L to the file's st_size.
|
|
if dict.get(headers, 'Content-Length') is None:
|
|
dict.pop(headers, 'Content-Length', None)
|
|
elif code < 200 or code in (204, 205, 304):
|
|
# "All 1xx (informational), 204 (no content),
|
|
# and 304 (not modified) responses MUST NOT
|
|
# include a message-body."
|
|
dict.pop(headers, 'Content-Length', None)
|
|
self.body = ntob("")
|
|
else:
|
|
# Responses which are not streamed should have a Content-Length,
|
|
# but allow user code to set Content-Length if desired.
|
|
if dict.get(headers, 'Content-Length') is None:
|
|
content = self.collapse_body()
|
|
dict.__setitem__(headers, 'Content-Length', len(content))
|
|
|
|
# Transform our header dict into a list of tuples.
|
|
self.header_list = h = headers.output()
|
|
|
|
cookie = self.cookie.output()
|
|
if cookie:
|
|
for line in cookie.split("\n"):
|
|
if line.endswith("\r"):
|
|
# Python 2.4 emits cookies joined by LF but 2.5+ by CRLF.
|
|
line = line[:-1]
|
|
name, value = line.split(": ", 1)
|
|
if isinstance(name, unicodestr):
|
|
name = name.encode("ISO-8859-1")
|
|
if isinstance(value, unicodestr):
|
|
value = headers.encode(value)
|
|
h.append((name, value))
|
|
|
|
def check_timeout(self):
|
|
"""If now > self.time + self.timeout, set self.timed_out.
|
|
|
|
This purposefully sets a flag, rather than raising an error,
|
|
so that a monitor thread can interrupt the Response thread.
|
|
"""
|
|
if time.time() > self.time + self.timeout:
|
|
self.timed_out = True
|