
engineio documentation
**********************

Index | Module Index | Search Page

This project implements an Engine.IO server that can run standalone or
integrated with a Python WSGI application. The following are some of
its features:

* Fully compatible with the Javascript engine.io-client library,
  versions 1.5.0 and up.

* Compatible with Python 2.7 and Python 3.3+.

* Supports large number of clients even on modest hardware when used
  with an asynchronous server based on eventlet or gevent. For
  development and testing, any WSGI compliant multi-threaded server
  can be used.

* Includes a WSGI middleware that integrates Engine.IO traffic with
  standard WSGI applications.

* Uses an event-based architecture implemented with decorators that
  hides the details of the protocol.

* Implements HTTP long-polling and WebSocket transports.

* Supports XHR2 and XHR browsers as clients.

* Supports text and binary messages.

* Supports gzip and deflate HTTP compression.

* Configurable CORS responses to avoid cross-origin problems with
  browsers.


What is Engine.IO?
==================

Engine.IO is a lightweight transport protocol that enables real-time
bidirectional event-based communication between clients (typically web
browsers) and a server. The official implementations of the client and
server components are written in JavaScript.

The protocol is extremely simple. The example that follows shows the
client-side Javascript code required to setup an Engine.IO connection
to a server:

   var socket = eio('http://chat.example.com');
   socket.on('open', function() { alert('connected'); });
   socket.on('message', function(data) { alert(data); });
   socket.on('close', function() { alert('disconnected'); });
   socket.send('Hello from the client!');


Getting Started
===============

The following application is a basic example that uses the Eventlet
asynchronous server and includes a small Flask application that serves
the HTML/Javascript to the client:

   import engineio
   import eventlet
   from flask import Flask, render_template

   eio = engineio.Server()
   app = Flask(__name__)

   @app.route('/')
   def index():
       """Serve the client-side application."""
       return render_template('index.html')

   @eio.on('connect')
   def connect(sid, environ):
       print("connect ", sid)

   @eio.on('message')
   def message(sid, data):
       print("message ", data)
       eio.send(sid, 'reply')

   @eio.on('disconnect')
   def disconnect(sid):
       print('disconnect ', sid)

   if __name__ == '__main__':
       # wrap Flask application with engineio's middleware
       app = engineio.Middleware(eio, app)

       # deploy as an eventlet WSGI server
       eventlet.wsgi.server(eventlet.listen(('', 8000)), app)

The client-side application must include the engine.io-client library
(version 1.5.0 or newer recommended).

Each time a client connects to the server the "connect" event handler
is invoked with the "sid" (session ID) assigned to the connection and
the WSGI environment dictionary. The server can inspect authentication
or other headers to decide if the client is allowed to connect. To
reject a client the handler must return "False".

When the client sends a message to the server the "message" event
handler is invoked with the "sid" and the message.

Finally, when the connection is broken, the "disconnect" event is
called, allowing the application to perform cleanup.

Because Engine.IO is a bidirectional protocol, the server can send
messages to any connected client at any time. The
"engineio.Server.send()" method takes the client's "sid" and the
message payload, which can be of type "str", "bytes", "list" or "dict"
(the last two are JSON encoded).


Deployment
==========

The following sections describe a variety of deployment strategies for
Engine.IO servers.


Eventlet
--------

Eventlet is a high performance concurrent networking library for
Python 2 and 3 that uses coroutines, enabling code to be written in
the same style used with the blocking standard library functions. An
Engine.IO server deployed with eventlet has access to the long-polling
and WebSocket transports.

Instances of class "engineio.Server" will automatically use eventlet
for asynchronous operations if the library is installed. To request
its use explicitly, the "async_mode" option can be given in the
constructor:

   eio = engineio.Server(async_mode='eventlet')

A server configured for eventlet is deployed as a regular WSGI
application, using the provided "engineio.Middleware":

   app = engineio.Middleware(eio)
   import eventlet
   eventlet.wsgi.server(eventlet.listen(('', 8000)), app)

An alternative to running the eventlet WSGI server as above is to use
gunicorn, a fully featured pure Python web server. The command to
launch the application under gunicorn is shown below:

   $ gunicorn -k eventlet -w 1 module:app

Due to limitations in its load balancing algorithm, gunicorn can only
be used with one worker process, so the "-w 1" option is required.
Note that a single eventlet worker can handle a large number of
concurrent clients.

Another limitation when using gunicorn is that the WebSocket transport
is not available, because this transport it requires extensions to the
WSGI standard.

Note: Eventlet provides a "monkey_patch()" function that replaces all
the blocking functions in the standard library with equivalent
asynchronous versions. While python-engineio does not require monkey
patching, other libraries such as database drivers are likely to
require it.


