README.md



Engine.IO: the realtime engine


Engine.IO is the implementation of transport-based
cross-browser/cross-device bi-directional communication layer for
Socket.IO.


How to use


Server


(A) Listening on a port

var engine = require('engine.io');
var server = engine.listen(80);

server.on('connection', function(socket){
  socket.send('utf 8 string');
  socket.send(new Buffer([0, 1, 2, 3, 4, 5])); // binary data
});


(B) Intercepting requests for a http.Server

var engine = require('engine.io');
var http = require('http').createServer().listen(3000);
var server = engine.attach(http);

server.on('connection', function (socket) {
  socket.on('message', function(data){ });
  socket.on('close', function(){ });
});


(C) Passing in requests

var engine = require('engine.io');
var server = new engine.Server();

server.on('connection', function(socket){
  socket.send('hi');
});

// …
httpServer.on('upgrade', function(req, socket, head){
  server.handleUpgrade(req, socket, head);
});
httpServer.on('request', function(req, res){
  server.handleRequest(req, res);
});


Client

<script src="/path/to/engine.io.js"></script>
<script>
  var socket = new eio.Socket('ws://localhost/');
  socket.on('open', function(){
    socket.on('message', function(data){});
    socket.on('close', function(){});
  });
</script>


For more information on the client refer to the
engine-client repository.


What features does it have?


Maximum reliability. Connections are established even in the presence of:


proxies and load balancers.
personal firewall and antivirus software.
for more information refer to Goals and Architecture sections


Minimal client size aided by:


lazy loading of flash transports.
lack of redundant transports.


Scalable


load balancer friendly


Future proof

100% Node.JS core style


No API sugar (left for higher level projects)
Written in readable vanilla JavaScript


API


Server


Top-level

These are exposed by require('engine.io'):


Events


flush


Called when a socket buffer is being flushed.

Arguments


Socket: socket being flushed

Array: write buffer


drain


Called when a socket buffer is drained

Arguments


Socket: socket being flushed


Properties


protocol (Number): protocol revision number

Server: Server class constructor

Socket: Socket class constructor

Transport (Function): transport constructor

transports (Object): map of available transports


Methods


()


Returns a new Server instance. If the first argument is an http.Server then the
new Server instance will be attached to it. Otherwise, the arguments are passed
directly to the Server constructor.

Parameters


http.Server: optional, server to attach to.

