def __init__(self, code, description, title=None):
"""
@param code: a response code in L{responsecode.RESPONSES}.
@param description: a string description.
@param title: the message title. If not specified or C{None}, defaults
to C{responsecode.RESPONSES[code]}.
"""
if title is None:
title = cgi.escape(responsecode.RESPONSES[code])
output = "".join((
"<html>",
"<head>",
"<title>%s</title>" % (title, ),
"</head>",
"<body>",
"<h1>%s</h1>" % (title, ),
"<p>%s</p>" % (cgi.escape(description), ),
"</body>",
"</html>",
))
if type(output) == unicode:
output = output.encode("utf-8")
mime_params = {"charset": "utf-8"}
else:
mime_params = {}
super(StatusResponse, self).__init__(code=code, stream=output)
self.headers.setHeader(
"content-type", http_headers.MimeType("text", "html", mime_params))
self.description = description
def packageSuccess(self, result):
headers, data = httputil.serialize(result)
response = http.Response(200, stream=stream.MemoryStream(data))
for k, v in headers.iteritems():
response.headers.addRawHeader(k, v)
response.headers.setHeader('content-type', http_headers.MimeType('text', 'plain'))
return response
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 defaultErrorHandler(request, response):
if response.stream is not None:
# Already got an error message
return response
if response.code < 300:
# We only do error messages
return response
message = ERROR_MESSAGES.get(response.code, None)
if message is None:
# No message specified for that code
return response
message = message % {
'uri': _escape(request.uri),
'location': _escape(response.headers.getHeader('location')),
'method': _escape(request.method)
}
title = RESPONSES.get(response.code, "")
body = ("<html><head><title>%d %s</title></head>"
"<body><h1>%s</h1>%s</body></html>") % (response.code, title,
title, message)
response.headers.setHeader("content-type",
http_headers.MimeType('text', 'html'))
response.stream = stream.MemoryStream(body)
return response
def packageFailure(self, f):
f.cleanFailure()
headers, data = httputil.serialize(f)
response = http.Response(200, stream=stream.MemoryStream(data))
for k, v in headers.iteritems():
response.headers.addRawHeader(k, v)
response.headers.setHeader('content-type', http_headers.MimeType('text', 'plain'))
return response
def packageFailure(self, f):
f.cleanFailure()
print "Failing:\n" + f.getTraceback()
data = simplejson.dumps(jsonifyFailure(f))
response = http.Response(200, stream=stream.MemoryStream(data))
response.headers.setHeader('content-type',
http_headers.MimeType('text', 'plain'))
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 _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 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 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 _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)
class HTTPNotebookBaseMethod(resource.Resource):
def __init__(self, nbc):
self.nbc = nbc
log.msg("Creating child resource...")
def locateChild(self, request, segments):
return self, ()
def renderHTTP(self, request):
print request, request.args
return http.Response(200, stream=stream.MemoryStream(repr(request)))
def buildRequestSummary(self, request):
reply = """host: %r
port: %r
path: %r
prepath: %r
postpath: %r
args: %r
method: %r
headers: %r
""" % (request.host, request.port, request.path, request.prepath,
request.postpath, request.args, request.method, request.headers)
return reply
def packageSuccess(self, result, justme=False):
print result
try:
if isinstance(result, type(None)):
data = ""
elif isinstance(result, list):
data = simplejson.dumps({
'list':
[r.jsonify(keepdict=True, justme=justme) for r in result]
})
else:
data = result.jsonify(justme=justme)
except AttributeError, e:
raise e
# data = simplejson.dumps(result)
response = http.Response(200, stream=stream.MemoryStream(data))
response.headers.setHeader('content-type',
http_headers.MimeType('text', 'plain'))
return response
def _sparse(nb):
data = str(nb[0].sparse())
response = http.Response(200, stream=stream.MemoryStream(data))
response.headers.setHeader('content-type',
http_headers.MimeType('text', 'plain'))
return response
class FileSaver(resource.PostableResource):
allowedTypes = (http_headers.MimeType('text', 'plain'),
http_headers.MimeType('text', 'html'),
http_headers.MimeType('text', 'css'))
def __init__(self, destination, expectedFields=[], allowedTypes=None, maxBytes=1000000, permissions=0644):
self.destination = destination
self.allowedTypes = allowedTypes or self.allowedTypes
self.maxBytes = maxBytes
self.expectedFields = expectedFields
self.permissions = permissions
def makeUniqueName(self, filename):
"""Called when a unique filename is needed.
filename is the name of the file as given by the client.
Returns the fully qualified path of the file to create. The
file must not yet exist.
"""
return tempfile.mktemp(suffix=os.path.splitext(filename)[1], dir=self.destination)
def isSafeToWrite(self, filename, mimetype, filestream):
"""Returns True if it's "safe" to write this file,
otherwise it raises an exception.
"""
if filestream.length > self.maxBytes:
raise IOError("%s: File exceeds maximum length (%d > %d)" % (filename,
filestream.length,
self.maxBytes))
if mimetype not in self.allowedTypes:
raise IOError("%s: File type not allowed %s" % (filename, mimetype))
return True
def writeFile(self, filename, mimetype, fileobject):
"""Does the I/O dirty work after it calls isWriteable to make
sure it's safe to write this file.
"""
filestream = stream.FileStream(fileobject)
if self.isSafeToWrite(filename, mimetype, filestream):
outname = self.makeUniqueName(filename)
fileobject = os.fdopen(os.open(outname, os.O_WRONLY | os.O_CREAT | os.O_EXCL,
self.permissions), 'w', 0)
stream.readIntoFile(filestream, fileobject)
return outname
def render(self, req):
content = ["<html><body>"]
if req.files:
for fieldName in req.files:
if fieldName in self.expectedFields:
for finfo in req.files[fieldName]:
try:
outname = self.writeFile(*finfo)
content.append("Saved file %s<br />" % outname)
except IOError, err:
content.append(str(err) + "<br />")
else:
content.append("%s is not a valid field" % fieldName)
else:
def rangefilter(request, oldresponse):
if oldresponse.stream is None:
return oldresponse
size = oldresponse.stream.length
if size is None:
# Does not deal with indeterminate length outputs
return oldresponse
oldresponse.headers.setHeader('accept-ranges',('bytes',))
rangespec = request.headers.getHeader('range')
# If we've got a range header and the If-Range header check passes, and
# the range type is bytes, do a partial response.
if (rangespec is not None and http.checkIfRange(request, oldresponse) and
rangespec[0] == 'bytes'):
# If it's a single range, return a simple response
if len(rangespec[1]) == 1:
try:
start,end = canonicalizeRange(rangespec[1][0], size)
except UnsatisfiableRangeRequest:
return makeUnsatisfiable(request, oldresponse)
response = http.Response(responsecode.PARTIAL_CONTENT, oldresponse.headers)
response.headers.setHeader('content-range',('bytes',start, end, size))
content, after = makeSegment(oldresponse.stream, 0, start, end)
after.close()
response.stream = content
return response
else:
# Return a multipart/byteranges response
lastOffset = -1
offsetList = []
for arange in rangespec[1]:
try:
start,end = canonicalizeRange(arange, size)
except UnsatisfiableRangeRequest:
continue
if start <= lastOffset:
# Stupid client asking for out-of-order or overlapping ranges, PUNT!
return oldresponse
offsetList.append((start,end))
lastOffset = end
if not offsetList:
return makeUnsatisfiable(request, oldresponse)
content_type = oldresponse.headers.getRawHeaders('content-type')
boundary = "%x%x" % (int(time.time()*1000000), os.getpid())
response = http.Response(responsecode.PARTIAL_CONTENT, oldresponse.headers)
response.headers.setHeader('content-type',
http_headers.MimeType('multipart', 'byteranges',
[('boundary', boundary)]))
response.stream = out = stream.CompoundStream()
lastOffset = 0
origStream = oldresponse.stream
headerString = "\r\n--%s" % boundary
if len(content_type) == 1:
headerString+='\r\nContent-Type: %s' % content_type[0]
headerString+="\r\nContent-Range: %s\r\n\r\n"
for start,end in offsetList:
out.addStream(headerString %
http_headers.generateContentRange(('bytes', start, end, size)))
content, origStream = makeSegment(origStream, lastOffset, start, end)
lastOffset = end + 1
out.addStream(content)
origStream.close()
out.addStream("\r\n--%s--\r\n" % boundary)
return response
else:
return oldresponse
