[原]tornado源码分析系列（六）[HTTPServer详解]

引言：上一章讲了关于HTTPServer的原理，这一次通过分析源码来了解更多的细节

看看HTTPServer类的组织结构：

HTTPServer的主要工作

一.提供了一些基础的比如说listen,bind此类共有操作

二.完成了一个 _handle_events()的公有回调函数，此函数是 IOLoop的基础，此函数为每一个连接创建一个单独的 IOStream 对象

三.start函数，启动HTTPServer,并设置相应的参数（如根据CPU个数来设置进程数等）

从HTTPServer类的构造函数可以看出，最重要的参数是设置回调函数，此回调函数用于处理request对象

每次有HTTP的请求，都会通过HTTPConnection 封装一个HTTPRequest对象，这个对象包含了HTTP请求的所有信息

所以在HTTPServer层，需要对这个对象进行一番处理后调用 request.write将结果返回给客户端

此回调函数会先注册到HTTPServer，然后注册到HTTPConnection 里面，因为request这个对象是由HTTPConnection对象产生

   def _handle_events(self, fd, events):
        while True:
            try:
                connection, address = self._socket.accept()
            except socket.error, e:
                if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):
                    return
                raise
            #SSL 选项
            if self.ssl_options is not None:
                assert ssl, "Python 2.6+ and OpenSSL required for SSL"
                try:
                    connection = ssl.wrap_socket(connection,
                                                 server_side=True,
                                                 do_handshake_on_connect=False,
                                                 **self.ssl_options)
                except ssl.SSLError, err:
                    if err.args[0] == ssl.SSL_ERROR_EOF:
                        return connection.close()
                    else:
                        raise
                except socket.error, err:
                    if err.args[0] == errno.ECONNABORTED:
                        return connection.close()
                    else:
                        raise
            try:
                if self.ssl_options is not None:
                    stream = iostream.SSLIOStream(connection, io_loop=self.io_loop)
                else:
                        #为每一个 connection 创建一个 iostream 实例，以后的IO操作由此实例负责
                        #IOLoop只负责 accept这个连接
                        
                    stream = iostream.IOStream(connection, io_loop=self.io_loop)
                
                #将 stream对象和对应的 address , callback加入到HTTPConnection 中
                #HTTPConnection稍后会有介绍
                #这里的 request_callback 是由Demo里 httpserver.HTTPServer(handle_request) 传递进来
                #现代的 HTTP 框架都采用这种模式
                #创建一个 handle_request 这个 回调函数嵌套的注册到下层，直到真正处理request
                #一般情况是回调继续传递下去直到遇到一个类方法能够传递 request 对象给这个函数
                HTTPConnection(stream, address, self.request_callback,
                               self.no_keep_alive, self.xheaders)
            except:
                logging.error("Error in connection callback", exc_info=True)

通过调用HTTPConnection，然后传递stream,address和request_callback到HTTPConnection可以看到，处理request的回调函数注册到了HTTPConnection.

还需要注意的地方就是，每一次有一个连接的到来，IOLoop都只负责处理accept此连接，然后后面的IO操作就交给IOStream来处理

在start()函数中，会为每个进程创建一个单独的IOLoop，然后此IOLoop的回调函数统一采用_handle_events()

_handle_events()函数的处理流程总体来说是这样：

1.注册到本进程的IOLoop中

2.当有事件发生，只注册了READ事件，也就是只接受新连接，每次有连接到来，都回调_handle_events()

3.accept此新连接，然后为此新连接创建一个IOStream对象，以后此IOStream负责本连接的所有IO操作，这里是一层抽象，实际

   在IOStream的读写事件也是注册到了本进程的IOLoop中，只不过回调函数不一样，因为注册时候的描述符不同。

　调用方式是通过handle[fd]()这种方式调用，所以对于监听套接口每次都只会调用_handle_events()而对于其他的IOStream的连接

   fd会调用在read_bytes(),read_utils()中注册的回调函数

 

再看看在HTTPServer中的 start()函数

    def start(self, num_processes=1):

        assert not self._started
        self._started = True
        if num_processes is None or num_processes <= 0:
            num_processes = _cpu_count()
        if num_processes > 1 and ioloop.IOLoop.initialized():
            logging.error("Cannot run in multiple processes: IOLoop instance "
                          "has already been initialized. You cannot call "
                          "IOLoop.instance() before calling start()")
            num_processes = 1
        if num_processes > 1:
            logging.info("Pre-forking %d server processes", num_processes)
            #根据 处理器个数来决定 fork多少个进程
            for i in range(num_processes):
                if os.fork() == 0:# fork() == 0 表示子进程
                    import random
                    from binascii import hexlify
                    try:
                        # If available, use the same method as
                        # random.py
                        seed = long(hexlify(os.urandom(16)), 16)
                    except NotImplementedError:
                        # Include the pid to avoid initializing two
                        # processes to the same value
                        seed(int(time.time() * 1000) ^ os.getpid())
                    random.seed(seed)
                    #为每个进程创建一个IOLoop实例
                    self.io_loop = ioloop.IOLoop.instance()
                    #为每个IOLoop 添加回调函数，这里采用统一回调方式，和IOStream 一样
                    self.io_loop.add_handler(
                        self._socket.fileno(), self._handle_events,
                        ioloop.IOLoop.READ)
                    return
            os.waitpid(-1, 0)#预防僵尸进程，Unix 环境编程介绍很多
        else:
            if not self.io_loop:
                self.io_loop = ioloop.IOLoop.instance()
            self.io_loop.add_handler(self._socket.fileno(),
                                     self._handle_events,
                                     ioloop.IOLoop.READ)

可以在代码注释中看到会根据每一个CPU一个IOLoop实例的方式处理，至于中间的产生随机数是为什么，如果有人知道请告知我

在start()函数的最后可以看到add_handle将监听套接口和_handle_events()函数注册到了IOLoop中，这就是上面所讲的HTTPServer处理连接的过程

总结：总结不想写了，土逼Continue...