Sticky session balancer based on a cluster and node-http-proxy modules, with express and socket.io support
npm install express-sticky-clustercluster and node-http-proxy modules, with express and socket.io support.
express-cluster.
bash
npm install express-sticky-cluster [--save]
`
Usage example
Express 4 example with socket.io and passport.js usage.
./bin/www:
`javascript
var app = require('../worker'),
debug = require('debug')('example-app:server'),
https = require('https'),
fs = require('fs'),
ipfilter = require('express-ipfilter').IpFilter;
var express_sticky_cluster = require('express-sticky-cluster');
var optionsHTTPs = {
key: fs.readFileSync('./cert/def-secured.key'),
cert: fs.readFileSync('./cert/def-secured.crt')
};
var server = https.createServer(optionsHTTPs, app);
require('../socket.io')(require('socket.io')(server));
express_sticky_cluster(
{
workers: 0,
respawn: true,
socket: true,
proxy_port: 443,
worker_port: 8000,
delay: 1000,
debug: true,
ssl: {
secure: true,
certs: optionsHTTPs
},
ipfilter: ipfilter(['127.0.0.1', ['192.168.0.1', '192.168.0.200']], {mode: allow, log: false}),
session: {
hash: 'connect.sid',
ttl: 360000
},
logger: undefined,
workerListener: function (message) {}
}, function (worker, port) {
console.info('Worker ID#' + worker.id + ' process started PID#' + worker.process.pid);
app.set('port', port);
return server.listen(port);
}
);
server.on('error', onError);
server.on('listening', onListening);
function onError(error) {
if (error.syscall !== 'listen')
throw error;
var bind = typeof port === 'string'
? 'Pipe ' + port
: 'Port ' + port;
switch (error.code) {
case 'EACCES':
console.error(bind + ' requires elevated privileges');
process.exit(1);
break;
case 'EADDRINUSE':
console.error(bind + ' is already in use');
process.exit(1);
break;
default:
throw error;
}
}
function onListening() {
var addr = server.address();
var bind = typeof addr === 'string'
? 'pipe ' + addr
: 'port ' + addr.port;
console.info('Listening on ' + bind + ' PID#' + process.pid);
}
`
./worker.js:
`javascript
var express = require('express'),
session = require('express-session'),
passport = require('passport'),
uuid = require('node-uuid');
var app = express();
var sessionFileStore = require('session-file-store')(session);
global.sessionStore = new sessionFileStore({
path : path.join(__dirname, '/sessions')
});
...
require('./passport')(passport);
app.use(passport.initialize());
app.use(passport.session());
...
app.use(session({
secret: 'keyboard-cat',
name: 'connect.sid',
resave: true,
rolling: true,
saveUninitialized: true,
cookie: {
path: '/',
httpOnly: false,
secure: true,
maxAge: 360000
},
store: global.sessionStore,
genid: function (req) {
return uuid.v4();
}
}));
...
module.exports = app;
`
./socket.io.js:
`javascript
var passportIo = require('passport.socketio'),
cookieParser = require('cookie-parser');
module.exports = function (io) {
io.use(passportIo.authorize({
cookieParser: cookieParser,
key: 'connect.sid',
secret: 'keyboard-cat',
store: global.sessionStore,
success: function (data, accept) {
accept();
},
fail: function (data, message, err, accept) {
if(err)
accept(new Error(message));
}
}));
io.on('connection', function (socket) {
socket.on('join', function (data) {
console.log('join', data);
});
socket.on('disconnect', function () {
socket.leave();
});
});
};
`
./passport.js:
`javascript
var LocalStrategy = require('passport-local').Strategy;
module.exports = function (passport, licensing) {
passport.serializeUser(function (user, done) {
done(null, user);
});
passport.deserializeUser(function (user, done) {
done(null, user);
});
passport.use(
'local-signin',
new LocalStrategy({
usernameField: 'username',
passwordField: 'password',
passReqToCallback: true
},
function (req, username, password, done) {
var objUser = {};
return done(null, objUser, {message: 'Successfull login'});
}
)
);
};
``