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)
