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