Tornado可以当做一个http客户端去发送请求，可以处理需要和客户端建立长连接的请求。可是Tornado最为知名的还是它作为一个HTTP web框架…,上一篇讲述了IOLoop的套路。本篇讲解一下如何将IOLoop和httpserver联系起来(本代码思路依据1.0.0版本)

目标

本文的基本目标是实现这个需求

1
2
3
4
5
6
7
8
9
10
11
12
from tornado import httpserver
from tornado import ioloop

def handle_request(request):
    message = b"Hello World\n"
    request.write(b"HTTP/1.0 200 OK\r\nContent-Length: %d\r\n\r\n%s" % (
        len(message), message))
    request.finish()

http_server = httpserver.HTTPServer(handle_request)
http_server.listen(8888)
ioloop.IOLoop.instance().start()

最简服务端

根据上一篇。我们可以想到当执行listen监听操作的时候，会创建一个监听socket.然后将处理函数添加到事件回调中。不考虑异常因素，最简单的是这样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import socket
from tornado import ioloop
from selectors import EVENT_READ, EVENT_WRITE

class HTTPServer:

    def __init__(self, handler):
        self.handler = handler
        self.io_loop = ioloop.IOLoop.instance()

    def listen(self, port):
        self.s = socket.socket()
        self.s.setblocking(0)
        self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.s.bind(('127.0.0.1', port))
        self.s.listen(128)
        self.io_loop.add_handler(self.s.fileno(), EVENT_READ, self._handle)

    def _handle(self):
        client_sock, _ = self.s.accept()
        client_sock.send(b"HTTP/1.0 200 OK\r\nContent-Length: 12\r\n\r\nHello World\n")
        client_sock.close()

对于监听socket,当触发可读的时候意味有新的客户端连接进来了，此时调用回调进行accept得到交互socket连接。简单起见直接send发送一个简易的HTTP消息然后关闭socket

封装Request对象

从上面的示例中可以看到。它没有调用传入的request函数，因为socket对象并没有write和finish方法。此外，即使我们将socket的send和close当做write和finish。它还有一个巨大的缺陷。我们只是进行了发送，而没有对接收到的http报文进行任何处理。
一般而言，会从它的行首、头部、消息体得到某一些我们需要的内容，然后对内容进行处理，最终写入信息，过程结束。因此，封装一个Request对象是必须的，最后将封装的对象传入到handler函数以供使用。如何封装呢？我们只需要知道一个完整的HTTP报文即可以得到一个requests对象，而一个http报文又有明显的分隔符.例如下文这个请求报文

1
2
3
4
5
6
7
GET /docs/index.html HTTP/1.1
Host: www.ipinfo.com
Accept: image/gif, image/jpeg, */*
Accept-Language: en-us
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
(blank line)

获取流程如下。当读取到第一个\r\n即确定Reques Line部分，当读取到\r\n\r\n即确定Header部分，如果Header部分存在Content-Length则表示存在body部分，存在则继续读取Content-Length长度。如此下来单个HTTP报文读取完毕。可以构建这个过程，Requests Line读取完毕后—>回调读取Header部分—>回调读取Body部分—>构建Request对象—>回调handler函数，将Request对象传入。另外第一步可以省略,读取Header即包含Requests Line

可以看到对于一个socket对象,将它根据分隔符以及长度读取就能解析成单个http包，另外对于很多流协议也是如此。我们将socket封装一下。让它提供两个功能read_until、read_bytes。允许读取到分隔符后调用回调函数、读取到固定长度后调用回调函数。最简代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
from tornado import ioloop
from selectors import EVENT_READ

class IOStream:

    def __init__(self, socket):
        self.socket = socket
        self.ioloop = ioloop.IOLoop.instance()
        self.ioloop.add_handler(self.socket.fileno(), EVENT_READ, self._handler)
        self._read_buffer = b""
        self._read_delimiter = None
        self._read_bytes = None
        self._read_callback = None

    def _handler(self):
        data = self.socket.recv(1024)
        self._read_buffer += data
        if self._read_delimiter and self._read_delimiter in self._read_buffer:
            result, self._read_buffer = self._read_buffer.split(self._read_delimiter)
            self._read_callback(result)
            self._read_delimiter = None
            self._read_callback = None
        elif self._read_bytes and len(self._read_buffer) > self._read_bytes:
            result = self._read_buffer[:self._read_bytes]
            self._read_buffer = self._read_buffer[self._read_bytes:]
            self._read_callback(result)
            self._read_bytes = None
            self._read_callback = None

    def read_until(self, delimiter, callback):
        self._read_delimiter = delimiter
        self._read_callback = callback

    def read_bytes(self, length, callback):
        self._read_bytes = length
        self._read_callback = callback

    def write(self, data):
        self.socket.send(data)

    def close(self):
        self.ioloop.ioloop.unregister(self.socket.fileno())
        self.socket.close()

对于创建的IOStream对象，它添加READ事件，将回调函数设置为self._handler。当使用read_until的时候将历史数据给callback函数调用。
再看一下HTTPConnect对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class HTTPConnection:
    def __init__(self, io_stream, handler_callback):
        self.io_loop = ioloop.IOLoop.instance()
        self.stream = io_stream
        self.handler_callback = handler_callback
        self.stream.read_until(b'\r\n\r\n', self._parse_header)

    def _parse_header(self, data):
        # 忽略行首，全部当做header
        request = Request(connect=self, header=data)
        self.handler_callback(request)

    def write(self, data):
        self.stream.write(data)

    def finish(self):
        self.stream.close()

显然，它传入的是IOStream对象，并且在初始化的时候就调用read_until读取HTTP Header部分内容。简单起见，这里只读取并没有解析。最后封装成Request对象。让handle_request函数调用。达到我们文章开头的目的

1
2
3
4
5
6
7
8
9
10
class Request:
    def __init__(self, connect, header):
        self.connect = connect
        self.header = header

    def write(self, data):
        self.connect.write(data)

    def finish(self):
        self.connect.finish()

将最开始的最简服务器部分稍微改动一下

1
2
3
4
def _handle(self):
    client_sock, _ = self.s.accept()
    stream = IOStream(client_sock)
    HTTPConnection(stream, self.handler)

小结

IOStream、HTTPConnection、Request、HTTPServer。其中暴漏给用户的几乎只有Request对象，从上面的分析中应该可以发现。将文件描述符加入事件，等待IOStream的全局_header进行回调，全局_header又针对各种情况(分隔符条件满足、长度条件满足)发起回调。同时如果不调用iostream.read_until等那么全局的_header就没有意义了。搞定IOStream后。立马在HTTPConnection里面调用iostream.read_until。被回调则表明HTTP头部接收完成。组装成Requests然后调用handle_request。

作用分工:
HTTPServer: 创建监听socket,传入http处理回调函数
IOStream: 提供通用TCP流解析，最重要的是提供了write、read_until、read_length，且可以传入回调
Request: 将字符串解析成一个Request对象。便于简单的获取访问信息。如url、host、port、body等等
HTTPConnection: 将前三者联系起来,调用IOStream.read_until开启获取HTTP数据包的流程

另外本文简单起见，只注册了READ事件。对于send操作。同样是需要进行注册事件。等到WRITE事件触发才执行send操作，希望不要引起误解，另外本例中使用HTTP/1.0的逻辑，处理完成单个链接后直接关闭。对于HTTP/1.1来说要实现keep-alive只需要在finish的使用并不关闭链接，而是继续执行self.read_until(b’\r\n\r\n’,self._parse_header)继续等待处理下一个HTTP报文