Tornado代码阅读笔记 IOLoop

#!/usr/bin/env python

import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web

from tornado.options import define, options

define("port", default=8888, help="run on the given port", type=int)

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def main():
    tornado.options.parse_command_line()
    application = tornado.web.Application([
        (r"/", MainHandler),
    ])
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()

if __name__ == "__main__":
    main()

    def add_handler(self, fd, handler, events):
        """Registers the given handler to receive the given events for fd."""
        self._handlers[fd] = stack_context.wrap(handler) # 加入到回调handler字典中
        self._impl.register(fd, events | self.ERROR) # 注册epoll 事件监听

    def update_handler(self, fd, events):
        """Changes the events we listen for fd."""
        self._impl.modify(fd, events | self.ERROR)

    def remove_handler(self, fd):
        """Stop listening for events on fd."""
        self._handlers.pop(fd, None)
        self._events.pop(fd, None)
        try:
            self._impl.unregister(fd)
        except (OSError, IOError):
            logging.debug("Error deleting fd from IOLoop", exc_info=True)

    def add_timeout(self, deadline, callback):
        """Calls the given callback at the time deadline from the I/O loop.

        Returns a handle that may be passed to remove_timeout to cancel.
        """
        timeout = _Timeout(deadline, stack_context.wrap(callback))
        heapq.heappush(self._timeouts, timeout)
        return timeout

    def remove_timeout(self, timeout):
        """Cancels a pending timeout.

        The argument is a handle as returned by add_timeout.
        """
        # Removing from a heap is complicated, so just leave the defunct
        # timeout object in the queue (see discussion in 
        # http://docs.python.org/library/heapq.html).
        # If this turns out to be a problem, we could add a garbage
        # collection pass whenever there are too many dead timeouts.
        timeout.callback = None

    def add_callback(self, callback):
        """Calls the given callback on the next I/O loop iteration.

        It is safe to call this method from any thread at any time.
        Note that this is the *only* method in IOLoop that makes this
        guarantee; all other interaction with the IOLoop must be done
        from that IOLoop's thread.  add_callback() may be used to transfer
        control from other threads to the IOLoop's thread.
        """
        if not self._callbacks:
            self._wake()
        self._callbacks.append(stack_context.wrap(callback))

            if not self.io_loop:
                self.io_loop = ioloop.IOLoop.instance() # 创建 ioloop 对象
            for fd in self._sockets.keys(): # 把socket字典中所有的socket加入到ioloop handler列表中，并监听可读事件，回调函数为_handle_events
                self.io_loop.add_handler(fd, self._handle_events,
                                         ioloop.IOLoop.READ)

    def _handle_events(self, fd, events): # 当接受到服务端socket的可读事件时，建立连接
        while True:
            try:
                connection, address = self._sockets[fd].accept() # 接受socket连接
            except socket.error, e:
                if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):
                    return
                raise
            
            stream = iostream.IOStream(connection, io_loop=self.io_loop) # 创建IOStream对象，封装子socket
            HTTPConnection(stream, address, self.request_callback,
                               self.no_keep_alive, self.xheaders) # 创建 HTTPonnection连接对象，处理http请求