connectionManager.js

var io = require('socket.io').listen(8080, "127.0.0.1");

io.configure('production', function(){
    io.enable('browser client minification');  // send minified client
    io.enable('browser client etag');          // apply etag caching logic based on version number
    io.set('log level', 1);                    // reduce logging
    io.set('transports', [                     // enable all transports (optional if you want flashsocket)
        'websocket'
      , 'flashsocket'
      , 'htmlfile'
      , 'jsonp-polling'
    ]);
});

var ConnectionManager = function() {
    this._innerSocket = {};
    this._outerSocket = {};
    this.inner = [];
    this.outer = [];
    this.connected = [];
};

ConnectionManager.prototype._addSocket = function(type, id, socket) {
    this["_" + type + "Socket"][id] = socket;
};

ConnectionManager.prototype.addInner = function(id, socket) {
    if (!~this.inner.indexOf(id)) {
        this._addSocket("inner", id, socket);
        this.inner.push(id);
        console.log("addInner", id);
        if (~this.outer.indexOf(id)) {
            this.connect(id);
        }
    }
};

ConnectionManager.prototype.addOuter = function(id, socket) {
    if (!~this.outer.indexOf(id)) {
        this._addSocket("outer", id, socket);
        this.outer.push(id);
        console.log("addOuter", id);
        if (~this.inner.indexOf(id)) {
            this.connect(id);
        }
    }
};

ConnectionManager.prototype.connect = function(id) {
    var innerSocket, outerSocket, that;

    console.log("connect", id)

    that = this;

    if (!~this.connected.indexOf(id)) {
        innerSocket = this._innerSocket[id];
        outerSocket = this._outerSocket[id];
        innerSocket.emit("connectedID", id);
        outerSocket.emit("connectedID", id);

        innerSocket.on("openOverlay", function(){
            outerSocket.emit("openOverlay");
        });

        innerSocket.on("disconnect", function(){
            console.log("disconnected inner", id);
            that.disconnect(id);
            that.addOuter(id, outerSocket);
        });

        outerSocket.on("disconnect", function(){
            console.log("disconnected outer", id);
            that.disconnect(id);
            that.addInner(id, innerSocket);
        });
    } else {
        console.log("Connection for " + id + " refused because its already existent.");
    }
};

ConnectionManager.prototype.disconnect = function(id) {
    var innerSocket, outerSocket;

    if (!~this.connected.indexOf(id)) {
        this.connected.splice(this.connected.indexOf(id), 1);
        this.inner.splice(this.inner.indexOf(id), 1);
        this.outer.splice(this.outer.indexOf(id), 1);
        console.log("disconnected", id)
    }
};

var connectionManager = new ConnectionManager();

io.sockets.on('connection', function (socket) {

    socket.on("registerInner", function(data){
        connectionManager.addInner(data.id, socket);
    });

    socket.on("registerOuter", function(data){
        connectionManager.addOuter(data.id, socket);
    });

});