A wrapper of node-websocket-server & WebSocket-Node

websocket.js

// A websocket server wrapper that uses alternative websocket library for different protocol clients
// This is an enhanced version listed in https://gist.github.com/1148686

var http = require('http'),
    events = require('events'),
    util = require('util'),
    WebSocketRequest = require('node-websocket').request,
    ws = require('node-websocket-server'),
    Connection = require('node-websocket-server/lib/ws/connection');

WebSocketServer = function(options) {
    var self = this;
    this.server = http.createServer(function(request, response) {
        response.writeHead(404);
        response.end();
    });

    // WebSocket-Node config
    var wsServerConfig = {
        // All options *except* 'httpServer' are required when bypassing
        // WebSocketServer.
        maxReceivedFrameSize: 0x10000,
        maxReceivedMessageSize: 0x100000,
        fragmentOutgoingMessages: true,
        fragmentationThreshold: 0x4000,
        keepalive: true,
        keepaliveInterval: 20000,
        assembleFragments: true,
        // autoAcceptConnections is not applicable when bypassing WebSocketServer
        // autoAcceptConnections: false,
        disableNagleAlgorithm: true,
        closeTimeout: 5000
    };

    this.miksagoServer = ws.createServer();

    this.miksagoServer.on('connection', function(connection) {
        connection.remoteAddress = connection._socket.remoteAddress;
        connection.remotePort = connection._socket.remotePort;
        connection.sendUTF = connection.send;
        self.emit('connection', connection);
    });
    this.miksagoServer.server = this.server;

    // Handle the upgrade event ourselves instead of using WebSocketServer
    this.server.on('upgrade', function(req, socket, head) {
        if (typeof req.headers['sec-websocket-version'] !== 'undefined') {
            // WebSocket hybi-08/-09/-10... connection (WebSocket-Node)
            var wsRequest = new WebSocketRequest(socket, req, wsServerConfig);
            try {
                wsRequest.readHandshake();
            }
            catch(e) {
                wsRequest.reject(
                    e.httpCode ? e.httpCode : 400,
                    e.message,
                    e.headers
                );
                console.error((new Date()) + " WebSocket: Invalid handshake: " + e.message);
                return;
            }
            try {
                var wsConnection = wsRequest.accept(wsRequest.requestedProtocols[0], wsRequest.origin);
                wsConnection.send = wsConnection.sendUTF;
                wsConnection.reject = wsRequest.reject;
                self.emit('connection', wsConnection);
            }
            catch(e) {
                console.log("WebSocket Request unsupported by WebSocket-Node: " + e.toString());
                return;
            }
        } else {
            // WebSocket hixie-75/-76/hybi-00 connection (node-websocket-server)
            if (req.method === 'GET' &&
                req.headers.upgrade && req.headers.connection &&
                req.headers.upgrade.toLowerCase() === 'websocket' &&
                req.headers.connection.toLowerCase() === 'upgrade') {
                new Connection(self.miksagoServer.manager, self.miksagoServer.options, req, socket, head);
            }
        }
    });

    events.EventEmitter.call(this);
}

util.inherits(WebSocketServer, events.EventEmitter);
module.exports = WebSocketServer;

WebSocketServer.prototype.listen = function(port, host) {
    this.server.listen(port, host);
}

WebSocketServer.prototype.listen = function(fd) {
    this.server.listenFD(fd);
}