def backup(path, type, callback=None, errback=None): """ Sets up and returns a StreamProducer containing the compress stream for a backup. @param path: the path to backup @param type: one of C{tar.gz}, C{tar.bz2}, C{zip} @param callback: the callback for the ProcessStreamer's run deferred @param errback: the errback for the ProcessStreamer's run deferred type = (tar.gz, tar.bz2, zip) """ if not isKnownType(type): raise KeyError("Type %s is not implemented." % type) command = commands[type] process = stream.ProcessStreamer(stream.MemoryStream(''), command[0], command + [path]) producer = stream.StreamProducer(process.outStream) d = process.run() if callback is not None and errback is not None: d.addBoth(callback, errback) else: if callback is not None: d.addCallback(callback) if errback is not None: d.addErrback(errback) return producer
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 getResponseStream(self): """ Stream the file contents (after decryption, if necessary). @see Basic.getResponseStream """ if self.isEncrypted(): fileContents = self.secretKey().decString(self.fp.open().read()) return stream.MemoryStream(fileContents, 0, len(fileContents)) else: return Basic.getResponseStream(self)
def _respond(self, image_data): return http.Response( responsecode.OK, { 'Content-Type': http_headers.MimeType('image', 'png'), # Not cacheable 'Cache-Control': { 'no-store': None }, 'Expires': 100, }, stream.MemoryStream(image_data))
def processLockRequest(resource, request): """ Respond to a LOCK request. (RFC 2518, section 8.10) Relevant notes: """ requestStream = request.stream depth = getDepth(request.headers) #log.error(request.headers.getRawHeaders("X-Litmus")[0]) # generate DAVDocument from request body lockInfo = waitForDeferred( deferredGenerator(parseLockRequest)(requestStream)) yield lockInfo lockInfo = lockInfo.getResult() assertExclusiveLock(lockInfo) assertWriteLock(lockInfo) # we currently only allow lock depths of "0" assertZeroLockDepth(depth) # build the corresponding activelock element # e.g. http://www.webdav.org/specs/rfc2518.html#rfc.section.8.10.8 activeLock = buildActiveLock(lockInfo, depth) # extract the lock token lt = activeLock.childOfType(davxml.LockToken).childOfType(davxml.HRef) # make headers with lock token header lth = http_headers.Headers(rawHeaders={"Lock-Token": [lt]}) ld = davxml.LockDiscovery(activeLock) ignored = waitForDeferred( deferredGenerator(resource._setLock)(ld, request)) yield ignored ignored = ignored.getResult() # debug ignored = waitForDeferred(deferredGenerator(resource._getLock)()) yield ignored ignored = ignored.getResult() pp = davxml.PropertyContainer(ld) yield Response(code=responsecode.OK, headers=lth, stream=stream.MemoryStream(pp.toxml()))
def _respond (self, images) : json = simplejson.dumps(images) r = http.Response( responsecode.OK, { 'Content-Type': http_headers.MimeType('text', 'javascript'), # Not cacheable 'Cache-Control': {'no-store': None}, 'Expires': 100, }, stream.MemoryStream(json) ) r.headers.addRawHeader('X-JSON', json) return r
def __init__(self, site, method, uri, headers=None, content=None): if not headers: headers = http_headers.Headers(headers) super(SimpleRequest, self).__init__(site=site, chanRequest=None, command=method, path=uri, version=self.clientproto, contentLength=len(content or ''), headers=headers) self.stream = stream.MemoryStream(content or '') self.remoteAddr = address.IPv4Address('TCP', '127.0.0.1', 0) self._parseURL() self.host = 'localhost' self.port = 8080
class Tile (resource.Resource) : def __init__ (self, images) : self.images = images def render (self, r) : f = r.args['f'][0] x = int(r.args['x'][0]) y = int(r.args['y'][0]) w = int(r.args['w'][0]) h = int(r.args['h'][0]) z = int(r.args['z'][0]) return self.images.getImage(f).getTile(x, y, w, h, z).addCallback(self._respond) def _respond (self, (ext, data)) : return http.Response( responsecode.OK, { 'Content-Type': http_headers.MimeType('image', ext) }, stream.MemoryStream(data) )
def responseStream(self): return stream.MemoryStream(self.responseText)
def runCode(self, code, inputStream=None): if inputStream is None: inputStream = stream.MemoryStream("") return stream.ProcessStreamer(inputStream, sys.executable, [sys.executable, "-u", "-c", code], os.environ)
def setUp(self): self.data = testdata.replace('\n', '\r\n') s = stream.MemoryStream(self.data) self.s = stream.BufferedStream(s)
def setUp(self): self.data = testdata self.s = stream.MemoryStream(self.data)
def makeStream(self, *args, **kw): return stream.MemoryStream(self.text, *args, **kw)