def test_decodesPath(self):
"""
server_name, path_info, and script_name are decoded as UTF-8 before
being handed to werkzeug.
"""
request = requestMock(b"/f\xc3\xb6\xc3\xb6")
_render(self.kr, request)
kreq = IKleinRequest(request)
self.assertIsInstance(kreq.mapper.server_name, unicode)
self.assertIsInstance(kreq.mapper.path_info, unicode)
self.assertIsInstance(kreq.mapper.script_name, unicode)
def render(self, request):
# Stuff we need to know for the mapper.
try:
url_scheme, server_name, server_port, path_info, script_name = \
_extractURLparts(request)
except _URLDecodeError as e:
for what, fail in e.errors:
log.err(fail, "Invalid encoding in {what}.".format(what=what))
request.setResponseCode(400)
return b"Non-UTF-8 encoding in URL."
# Bind our mapper.
mapper = self._app.url_map.bind(
server_name,
script_name,
path_info=path_info,
default_method=request.method,
url_scheme=url_scheme,
)
# Make the mapper available to the view.
kleinRequest = IKleinRequest(request)
kleinRequest.mapper = mapper
# Make sure we'll notice when the connection goes away unambiguously.
request_finished = [False]
def _finish(result):
request_finished[0] = True
def _execute():
# Actually doing the match right here. This can cause an exception
# to percolate up. If that happens it will be handled below in
# processing_failed, either by a user-registered error handler or
# one of our defaults.
(rule, kwargs) = mapper.match(return_rule=True)
endpoint = rule.endpoint
# Try pretty hard to fix up prepath and postpath.
segment_count = self._app.endpoints[endpoint].segment_count
request.prepath.extend(request.postpath[:segment_count])
request.postpath = request.postpath[segment_count:]
request.notifyFinish().addBoth(_finish)
# Standard Twisted Web stuff. Defer the method action, giving us
# something renderable or printable. Return NOT_DONE_YET and set up
# the incremental renderer.
d = defer.maybeDeferred(self._app.execute_endpoint,
endpoint,
request,
**kwargs)
request.notifyFinish().addErrback(lambda _: d.cancel())
return d
d = defer.maybeDeferred(_execute)
def write_response(r):
if r is not _StandInResource:
if isinstance(r, unicode):
r = r.encode('utf-8')
if (r is not None) and (r != NOT_DONE_YET):
request.write(r)
if not request_finished[0]:
request.finish()
def process(r):
"""
Recursively go through r and any child Resources until something
returns an IRenderable, then render it and let the result of that
bubble back up.
"""
if IResource.providedBy(r):
request.render(getChildForRequest(r, request))
return _StandInResource
if IRenderable.providedBy(r):
return renderElement(request, r)
return r
d.addCallback(process)
def processing_failed(failure, error_handlers):
# The failure processor writes to the request. If the
# request is already finished we should suppress failure
# processing. We don't return failure here because there
# is no way to surface this failure to the user if the
# request is finished.
if request_finished[0]:
if not failure.check(defer.CancelledError):
log.err(failure, "Unhandled Error Processing Request.")
return
# If there are no more registered handlers, apply some defaults
if len(error_handlers) == 0:
if failure.check(HTTPException):
he = failure.value
request.setResponseCode(he.code)
resp = he.get_response({})
for header, value in resp.headers:
request.setHeader(ensure_utf8_bytes(header), ensure_utf8_bytes(value))
return ensure_utf8_bytes(he.get_body({}))
else:
request.processingFailed(failure)
return
error_handler = error_handlers[0]
# Each error handler is a tuple of (list_of_exception_types, handler_fn)
if failure.check(*error_handler[0]):
d = defer.maybeDeferred(self._app.execute_error_handler,
error_handler[1],
request,
failure)
return d.addErrback(processing_failed, error_handlers[1:])
return processing_failed(failure, error_handlers[1:])
d.addErrback(processing_failed, self._app._error_handlers)
d.addCallback(write_response).addErrback(log.err, _why="Unhandled Error writing response")
return server.NOT_DONE_YET
def foo(request, bar):
krequest = IKleinRequest(request)
relative_url[0] = krequest.url_for('foo', {'bar': bar + 1}, force_external=True)
def foo(request, bar):
krequest = IKleinRequest(request)
relative_url[0] = krequest.url_for('foo', {'bar': bar + 1})
def branch_f(request, *a, **kw):
IKleinRequest(request).branch_segments = kw.pop('__rest__', '').split('/')
return f(request, *a, **kw)
def foo(request, bar):
krequest = IKleinRequest(request)
relative_url[0] = krequest.url_for('foo', {'bar': bar + 1}, force_external=True)
def foo(request, bar):
krequest = IKleinRequest(request)
relative_url[0] = krequest.url_for('foo', {'bar': bar + 1})
def branch_f(instance, request, *a, **kw):
IKleinRequest(request).branch_segments = kw.pop(
'__rest__', '').split('/')
return _call(instance, f, request, *a, **kw)
def render(self, request):
# Stuff we need to know for the mapper.
server_name = request.getRequestHostname()
server_port = request.getHost().port
if (bool(request.isSecure()), server_port) not in [
(True, 443), (False, 80)]:
server_name = '%s:%d' % (server_name, server_port)
script_name = ''
if request.prepath:
script_name = '/'.join(request.prepath)
if not script_name.startswith('/'):
script_name = '/' + script_name
path_info = ''
if request.postpath:
path_info = '/'.join(request.postpath)
if not path_info.startswith('/'):
path_info = '/' + path_info
url_scheme = 'https' if request.isSecure() else 'http'
# Bind our mapper.
mapper = self._app.url_map.bind(server_name, script_name, path_info=path_info,
default_method=request.method, url_scheme=url_scheme)
# Make the mapper available to the view.
kleinRequest = IKleinRequest(request)
kleinRequest.mapper = mapper
# Actually doing the match right here. This can cause an exception to
# percolate up, which we can catch and render directly in order to
# save ourselves some legwork.
try:
(rule, kwargs) = mapper.match(return_rule=True)
endpoint = rule.endpoint
except HTTPException as he:
request.setResponseCode(he.code)
return he.get_body({})
handler = self._app.endpoints[endpoint]
def _pre_process(res):
# Standard Twisted Web stuff. Defer the method action, giving us
# something renderable or printable. Return NOT_DONE_YET and set up
# the incremental renderer.
d = defer.maybeDeferred(handler, request, **kwargs)
return d
@defer.inlineCallbacks
def _run_handlers(request):
for i in self._app._request_handlers:
yield defer.maybeDeferred(i, request)
defer.returnValue(None)
# Run request handler, if present
if self._app._request_handlers:
d = _run_handlers(request)
d.addCallback(_pre_process)
else:
d = _pre_process(None)
def process(r):
if r == server.NOT_DONE_YET:
return
if IResource.providedBy(r):
while (request.postpath and
request.postpath != kleinRequest.branch_segments):
request.prepath.append(request.postpath.pop(0))
return request.render(getChildForRequest(r, request))
if IRenderable.providedBy(r):
return flattenString(request, r).addCallback(process)
if isinstance(r, unicode):
r = r.encode('utf-8')
if r is not None:
request.write(r)
request.finish()
d.addCallback(process)
d.addErrback(request.processingFailed)
return server.NOT_DONE_YET
def render(self, request):
# Stuff we need to know for the mapper.
server_name = request.getRequestHostname()
server_port = request.getHost().port
if (bool(request.isSecure()), server_port) not in [
(True, 443), (False, 80)]:
server_name = '%s:%d' % (server_name, server_port)
script_name = ''
if request.prepath:
script_name = '/'.join(request.prepath)
if not script_name.startswith('/'):
script_name = '/' + script_name
path_info = ''
if request.postpath:
path_info = '/'.join(request.postpath)
if not path_info.startswith('/'):
path_info = '/' + path_info
url_scheme = 'https' if request.isSecure() else 'http'
# Bind our mapper.
mapper = self._app.url_map.bind(server_name, script_name, path_info=path_info,
default_method=request.method, url_scheme=url_scheme)
# Make the mapper available to the view.
kleinRequest = IKleinRequest(request)
kleinRequest.mapper = mapper
# Actually doing the match right here. This can cause an exception to
# percolate up, which we can catch and render directly in order to
# save ourselves some legwork.
try:
(rule, kwargs) = mapper.match(return_rule=True)
endpoint = rule.endpoint
except HTTPException as he:
request.setResponseCode(he.code)
resp = he.get_response({})
for header, value in resp.headers:
request.setHeader(ensure_utf8_bytes(header), ensure_utf8_bytes(value))
return ensure_utf8_bytes(he.get_body({}))
# Try pretty hard to fix up prepath and postpath.
segment_count = self._app.endpoints[endpoint].segment_count
request.prepath.extend(request.postpath[:segment_count])
request.postpath = request.postpath[segment_count:]
# Standard Twisted Web stuff. Defer the method action, giving us
# something renderable or printable. Return NOT_DONE_YET and set up
# the incremental renderer.
d = defer.maybeDeferred(self._app.execute_endpoint,
endpoint,
request,
**kwargs)
def process(r):
if IResource.providedBy(r):
return request.render(getChildForRequest(r, request))
if IRenderable.providedBy(r):
return flattenString(request, r).addCallback(process)
if isinstance(r, unicode):
r = r.encode('utf-8')
if r is not None:
request.write(r)
request.finish()
d.addCallback(process)
d.addErrback(request.processingFailed)
return server.NOT_DONE_YET
def render(self, request):
# Stuff we need to know for the mapper.
server_name = request.getRequestHostname()
server_port = request.getHost().port
if (bool(request.isSecure()), server_port) not in [
(True, 443), (False, 80)]:
server_name = '%s:%d' % (server_name, server_port)
script_name = ''
if request.prepath:
script_name = '/'.join(request.prepath)
if not script_name.startswith('/'):
script_name = '/' + script_name
path_info = ''
if request.postpath:
path_info = '/'.join(request.postpath)
if not path_info.startswith('/'):
path_info = '/' + path_info
url_scheme = 'https' if request.isSecure() else 'http'
# Bind our mapper.
mapper = self._app.url_map.bind(server_name, script_name, path_info=path_info,
default_method=request.method, url_scheme=url_scheme)
# Make the mapper available to the view.
kleinRequest = IKleinRequest(request)
kleinRequest.mapper = mapper
# Make sure we'll notice when the connection goes away unambiguously.
request_finished = [False]
def _finish(result):
request_finished[0] = True
def _execute():
# Actually doing the match right here. This can cause an exception
# to percolate up. If that happens it will be handled below in
# processing_failed, either by a user-registered error handler or
# one of our defaults.
(rule, kwargs) = mapper.match(return_rule=True)
endpoint = rule.endpoint
# Try pretty hard to fix up prepath and postpath.
segment_count = self._app.endpoints[endpoint].segment_count
request.prepath.extend(request.postpath[:segment_count])
request.postpath = request.postpath[segment_count:]
request.notifyFinish().addBoth(_finish)
# Standard Twisted Web stuff. Defer the method action, giving us
# something renderable or printable. Return NOT_DONE_YET and set up
# the incremental renderer.
d = defer.maybeDeferred(self._app.execute_endpoint,
endpoint,
request,
**kwargs)
request.notifyFinish().addErrback(lambda _: d.cancel())
return d
d = defer.maybeDeferred(_execute)
def write_response(r):
if r is not _StandInResource:
if isinstance(r, unicode):
r = r.encode('utf-8')
if r is not None:
request.write(r)
if not request_finished[0]:
request.finish()
def process(r):
if IResource.providedBy(r):
request.render(getChildForRequest(r, request))
return _StandInResource
if IRenderable.providedBy(r):
return flattenString(request, r).addCallback(process)
return r
d.addCallback(process)
def processing_failed(failure, error_handlers):
# The failure processor writes to the request. If the
# request is already finished we should suppress failure
# processing. We don't return failure here because there
# is no way to surface this failure to the user if the
# request is finished.
if request_finished[0]:
if not failure.check(defer.CancelledError):
log.err(failure, _why="Unhandled Error Processing Request.")
return
# If there are no more registered handlers, apply some defaults
if len(error_handlers) == 0:
if failure.check(HTTPException):
he = failure.value
request.setResponseCode(he.code)
resp = he.get_response({})
for header, value in resp.headers:
request.setHeader(ensure_utf8_bytes(header), ensure_utf8_bytes(value))
return ensure_utf8_bytes(he.get_body({}))
else:
request.processingFailed(failure)
return
error_handler = error_handlers[0]
# Each error handler is a tuple of (list_of_exception_types, handler_fn)
if failure.check(*error_handler[0]):
d = defer.maybeDeferred(self._app.execute_error_handler,
error_handler[1],
request,
failure)
return d.addErrback(processing_failed, error_handlers[1:])
return processing_failed(failure, error_handlers[1:])
d.addErrback(processing_failed, self._app._error_handlers)
d.addCallback(write_response).addErrback(log.err, _why="Unhandled Error writing response")
return server.NOT_DONE_YET
def foo(request, bar):
krequest = IKleinRequest(request)
relative_url[0] = krequest.url_for("foo", {"bar": bar + 1}, force_external=True)
def foo(request, bar):
krequest = IKleinRequest(request)
relative_url[0] = krequest.url_for("foo", {"bar": bar + 1})
def render(self, request):
# Stuff we need to know for the mapper.
server_name = request.getRequestHostname()
server_port = request.getHost().port
if (bool(request.isSecure()), server_port) not in [(True, 443),
(False, 80)]:
server_name = '%s:%d' % (server_name, server_port)
script_name = ''
if request.prepath:
script_name = '/'.join(request.prepath)
if not script_name.startswith('/'):
script_name = '/' + script_name
path_info = ''
if request.postpath:
path_info = '/'.join(request.postpath)
if not path_info.startswith('/'):
path_info = '/' + path_info
url_scheme = 'https' if request.isSecure() else 'http'
# Bind our mapper.
mapper = self._app.url_map.bind(server_name,
script_name,
path_info=path_info,
default_method=request.method,
url_scheme=url_scheme)
# Make the mapper available to the view.
kleinRequest = IKleinRequest(request)
kleinRequest.mapper = mapper
# Actually doing the match right here. This can cause an exception to
# percolate up, which we can catch and render directly in order to
# save ourselves some legwork.
try:
(rule, kwargs) = mapper.match(return_rule=True)
endpoint = rule.endpoint
except HTTPException as he:
request.setResponseCode(he.code)
resp = he.get_response({})
for header, value in resp.headers:
request.setHeader(ensure_utf8_bytes(header),
ensure_utf8_bytes(value))
return ensure_utf8_bytes(he.get_body({}))
# Try pretty hard to fix up prepath and postpath.
segment_count = self._app.endpoints[endpoint].segment_count
request.prepath.extend(request.postpath[:segment_count])
request.postpath = request.postpath[segment_count:]
# Standard Twisted Web stuff. Defer the method action, giving us
# something renderable or printable. Return NOT_DONE_YET and set up
# the incremental renderer.
d = defer.maybeDeferred(self._app.execute_endpoint, endpoint, request,
**kwargs)
def process(r):
if IResource.providedBy(r):
return request.render(getChildForRequest(r, request))
if IRenderable.providedBy(r):
return flattenString(request, r).addCallback(process)
if isinstance(r, unicode):
r = r.encode('utf-8')
if r is not None:
request.write(r)
request.finish()
d.addCallback(process)
d.addErrback(request.processingFailed)
return server.NOT_DONE_YET
def foo(request, bar):
krequest = IKleinRequest(request)
relative_url[0] = krequest.url_for(fullyQualifiedName(foo), {'bar': bar + 1},
force_external=True)
def render(self, request):
# Stuff we need to know for the mapper.
server_name = request.getRequestHostname()
server_port = request.getHost().port
if (bool(request.isSecure()), server_port) not in [(True, 443),
(False, 80)]:
server_name = '%s:%d' % (server_name, server_port)
script_name = ''
if request.prepath:
script_name = '/'.join(request.prepath)
if not script_name.startswith('/'):
script_name = '/' + script_name
path_info = ''
if request.postpath:
path_info = '/'.join(request.postpath)
if not path_info.startswith('/'):
path_info = '/' + path_info
url_scheme = 'https' if request.isSecure() else 'http'
# Bind our mapper.
mapper = self._app.url_map.bind(server_name,
script_name,
path_info=path_info,
default_method=request.method,
url_scheme=url_scheme)
# Make the mapper available to the view.
kleinRequest = IKleinRequest(request)
kleinRequest.mapper = mapper
# Make sure we'll notice when the connection goes away unambiguously.
request_finished = [False]
def _finish(result):
request_finished[0] = True
def _execute():
# Actually doing the match right here. This can cause an exception
# to percolate up. If that happens it will be handled below in
# processing_failed, either by a user-registered error handler or
# one of our defaults.
(rule, kwargs) = mapper.match(return_rule=True)
endpoint = rule.endpoint
# Try pretty hard to fix up prepath and postpath.
segment_count = self._app.endpoints[endpoint].segment_count
request.prepath.extend(request.postpath[:segment_count])
request.postpath = request.postpath[segment_count:]
request.notifyFinish().addBoth(_finish)
# Standard Twisted Web stuff. Defer the method action, giving us
# something renderable or printable. Return NOT_DONE_YET and set up
# the incremental renderer.
d = defer.maybeDeferred(self._app.execute_endpoint, endpoint,
request, **kwargs)
request.notifyFinish().addErrback(lambda _: d.cancel())
return d
d = defer.maybeDeferred(_execute)
def write_response(r):
if r is not _StandInResource:
if isinstance(r, unicode):
r = r.encode('utf-8')
if r is not None:
request.write(r)
if not request_finished[0]:
request.finish()
def process(r):
if IResource.providedBy(r):
request.render(getChildForRequest(r, request))
return _StandInResource
if IRenderable.providedBy(r):
return flattenString(request, r).addCallback(process)
return r
d.addCallback(process)
def processing_failed(failure, error_handlers):
# The failure processor writes to the request. If the
# request is already finished we should suppress failure
# processing. We don't return failure here because there
# is no way to surface this failure to the user if the
# request is finished.
if request_finished[0]:
if not failure.check(defer.CancelledError):
log.err(failure,
_why="Unhandled Error Processing Request.")
return
# If there are no more registered handlers, apply some defaults
if len(error_handlers) == 0:
if failure.check(HTTPException):
he = failure.value
request.setResponseCode(he.code)
resp = he.get_response({})
for header, value in resp.headers:
request.setHeader(ensure_utf8_bytes(header),
ensure_utf8_bytes(value))
return ensure_utf8_bytes(he.get_body({}))
else:
request.processingFailed(failure)
return
error_handler = error_handlers[0]
# Each error handler is a tuple of (list_of_exception_types, handler_fn)
if failure.check(*error_handler[0]):
d = defer.maybeDeferred(self._app.execute_error_handler,
error_handler[1], request, failure)
return d.addErrback(processing_failed, error_handlers[1:])
return processing_failed(failure, error_handlers[1:])
d.addErrback(processing_failed, self._app._error_handlers)
d.addCallback(write_response).addErrback(
log.err, _why="Unhandled Error writing response")
return server.NOT_DONE_YET
