hyperzlib
/
nodebb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix circular dependency -- involves indentations fix

Browse Source
v1.18.x
Aziz Khoury 9 years ago
parent 807e3a9d7e
commit c07e29bad6
1 changed files with 170 additions and 170 deletions
Show Stats Download Patch File Download Diff File

340
src/socket.io/index.js
Unescape Escape View File

@ -12,217 +12,217 @@ var logger = require('../logger');
var ratelimit = require('../middleware/ratelimit'); var ratelimit = require('../middleware/ratelimit');
var cls = require('../middleware/cls'); var cls = require('../middleware/cls');
var Sockets = {}; (function(Sockets) {
var Namespaces = {}; var Namespaces = {};
var io;
var io; Sockets.init = function (server) {
requireModules();
Sockets.init = function(server) { io = new SocketIO({
requireModules(); path: nconf.get('relative_path') + '/socket.io'
});
io = new SocketIO({
path: nconf.get('relative_path') + '/socket.io'
});
addRedisAdapter(io); addRedisAdapter(io);
io.use(socketioWildcard); io.use(socketioWildcard);
io.use(authorize); io.use(authorize);
io.on('connection', onConnection); io.on('connection', onConnection);
io.on('disconnect', onDisconnect); io.on('disconnect', onDisconnect);
io.listen(server, { io.listen(server, {
transports: nconf.get('socket.io:transports') transports: nconf.get('socket.io:transports')
}); });
Sockets.server = io; Sockets.server = io;
}; };
function onConnection(socket) { function onConnection(socket) {
socket.ip = socket.request.headers['x-forwarded-for'] || socket.request.connection.remoteAddress; socket.ip = socket.request.headers['x-forwarded-for'] || socket.request.connection.remoteAddress;
logger.io_one(socket, socket.uid); logger.io_one(socket, socket.uid);
cls.socket(socket, null, 'connection', function() { cls.socket(socket, null, 'connection', function () {
onConnect(socket); onConnect(socket);
}); });
socket.on('*', function(payload) { socket.on('*', function (payload) {
cls.socket(socket, payload, null, function() { cls.socket(socket, payload, null, function () {
onMessage(socket, payload); onMessage(socket, payload);
});
}); });
});
}
function onConnect(socket) {
if (socket.uid) {
socket.join('uid_' + socket.uid);
socket.join('online_users');
} else {
socket.join('online_guests');
} }
}
function onDisconnect(socket) { function onConnect(socket) {
cls.socket(socket, null, 'disconnect', function() {}); if (socket.uid) {
} socket.join('uid_' + socket.uid);
socket.join('online_users');
} else {
function onMessage(socket, payload) { socket.join('online_guests');
if (!payload.data.length) { }
return winston.warn('[socket.io] Empty payload');
} }
var eventName = payload.data[0]; function onDisconnect(socket) {
var params = payload.data[1]; cls.socket(socket, null, 'disconnect', function () {
var callback = typeof payload.data[payload.data.length - 1] === 'function' ? payload.data[payload.data.length - 1] : function() {}; });
if (!eventName) {
return winston.warn('[socket.io] Empty method name');
} }
var parts = eventName.toString().split('.');
var namespace = parts[0];
var methodToCall = parts.reduce(function(prev, cur) {
if (prev !== null && prev[cur]) {
return prev[cur];
} else {
return null;
}
}, Namespaces);
if(!methodToCall) { function onMessage(socket, payload) {
if (process.env.NODE_ENV === 'development') { if (!payload.data.length) {
winston.warn('[socket.io] Unrecognized message: ' + eventName); return winston.warn('[socket.io] Empty payload');
} }
return;
}
socket.previousEvents = socket.previousEvents || []; var eventName = payload.data[0];
socket.previousEvents.push(eventName); var params = payload.data[1];
if (socket.previousEvents.length > 20) { var callback = typeof payload.data[payload.data.length - 1] === 'function' ? payload.data[payload.data.length - 1] : function () {
socket.previousEvents.shift(); };
}
if (!eventName.startsWith('admin.') && ratelimit.isFlooding(socket)) { if (!eventName) {
winston.warn('[socket.io] Too many emits! Disconnecting uid : ' + socket.uid + '. Events : ' + socket.previousEvents); return winston.warn('[socket.io] Empty method name');
return socket.disconnect(); }
}
async.waterfall([ var parts = eventName.toString().split('.');
function (next) { var namespace = parts[0];
validateSession(socket, next); var methodToCall = parts.reduce(function (prev, cur) {
}, if (prev !== null && prev[cur]) {
function (next) { return prev[cur];
if (Namespaces[namespace].before) {
Namespaces[namespace].before(socket, eventName, params, next);
} else { } else {
next(); return null;
} }
}, }, Namespaces);
function (next) {
methodToCall(socket, params, next); if (!methodToCall) {
if (process.env.NODE_ENV === 'development') {
winston.warn('[socket.io] Unrecognized message: ' + eventName);
}
return;
} }
], function(err, result) {
callback(err ? {message: err.message} : null, result); socket.previousEvents = socket.previousEvents || [];
}); socket.previousEvents.push(eventName);
} if (socket.previousEvents.length > 20) {
socket.previousEvents.shift();
function requireModules() {
var modules = ['admin', 'categories', 'groups', 'meta', 'modules',
'notifications', 'plugins', 'posts', 'topics', 'user', 'blacklist'
];
modules.forEach(function(module) {
Namespaces[module] = require('./' + module);
});
}
function validateSession(socket, callback) {
var req = socket.request;
if (!req.signedCookies || !req.signedCookies['express.sid']) {
return callback(new Error('[[error:invalid-session]]'));
}
db.sessionStore.get(req.signedCookies['express.sid'], function(err, sessionData) {
if (err || !sessionData) {
return callback(err || new Error('[[error:invalid-session]]'));
} }
callback(); if (!eventName.startsWith('admin.') && ratelimit.isFlooding(socket)) {
}); winston.warn('[socket.io] Too many emits! Disconnecting uid : ' + socket.uid + '. Events : ' + socket.previousEvents);
} return socket.disconnect();
}
function authorize(socket, callback) { async.waterfall([
var request = socket.request; function (next) {
validateSession(socket, next);
},
function (next) {
if (Namespaces[namespace].before) {
Namespaces[namespace].before(socket, eventName, params, next);
} else {
next();
}
},
function (next) {
methodToCall(socket, params, next);
}
], function (err, result) {
callback(err ? {message: err.message} : null, result);
});
}
function requireModules() {
var modules = ['admin', 'categories', 'groups', 'meta', 'modules',
'notifications', 'plugins', 'posts', 'topics', 'user', 'blacklist'
];
if (!request) { modules.forEach(function (module) {
return callback(new Error('[[error:not-authorized]]')); Namespaces[module] = require('./' + module);
});
} }
async.waterfall([ function validateSession(socket, callback) {
function(next) { var req = socket.request;
cookieParser(request, {}, next); if (!req.signedCookies || !req.signedCookies['express.sid']) {
}, return callback(new Error('[[error:invalid-session]]'));
function(next) {
db.sessionStore.get(request.signedCookies['express.sid'], function(err, sessionData) {
if (err) {
return next(err);
}
if (sessionData && sessionData.passport && sessionData.passport.user) {
request.session = sessionData;
socket.uid = parseInt(sessionData.passport.user, 10);
} else {
socket.uid = 0;
}
next();
});
} }
], callback); db.sessionStore.get(req.signedCookies['express.sid'], function (err, sessionData) {
} if (err || !sessionData) {
return callback(err || new Error('[[error:invalid-session]]'));
function addRedisAdapter(io) { }
if (nconf.get('redis')) {
var redisAdapter = require('socket.io-redis'); callback();
var redis = require('../database/redis'); });
var pub = redis.connect({return_buffers: true});
var sub = redis.connect({return_buffers: true});
io.adapter(redisAdapter({pubClient: pub, subClient: sub}));
} else if (nconf.get('isCluster') === 'true') {
winston.warn('[socket.io] Clustering detected, you are advised to configure Redis as a websocket store.');
} }
}
Sockets.in = function(room) { function authorize(socket, callback) {
return io.in(room); var request = socket.request;
};
if (!request) {
return callback(new Error('[[error:not-authorized]]'));
}
Sockets.getUserSocketCount = function(uid) { async.waterfall([
if (!io) { function (next) {
return 0; cookieParser(request, {}, next);
},
function (next) {
db.sessionStore.get(request.signedCookies['express.sid'], function (err, sessionData) {
if (err) {
return next(err);
}
if (sessionData && sessionData.passport && sessionData.passport.user) {
request.session = sessionData;
socket.uid = parseInt(sessionData.passport.user, 10);
} else {
socket.uid = 0;
}
next();
});
}
], callback);
} }
var room = io.sockets.adapter.rooms['uid_' + uid]; function addRedisAdapter(io) {
return room ? room.length : 0; if (nconf.get('redis')) {
}; var redisAdapter = require('socket.io-redis');
var redis = require('../database/redis');
var pub = redis.connect({return_buffers: true});
var sub = redis.connect({return_buffers: true});
io.adapter(redisAdapter({pubClient: pub, subClient: sub}));
} else if (nconf.get('isCluster') === 'true') {
winston.warn('[socket.io] Clustering detected, you are advised to configure Redis as a websocket store.');
}
}
Sockets.reqFromSocket = function(socket) { Sockets.in = function (room) {
var headers = socket.request.headers; return io.in(room);
var host = headers.host; };
var referer = headers.referer || '';
Sockets.getUserSocketCount = function (uid) {
if (!io) {
return 0;
}
return { var room = io.sockets.adapter.rooms['uid_' + uid];
ip: headers['x-forwarded-for'] || socket.ip, return room ? room.length : 0;
host: host,
protocol: socket.request.connection.encrypted ? 'https' : 'http',
secure: !!socket.request.connection.encrypted,
url: referer,
path: referer.substr(referer.indexOf(host) + host.length),
headers: headers
}; };
};
module.exports = Sockets; Sockets.reqFromSocket = function (socket) {
var headers = socket.request.headers;
var host = headers.host;
var referer = headers.referer || '';
return {
ip: headers['x-forwarded-for'] || socket.ip,
host: host,
protocol: socket.request.connection.encrypted ? 'https' : 'http',
secure: !!socket.request.connection.encrypted,
url: referer,
path: referer.substr(referer.indexOf(host) + host.length),
headers: headers
};
};
})(exports);
Write Preview
Loading…
Cancel
Save