A utility class to write to and read from a non-blocking socket.

IOstream wraps the socket and uses a register callback to make it non-blocking. Register the individual event callbacks through the interface

  • _read_callback
  • _write_callback
  • _close_callback
  • _connect_callback

When a socket event occurs in iOLoop, the iostream._handle_events method is called to distribute the event. The callback function is called in iostream._handle_events if the registered callback condition is met during the corresponding event processing



    • contents
    • example
    • head
    • IOStream.__init__
    • IOStream.connect
    • IOStream.read_until
    • IOStream.read_bytes
    • IOStream.write
    • IOStream.close
    • IOStream._handle_events
    • IOStream._run_callback
    • IOStream._run_callback
    • IOStream._read_from_socket
    • IOStream._read_to_buffer
    • IOStream._read_from_buffer
    • IOStream._handle_connect
    • IOStream._handle_write
    • IOStream._consume
    • IOStream._add_io_state
    • IOStream._read_buffer_size
    • copyright


As you can see from a simple example of an IOStream client, IOStream is an asynchronous callback chain

  1. Create a socket
  2. Create an IOStream object
  3. Connect to the host and pass in the callback function send_request if the connection is successful
  4. Socket output data request page, read HEAD, pass read HEAD successful callback function on_headers
  5. Continue reading the body and pass in the on_body callback function if the body is successfully read
  6. Close the stream, close ioloop
from tornado import ioloop from tornado import iostream import socket def send_request(): Stream. Write (" GET/HTTP / 1.0 \ r \ nHost:\r\n\r\n") stream.read_until("\r\n\r\n", on_headers) def on_headers(data): headers = {} for line in data.split("\r\n"): parts = line.split(":") if len(parts) == 2: headers[parts[0].strip()] = parts[1].strip() stream.read_bytes(int(headers["Content-Length"]), on_body) def on_body(data): print data stream.close() ioloop.IOLoop.instance().stop() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) stream = iostream.IOStream(s) stream.connect(("", 80), send_request) ioloop.IOLoop.instance().start() # html> # <meta http-equiv="refresh" content="0; url="> # </html>


from __future__ import with_statement import collections import errno import logging import socket import sys from Tornado import ioloop from Tornado import stack_context try: import SSL # Python 2.6+ except ImporError: SSL = None


Self packing socket class key statements. Io_loop. Add_handler (self. Socket. Fileno (), the self. _handle_events, Self._state) adds its own _handle_events to the global IOLoop poll event callback. Only events of type Error are registered at this time

_read_buffer: read buffer

class IOStream(object):

    def __init__(self, socket, io_loop=None, max_buffer_size=104857600,
        self.socket = socket
        self.io_loop = io_loop or ioloop.IOLoop.instance()
        self.max_buffer_size = max_buffer_size
        self.read_chunk_size = read_chunk_size
        self._read_buffer = collections.deque()
        self._write_buffer = collections.deque()
        self._write_buffer_frozen = False
        self._read_delimiter = None
        self._read_bytes = None
        self._read_callback = None
        self._write_callback = None
        self._close_callback = None
        self._connect_callback = None
        self._connecting = False
        self._state = self.io_loop.ERROR
        with stack_context.NullContext():
                self.socket.fileno(), self._handle_events, self._state)


