Inheritance diagram for tornado.platform.twisted.TwistedIOLoop:

Public Member Functions
def	add_callback
def	add_callback_from_signal
def	add_handler
def	add_timeout
def	close
def	initialize
def	remove_handler
def	remove_timeout
def	start
def	stop
def	update_handler
Public Attributes
	fds
	reactor

Detailed Description

IOLoop implementation that runs on Twisted.

Uses the global Twisted reactor by default.  To create multiple
`TwistedIOLoops` in the same process, you must pass a unique reactor
when constructing each one.

Not compatible with `tornado.process.Subprocess.set_exit_callback`
because the ``SIGCHLD`` handlers used by Tornado and Twisted conflict
with each other.

Definition at line 398 of file twisted.py.

Member Function Documentation

def tornado.platform.twisted.TwistedIOLoop.add_callback	(	self,
		callback,
		args,
		kwargs
	)

Calls the given callback on the next I/O loop iteration.

It is safe to call this method from any thread at any time,
except from a signal handler.  Note that this is the **only**
method in `IOLoop` that makes this thread-safety 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.

To add a callback from a signal handler, see
`add_callback_from_signal`.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 493 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.add_callback_from_signal	(	self,
		callback,
		args,
		kwargs
	)

Calls the given callback on the next I/O loop iteration.

Safe for use from a Python signal handler; should not be used
otherwise.

Callbacks added with this method will be run without any
`.stack_context`, to avoid picking up the context of the function
that was interrupted by the signal.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 498 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.add_handler	(	self,
		fd,
		handler,
		events
	)

Registers the given handler to receive the given events for ``fd``.

The ``fd`` argument may either be an integer file descriptor or
a file-like object with a ``fileno()`` method (and optionally a
``close()`` method, which may be called when the `IOLoop` is shut
down).

The ``events`` argument is a bitwise or of the constants
``IOLoop.READ``, ``IOLoop.WRITE``, and ``IOLoop.ERROR``.

When an event occurs, ``handler(fd, events)`` will be run.

.. versionchanged:: 4.0
   Added the ability to pass file-like objects in addition to
   raw file descriptors.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 426 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.add_timeout	(	self,
		deadline,
		callback,
		args,
		kwargs
	)

Runs the ``callback`` at the time ``deadline`` from the I/O loop.

Returns an opaque handle that may be passed to
`remove_timeout` to cancel.

``deadline`` may be a number denoting a time (on the same
scale as `IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time.  Since Tornado 4.0, `call_later` is a more
convenient alternative for the relative case since it does not
require a timedelta object.

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.

Subclasses of IOLoop must implement either `add_timeout` or
`call_at`; the default implementations of each will call
the other.  `call_at` is usually easier to implement, but
subclasses that wish to maintain compatibility with Tornado
versions prior to 4.0 must use `add_timeout` instead.

.. versionchanged:: 4.0
   Now passes through ``*args`` and ``**kwargs`` to the callback.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 475 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.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`.

.. versionchanged:: 3.1
   If the `IOLoop` implementation supports non-integer objects
   for "file descriptors", those objects will have their
   ``close`` method when ``all_fds`` is true.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 417 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.initialize	(	self,
		reactor = `None`
	)

Definition at line 409 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.remove_handler	(	self,
		fd
	)

Stop listening for events on ``fd``.

.. versionchanged:: 4.0
   Added the ability to pass file-like objects in addition to
   raw file descriptors.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 457 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.remove_timeout	(	self,
		timeout
	)

Cancels a pending timeout.

The argument is a handle as returned by `add_timeout`.  It is
safe to call `remove_timeout` even if the callback has already
been run.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 489 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.start ( self )

Starts the I/O loop.

The loop will run until one of the callbacks calls `stop()`, which
will make the loop stop after the current event iteration completes.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 468 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.stop ( self )

Stop the I/O loop.

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.
Some work that was scheduled before the call to `stop` may still
be run before the `IOLoop` shuts down.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 472 of file twisted.py.

def tornado.platform.twisted.TwistedIOLoop.update_handler	(	self,
		fd,
		events
	)

Changes the events we listen for ``fd``.

.. versionchanged:: 4.0
   Added the ability to pass file-like objects in addition to
   raw file descriptors.

Reimplemented from tornado.ioloop.IOLoop.

Definition at line 438 of file twisted.py.

Member Data Documentation

tornado::platform::twisted.TwistedIOLoop::fds

Definition at line 409 of file twisted.py.

tornado::platform::twisted.TwistedIOLoop::reactor

Definition at line 409 of file twisted.py.

The documentation for this class was generated from the following file:

twisted.py

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation