def getresponse(self, body):
self.request["Content-Type"] = "text/xml"
self.request["Content-Length"] = len(body)
self.request.push(body)
connection = get_header(self.CONNECTION, self.request.header)
close_it = 0
wrap_in_chunking = 0
if self.request.version == "1.0":
if connection == "keep-alive":
if not self.request.has_key("Content-Length"):
close_it = 1
else:
self.request["Connection"] = "Keep-Alive"
else:
close_it = 1
elif self.request.version == "1.1":
if connection == "close":
close_it = 1
elif not self.request.has_key("Content-Length"):
if self.request.has_key("Transfer-Encoding"):
if not self.request["Transfer-Encoding"] == "chunked":
close_it = 1
elif self.request.use_chunked:
self.request["Transfer-Encoding"] = "chunked"
wrap_in_chunking = 1
else:
close_it = 1
elif self.request.version is None:
close_it = 1
outgoing_header = producers.simple_producer(self.request.build_reply_header())
if close_it:
self.request["Connection"] = "close"
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer(producers.composite_producer(self.request.outgoing))
# prepend the header
outgoing_producer = producers.composite_producer([outgoing_header, outgoing_producer])
else:
# prepend the header
self.request.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer(self.request.outgoing)
# apply a few final transformations to the output
self.request.channel.push_with_producer(
# globbing gives us large packets
producers.globbing_producer(
# hooking lets us log the number of bytes sent
producers.hooked_producer(outgoing_producer, self.request.log)
)
)
self.request.channel.current_request = None
if close_it:
self.request.channel.close_when_done()
def check_chunked (self):
p1 = producers.simple_producer('the quick brown fox', buffer_size = 5)
p = producers.chunked_producer(p1, footers=['FOOTER'])
self._check_all(p, """5\r
the q\r
5\r
uick \r
5\r
brown\r
4\r
fox\r
0\r
FOOTER\r
\r\n""")
def check_chunked (self):
p1 = producers.simple_producer('the quick brown fox', buffer_size = 5)
p = producers.chunked_producer(p1, footers=['FOOTER'])
self._check_all(p, """5\r
the q\r
5\r
uick \r
5\r
brown\r
4\r
fox\r
0\r
FOOTER\r
\r\n""")
def sendresponse(self, response):
headers = response.get('headers', {})
for header in headers:
self.request[header] = headers[header]
if not self.request.has_key('Content-Type'):
self.request['Content-Type'] = 'text/plain'
if headers.get('Location'):
self.request['Content-Length'] = 0
self.request.error(301)
return
body = response.get('body', '')
self.request['Content-Length'] = len(body)
self.request.push(body)
connection = get_header(self.CONNECTION, self.request.header)
close_it = 0
wrap_in_chunking = 0
if self.request.version == '1.0':
if connection == 'keep-alive':
if not self.request.has_key('Content-Length'):
close_it = 1
else:
self.request['Connection'] = 'Keep-Alive'
else:
close_it = 1
elif self.request.version == '1.1':
if connection == 'close':
close_it = 1
elif not self.request.has_key('Content-Length'):
if self.request.has_key('Transfer-Encoding'):
if not self.request['Transfer-Encoding'] == 'chunked':
close_it = 1
elif self.request.use_chunked:
self.request['Transfer-Encoding'] = 'chunked'
wrap_in_chunking = 1
else:
close_it = 1
elif self.request.version is None:
close_it = 1
outgoing_header = producers.simple_producer(
self.request.build_reply_header())
if close_it:
self.request['Connection'] = 'close'
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer(
producers.composite_producer(self.request.outgoing))
# prepend the header
outgoing_producer = producers.composite_producer(
[outgoing_header, outgoing_producer])
else:
# prepend the header
self.request.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer(
self.request.outgoing)
# apply a few final transformations to the output
self.request.channel.push_with_producer(
# globbing gives us large packets
producers.globbing_producer(
# hooking lets us log the number of bytes sent
producers.hooked_producer(outgoing_producer,
self.request.log)))
self.request.channel.current_request = None
if close_it:
self.request.channel.close_when_done()
def sendresponse(self, response):
headers = response.get('headers', {})
for header in headers:
self.request[header] = headers[header]
if not self.request.has_key('Content-Type'):
self.request['Content-Type'] = 'text/plain'
if headers.get('Location'):
self.request['Content-Length'] = 0
self.request.error(301)
return
body = response.get('body', '')
self.request['Content-Length'] = len(body)
self.request.push(body)
connection = get_header(self.CONNECTION, self.request.header)
close_it = 0
wrap_in_chunking = 0
if self.request.version == '1.0':
if connection == 'keep-alive':
if not self.request.has_key('Content-Length'):
close_it = 1
else:
self.request['Connection'] = 'Keep-Alive'
else:
close_it = 1
elif self.request.version == '1.1':
if connection == 'close':
close_it = 1
elif not self.request.has_key ('Content-Length'):
if self.request.has_key ('Transfer-Encoding'):
if not self.request['Transfer-Encoding'] == 'chunked':
close_it = 1
elif self.request.use_chunked:
self.request['Transfer-Encoding'] = 'chunked'
wrap_in_chunking = 1
else:
close_it = 1
elif self.request.version is None:
close_it = 1
outgoing_header = producers.simple_producer (
self.request.build_reply_header())
if close_it:
self.request['Connection'] = 'close'
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer (
producers.composite_producer (self.request.outgoing)
)
# prepend the header
outgoing_producer = producers.composite_producer(
[outgoing_header, outgoing_producer]
)
else:
# prepend the header
self.request.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer (
self.request.outgoing)
# apply a few final transformations to the output
self.request.channel.push_with_producer (
# globbing gives us large packets
producers.globbing_producer (
# hooking lets us log the number of bytes sent
producers.hooked_producer (
outgoing_producer,
self.request.log
)
)
)
self.request.channel.current_request = None
if close_it:
self.request.channel.close_when_done()
def getresponse(self, body):
self.request['Content-Type'] = 'text/xml'
self.request['Content-Length'] = len(body)
self.request.push(body)
connection = get_header(self.CONNECTION, self.request.header)
close_it = 0
wrap_in_chunking = 0
if self.request.version == '1.0':
if connection == 'keep-alive':
if 'Content-Length' not in self.request:
close_it = 1
else:
self.request['Connection'] = 'Keep-Alive'
else:
close_it = 1
elif self.request.version == '1.1':
if connection == 'close':
close_it = 1
elif 'Content-Length' not in self.request:
if 'Transfer-Encoding' in self.request:
if not self.request['Transfer-Encoding'] == 'chunked':
close_it = 1
elif self.request.use_chunked:
self.request['Transfer-Encoding'] = 'chunked'
wrap_in_chunking = 1
else:
close_it = 1
elif self.request.version is None:
close_it = 1
outgoing_header = producers.simple_producer (
self.request.build_reply_header())
if close_it:
self.request['Connection'] = 'close'
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer (
producers.composite_producer (self.request.outgoing)
)
# prepend the header
outgoing_producer = producers.composite_producer(
[outgoing_header, outgoing_producer]
)
else:
# prepend the header
self.request.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer (
self.request.outgoing)
# apply a few final transformations to the output
self.request.channel.push_with_producer (
# globbing gives us large packets
producers.globbing_producer (
# hooking lets us log the number of bytes sent
producers.hooked_producer (
outgoing_producer,
self.request.log
)
)
)
self.request.channel.current_request = None
if close_it:
self.request.channel.close_when_done()
def getresponse(self, body):
self.request['Content-Type'] = 'text/xml'
self.request['Content-Length'] = len(body)
self.request.push(body)
connection = get_header(self.CONNECTION, self.request.header)
close_it = 0
wrap_in_chunking = 0
if self.request.version == '1.0':
if connection == 'keep-alive':
if 'Content-Length' not in self.request:
close_it = 1
else:
self.request['Connection'] = 'Keep-Alive'
else:
close_it = 1
elif self.request.version == '1.1':
if connection == 'close':
close_it = 1
elif 'Content-Length' not in self.request:
if 'Transfer-Encoding' in self.request:
if not self.request['Transfer-Encoding'] == 'chunked':
close_it = 1
elif self.request.use_chunked:
self.request['Transfer-Encoding'] = 'chunked'
wrap_in_chunking = 1
else:
close_it = 1
elif self.request.version is None:
close_it = 1
outgoing_header = producers.simple_producer(
self.request.build_reply_header())
if close_it:
self.request['Connection'] = 'close'
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer(
producers.composite_producer(self.request.outgoing))
# prepend the header
outgoing_producer = producers.composite_producer(
[outgoing_header, outgoing_producer])
else:
# prepend the header
self.request.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer(
self.request.outgoing)
# apply a few final transformations to the output
self.request.channel.push_with_producer(
# globbing gives us large packets
producers.globbing_producer(
# hooking lets us log the number of bytes sent
producers.hooked_producer(outgoing_producer,
self.request.log)))
self.request.channel.current_request = None
if close_it:
self.request.channel.close_when_done()
def done(self):
"""finalize this transaction - send output to the http channel"""
# ----------------------------------------
# persistent connection management
# ----------------------------------------
# --- BUCKLE UP! ----
connection = get_header(CONNECTION, self.header).lower()
close_it = 0
wrap_in_chunking = 0
if self.version == '1.0':
if connection == 'keep-alive':
if 'Content-Length' not in self:
close_it = 1
else:
self['Connection'] = 'Keep-Alive'
else:
close_it = 1
elif self.version == '1.1':
if connection == 'close':
close_it = 1
elif 'Content-Length' not in self:
if 'Transfer-Encoding' in self:
if not self['Transfer-Encoding'] == 'chunked':
close_it = 1
elif self.use_chunked:
self['Transfer-Encoding'] = 'chunked'
wrap_in_chunking = 1
else:
close_it = 1
elif self.version is None:
# Although we don't *really* support http/0.9 (because we'd have to
# use \r\n as a terminator, and it would just yuck up a lot of stuff)
# it's very common for developers to not want to type a version number
# when using telnet to debug a server.
close_it = 1
outgoing_header = producers.simple_producer(
self.get_reply_header_text())
if close_it:
self['Connection'] = 'close'
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer(
producers.composite_producer(self.outgoing))
# prepend the header
outgoing_producer = producers.composite_producer(
[outgoing_header, outgoing_producer])
else:
# prepend the header
self.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer(self.outgoing)
# apply a few final transformations to the output
self.channel.push_with_producer(
# globbing gives us large packets
producers.globbing_producer(
# hooking lets us log the number of bytes sent
producers.hooked_producer(outgoing_producer, self.log)))
self.channel.current_request = None
if close_it:
self.channel.close_when_done()
def sendresponse(self, response):
headers = response.get("headers", {})
for header in headers:
self.request[header] = headers[header]
if "Content-Type" not in self.request:
self.request["Content-Type"] = "text/plain"
if headers.get("Location"):
self.request["Content-Length"] = 0
self.request.error(301)
return
body = response.get("body", "")
self.request["Content-Length"] = len(body)
self.request.push(body)
connection = get_header(self.CONNECTION, self.request.header)
close_it = 0
wrap_in_chunking = 0
if self.request.version == "1.0":
if connection == "keep-alive":
if not self.request.has_key("Content-Length"):
close_it = 1
else:
self.request["Connection"] = "Keep-Alive"
else:
close_it = 1
elif self.request.version == "1.1":
if connection == "close":
close_it = 1
elif "Content-Length" not in self.request:
if "Transfer-Encoding" in self.request:
if not self.request["Transfer-Encoding"] == "chunked":
close_it = 1
elif self.request.use_chunked:
self.request["Transfer-Encoding"] = "chunked"
wrap_in_chunking = 1
else:
close_it = 1
elif self.request.version is None:
close_it = 1
outgoing_header = producers.simple_producer(self.request.build_reply_header())
if close_it:
self.request["Connection"] = "close"
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer(producers.composite_producer(self.request.outgoing))
# prepend the header
outgoing_producer = producers.composite_producer([outgoing_header, outgoing_producer])
else:
# fix AttributeError: 'unicode' object has no attribute 'more'
if (not PY3) and (len(self.request.outgoing) > 0):
body = self.request.outgoing[0]
if isinstance(body, unicode):
self.request.outgoing[0] = producers.simple_producer(body)
# prepend the header
self.request.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer(self.request.outgoing)
# apply a few final transformations to the output
self.request.channel.push_with_producer(
# globbing gives us large packets
producers.globbing_producer(
# hooking lets us log the number of bytes sent
producers.hooked_producer(outgoing_producer, self.request.log)
)
)
self.request.channel.current_request = None
if close_it:
self.request.channel.close_when_done()
def done (self):
"""finalize this transaction - send output to the http channel"""
# ----------------------------------------
# persistent connection management
# ----------------------------------------
# --- BUCKLE UP! ----
connection = get_header(CONNECTION, self.header).lower()
close_it = 0
wrap_in_chunking = 0
if self.version == '1.0':
if connection == 'keep-alive':
if 'Content-Length' not in self:
close_it = 1
else:
self['Connection'] = 'Keep-Alive'
else:
close_it = 1
elif self.version == '1.1':
if connection == 'close':
close_it = 1
elif 'Content-Length' not in self:
if 'Transfer-Encoding' in self:
if not self['Transfer-Encoding'] == 'chunked':
close_it = 1
elif self.use_chunked:
self['Transfer-Encoding'] = 'chunked'
wrap_in_chunking = 1
else:
close_it = 1
elif self.version is None:
# Although we don't *really* support http/0.9 (because we'd have to
# use \r\n as a terminator, and it would just yuck up a lot of stuff)
# it's very common for developers to not want to type a version number
# when using telnet to debug a server.
close_it = 1
outgoing_header = producers.simple_producer(self.get_reply_header_text())
if close_it:
self['Connection'] = 'close'
if wrap_in_chunking:
outgoing_producer = producers.chunked_producer (
producers.composite_producer (self.outgoing)
)
# prepend the header
outgoing_producer = producers.composite_producer(
[outgoing_header, outgoing_producer]
)
else:
# prepend the header
self.outgoing.insert(0, outgoing_header)
outgoing_producer = producers.composite_producer (self.outgoing)
# apply a few final transformations to the output
self.channel.push_with_producer (
# globbing gives us large packets
producers.globbing_producer (
# hooking lets us log the number of bytes sent
producers.hooked_producer (
outgoing_producer,
self.log
)
)
)
self.channel.current_request = None
if close_it:
self.channel.close_when_done()