tornado源码分析（二）之iostream

与ioloop直接交互时通用的过程

需要读数据时：将socket添加至ioloop中，并设置回掉函数，在回掉函数中从socket中读取数据，并且检查是否接受到了足够的数据，如果没有接收完则需要保存当前的数据，直到读去完为止。

需要写数据时：将socket添加至ioloop中，并设置回掉函数，在回掉函数中向socket写数据，如果数据比较多，则需要分多次去写。

iostream的作用

让各组件，不需要与ioloop直接交互，iostream帮助各组件将socket添加至ioloop，并设置回掉函数，读取并保存数据，直到所有数据都接收完为止，或向socket写入数据，直到写完所有数据，完成后调用其它组件设置的回掉函数。

iostream同样可以看作一个事件循环，它提供两类事件：读完成、写完成。

iostream的事件循环

iostream是基于ioloop的，创建iostream时必需给定一个文件描述符，iostream将该文件描述符添加至ioloop的io事件中，并设置回调函数_handle_events，该函数中实现了iostream的事件循环。

_handle_events中判断文件描述符的事件：

当该文件描述符可读时，iostream从文件描述符中读出数据，并存至自己的数据缓冲中。每次读取到新的数据后，iostream都检查是否触发了自己管理的事件，如：是否读到了某一特定的数据（由read_until、read_until_regex等接口注册），是否读到了足够多的数据（由read_bytes注册）等，如果触发了事件，则调用对应事件的回调函数（异步事件为future，设置future的result即可调用异步事件的回调函数）。

当文件描述符可写时，首先iostream从写缓冲中，读取足量的数据，写入至文件描述符中。其次能进入当前逻辑，说明上一次写入文件描述符的数据已经发送出去了，此时需要逐个检查注册的写事件是否已经完成（各写事件中存储了自己关注的写缓冲区的位置，通过检查该位置判断该事件的数据是否已经发送），如果完成则调用事件的回调函数。

当文件描述符异常（EPOLLERR、EPOLLHUP）时，将文件描述符从ioloop中删除，并设置自己为关闭状态，上层再向自己读写数据时，触发异常。

iostream的接口

读数据的接口：read_until，read_bytes，read_unitl_regex等，iostream在同一时间内只能存在一个读事件。

写数据的接口：write，可以同时存在多个（只要iostream的写缓冲区足够）。每次添加时创建一个future，并且记录该事件的要写的数据在写缓冲区中的位置（加入数据后iostream的_total_write_index），每次有数据发送后根据该位置信息判断是否结束（iostream的_total_write_done_index是否超过了事件的数据的位置）。 

 源码参考：tornado.iostream.IOStream

iostream用法举例

server端

from tornado.tcpserver import TCPServer
from tornado import gen


class MyTCPConnection(object):
    def __init__(self, stream, address):
        self.stream = stream
        self.address = address

    @gen.coroutine
    def start_serving(self, server):
        while True:
            #循环从stream中读取消息，每个消息以that is all!结尾
            future = self.stream.read_until("that is all!".encode())
            message = yield future
            message = message.decode()

            if message == "that is all!": #如果仅发送that is all!，则说明客户端消息已发送完毕
                print("no more messages")
                self.stream.close()
                server.on_conn_close(self)
                break
            else:
                print("data recieved: ", message)
                future = self.stream.write(message.encode()) #把接收到的消息以异步的方式写回至client
                yield future


class MyTCPServer(TCPServer):
    def __init__(self):
        super().__init__()
        self._conns = set()

    #tcpserver已经建立好了iostream，我们只需要使用iostream即可
    def handle_stream(self, stream, address):
        conn = MyTCPConnection(stream, address)
        self._conns.add(conn)
        return conn.start_serving(self)

    def on_conn_close(self, conn):
        self._conns.remove(conn)


if __name__ == "__main__":
    server = MyTCPServer()
    server.listen(8000, '0.0.0.0')
    from tornado.ioloop import IOLoop
    IOLoop().current().start()

client端：

import time
import socket


HOST = '132.232.191.131'
PORT = 8000
BUFSIZE = 1024


s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.send("hi dude! that is all!".encode())
data = s.recv(BUFSIZE).decode()
print(data)

s.send("whats up! that is all!".encode())
data = s.recv(BUFSIZE).decode()
print(data)

s.send("that is all!".encode())
time.sleep(2)

s.close()