Connect the socket to a remote address in non-blocking mode

  1. The connection socket
  2. Register the connection completion callback
  3. Poll increases the socket write event
    def connect(self, address, callback=None):
        """Connects the socket to a remote address without blocking.

        May only be called if the socket passed to the constructor was
        not previously connected.  The address parameter is in the
        same format as for socket.connect, i.e. a (host, port) tuple.
        If callback is specified, it will be called when the
        connection is completed.

        Note that it is safe to call IOStream.write while the
        connection is pending, in which case the data will be written
        as soon as the connection is ready.  Calling IOStream read
        methods before the socket is connected works on some platforms
        but is non-portable.
        self._connecting = True
        except socket.error, e:
            # In non-blocking mode connect() always raises an exception
            if e.args[0] not in (errno.EINPROGRESS, errno.EWOULDBLOCK):
        self._connect_callback = stack_context.wrap(callback)


  1. Register the read completion callback
  2. Try to read from the buffer
  3. Read the buffer from the socket
  4. Repeat 2,3, exit if no data
  5. Add the socket read event to the poll

If the data in the cache meets the criteria, the callback is executed and returned directly. Otherwise, the next time a read event occurs and _handle_events processes the read event, the callback function is detected and called

    def read_until(self, delimiter, callback):
        """Call callback when we read the given delimiter."""
        assert not self._read_callback, "Already reading"
        self._read_delimiter = delimiter
        self._read_callback = stack_context.wrap(callback)
        while True:
            # See if we've already got the data from a previous read
            if self._read_from_buffer():
            if self._read_to_buffer() == 0:


Refer to read_until to read qualified bytes

    def read_bytes(self, num_bytes, callback):
        """Call callback when we read the given number of bytes."""
        assert not self._read_callback, "Already reading"
        if num_bytes == 0:
        self._read_bytes = num_bytes
        self._read_callback = stack_context.wrap(callback)
        while True:
            if self._read_from_buffer():
            if self._read_to_buffer() == 0:


    def write(self, data, callback=None):
        """Write the given data to this stream.

        If callback is given, we call it when all of the buffered write
        data has been successfully written to the stream. If there was
        previously buffered write data and an old write callback, that
        callback is simply overwritten with this new callback.
        self._write_callback = stack_context.wrap(callback)

    def set_close_callback(self, callback):
        """Call the given callback when the stream is closed."""
        self._close_callback = stack_context.wrap(callback)


  1. Removes socket events from iOLoop
  2. Close the socket
  3. Call the close callback
    def close(self):
        """Close this stream."""
        if self.socket is not None:
            self.socket = None
            if self._close_callback:

    def reading(self):
        """Returns true if we are currently reading from the stream."""
        return self._read_callback is not None

    def writing(self):
        """Returns true if we are currently writing to the stream."""
        return bool(self._write_buffer)

    def closed(self):
        return self.socket is None


Core callback Any type of socket event triggers Ioloop callback _handle_events, which is then distributed at _handle_events. Note that IOStream does not handle read events for connection requests. The default proxy is a socket that has already established a connection

Iostream (connection, io_loop=self.io_loop) : httpserver.handle_events: httpserver.handle_events: httpserver.handle_events: httpserver.handle_events

As a client, you need to call iostream.connect manually, and when the connection is successful, the success callback is handled in the write event

This is an awkward implementation

def _handle_events(self, fd, events): if not self.socket: Warning ("Got events for closed stream %d", fd) return try: # if events & self.io_loop.READ: Self._handle_read() if not self. Socket: return # if events & self.io_loop. Write: if self._connecting: self._handle_connect() self._handle_write() if not self.socket: Return # ERROR, close socket if events & self.io_loop.ERROR: 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


Implement the callback

def _run_callback(self, callback, *args, **kwargs): try: # Use a NullContext to ensure that all StackContexts are run # inside our blanket exception handler rather than outside.  with stack_context.NullContext(): callback(*args, **kwargs) except: logging.error("Uncaught exception, closing connection.", exc_info=True) # Close the socket on an uncaught exception from a user callback # (It would eventually get closed when the socket object is # gc'd, but we don't want to rely on gc happening before we # run out of file descriptors) self.close() # Re-raise the exception  so that IOLoop.handle_callback_exception # can see it and log the error raise


Read the callback

  1. Reads data from the socket into the cache
  2. No data,socket closed
  3. Check if read_until read_bytes is satisfied
  4. If it is, the corresponding callback is executed
    def _handle_read(self):
        while True:
                # Read from the socket until we get EWOULDBLOCK or equivalent.
                # SSL sockets do some internal buffering, and if the data is
                # sitting in the SSL object's buffer select() and friends
                # can't see it; the only way to find out if it's there is to
                # try to read it.
                result = self._read_to_buffer()
            except Exception:
            if result == 0:
                if self._read_from_buffer():