Object: optional, options object (see Server#constructor api docs below)


The following are identical ways to instantiate a server and then attach it.

  var httpServer; // previously created with `http.createServer();` from node.js api.

  // create a server first, and then attach
  var eioServer = require('engine.io').Server();
  eioServer.attach(httpServer);

  // or call the module as a function to get `Server`
  var eioServer = require('engine.io')();
  eioServer.attach(httpServer);

  // immediately attach
  var eioServer = require('engine.io')(httpServer);


listen


Creates an http.Server which listens on the given port and attaches WS
to it. It returns 501 Not Implemented for regular http requests.

Parameters


Number: port to listen on.

Object: optional, options object

Function: callback for listen.


Options


All options from Server.attach method, documented below.

Additionally See Server constructor below for options you can pass for creating the new Server


Returns Server


attach


Captures upgrade requests for a http.Server. In other words, makes
a regular http.Server WebSocket-compatible.

Parameters


http.Server: server to attach to.

Object: optional, options object


Options


All options from Server.attach method, documented below.

Additionally See Server constructor below for options you can pass for creating the new Server


Returns Server a new Server instance.


Server

The main server/manager. Inherits from EventEmitter.


Events


connection


Fired when a new connection is established.

Arguments


Socket: a Socket object


Properties

Important: if you plan to use Engine.IO in a scalable way, please
keep in mind the properties below will only reflect the clients connected
to a single process.


clients (Object): hash of connected clients by id.

clientsCount (Number): number of connected clients.


Methods


constructor


Initializes the server

Parameters


Object: optional, options object


Options


pingTimeout (Number): how many ms without a pong packet to
consider the connection closed (60000)

pingInterval (Number): how many ms before sending a new ping
packet (25000)

upgradeTimeout (Number): how many ms before an uncompleted transport upgrade is cancelled (10000)

maxHttpBufferSize (Number): how many bytes or characters a message
can be, before closing the session (to avoid DoS). Default
value is 10E7.

allowRequest (Function): A function that receives a given handshake
or upgrade request as its first parameter, and can decide whether to
continue or not. The second argument is a function that needs to be
called with the decided information: fn(err, success), where
success is a boolean value where false means that the request is
rejected, and err is an error code.

transports (<Array> String): transports to allow connections
to (['polling', 'websocket'])

allowUpgrades (Boolean): whether to allow transport upgrades
(true)

perMessageDeflate (Object|Boolean): parameters of the WebSocket permessage-deflate extension
(see ws module api docs). Set to false to disable. (true)

threshold (Number): data is compressed only if the byte size is above this value (1024)

httpCompression (Object|Boolean): parameters of the http compression for the polling transports
(see zlib api docs). Set to false to disable. (true)

threshold (Number): data is compressed only if the byte size is above this value (1024)

cookie (String|Boolean): name of the HTTP cookie that
contains the client sid to send as part of handshake response
headers. Set to false to not send one. (io)

cookiePath (String|Boolean): path of the above cookie
option. If false, no path will be sent, which means browsers will only send the cookie on the engine.io attached path (/engine.io).
Set false to not save io cookie on all requests. (/)

cookieHttpOnly (Boolean): If true HttpOnly io cookie cannot be accessed by client-side APIs, such as JavaScript. (true) This option has no effect if cookie or cookiePath is set to false.


wsEngine (String): what WebSocket server implementation to use. Specified module must conform to the ws interface (see ws module api docs). Default value is ws. An alternative c++ addon is also available by installing uws module.

initialPacket (Object): an optional packet which will be concatenated to the handshake packet emitted by Engine.IO.


close


Closes all clients

Returns Server for chaining


handleRequest


Called internally when a Engine request is intercepted.

Parameters


http.IncomingMessage: a node request object

http.ServerResponse: a node response object


Returns Server for chaining


handleUpgrade


Called internally when a Engine ws upgrade is intercepted.

Parameters (same as upgrade event)


http.IncomingMessage: a node request object

net.Stream: TCP socket for the request

Buffer: legacy tail bytes


Returns Server for chaining


attach


Attach this Server instance to an http.Server

Captures upgrade requests for a http.Server. In other words, makes
a regular http.Server WebSocket-compatible.

Parameters


http.Server: server to attach to.

Object: optional, options object


Options


path (String): name of the path to capture (/engine.io).

destroyUpgrade (Boolean): destroy unhandled upgrade requests (true)

destroyUpgradeTimeout (Number): milliseconds after which unhandled requests are ended (1000)

handlePreflightRequest (Boolean|Function): whether to let engine.io handle the OPTIONS requests. You can also pass a custom function to handle the requests (true)


generateId


Generate a socket id.
Overwrite this method to generate your custom socket id.

Parameters


http.IncomingMessage: a node request object


Returns A socket id for connected client.


Socket

A representation of a client. Inherits from EventEmitter.


Events


close


Fired when the client is disconnected.

Arguments


String: reason for closing

Object: description object (optional)


message


Fired when the client sends a message.

Arguments


String or Buffer: Unicode string or Buffer with binary contents


error


Fired when an error occurs.

Arguments


Error: error object


flush


Called when the write buffer is being flushed.

Arguments


Array: write buffer


drain


Called when the write buffer is drained


packet


Called when a socket received a packet (message, ping)

Arguments


type: packet type

data: packet data (if type is message)


packetCreate


Called before a socket sends a packet (message, pong)

Arguments


type: packet type

data: packet data (if type is message)


Properties


id (String): unique identifier

server (Server): engine parent reference

request (http.IncomingMessage): request that originated the Socket

upgraded (Boolean): whether the transport has been upgraded

readyState (String): opening|open|closing|closed

transport (Transport): transport reference


Methods


send:


Sends a message, performing message = toString(arguments[0]) unless
sending binary data, which is sent as is.

Parameters


String | Buffer | ArrayBuffer | ArrayBufferView: a string or any object implementing toString(), with outgoing data, or a Buffer or ArrayBuffer with binary data. Also any ArrayBufferView can be sent as is.

Object: optional, options object

Function: optional, a callback executed when the message gets flushed out by the transport


Options


compress (Boolean): whether to compress sending data. This option might be ignored and forced to be true when using polling. (true)


Returns Socket for chaining


close


Disconnects the client

Returns Socket for chaining


Client


Exposed in the eio global namespace (in the browser), or by
require('engine.io-client') (in Node.JS).

For the client API refer to the
engine-client repository.


Debug / logging

Engine.IO is powered by debug.
In order to see all the debug output, run your app with the environment variable
DEBUG including the desired scope.

To see the output from all of Engine.IO's debugging scopes you can use:

DEBUG=engine* node myapp


Transports


polling: XHR / JSONP polling transport.

websocket: WebSocket transport.


Plugins


engine.io-conflation: Makes conflation and aggregation of messages straightforward.


Support

The support channels for engine.io are the same as socket.io:


irc.freenode.net #socket.io

Google Groups
Website


Development

To contribute patches, run tests or benchmarks, make sure to clone the
repository:

git clone git://github.com/LearnBoost/engine.io.git


Then:

cd engine.io
npm install


Tests

Tests run with make test. It runs the server tests that are aided by
the usage of engine.io-client.

Make sure npm install is run first.


Goals

The main goal of Engine is ensuring the most reliable realtime communication.
Unlike the previous Socket.IO core, it always establishes a long-polling
connection first, then tries to upgrade to better transports that are "tested" on
the side.

During the lifetime of the Socket.IO projects, we've found countless drawbacks
to relying on HTML5 WebSocket or Flash Socket as the first connection
mechanisms.

Both are clearly the right way of establishing a bidirectional communication,
with HTML5 WebSocket being the way of the future. However, to answer most business
needs, alternative traditional HTTP 1.1 mechanisms are just as good as delivering
the same solution.

WebSocket based connections have two fundamental benefits:


Better server performance


A: Load balancers

Load balancing a long polling connection poses a serious architectural nightmare
since requests can come from any number of open sockets by the user agent, but
they all need to be routed to the process and computer that owns the Engine
connection. This negatively impacts RAM and CPU usage.

B: Network traffic

WebSocket is designed around the premise that each message frame has to be
surrounded by the least amount of data. In HTTP 1.1 transports, each message
frame is surrounded by HTTP headers and chunked encoding frames. If you try to
send the message "Hello world" with xhr-polling, the message ultimately
becomes larger than if you were to send it with WebSocket.

C: Lightweight parser

As an effect of B, the server has to do a lot more work to parse the network
data and figure out the message when traditional HTTP requests are used
(as in long polling). This means that another advantage of WebSocket is
less server CPU usage.


Better user experience

Due to the reasons stated in point 1, the most important effect of being able
to establish a WebSocket connection is raw data transfer speed, which translates
in some cases in better user experience.

Applications with heavy realtime interaction (such as games) will benefit greatly,
whereas applications like realtime chat (Gmail/Facebook), newsfeeds (Facebook) or
timelines (Twitter) will have negligible user experience improvements.


Having said this, attempting to establish a WebSocket connection directly so far has
proven problematic:


Proxies

Many corporate proxies block WebSocket traffic.
Personal firewall and antivirus software

As a result of our research, we've found that at least 3 personal security
applications block WebSocket traffic.
Cloud application platforms

Platforms like Heroku or No.de have had trouble keeping up with the fast-paced
nature of the evolution of the WebSocket protocol. Applications therefore end up
inevitably using long polling, but the seamless installation experience of
Socket.IO we strive for ("require() it and it just works") disappears.


Some of these problems have solutions. In the case of proxies and personal programs,
however, the solutions many times involve upgrading software. Experience has shown
that relying on client software upgrades to deliver a business solution is
fruitless: the very existence of this project has to do with a fragmented panorama
of user agent distribution, with clients connecting with latest versions of the most
modern user agents (Chrome, Firefox and Safari), but others with versions as low as
IE 5.5.

From the user perspective, an unsuccessful WebSocket connection can translate in
up to at least 10 seconds of waiting for the realtime application to begin
exchanging data. This perceptively hurts user experience.

To summarize, Engine focuses on reliability and user experience first, marginal
potential UX improvements and increased server performance second. Engine is the
result of all the lessons learned with WebSocket in the wild.


Architecture

The main premise of Engine, and the core of its existence, is the ability to
swap transports on the fly. A connection starts as xhr-polling, but it can
switch to WebSocket.

The central problem this poses is: how do we switch transports without losing
messages?

Engine only switches from polling to another transport in between polling
cycles. Since the server closes the connection after a certain timeout when
there's no activity, and the polling transport implementation buffers messages
in between connections, this ensures no message loss and optimal performance.

Another benefit of this design is that we workaround almost all the limitations
of Flash Socket, such as slow connection times, increased file size (we can
safely lazy load it without hurting user experience), etc.


FAQ


Can I use engine without Socket.IO ?

Absolutely. Although the recommended framework for building realtime applications
is Socket.IO, since it provides fundamental features for real-world applications
such as multiplexing, reconnection support, etc.

Engine is to Socket.IO what Connect is to Express. An essential piece for building
realtime frameworks, but something you probably won't be using for building
actual applications.


Does the server serve the client?

No. The main reason is that Engine is meant to be bundled with frameworks.
Socket.IO includes Engine, therefore serving two clients is not necessary. If
you use Socket.IO, including

<script src="/socket.io/socket.io.js">


has you covered.


Can I implement Engine in other languages?

Absolutely. The engine.io-protocol
repository contains the most up to date description of the specification
at all times, and the parser implementation in JavaScript.


License

(The MIT License)

Copyright (c) 2014 Guillermo Rauch <guillermo@learnboost.com>

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.