sockjs

npm install sockjs

var http = require('http');
var sockjs = require('sockjs');

var echo = sockjs.createServer();
echo.on('connection', function(conn) {
    conn.on('data', function(message) {
        conn.write(message);
    });
    conn.on('close', function() {});
});

var server = http.createServer();
echo.installHandlers(server, {prefix:'/echo'});
server.listen(9999, '0.0.0.0');

SockJS-node API

Server class

var sockjs_server = sockjs.createServer(options);

sockjsurl (string)

Transports which don't support cross-domain communication natively

('eventsource' to name one) use an iframe trick. A simple page is
served from the SockJS server (using its foreign domain) and is
placed in an invisible iframe. Code run from this iframe doesn't
need to worry about cross-domain issues, as it's being run from
domain local to the SockJS server. This iframe also does need to
load SockJS javascript client library, and this option lets you specify
its url (if you're unsure, point it to
<a href="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js">
the latest minified SockJS client release</a>, this is the default).
You must explicitly specify this url on the server side for security
reasons - we don't want the possibility of running any foreign
javascript within the SockJS domain (aka cross site scripting attack).
Also, sockjs javascript library is probably already cached by the
browser - it makes sense to reuse the sockjs url you're using in
normally.</dd>

prefix (string regex)

A url prefix for the server. All http requests which paths begins

with selected prefix will be handled by SockJS. All other requests
will be passed through, to previously registered handlers.</dd>

responselimit (integer)

Most streaming transports save responses on the client side and

don't free memory used by delivered messages. Such transports need
to be garbage-collected once in a while. `response_limit` sets
a minimum number of bytes that can be send over a single http streaming
request before it will be closed. After that client needs to open
new request. Setting this value to one effectively disables
streaming and will make streaming transports to behave like polling
transports. The default value is 128K.</dd>

websocket (boolean)

Some load balancers don't support websockets. This option can be used

to disable websockets support by the server. By default websockets are
enabled.</dd>

jsessionid (boolean or function)

Some hosting providers enable sticky sessions only to requests that have JSESSIONID cookie set. This setting controls if the server should set this cookie to a dummy value. By default setting JSESSIONID cookie is disabled. More sophisticated behaviour can be achieved by supplying a function.

log (function(severity, message))

It's quite useful, especially for debugging, to see some messages printed by a SockJS-node library. This is done using this log function, which is by default set to console.log. If this behaviour annoys you for some reason, override log setting with a custom handler. The following severities are used: debug (miscellaneous logs), info (requests logs), error (serious errors, consider filing an issue).

heartbeatdelay (milliseconds)

In order to keep proxies and load balancers from closing long running http requests we need to pretend that the connection is active and send a heartbeat packet once in a while. This setting controls how often this is done. By default a heartbeat packet is sent every 25 seconds.

disconnectdelay (milliseconds)

The server sends a close event when a client receiving connection have not been seen for a while. This delay is configured by this setting. By default the close event will be emitted when a receiving connection wasn't seen for 5 seconds.

disablecors (boolean)

Enabling this option will prevent CORS headers from being included in the HTTP response. Can be used when the sockjs client is known to be connecting from the same origin as the sockjs server.

Server instance

var http_server = http.createServer();
sockjs_server.installHandlers(http_server, options);
http_server.listen(...);

Event: connection (connection)

A new connection has been successfully opened.

Connection instance

Property: readable (boolean)

Is the stream readable?

Property: writable (boolean)

Is the stream writable?

Property: remoteAddress (string)

Last known IP address of the client.

Property: remotePort (number)

Last known port number of the client.

Property: address (object)

Hash with 'address' and 'port' fields.

Property: headers (object)

Hash containing various headers copied from last receiving request

on that connection. Exposed headers include: `origin`, `referer`
and `x-forwarded-for` (and friends). We explicitly do not grant
access to `cookie` header, as using it may easily lead to security
issues (for details read the section "Authorisation").</dd>

Property: url (string)

Url

property copied from last request.</dd>

Property: pathname (string)

pathname from parsed url, for convenience.

Property: prefix (string)

Prefix of the url on which the request was handled.

Property: protocol (string)

Protocol used by the connection. Keep in mind that some protocols

are indistinguishable - for example "xhr-polling" and "xdr-polling".</dd>

Property: readyState (integer)

Current state of the connection:

0-connecting, 1-open, 2-closing, 3-closed.</dd>

write(message)

Sends a message over opened connection. A message must be a non-empty string. It's illegal to send a message after the connection was closed (either after 'close' or 'end' method or 'close' event).

close(code, reason)

Asks the remote client to disconnect. 'code' and 'reason'

parameters are optional and can be used to share the reason of
disconnection.</dd>

end()

Asks the remote client to disconnect with default 'code' and

'reason' values.</dd>

Event: data (message)

A message arrived on the connection. Message is a unicode string.

Event: close ()

Connection was closed. This event is triggered exactly once for

every connection.</dd>

sockjs_server.on('connection', function(conn) {
    console.log('connection' + conn);
    conn.on('close', function() {
        console.log('close ' + conn);
    });
    conn.on('data', function(message) {
        console.log('message ' + conn,
                    message);
    });
});

Footnote

Examples

directory, which contains a full example of a echo server.

Connecting to SockJS-node without the client

Sticky sessions

`/resource/<server_number>/<session_id>/transport`.  This is
useful for load balancers that support prefix-based affinity
(HAProxy does).

balancers turn on sticky sessions if that cookie is set. This
technique is derived from Java applications, where sticky sessions
are often necessary. HAProxy does support this method, as well as
some hosting providers, for example CloudFoundry.  In order to
enable this method on the client side, please supply a
`cookie:true` option to SockJS constructor.

Development and testing

cd sockjs-node
npm install
npm install --dev
ln -s .. node_modules/sockjs

make build

make test_server

SockJS-protocol Python tests

cd sockjs-protocol
make test_deps
./venv/bin/python sockjs-protocol.py

SockJS-client QUnit tests

cd sockjs-client
make test

Various issues and design considerations

Authorisation

• an iframe hosted from target SockJS domain. That means the server

Deploying SockJS on Heroku