SockJS family:
Work in progress:
SockJS is a JavaScript library (for browsers) that provides a WebSocket-like
object. SockJS gives you a coherent, cross-browser, Javascript API
which creates a low latency, full duplex, cross-domain communication
channel between the browser and the web server, with WebSockets or without.
This necessitates the use of a server, which this is one version of, for Node.js.
SockJS-node is a Node.js server side counterpart of
SockJS-client browser library
written in CoffeeScript.
To install sockjs-node run:
npm install sockjs
A simplified echo SockJS server could look more or less like:
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');
(Take look at
examples
directory for a complete version.)
Subscribe to
SockJS mailing list for
discussions and support.
The API design is based on common Node APIs like the
Streams API or the
Http.Server API.
SockJS module is generating a Server class, similar to
Node.js http.createServer
module.
var sockjs_server = sockjs.createServer(options);
Where options is a hash which can contain:
Once you have create Server instance you can hook it to the
http.Server instance.
var http_server = http.createServer();
sockjs_server.installHandlers(http_server, options);
http_server.listen(...);
Where options can overshadow options given when creating Server
instance.
Server instance is an
EventEmitter,
and emits following event:
All http requests that don't go under the path selected by prefix
will remain unanswered and will be passed to previously registered
handlers. You must install your custom http handlers before callinginstallHandlers.
A Connection instance supports
Node Stream API and
has following methods and properties:
A Connection instance emits the following events:
For example:
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);
});
});
A fully working echo server does need a bit more boilerplate (to
handle requests unanswered by SockJS), see theecho example
for a complete code.
If you want to see samples of running code, take a look at:
Although the main point of SockJS it to enable browser-to-server
connectivity, it is possible to connect to SockJS from an external
application. Any SockJS server complying with 0.3 protocol does
support a raw WebSocket url. The raw WebSocket url for the test server
looks like:
You can connect any WebSocket RFC 6455 compliant WebSocket client to
this url. This can be a command line client, external application,
third party code or even a browser (though I don't know why you would
want to do so).
Note: This endpoint will not send any heartbeat packets.
There are two issues that need to be considered when planning a
non-trivial SockJS-node deployment: WebSocket-compatible load balancer
and sticky sessions (aka session affinity).
Often WebSockets don't play nicely with proxies and load balancers.
Deploying a SockJS server behind Nginx or Apache could be painful.
Fortunately recent versions of an excellent load balancer
HAProxy are able to proxy WebSocket
connections. We propose to put HAProxy as a front line load balancer
and use it to split SockJS traffic from normal HTTP data. Take a look
at the sample
SockJS HAProxy configuration.
The config also shows how to use HAproxy balancing to split traffic
between multiple Node.js servers. You can also do balancing using dns
names.
If you plan deploying more than one SockJS server, you must make sure
that all HTTP requests for a single session will hit the same server.
SockJS has two mechanisms that can be useful to achieve that:
/resource/<server_number>/<session_id>/transport. This isJSESSIONID cookie is being set by SockJS-node. Many loadcookie:true option to SockJS constructor.If you want to work on SockJS-node source code, you need to clone the
git repo and follow these steps. First you need to install
dependencies:
cd sockjs-node
npm install
npm install --dev
ln -s .. node_modules/sockjs
You're ready to compile CoffeeScript:
make build
If compilation succeeds you may want to test if your changes pass all
the tests. Currently, there are two separate test suites. For both of
them you need to start a SockJS-node test server (by default listening
on port 8081):
make test_server
To run it run something like:
cd sockjs-protocol
make test_deps
./venv/bin/python sockjs-protocol.py
For details see
SockJS-protocol README.
You need to start a second web server (by default listening on 8080)
that is serving various static html and javascript files:
cd sockjs-client
make test
At that point you should have two web servers running: sockjs-node on
8081 and sockjs-client on 8080. When you open the browser on
http://localhost:8080/ you should be able
run the QUnit tests against your sockjs-node server.
For details see
SockJS-client README.
Additionally, if you're doing more serious development consider usingmake serve, which will automatically the server when you modify the
source code.
SockJS-node does not expose cookies to the application. This is done
deliberately as using cookie-based authorisation with SockJS simply
doesn't make sense and will lead to security issues.
Cookies are a contract between a browser and an http server, and are
identified by a domain name. If a browser has a cookie set for
particular domain, it will pass it as a part of all http requests to
the host. But to get various transports working, SockJS uses a middleman
- an iframe hosted from target SockJS domain. That means the server
will receive requests from the iframe, and not from the real
domain. The domain of an iframe is the same as the SockJS domain. The
problem is that any website can embed the iframe and communicate with
it - and request establishing SockJS connection. Using cookies for
authorisation in this scenario will result in granting full access to
SockJS communication with your website from any website. This is a
classic CSRF attack.
Basically - cookies are not suited for SockJS model. If you want to
authorise a session - provide a unique token on a page, send it as a
first thing over SockJS connection and validate it on the server
side. In essence, this is how cookies work.
Long polling is known to cause problems on Heroku, but
workaround for SockJS is available.