import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("Hello, world")

application = tornado.web.Application([

    (r"/", MainHandler),

])

if __name__ == "__main__":

    application.listen(8888)

    tornado.ioloop.IOLoop.instance().start()

def bind(self, port, address=None, family=socket.AF_UNSPEC):

        if address == "":

            address = None

                   // 查找网卡信息

        for res in socket.getaddrinfo(address, port, family, socket.SOCK_STREAM,

                                      0, socket.AI_PASSIVE | socket.AI_ADDRCONFIG):

            af, socktype, proto, canonname, sockaddr = res

            sock = socket.socket(af, socktype, proto)

            flags = fcntl.fcntl(sock.fileno(), fcntl.F_GETFD)

            flags |= fcntl.FD_CLOEXEC

            fcntl.fcntl(sock.fileno(), fcntl.F_SETFD, flags)

            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

            if af == socket.AF_INET6:

                if hasattr(socket, "IPPROTO_IPV6"):

                    sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)

            sock.setblocking(0)

                            // bind和listen

            sock.bind(sockaddr)

            sock.listen(128)

            self._sockets[sock.fileno()] = sock

                   // 加入io_loop

            if self._started:

                self.io_loop.add_handler(sock.fileno(), self._handle_events,

                                         ioloop.IOLoop.READ)

    def _handle_events(self, fd, events):

        while True:

            try:

                connection, address = self._sockets[fd].accept()

            except socket.error, e:

                if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):

                    return

                raise

            if self.ssl_options is not None:

                                   //这里有一段处理ssl的代码，比较长，省略

            try:

                stream = iostream.IOStream(connection, io_loop=self.io_loop)

                HTTPConnection(stream, address, self.request_callback,

                               self.no_keep_alive, self.xheaders)

            except:

                logging.error("Error in connection callback", exc_info=True)

    def __init__(self, socket, io_loop=None, max_buffer_size=104857600,

                 read_chunk_size=4096):

        self.socket = socket

        self.socket.setblocking(False)

        self.io_loop = io_loop or ioloop.IOLoop.instance()

        self._read_buffer = collections.deque()

        self._write_buffer = collections.deque()

        self._state = self.io_loop.ERROR

        with stack_context.NullContext():

            self.io_loop.add_handler(

                self.socket.fileno(), self._handle_events, self._state)

    def _handle_events(self, fd, events):

        if not self.socket:

            logging.warning("Got events for closed stream %d", fd)

            return

        try:

            if events & self.io_loop.READ:

                self._handle_read()

            if events & self.io_loop.WRITE:

                self._handle_write()

            if events & self.io_loop.ERROR:

                self.io_loop.add_callback(self.close)

                return

            state = self.io_loop.ERROR

            if self.reading():

                state |= self.io_loop.READ

            if self.writing():

                state |= self.io_loop.WRITE

            if state != self._state:

                self._state = state

                self.io_loop.update_handler(self.socket.fileno(), self._state)

        except:

            logging.error("Uncaught exception, closing connection.",

                          exc_info=True)

            self.close()

            raise

class IOLoop(object):

    def instance(cls):

        if not hasattr(cls, "_instance"):

            cls._instance = cls()

        return cls._instance

    def initialized(cls):

        return hasattr(cls, "_instance")

def start(self):

        if self._stopped:

            self._stopped = False

            return

        self._running = True

        while True:

            poll_timeout = 0.2

            callbacks = self._callbacks

            self._callbacks = []

            for callback in callbacks:

                self._run_callback(callback)

            try:

                event_pairs = self._impl.poll(poll_timeout)

            except Exception, e:

                if (getattr(e, 'errno', None) == errno.EINTR or

                    (isinstance(getattr(e, 'args', None), tuple) and

                     len(e.args) == 2 and e.args[0] == errno.EINTR)):

                    continue

                else:

                    raise

            if self._blocking_signal_threshold is not None:

                signal.setitimer(signal.ITIMER_REAL,

                                 self._blocking_signal_threshold, 0)

            self._events.update(event_pairs)

            while self._events:

                fd, events = self._events.popitem()

                self._handlers[fd](fd, events)

        self._stopped = False

        if self._blocking_signal_threshold is not None:

            signal.setitimer(signal.ITIMER_REAL, 0, 0)

class _EPoll(object):

    _EPOLL_CTL_ADD = 1

    _EPOLL_CTL_DEL = 2

    _EPOLL_CTL_MOD = 3

    def __init__(self):

        self._epoll_fd = epoll.epoll_create()

    def fileno(self):

        return self._epoll_fd

    def register(self, fd, events):

       epoll.epoll_ctl(self._epoll_fd, self._EPOLL_CTL_ADD, fd, events)

    def modify(self, fd, events):

        epoll.epoll_ctl(self._epoll_fd, self._EPOLL_CTL_MOD, fd, events)

    def unregister(self, fd):

        epoll.epoll_ctl(self._epoll_fd, self._EPOLL_CTL_DEL, fd, 0)

    def poll(self, timeout):

        return epoll.epoll_wait(self._epoll_fd, int(timeout * 1000))