def push(self, thing):
if type(thing) == type(""):
self.outgoing.append(producers.simple_producer(thing))
elif type(thing) == types.UnicodeType:
# note("Unicode push: <%s>", thing)
self.outgoing.append(producers.simple_producer(thing.encode("latin-1", "replace")))
else:
self.outgoing.append(thing)
def status (self):
return producers.simple_producer (
'<li>%s' % status_handler.html_repr (self)
+ '<ul>'
+ ' <li><b>Total Hits:</b> %s' % self.hit_counter
+ '</ul>'
)
def greet(self):
msg = "* OK [CAPABILITY %s] %s ready.\r\n" % (
self.server.mailcontext.capabilities(self.clientstate),
self.server.mailcontext.IDENT,
)
# msg = "* OK %s ready.\r\n" % self.server.SERVER_IDENT
self.push_with_producer(producers.simple_producer(msg))
def status(self):
return producers.simple_producer("""
<li>Zope Handler
<ul>
<li><b>Published Module:</b> %s
<li><b>Hits:</b> %s
</ul>""" % (self.module_name, self.hits))
def status(self):
def nice_bytes(n):
return string.join(status_handler.english_bytes(n))
if self.total_clients:
ratio = self.total_requests.as_long() / float(self.total_clients.as_long())
else:
ratio = 0.0
return producers.composite_producer(
[
producers.lines_producer(
[
"<h2>%s</h2>" % self.mailcontext.IDENT,
"<br>Listening on: <b>Host:</b> %s" % self.server_name,
"<b>Port:</b> %d" % self.port,
"<p><ul>" "<li>Total <b>Clients:</b> %s" % self.total_clients,
"<b>Requests:</b> %s" % self.total_requests,
"<b>Requests/Client:</b> %.1f" % (ratio),
"<li>Total <b>Bytes In:</b> %s" % (nice_bytes(self.bytes_in.as_long())),
"<b>Bytes Out:</b> %s" % (nice_bytes(self.bytes_out.as_long())),
"<li>Total <b>Exceptions:</b> %s" % self.exceptions,
"</ul><p>" "<b>Extension List</b><ul>",
]
)
]
+ [producers.simple_producer("</ul>")]
)
def status(self):
return producers.simple_producer(
'<li>%s' % status_handler.html_repr(self) + '<ul>' +
' <li><b>Total Commands:</b> %s' % self.commandCounter +
' <li><b>Completed:</b> %s' % self.completedCounter +
' <li><b>Serious Exceptions:</b> %s' % self.seriousExcCounter +
' <li><b>Total Exceptions:</b> %s' % self.exceptionsCounter +
'</ul>')
def status(self):
return producers.simple_producer("""
<li>Zope Handler
<ul>
<li><b>Published Module:</b> %s
<li><b>Hits:</b> %s
</ul>""" %(self.module_name, self.hits)
)
def status (self):
return producers.simple_producer (
'<li>%s' % status_handler.html_repr (self)
+ '<ul>'
+ ' <li><b>Total Commands:</b> %s' % self.commandCounter
+ ' <li><b>Completed:</b> %s' % self.completedCounter
+ ' <li><b>Serious Exceptions:</b> %s' % self.seriousExcCounter
+ ' <li><b>Total Exceptions:</b> %s' % self.exceptionsCounter
+ '</ul>'
)
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 handle_data(self, fp, extra):
self.current_request.args.append(fp.read())
fp.close()
note("handle_data: extra is %s", repr(extra))
count, litcount = self.current_request.parse_args(extra)
# note("count is %s, litcount is %s", count, litcount)
self.collector = None
if count > 0:
# need still more stuff from the client
self.collector = data_collector(count, self)
if not litcount:
self.push_with_producer(producers.simple_producer("+ Ready for more data\r\n"))
else:
self.do_request()
def write(self, data):
try:
if self.head_sent == 0:
self.head_sent = 1
self._send_head()
# TODO: This should get done down in the medusa code... we
# should not have to do this. It is a result of medusa
# using "if type(thing) == type('')" as the test.
if isinstance(data, StringType):
data = producers.simple_producer(data)
self.__request.push(data)
except IOError:
raise BadRequestError("write failed")
def parse_request(self, rline):
# note("IMAP request: %s", rline.strip())
m = re.match(r"(?P<tag>[^\s]+)\s+(?P<command>[^\s]+)(\s+(?P<args>.*))?$", rline, re.MULTILINE | re.DOTALL)
if m:
r = imap_request(m.group("tag"), m.group("command"), self.clientstate, self.server.mailcontext)
count, litcount = r.parse_args(m.group("args"))
# note("count is %s, litcount is %s", count, litcount)
self.current_request = r
if count > 0:
self.collector = data_collector(count, self)
if not litcount:
self.push_with_producer(producers.simple_producer("+ Ready for more data\r\n"))
return r
else:
return imap_request(None, None, self.clientstate, self.server.mailcontext)
def done(self, *arg, **kw):
""" I didn't want to override this, but there's no way around
it in order to support deferreds - CM
finalize this transaction - send output to the http channel"""
# ----------------------------------------
# persistent connection management
# ----------------------------------------
# --- BUCKLE UP! ----
connection = http_server.get_header(http_server.CONNECTION,self.header)
connection = connection.lower()
close_it = 0
wrap_in_chunking = 0
globbing = 1
if self.version == '1.0':
if connection == 'keep-alive':
if not 'Content-Length' 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 not 'Content-Length' 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
# globbing slows down tail -f output, so only use it if
# we're not in chunked mode
globbing = 0
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.build_reply_header())
if close_it:
self['Connection'] = 'close'
if wrap_in_chunking:
outgoing_producer = deferring_chunked_producer(
deferring_composite_producer(self.outgoing)
)
# prepend the header
outgoing_producer = deferring_composite_producer(
[outgoing_header, outgoing_producer]
)
else:
# prepend the header
self.outgoing.insert(0, outgoing_header)
outgoing_producer = deferring_composite_producer(self.outgoing)
# hook logging into the output
outgoing_producer = deferring_hooked_producer(outgoing_producer,
self.log)
if globbing:
outgoing_producer = deferring_globbing_producer(outgoing_producer)
self.channel.push_with_producer(outgoing_producer)
self.channel.current_request = None
if close_it:
self.channel.close_when_done()
def check_escaping (self):
p1 = producers.simple_producer('the quick brown fox', buffer_size = 5)
p = producers.escaping_producer(p1,
esc_from = ' ',
esc_to = '_')
self._check_all(p, 'the_quick_brown_fox')
def check_composite (self):
p1 = producers.simple_producer('a'*66, buffer_size = 5)
p2 = producers.lines_producer(['b']*65)
p = producers.composite_producer([p1, p2])
self._check_all(p, 'a'*66 + 'b\r\n'*65)
def check_simple (self):
p = producers.simple_producer(test_string)
self.test_val('p.more()', test_string[:1024])
p = producers.simple_producer(test_string, buffer_size = 5)
self._check_all(p, test_string)
def status(self):
return producers.simple_producer('<li>XML-RPC <b>Requests</b> : %s' %
self.requestCntr)
def check_glob (self):
p1 = producers.simple_producer(test_string, buffer_size = 5)
p = producers.globbing_producer(p1, buffer_size = 1024)
self.test_true('1024 <= len(p.more())')
def check_hooked (self):
def f (num_bytes):
self.test_val('num_bytes', len(test_string))
p1 = producers.simple_producer(test_string, buffer_size = 5)
p = producers.hooked_producer(p1, f)
self._check_all(p, test_string)
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 check_compressed (self):
p1 = producers.simple_producer(test_string, buffer_size = 5)
p = producers.compressed_producer(p1)
compr_data = self._check_all(p, zlib.compress(test_string, 5))
self.test_val('zlib.decompress(compr_data)', test_string)
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 status(self):
return producers.simple_producer (
'<li>XML-RPC <b>Requests</b> : %s' % self.requestCntr
)