Gevent
------

Gevent is another asynchronous framework based on coroutines, very
similar to eventlet. An Engine.IO server deployed with gevent has
access to the long-polling transport. If project gevent-websocket is
installed, the WebSocket transport is also available.

Instances of class "engineio.Server" will automatically use gevent for
asynchronous operations if the library is installed and eventlet is
not installed. To request gevent to be selected explicitly, the
"async_mode" option can be given in the constructor:

   eio = engineio.Server(async_mode='gevent')

A server configured for gevent is deployed as a regular WSGI
application, using the provided "engineio.Middleware":

   from gevent import pywsgi
   app = engineio.Middleware(eio)
   pywsgi.WSGIServer(('', 8000), app).serve_forever()

If the WebSocket transport is installed, then the server must be
started as follows:

   from gevent import pywsgi
   from geventwebsocket.handler import WebSocketHandler
   app = engineio.Middleware(eio)
   pywsgi.WSGIServer(('', 8000), app,
                     handler_class=WebSocketHandler).serve_forever()

An alternative to running the gevent WSGI server as above is to use
gunicorn, a fully featured pure Python web server. The command to
launch the application under gunicorn is shown below:

   $ gunicorn -k gevent -w 1 module:app

Or to include WebSocket:

   $ gunicorn -k geventwebsocket.gunicorn.workers.GeventWebSocketWorker -w 1 module: app

Same as with eventlet, due to limitations in its load balancing
algorithm, gunicorn can only be used with one worker process, so the
"-w 1" option is required. Note that a single gevent worker can handle
a large number of concurrent clients.

Note: Gevent provides a "monkey_patch()" function that replaces all
the blocking functions in the standard library with equivalent
asynchronous versions. While python-engineio does not require monkey
patching, other libraries such as database drivers are likely to
require it.


Standard Threading Library
--------------------------

While not comparable to eventlet and gevent in terms of performance,
the Engine.IO server can also be configured to work with multi-
threaded web servers that use standard Python threads. This is an
ideal setup to use with development servers such as Werkzeug. Only the
long-polling transport is currently available when using standard
threads.

Instances of class "engineio.Server" will automatically use the
threading mode if neither eventlet nor gevent are not installed. To
request the threading mode explicitly, the "async_mode" option can be
given in the constructor:

   eio = engineio.Server(async_mode='threading')

A server configured for threading is deployed as a regular web
application, using any WSGI complaint multi-threaded server. The
example below deploys an Engine.IO application combined with a Flask
web application, using Flask's development web server based on
Werkzeug:

   eio = engineio.Server(async_mode='threading')
   app = Flask(__name__)
   app.wsgi_app = engineio.Middleware(eio, app.wsgi_app)

   # ... Engine.IO and Flask handler functions ...

   if __name__ == '__main__':
       app.run(threaded=True)

When using the threading mode, it is important to ensure that the WSGI
server can handle multiple concurrent requests using threads, since a
client can have up to two outstanding requests at any given time. The
Werkzeug server is single-threaded by default, so the "threaded=True"
option is required.

Note that servers that use worker processes instead of threads, such
as gunicorn, do not support an Engine.IO server configured in
threading mode.


Multi-process deployments
-------------------------

Engine.IO is a stateful protocol, which makes horizontal scaling more
difficult. To deploy a cluster of Engine.IO processes (hosted on one
or multiple servers), the following conditions must be met:

* Each Engine.IO process must be able to handle multiple requests,
  either by using eventlet, gevent, or standard threads. Worker
  processes that only handle one request at a time are not supported.

* The load balancer must be configured to always forward requests
  from a client to the same process. Load balancers call this *sticky
  sessions*, or *session affinity*.


API Reference
=============

class engineio.Middleware(engineio_app, wsgi_app=None, engineio_path='engine.io')

   WSGI middleware for Engine.IO.

   This middleware dispatches traffic to an Engine.IO application, and
   optionally forwards regular HTTP traffic to a WSGI application.

   Parameters:
      * **engineio_app** -- The Engine.IO server.

      * **wsgi_app** -- The WSGI app that receives all other
        traffic.

      * **engineio_path** -- The endpoint where the Engine.IO
        application should be installed. The default value is
        appropriate for most cases.

   Example usage:

      import engineio
      import eventlet
      from . import wsgi_app

      eio = engineio.Server()
      app = engineio.Middleware(eio, wsgi_app)
      eventlet.wsgi.server(eventlet.listen(('', 8000)), app)