Read data from the socket

    def _read_from_socket(self):
        """Attempts to read from the socket.

        Returns the data read or None if there is nothing to read.
        May be overridden in subclasses.
            chunk = self.socket.recv(self.read_chunk_size)
        except socket.error, e:
            if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):
                return None
        if not chunk:
            return None
        return chunk


Reads data from the socket into the cache

def _read_to_buffer(self): """Reads from the socket and appends the result to the read buffer. Returns the number of bytes read. Returns 0 if there  is nothing to read (i.e. the read returns EWOULDBLOCK or equivalent). On error closes the socket and raises an exception. """ try: chunk = self._read_from_socket() except socket.error, e: # ssl.SSLError is a subclass of socket.error logging.warning("Read error on %d: %s", self.socket.fileno(), e) self.close() raise if chunk is None: return 0 self._read_buffer.append(chunk) if self._read_buffer_size() >= self.max_buffer_size: logging.error("Reached maximum read buffer size") self.close() raise IOError("Reached maximum read buffer size") return len(chunk)


Filter data from the buffer to check if the end condition (read_until/read_bytes) is met. If so, the previously registered callbacks are called in query mode

def _read_from_buffer(self): """Attempts to complete the currently-pending read from the buffer. Returns True if the read was completed. """ if self._read_bytes: if self._read_buffer_size() >= self._read_bytes: num_bytes = self._read_bytes callback = self._read_callback self._read_callback = None self._read_bytes = None self._run_callback(callback, self._consume(num_bytes)) return True elif self._read_delimiter: _merge_prefix(self._read_buffer, sys.maxint) loc = self._read_buffer[0].find(self._read_delimiter) if loc ! = 1: callback = self._read_callback delimiter_len = len(self._read_delimiter) self._read_callback = None self._read_delimiter  = None self._run_callback(callback, self._consume(loc + delimiter_len)) return True return False


Invokes the connection to establish a callback and clears the flag in the connection

    def _handle_connect(self):
        if self._connect_callback is not None:
            callback = self._connect_callback
            self._connect_callback = None
        self._connecting = False


Write the event

  1. Retrieves scoped data from the buffer
  2. Call socket.send to output data
  3. If the data is sent to me and the callback is registered, the call sends the completion callback
def _handle_write(self): while self._write_buffer: try: if not self._write_buffer_frozen: # On windows, socket.send blows up if given a # write buffer that's too large, instead of just # returning the number of bytes it was able to # process. Therefore we must not call socket.send # with more than 128KB at a time. _merge_prefix(self._write_buffer, 128 * 1024) num_bytes = self.socket.send(self._write_buffer[0]) self._write_buffer_frozen = False _merge_prefix(self._write_buffer, num_bytes) self._write_buffer.popleft() except socket.error, e: if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN): # With OpenSSL, after send returns EWOULDBLOCK, # the very same string object must be used on the # next call to send. Therefore we suppress # merging the write buffer after an EWOULDBLOCK. # A cleaner solution would be to set # SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER, but this is # not yet accessible from python # ( self._write_buffer_frozen = True break  else: logging.warning("Write error on %d: %s", self.socket.fileno(), e) self.close() return if not self._write_buffer and self._write_callback: callback = self._write_callback self._write_callback = None self._run_callback(callback)


Consume loc length data from the read cache

    def _consume(self, loc):
        _merge_prefix(self._read_buffer, loc)
        return self._read_buffer.popleft()

    def _check_closed(self):
        if not self.socket:
            raise IOError("Stream is closed")


Increases the socket event state

    def _add_io_state(self, state):
        if self.socket is None:
            # connection has been closed, so there can be no future events
        if not self._state & state:
            self._state = self._state | state
            self.io_loop.update_handler(self.socket.fileno(), self._state)


Gets the length of the existing data in the read cache

    def _read_buffer_size(self):
        return sum(len(chunk) for chunk in self._read_buffer)

class SSLIOStream(IOStream):
    """A utility class to write to and read from a non-blocking socket.

    If the socket passed to the constructor is already connected,
    it should be wrapped with
        ssl.wrap_socket(sock, do_handshake_on_connect=False, **kwargs)
    before constructing the SSLIOStream.  Unconnected sockets will be
    wrapped when IOStream.connect is finished.
    def __init__(self, *args, **kwargs):
        """Creates an SSLIOStream.

        If a dictionary is provided as keyword argument ssl_options,
        it will be used as additional keyword arguments to ssl.wrap_socket.
        self._ssl_options = kwargs.pop('ssl_options', {})
        super(SSLIOStream, self).__init__(*args, **kwargs)
        self._ssl_accepting = True
        self._handshake_reading = False
        self._handshake_writing = False

    def reading(self):
        return self._handshake_reading or super(SSLIOStream, self).reading()

    def writing(self):
        return self._handshake_writing or super(SSLIOStream, self).writing()

    def _do_ssl_handshake(self):
        # Based on code from in the python stdlib
            self._handshake_reading = False
            self._handshake_writing = False
        except ssl.SSLError, err:
            if err.args[0] == ssl.SSL_ERROR_WANT_READ:
                self._handshake_reading = True
            elif err.args[0] == ssl.SSL_ERROR_WANT_WRITE:
                self._handshake_writing = True
            elif err.args[0] in (ssl.SSL_ERROR_EOF,
                return self.close()
            elif err.args[0] == ssl.SSL_ERROR_SSL:
                logging.warning("SSL Error on %d: %s", self.socket.fileno(), err)
                return self.close()
        except socket.error, err:
            if err.args[0] == errno.ECONNABORTED:
                return self.close()
            self._ssl_accepting = False
            super(SSLIOStream, self)._handle_connect()

    def _handle_read(self):
        if self._ssl_accepting:
        super(SSLIOStream, self)._handle_read()

    def _handle_write(self):
        if self._ssl_accepting:
        super(SSLIOStream, self)._handle_write()

    def _handle_connect(self):
        self.socket = ssl.wrap_socket(self.socket,
        # Don't call the superclass's _handle_connect (which is responsible
        # for telling the application that the connection is complete)
        # until we've completed the SSL handshake (so certificates are
        # available, etc).

    def _read_from_socket(self):
            # SSLSocket objects have both a read() and recv() method,
            # while regular sockets only have recv().
            # The recv() method blocks (at least in python 2.6) if it is
            # called when there is nothing to read, so we have to use
            # read() instead.
            chunk =
        except ssl.SSLError, e:
            # SSLError is a subclass of socket.error, so this except
            # block must come first.
            if e.args[0] == ssl.SSL_ERROR_WANT_READ:
                return None
        except socket.error, e:
            if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):
                return None
        if not chunk:
            return None
        return chunk

def _merge_prefix(deque, size):
    """Replace the first entries in a deque of strings with a single
    string of up to size bytes.

    >>> d = collections.deque(['abc', 'de', 'fghi', 'j'])
    >>> _merge_prefix(d, 5); print d
    deque(['abcde', 'fghi', 'j'])

    Strings will be split as necessary to reach the desired size.
    >>> _merge_prefix(d, 7); print d
    deque(['abcdefg', 'hi', 'j'])

    >>> _merge_prefix(d, 3); print d
    deque(['abc', 'defg', 'hi', 'j'])

    >>> _merge_prefix(d, 100); print d
    prefix = []
    remaining = size
    while deque and remaining > 0:
        chunk = deque.popleft()
        if len(chunk) > remaining:
            chunk = chunk[:remaining]
        remaining -= len(chunk)

def doctests():
    import doctest
    return doctest.DocTestSuite()


Creative Commons Attribute – Non-Commercial 4.0 International License Agreement