该模块基于asyncore简化了异步客户端和服务器，并使其更容易元素处理由任意的字符串结束，或者是可变长度的的协议。它提供了抽象类async_chat，提供collect_incoming_data()和found_terminator()方法。循环和asyncore的一样，有2种信道：asyncore.dispatcher和asynchat.async_chat，可以自由混合信道。通常asyncore.dispatcher服务器通道在接收到连接请求时产生新的asynchat.async_chat通道对象。
接口文档
class asynchat.async_chat:这个类是asyncore.dispatcher的抽象子类。一般使用其collect_incoming_data()和found_terminator()方法，asyncore.dispatcher的方法都可以使用，尽管不是所有在消息/响应上下文都有意义。
async_chat.close_when_done()推None到生产者FIFO。当此None弹出的fifo时，通道将关闭。
async_chat.collect_incoming_data(data)：数据到达。默认引发NotImplementedError异常。使用时必须重载。
async_chat.discard_buffers():在紧急情况下方法将丢弃在输入和/或输出缓冲器和生产者FIFO持有数据。
async_chat.found_terminator():当输入的数据流相匹配set_terminator()中设定的终止条件时调用。默认引发NotImplementedError异常。使用时必须重载。缓冲输入的数据在实例属性是可用的。
async_chat.get_terminator():返回当前通道的结束符。
async_chat.push(data)：往通道的FIFO中添加数据，当然可以使用自己制作的更复杂的方案来实现加密和分块之类的。
async_chat.push_with_producer(producer)：往通道的FIFO中添加数据生产者FIFO中添加生产者。当所有当前生产者队列用尽之后将调用其more()方法并发送数据到远端。
async_chat.set_terminator(term) 设定终止符号。类型如下：
string： Will call found_terminator() when the string is found in the input stream。
integer： Will call found_terminator() when the indicated number of characters have been received。
None： The channel continues to collect data forever。
ac_in_buffer_size异步输入缓冲区的大小（默认4096）。
ac_out_buffer_size异步输出缓冲区的大小（默认4096）。
像asyncore.dispatcher， async_chat定义了一组由select()调用后的socket条件分析生成的事件。轮询循环开始后async_chat对象的方法被事件处理框架调用，不需要程序员干预。。两个类的属性可以修改，以提高性能，甚至节省内存。
不像asyncore.dispatcher， async_chat允许您定义生产者的先进先出队列(FIFO)。生产者有唯一的方法中more()，返回通道上要传输的数据。生产者没有数据时返回空字符串。这时async_chat对象从FIFO移除生产者并开始使用下一个生产者，如果有的话。当生产者FIFO为空时handle_write()什么都不会做。通道对象的set_terminator()方法来识别远端的结束，重要的断点，输入。
为了建立一个有效的async_chat子类，方法collect_incoming_data()和found_terminator()必须处理该通道异步接收数据。相关方法如下：
class asynchat.fifo([list=None]): 辅助类asynchat.fifo的方法如下：
is_empty()： Returns True if and only if the fifo is empty.
first(): Returns the least-recently push()ed item from the fifo.
push(data): Adds the given data (which may be a string or a producer object) to the producer fifo.
pop(): If the fifo is not empty, returns True, first(), deleting the popped item. Returns False, None for an empty fifo.
HTTP实例
下例说明如何通过async_chat读取HTTP请求。 Web服务器可以为每个传入客户端连接创建一个http_request_handler对象。请注意， 初始的信道终结符设置为HTTP头的末尾空行和一个表示正在读取头的标志。
报头读完后，如果请求的类型是POST的（这表明还有其他数据），则内容长度：头用来设置数值终止符。
数据整理完毕， 设置terminator为None，确保web客户端不会读取多余的数据之后调用handle_request()进行数据处理。
class http_request_handler(asynchat.async_chat):
def __init__(self, sock, addr, sessions, log):
asynchat.async_chat.__init__(self, sock=sock)
self.addr = addr self.sessions = sessions self.ibuffer = []
self.obuffer = ""
self.set_terminator("\r\n\r\n")
self.reading_headers = True
self.handling = False
self.cgi_data = None
self.log = log def collect_incoming_data(self, data):
"""Buffer the data"""
self.ibuffer.append(data)
def found_terminator(self):
if self.reading_headers:
self.reading_headers = False
self.parse_headers("".join(self.ibuffer))
self.ibuffer = []
if self.op.upper() == "POST":
clen = self.headers.getheader("content-length")
self.set_terminator(int(clen))
else:
self.handling = True
self.set_terminator(None)
self.handle_request()
elif not self.handling:
self.set_terminator(None) # browsers sometimes over-send
self.cgi_data = parse(self.headers, "".join(self.ibuffer))
self.handling = True
self.ibuffer = []
self.handle_request()注意：这并不是一个不添加代码就可以实际运行的实例。
ECHO实例
下面实例来源于《The Python Standard Library by Example 2011》，更详细。
asynchat_echo_server.py：
import asyncoreimport loggingimport socketfrom asynchat_echo_handler import EchoHandlerclass EchoServer(asyncore.dispatcher):
"""Receives connections and establishes handlers for each client.
"""
def __init__(self, address):
asyncore.dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.bind(address)
self.address = self.socket.getsockname()
self.listen(1)
return
def handle_accept(self):
# Called when a client connects to our socket
client_info = self.accept()
EchoHandler(sock=client_info[0])
# Only deal with one client at a time,
# so close as soon as the handler is set up.
# Under normal conditions, the server
# would run forever or until it received
# instructions to stop.
self.handle_close()
return
def handle_close(self):
self.close()asynchat_echo_handler.py: EchoHandler继承asynchat.async_chat，收发可以自动处理，不过需要处理如下东东：
处理输入数据,重载handle_incoming_data()
认识输入数据的结束符,通过set_terminator()
收到完整信息后的处理：found_terminator()
发送数据push()
该示例应用程序有两种工作模式。它要么等待像"ECHO length\n"之类的命令，要么等待要显示的数据，通过实例变量process_data切换模式。一旦找到完整的命令，处理程序切换到消息处理模式，并等待接收的完整文本。当所有的数据可用时，它被推入到输出信道。数据被发送处理程序被设置为关闭。
import asynchatimport loggingclass EchoHandler(asynchat.async_chat):
"""Handles echoing messages from a single client.
"""
# Artificially reduce buffer sizes to illustrate
# sending and receiving partial messages.
ac_in_buffer_size = 128
ac_out_buffer_size = 128
def __init__(self, sock):
self.received_data = []
self.logger = logging.getLogger('EchoHandler')
asynchat.async_chat.__init__(self, sock)
# Start looking for the ECHO command
self.process_data = self._process_command self.set_terminator('\n')
return
def collect_incoming_data(self, data):
"""Read an incoming message from the client
and put it into the outgoing queue.
"""
self.logger.debug(
'collect_incoming_data() -> (%d bytes) %r',
len(data), data)
self.received_data.append(data)
def found_terminator(self):
"""The end of a command or message has been seen."""
self.logger.debug('found_terminator()')
self.process_data()
def _process_command(self):
"""Have the full ECHO command"""
command = ''.join(self.received_data)
self.logger.debug('_process_command() %r', command)
command_verb, command_arg = command.strip().split(' ')
expected_data_len = int(command_arg)
self.set_terminator(expected_data_len)
self.process_data = self._process_message self.received_data = []
def _process_message(self):
"""Have read the entire message."""
to_echo = ''.join(self.received_data)
self.logger.debug('_process_message() echoing %r',
to_echo)
self.push(to_echo)
# Disconnect after sending the entire response
# since we only want to do one thing at a time
self.close_when_done()客户端和处理器类似。要发送的消息先传递给客户端的构造函数。当socket连接建立后，调用handle_connect()发送命令和消息数据。
命令是直接push，消息文本则使用生产者类。生产者有轮询机制把数据块发送到网络。当生产者返回空字符串，写停止。
import asynchatimport loggingimport socketclass EchoClient(asynchat.async_chat):
"""Sends messages to the server and receives responses.
"""
# Artificially reduce buffer sizes to show
# sending and receiving partial messages.
ac_in_buffer_size = 128
ac_out_buffer_size = 128
def __init__(self, host, port, message):
self.message = message self.received_data = []
self.logger = logging.getLogger('EchoClient')
asynchat.async_chat.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.logger.debug('connecting to %s', (host, port))
self.connect((host, port))
return
def handle_connect(self):
self.logger.debug('handle_connect()')
# Send the command
self.push('ECHO %d\n' % len(self.message))
# Send the data
self.push_with_producer(
EchoProducer(self.message,
buffer_size=self.ac_out_buffer_size)
)
# We expect the data to come back as-is,
# so set a length-based terminator
self.set_terminator(len(self.message))
def collect_incoming_data(self, data):
"""Read an incoming message from the client
and add it to the outgoing queue.
"""
self.logger.debug(
'collect_incoming_data() -> (%d) %r',
len(data), data)
self.received_data.append(data)
def found_terminator(self):
self.logger.debug('found_terminator()')
received_message = ''.join(self.received_data)
if received_message == self.message:
self.logger.debug('RECEIVED COPY OF MESSAGE')
else:
self.logger.debug('ERROR IN TRANSMISSION')
self.logger.debug('EXPECTED %r', self.message)
self.logger.debug('RECEIVED %r', received_message)
returnclass EchoProducer(asynchat.simple_producer):
logger = logging.getLogger('EchoProducer')
def more(self):
response = asynchat.simple_producer.more(self)
self.logger.debug('more() -> (%s bytes) %r',
len(response), response)
return response主程序：
import asyncoreimport loggingimport socketfrom asynchat_echo_server import EchoServerfrom asynchat_echo_client import EchoClient
logging.basicConfig(level=logging.DEBUG,
format='%(name)-11s: %(message)s',
)address = ('localhost', 0) # let the kernel give us a portserver = EchoServer(address)ip, port = server.address # find out what port we were givenmessage_data = open('lorem.txt', 'r').read()client = EchoClient(ip, port, message=message_data)asyncore.loop()辅助文本：
# vi lorem.txt
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec
egestas, enim et consectetuer ullamcorper, lectus ligula rutrum
leo, a elementum elit tortor eu quam.执行结果：
# ./asynchat_echo_main.py
EchoClient : connecting to ('127.0.0.1', 58974)EchoClient : handle_connect()EchoHandler: collect_incoming_data() -> (8 bytes) 'ECHO 166'EchoHandler: found_terminator()EchoHandler: _process_command() 'ECHO 166'EchoProducer: more() -> (128 bytes) 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec\negestas, enim et consectetuer ullamcorper, lectus ligula rutrum\n'EchoHandler: collect_incoming_data() -> (128 bytes) 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec\negestas, enim et consectetuer ullamcorper, lectus ligula rutrum\n'EchoProducer: more() -> (38 bytes) 'leo, a elementum elit tortor eu quam.\n'EchoHandler: collect_incoming_data() -> (38 bytes) 'leo, a elementum elit tortor eu quam.\n'EchoHandler: found_terminator()EchoHandler: _process_message() echoing 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec\negestas, enim et consectetuer ullamcorper, lectus ligula rutrum\nleo, a elementum elit tortor eu quam.\n'EchoProducer: more() -> (0 bytes) ''EchoClient : collect_incoming_data() -> (128) 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec\negestas, enim et consectetuer ullamcorper, lectus ligula rutrum\n'EchoClient : collect_incoming_data() -> (38) 'leo, a elementum elit tortor eu quam.\n'EchoClient : found_terminator()EchoClient : RECEIVED COPY OF MESSAGE参考资料
《The Python Standard Library by Example 2011》
本文地址
本站地址：python自动化测试http://automationtesting.sinaapp.com python开发自动化测试群113938272和开发测试群6089740 微博 http://weibo.com/cizhenshi
166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