class engineio.Server(async_mode=None, ping_timeout=60, ping_interval=25, max_http_buffer_size=100000000, allow_upgrades=True, http_compression=True, compression_threshold=1024, cookie='io', cors_allowed_origins=None, cors_credentials=True, logger=False, json=None, **kwargs)

   An Engine.IO server.

   This class implements a fully compliant Engine.IO web server with
   support for websocket and long-polling transports.

   Parameters:
      * **async_mode** -- The library used for asynchronous
        operations. Valid options are "threading", "eventlet" and
        "gevent". If this argument is not given, "eventlet" is tried
        first, then "gevent", and finally "threading". The websocket
        transport is only supported in "eventlet" mode.

      * **ping_timeout** -- The time in seconds that the client
        waits for the server to respond before disconnecting.

      * **ping_interval** -- The interval in seconds at which the
        client pings the server.

      * **max_http_buffer_size** -- The maximum size of a message
        when using the polling transport.

      * **allow_upgrades** -- Whether to allow transport upgrades or
        not.

      * **http_compression** -- Whether to compress packages when
        using the polling transport.

      * **compression_threshold** -- Only compress messages when
        their byte size is greater than this value.

      * **cookie** -- Name of the HTTP cookie that contains the
        client session id. If set to "None", a cookie is not sent to
        the client.

      * **cors_allowed_origins** -- List of origins that are allowed
        to connect to this server. All origins are allowed by default.

      * **cors_credentials** -- Whether credentials (cookies,
        authentication) are allowed in requests to this server.

      * **logger** -- To enable logging set to "True" or pass a
        logger object to use. To disable logging set to "False".

      * **json** -- An alternative json module to use for encoding
        and decoding packets. Custom json modules must have "dumps"
        and "loads" functions that are compatible with the standard
        library versions.

      * **kwargs** -- Reserved for future extensions, any additional
        parameters given as keyword arguments will be silently
        ignored.

   disconnect(sid=None)

      Disconnect a client.

      Parameters:
         **sid** -- The session id of the client to close. If this
         parameter is not given, then all clients are closed.

   handle_request(environ, start_response)

      Handle an HTTP request from the client.

      This is the entry point of the Engine.IO application, using the
      same interface as a WSGI application. For the typical usage,
      this function is invoked by the "Middleware" instance, but it
      can be invoked directly when the middleware is not used.

      Parameters:
         * **environ** -- The WSGI environment.

         * **start_response** -- The WSGI "start_response" function.

      This function returns the HTTP response body to deliver to the
      client as a byte sequence.

   on(event, handler=None)

      Register an event handler.

      Parameters:
         * **event** -- The event name. Can be "'connect'",
           "'message'" or "'disconnect'".

         * **handler** -- The function that should be invoked to
           handle the event. When this parameter is not given, the
           method acts as a decorator for the handler function.

      Example usage:

         # as a decorator:
         @eio.on('connect')
         def connect_handler(sid, environ):
             print('Connection request')
             if environ['REMOTE_ADDR'] in blacklisted:
                 return False  # reject

         # as a method:
         def message_handler(sid, msg):
             print('Received message: ', msg)
             eio.send(sid, 'response')
         eio.on('message', message_handler)

      The handler function receives the "sid" (session ID) for the
      client as first argument. The "'connect'" event handler receives
      the WSGI environment as a second argument, and can return
      "False" to reject the connection. The "'message'" handler
      receives the message payload as a second argument. The
      "'disconnect'" handler does not take a second argument.

   send(sid, data, binary=None)

      Send a message to a client.

      Parameters:
         * **sid** -- The session id of the recipient client.

         * **data** -- The data to send to the client. Data can be
           of type "str", "bytes", "list" or "dict". If a "list" or
           "dict", the data will be serialized as JSON.

         * **binary** -- "True" to send packet as binary, "False" to
           send as text. If not given, unicode (Python 2) and str
           (Python 3) are sent as text, and str (Python 2) and bytes
           (Python 3) are sent as binary.

   start_background_task(target, *args, **kwargs)

      Start a background task using the appropriate async model.

      This is a utility function that applications can use to start a
      background task using the method that is compatible with the
      selected async mode.

      Parameters:
         * **target** -- the target function to execute.

         * **args** -- arguments to pass to the function.

         * **kwargs** -- keyword arguments to pass to the function.

      This function returns an object compatible with the *Thread*
      class in the Python standard library. The *start()* method on
      this object is already called by this function.

   transport(sid)

      Return the name of the transport used by the client.

      The two possible values returned by this function are
      "'polling'" and "'websocket'".

      Parameters:
         **sid** -- The session of the client.
