Public Member Functions | |
| def | __init__ |
| def | add_callback |
| def | add_handler |
| def | add_timeout |
| def | close |
| def | handle_callback_exception |
| def | install |
| def | log_stack |
| def | remove_handler |
| def | remove_timeout |
| def | running |
| def | set_blocking_log_threshold |
| def | set_blocking_signal_threshold |
| def | start |
| def | stop |
| def | update_handler |
Static Public Member Functions | |
| def | initialized |
| def | instance |
Static Public Attributes | |
| ERROR = _EPOLLERR|_EPOLLHUP | |
| int | NONE = 0 |
| READ = _EPOLLIN | |
| WRITE = _EPOLLOUT | |
Private Member Functions | |
| def | _run_callback |
Private Attributes | |
| _blocking_signal_threshold | |
| _callback_lock | |
| _callbacks | |
| _events | |
| _handlers | |
| _impl | |
| _running | |
| _stopped | |
| _thread_ident | |
| _timeouts | |
| _waker | |
Static Private Attributes | |
| int | _EPOLLERR = 0x008 |
| tuple | _EPOLLET = (1 << 31) |
| int | _EPOLLHUP = 0x010 |
| int | _EPOLLIN = 0x001 |
| tuple | _EPOLLONESHOT = (1 << 30) |
| int | _EPOLLOUT = 0x004 |
| int | _EPOLLPRI = 0x002 |
| int | _EPOLLRDHUP = 0x2000 |
| tuple | _instance_lock = threading.Lock() |
A level-triggered I/O loop.
We use epoll (Linux) or kqueue (BSD and Mac OS X; requires python
2.6+) if they are available, or else we fall back on select(). If
you are implementing a system that needs to handle thousands of
simultaneous connections, you should use a system that supports either
epoll or queue.
Example usage for a simple TCP server::
import errno
import functools
import ioloop
import socket
def connection_ready(sock, fd, events):
while True:
try:
connection, address = sock.accept()
except socket.error, e:
if e.args[0] not in (errno.EWOULDBLOCK, errno.EAGAIN):
raise
return
connection.setblocking(0)
handle_connection(connection, address)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setblocking(0)
sock.bind(("", port))
sock.listen(128)
io_loop = ioloop.IOLoop.instance()
callback = functools.partial(connection_ready, sock)
io_loop.add_handler(sock.fileno(), callback, io_loop.READ)
io_loop.start()
| def tornado.ioloop.IOLoop.__init__ | ( | self, | |
impl = None |
|||
| ) |
| def tornado.ioloop.IOLoop._run_callback | ( | self, | |
| callback | |||
| ) | [private] |
| def tornado.ioloop.IOLoop.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.
| def tornado.ioloop.IOLoop.add_handler | ( | self, | |
| fd, | |||
| handler, | |||
| events | |||
| ) |
| def tornado.ioloop.IOLoop.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. ``deadline`` may be a number denoting a unix timestamp (as returned by ``time.time()`` or a ``datetime.timedelta`` object for a deadline relative to the current time. Note that it is not safe to call `add_timeout` from other threads. Instead, you must use `add_callback` to transfer control to the IOLoop's thread, and then call `add_timeout` from there.
| def tornado.ioloop.IOLoop.close | ( | self, | |
all_fds = False |
|||
| ) |
Closes the IOLoop, freeing any resources used. If ``all_fds`` is true, all file descriptors registered on the IOLoop will be closed (not just the ones created by the IOLoop itself). Many applications will only use a single IOLoop that runs for the entire lifetime of the process. In that case closing the IOLoop is not necessary since everything will be cleaned up when the process exits. `IOLoop.close` is provided mainly for scenarios such as unit tests, which create and destroy a large number of IOLoops. An IOLoop must be completely stopped before it can be closed. This means that `IOLoop.stop()` must be called *and* `IOLoop.start()` must be allowed to return before attempting to call `IOLoop.close()`. Therefore the call to `close` will usually appear just after the call to `start` rather than near the call to `stop`.
| def tornado.ioloop.IOLoop.handle_callback_exception | ( | self, | |
| callback | |||
| ) |
This method is called whenever a callback run by the IOLoop throws an exception. By default simply logs the exception as an error. Subclasses may override this method to customize reporting of exceptions. The exception itself is not passed explicitly, but is available in sys.exc_info.
| def tornado.ioloop.IOLoop.initialized | ( | ) | [static] |
| def tornado.ioloop.IOLoop.install | ( | self | ) |
| def tornado.ioloop.IOLoop.instance | ( | ) | [static] |
Returns a global IOLoop instance.
Most single-threaded applications have a single, global IOLoop.
Use this method instead of passing around IOLoop instances
throughout your code.
A common pattern for classes that depend on IOLoops is to use
a default argument to enable programs with multiple IOLoops
but not require the argument for simpler applications::
class MyClass(object):
def __init__(self, io_loop=None):
self.io_loop = io_loop or IOLoop.instance()
| def tornado.ioloop.IOLoop.log_stack | ( | self, | |
| signal, | |||
| frame | |||
| ) |
| def tornado.ioloop.IOLoop.remove_handler | ( | self, | |
| fd | |||
| ) |
| def tornado.ioloop.IOLoop.remove_timeout | ( | self, | |
| timeout | |||
| ) |
| def tornado.ioloop.IOLoop.running | ( | self | ) |
| def tornado.ioloop.IOLoop.set_blocking_log_threshold | ( | self, | |
| seconds | |||
| ) |
| def tornado.ioloop.IOLoop.set_blocking_signal_threshold | ( | self, | |
| seconds, | |||
| action | |||
| ) |
Sends a signal if the ioloop is blocked for more than s seconds. Pass seconds=None to disable. Requires python 2.6 on a unixy platform. The action parameter is a python signal handler. Read the documentation for the python 'signal' module for more information. If action is None, the process will be killed if it is blocked for too long.
| def tornado.ioloop.IOLoop.start | ( | self | ) |
| def tornado.ioloop.IOLoop.stop | ( | self | ) |
Stop the loop after the current event loop iteration is complete. If the event loop is not currently running, the next call to start() will return immediately. To use asynchronous methods from otherwise-synchronous code (such as unit tests), you can start and stop the event loop like this:: ioloop = IOLoop() async_method(ioloop=ioloop, callback=ioloop.stop) ioloop.start() ioloop.start() will return after async_method has run its callback, whether that callback was invoked before or after ioloop.start. Note that even after `stop` has been called, the IOLoop is not completely stopped until `IOLoop.start` has also returned.
| def tornado.ioloop.IOLoop.update_handler | ( | self, | |
| fd, | |||
| events | |||
| ) |
tornado::ioloop.IOLoop::_callback_lock [private] |
tornado::ioloop.IOLoop::_callbacks [private] |
int tornado::ioloop.IOLoop::_EPOLLERR = 0x008 [static, private] |
tuple tornado::ioloop.IOLoop::_EPOLLET = (1 << 31) [static, private] |
int tornado::ioloop.IOLoop::_EPOLLHUP = 0x010 [static, private] |
int tornado::ioloop.IOLoop::_EPOLLIN = 0x001 [static, private] |
tuple tornado::ioloop.IOLoop::_EPOLLONESHOT = (1 << 30) [static, private] |
int tornado::ioloop.IOLoop::_EPOLLOUT = 0x004 [static, private] |
int tornado::ioloop.IOLoop::_EPOLLPRI = 0x002 [static, private] |
int tornado::ioloop.IOLoop::_EPOLLRDHUP = 0x2000 [static, private] |
tornado::ioloop.IOLoop::_events [private] |
tornado::ioloop.IOLoop::_handlers [private] |
tornado::ioloop.IOLoop::_impl [private] |
tuple tornado::ioloop.IOLoop::_instance_lock = threading.Lock() [static, private] |
tornado::ioloop.IOLoop::_running [private] |
tornado::ioloop.IOLoop::_stopped [private] |
tornado::ioloop.IOLoop::_thread_ident [private] |
tornado::ioloop.IOLoop::_timeouts [private] |
tornado::ioloop.IOLoop::_waker [private] |
tornado::ioloop.IOLoop::ERROR = _EPOLLERR|_EPOLLHUP [static] |
int tornado::ioloop.IOLoop::NONE = 0 [static] |
tornado::ioloop.IOLoop::READ = _EPOLLIN [static] |
tornado::ioloop.IOLoop::WRITE = _EPOLLOUT [static] |