def makeUnsatisfiable(request, oldresponse):
if request.headers.hasHeader('if-range'):
return oldresponse # Return resource instead of error
response = http.Response(responsecode.REQUESTED_RANGE_NOT_SATISFIABLE)
response.headers.setHeader(
"content-range", ('bytes', None, None, oldresponse.stream.length))
return response
def renderHTTP(self, request):
"""
See L{iweb.IResource.renderHTTP}.
This implementation will dispatch the given C{request} to another method
of C{self} named C{http_}METHOD, where METHOD is the HTTP method used by
C{request} (eg. C{http_GET}, C{http_POST}, etc.).
Generally, a subclass should implement those methods instead of
overriding this one.
C{http_*} methods are expected provide the same interface and return the
same results as L{iweb.IResource}C{.renderHTTP} (and therefore this method).
C{etag} and C{last-modified} are added to the response returned by the
C{http_*} header, if known.
If an appropriate C{http_*} method is not found, a
L{responsecode.NOT_ALLOWED}-status response is returned, with an
appropriate C{allow} header.
@param request: the request to process.
@return: an object adaptable to L{iweb.IResponse}.
"""
method = getattr(self, "http_" + request.method, None)
if not method:
response = http.Response(responsecode.NOT_ALLOWED)
response.headers.setHeader("allow", self.allowedMethods())
return response
d = self.checkPreconditions(request)
if d is None:
return method(request)
else:
return d.addCallback(lambda _: method(request))
def render(self, request):
title = "Directory listing for %s" % urllib.unquote(request.path)
s = """<html><head><title>%s</title><style>
th, .even td, .odd td { padding-right: 0.5em; font-family: monospace}
.even-dir { background-color: #efe0ef }
.even { background-color: #eee }
.odd-dir {background-color: #f0d0ef }
.odd { background-color: #dedede }
.icon { text-align: center }
.listing {
margin-left: auto;
margin-right: auto;
width: 50%%;
padding: 0.1em;
}
body { border: 0; padding: 0; margin: 0; background-color: #efefef;}
h1 {padding: 0.1em; background-color: #777; color: white; border-bottom: thin white dashed;}
</style></head><body><div class="directory-listing"><h1>%s</h1>""" % (title,
title)
s += "<table>"
s += "<tr><th>Filename</th><th>Size</th><th>Last Modified</th><th>File Type</th></tr>"
even = False
for row in self.data_listing(request, None):
s += '<tr class="%s">' % (even and 'even' or 'odd', )
s += '<td><a href="%(link)s">%(linktext)s</a></td><td align="right">%(size)s</td><td>%(lastmod)s</td><td>%(type)s</td></tr>' % row
even = not even
s += "</table></div></body></html>"
response = http.Response(200, {}, s)
response.headers.setHeader("content-type",
http_headers.MimeType('text', 'html'))
return response
def render(self, request):
for filterscript in self.filters:
if os.path.exists(filterscript):
return runCGI(request, self.filename, filterscript)
else:
log.err(self.__class__.__name__ + ' could not find any of: ' + ', '.join(self.filters))
return http.Response(responsecode.INTERNAL_SERVER_ERROR)
def __init__(self, request):
from hack.web2 import http
components.Componentized.__init__(self)
self.request = request
self.response = http.Response(stream=stream.ProducerStream())
# This deferred will be fired by the first call to write on OldRequestAdapter
# and will cause the headers to be output.
self.deferredResponse = defer.Deferred()
def http_OPTIONS(self, request):
"""
Respond to a OPTIONS request.
@param request: the request to process.
@return: an object adaptable to L{iweb.IResponse}.
"""
response = http.Response(responsecode.OK)
response.headers.setHeader("allow", self.allowedMethods())
return response
def render(self, request):
# For GET/HEAD: Return an error message
s = (
"<html><head><title>XML-RPC responder</title></head>"
"<body><h1>XML-RPC responder</h1>POST your XML-RPC here.</body></html>"
)
return http.Response(
responsecode.OK,
{'content-type': http_headers.MimeType('text', 'html')}, s)
def testIfMatch(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# Behavior with no ETag set, should be same as with an ETag
request.headers.setRawHeaders("If-Match", ('*', ))
self.checkPreconditions(request, response, True, responsecode.OK)
self.checkPreconditions(request,
response,
False,
responsecode.PRECONDITION_FAILED,
entityExists=False)
# Ask for tag, but no etag set.
request.headers.setRawHeaders("If-Match", ('"frob"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
## Actually set the ETag header
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
# behavior of entityExists
request.headers.setRawHeaders("If-Match", ('*', ))
self.checkPreconditions(request, response, True, responsecode.OK)
self.checkPreconditions(request,
response,
False,
responsecode.PRECONDITION_FAILED,
entityExists=False)
# tag matches
request.headers.setRawHeaders("If-Match", ('"frob", "foo"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# none match
request.headers.setRawHeaders("If-Match", ('"baz", "bob"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# Must only compare strong tags
out_headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
request.headers.setRawHeaders("If-Match", ('W/"foo"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
def _cbRender(self, result, request):
if not isinstance(result, Fault):
result = (result, )
try:
s = xmlrpclib.dumps(result, methodresponse=1)
except:
f = Fault(self.FAILURE, "can't serialize output")
s = xmlrpclib.dumps(f, methodresponse=1)
return http.Response(
responsecode.OK,
{'content-type': http_headers.MimeType('text', 'xml')}, s)
def processEnded(self, reason):
if reason.value.exitCode != 0:
log.msg("CGI %s exited with exit code %s" %
(self.request.uri, reason.value.exitCode))
if self.errortext:
log.msg("Errors from CGI %s: %s" % (self.request.uri, self.errortext))
if self.handling_headers:
log.msg("Premature end of headers in %s: %s" % (self.request.uri, self.headertext))
self.response = http.Response(responsecode.INTERNAL_SERVER_ERROR)
self._sendResponse()
self.stream.finish()
def renderHTTP_exception(self, req, reason):
log.msg("Exception rendering:", isErr=1)
log.err(reason)
body = (
"<html><head><title>Internal Server Error</title></head>"
"<body><h1>Internal Server Error</h1>An error occurred rendering the requested page. More information is available in the server log.</body></html>"
)
return http.Response(
responsecode.INTERNAL_SERVER_ERROR,
{'content-type': http_headers.MimeType('text', 'html')}, body)
def render(self, req):
if req.avatar.username == 'anonymous':
if not self.sendOwnHeaders:
raise http.HTTPError(responsecode.UNAUTHORIZED)
else:
return http.Response(
responsecode.UNAUTHORIZED,
{'www-authenticate': [('basic', {
'realm': 'foo'
})]})
else:
return super(NonAnonymousResource, self).render(req)
def preprocessRequest(self):
"""Do any request processing that doesn't follow the normal
resource lookup procedure. "OPTIONS *" is handled here, for
example. This would also be the place to do any CONNECT
processing."""
if self.method == "OPTIONS" and self.uri == "*":
response = http.Response(responsecode.OK)
response.headers.setHeader('allow',
('GET', 'HEAD', 'OPTIONS', 'TRACE'))
return response
# This is where CONNECT would go if we wanted it
return None
def testIfModifiedSince(self):
if time.time() < 946771200:
self.fail(
RuntimeError("Your computer's clock is way wrong, "
"this test will be invalid."))
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# No Last-Modified => always succeed
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# Set output headers
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
# With a non-GET method
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
request.headers.setRawHeaders("If-Modified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# invalid date => header ignored
request.headers.setRawHeaders("If-Modified-Since",
('alalalalalalalalalala', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# date in the future => assume modified
request.headers.setHeader("If-Modified-Since", time.time() + 500)
self.checkPreconditions(request, response, True, responsecode.OK)
def renderHTTP(self, req):
responder = getattr(logic_tree['__val__'], self.mode,
logic_tree['__val__'].http)(req)
view = view_tree['__val__']()
view.req = req
response = http.Response(200,
stream=stream.MemoryStream(
view.respond().encode('utf8')))
response.headers.setRawHeaders('Content-Type',
['text/html; charset=utf-8'])
if responder:
responder(response)
return response
def _processingReallyFailed(self, reason, origReason):
log.msg("Exception rendering error page:", isErr=1)
log.err(reason)
log.msg("Original exception:", isErr=1)
log.err(origReason)
body = (
"<html><head><title>Internal Server Error</title></head>"
"<body><h1>Internal Server Error</h1>An error occurred rendering the requested page. Additionally, an error occured rendering the error page.</body></html>"
)
response = http.Response(
responsecode.INTERNAL_SERVER_ERROR,
{'content-type': http_headers.MimeType('text', 'html')}, body)
self.writeResponse(response)
def doTrace(request):
request = iweb.IRequest(request)
txt = "%s %s HTTP/%d.%d\r\n" % (request.method, request.uri,
request.clientproto[0],
request.clientproto[1])
l = []
for name, valuelist in request.headers.getAllRawHeaders():
for value in valuelist:
l.append("%s: %s\r\n" % (name, value))
txt += ''.join(l)
return http.Response(
responsecode.OK,
{'content-type': http_headers.MimeType('message', 'http')}, txt)
def startWSGIResponse(self, status, response_headers, exc_info=None):
# Called in application thread
if exc_info is not None:
try:
if self.headersSent:
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None
elif self.response is not None:
raise AlreadyStartedResponse, 'startWSGIResponse(%r)' % status
status = int(status.split(' ')[0])
self.response = http.Response(status)
for key, value in response_headers:
self.response.headers.addRawHeader(key, value)
return self.write
def testWithoutHeaders(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.removeHeader("ETag")
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
self.checkPreconditions(request, response, True, responsecode.OK)
def renderCallback(responder):
if isinstance(responder, HardResponder):
return responder.response(getattr(req, 'cookies', None))
view = self.view['__val__']()
view.req = req
responseData = view.respond().encode('utf8')
response = http.Response(200,
stream=stream.MemoryStream(responseData))
response.headers.setRawHeaders('Content-Type',
['text/html; charset=utf-8'])
if getattr(req, 'cookies', None):
response.headers.setHeader('Set-Cookie', req.cookies)
if responder:
responder(response)
return response
def runCGI(request, filename, filterscript=None):
# Make sure that we don't have an unknown content-length
if request.stream.length is None:
return http.Response(responsecode.LENGTH_REQUIRED)
env = createCGIEnvironment(request)
env['SCRIPT_FILENAME'] = filename
if '=' in request.querystring:
qargs = []
else:
qargs = [urllib.unquote(x) for x in request.querystring.split('+')]
if filterscript is None:
filterscript = filename
qargs = [filename] + qargs
else:
qargs = [filterscript, filename] + qargs
d = defer.Deferred()
proc = CGIProcessProtocol(request, d)
reactor.spawnProcess(proc, filterscript, qargs, env, os.path.dirname(filename))
return d
def testIfUnmodifiedSince(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# No Last-Modified => always fail.
request.headers.setRawHeaders("If-Unmodified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# Set output headers
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
request.headers.setRawHeaders("If-Unmodified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.setRawHeaders("If-Unmodified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# invalid date => header ignored
request.headers.setRawHeaders("If-Unmodified-Since",
('alalalalalalalalalala', ))
self.checkPreconditions(request, response, True, responsecode.OK)
def renderHTTP(self, req):
return http.Response(responsecode.NOT_FOUND)
def render(self, req):
return http.Response(stream="Host:%s, Path:%s" %
(req.host, req.path))
def render(self, req):
return http.Response(stream="prepath:%s postpath:%s" %
(req.prepath, req.postpath))
def render(self, req):
return http.Response(self.responseCode,
headers=self.responseHeaders,
stream=self.responseStream())
def render(self, req):
response = req.scheme + '://' + '/'.join([
req.host,
] + req.prepath + req.postpath)
return http.Response(responsecode.OK, stream=response)
def render(self, req):
h = req.host
return http.Response(responsecode.OK, stream=h)
def render(self, req):
return http.Response(200, stream=str(req.remoteAddr))
def testIfNoneMatch(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
request.headers.setRawHeaders("If-None-Match", ('"foo"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
# behavior of entityExists
request.headers.setRawHeaders("If-None-Match", ('*', ))
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
self.checkPreconditions(request,
response,
True,
responsecode.OK,
entityExists=False)
# tag matches
request.headers.setRawHeaders("If-None-Match", ('"frob", "foo"', ))
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
# now with IMS, also:
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
request.headers.setRawHeaders("If-Modified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.removeHeader("If-Modified-Since")
# none match
request.headers.setRawHeaders("If-None-Match", ('"baz", "bob"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# now with IMS, also:
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.setRawHeaders("If-Modified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.removeHeader("If-Modified-Since")
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# Weak tags okay for GET
out_headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
request.headers.setRawHeaders("If-None-Match", ('W/"foo"', ))
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
# Weak tags not okay for other methods
request.method = "PUT"
out_headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
request.headers.setRawHeaders("If-None-Match", ('W/"foo"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
