Como compartilhar sessões com o Socket.IO 1.xe Express 4.x?

Como posso compartilhar uma session com Socket.io 1.0 e Express 4.x? Eu uso uma Redis Store, mas acredito que não importa. Eu sei que tenho que usar um middleware para olhar cookies e buscar a session, mas não sei como. Eu procurei, mas não consegui encontrar nenhum trabalho

var RedisStore = connectRedis(expressSession); var session = expressSession({ store: new RedisStore({ client: redisClient }), secret: mysecret, saveUninitialized: true, resave: true }); app.use(session); io.use(function(socket, next) { var handshake = socket.handshake; if (handshake.headers.cookie) { var str = handshake.headers.cookie; next(); } else { next(new Error('Missing Cookies')); } }); 

A solução é surpreendentemente simples. Não é muito bem documentado. É possível usar o middleware de session expressa como um middleware Socket.IO também com um adaptador pequeno como este:

 sio.use(function(socket, next) { sessionMiddleware(socket.request, socket.request.res, next); }); 

Aqui está um exemplo completo com o express 4.x, Socket.IO 1.xe Redis:

 var express = require("express"); var Server = require("http").Server; var session = require("express-session"); var RedisStore = require("connect-redis")(session); var app = express(); var server = Server(app); var sio = require("socket.io")(server); var sessionMiddleware = session({ store: new RedisStore({}), // XXX redis server config secret: "keyboard cat", }); sio.use(function(socket, next) { sessionMiddleware(socket.request, socket.request.res, next); }); app.use(sessionMiddleware); app.get("/", function(req, res){ req.session // Session object in a normal request }); sio.sockets.on("connection", function(socket) { socket.request.session // Now it's available from Socket.IO sockets too! Win! }); server.listen(8080); 

Apenas um mês e meio atrás, eu lidei com o mesmo problema e depois escrevi um extenso post no blog sobre este tópico, que acompanha um aplicativo demo totalmente funcional hospedado no GitHub. A solução depende dos módulos de session express , cookie-parser e connect-redis para amarrar tudo. Ele permite que você acesse e modifique sessões do contexto REST e Sockets, o que é bastante útil.

As duas partes cruciais são a configuração de middleware:

 app.use(cookieParser(config.sessionSecret)); app.use(session({ store: redisStore, key: config.sessionCookieKey, secret: config.sessionSecret, resave: true, saveUninitialized: true })); 

… e configuração do servidor SocketIO:

 ioServer.use(function (socket, next) { var parseCookie = cookieParser(config.sessionSecret); var handshake = socket.request; parseCookie(handshake, null, function (err, data) { sessionService.get(handshake, function (err, session) { if (err) next(new Error(err.message)); if (!session) next(new Error("Not authorized")); handshake.session = session; next(); }); }); }); 

Eles vão junto com um módulo sessionService simples que eu fiz, o que permite que você faça algumas operações básicas com sessões e que o código seja assim:

 var config = require('../config'); var redisClient = null; var redisStore = null; var self = module.exports = { initializeRedis: function (client, store) { redisClient = client; redisStore = store; }, getSessionId: function (handshake) { return handshake.signedCookies[config.sessionCookieKey]; }, get: function (handshake, callback) { var sessionId = self.getSessionId(handshake); self.getSessionBySessionID(sessionId, function (err, session) { if (err) callback(err); if (callback != undefined) callback(null, session); }); }, getSessionBySessionID: function (sessionId, callback) { redisStore.load(sessionId, function (err, session) { if (err) callback(err); if (callback != undefined) callback(null, session); }); }, getUserName: function (handshake, callback) { self.get(handshake, function (err, session) { if (err) callback(err); if (session) callback(null, session.userName); else callback(null); }); }, updateSession: function (session, callback) { try { session.reload(function () { session.touch().save(); callback(null, session); }); } catch (err) { callback(err); } }, setSessionProperty: function (session, propertyName, propertyValue, callback) { session[propertyName] = propertyValue; self.updateSession(session, callback); } }; 

Como há mais código para a coisa toda do que isso (como a boot de módulos, trabalhando com sockets e chamadas REST no cliente e no servidor), não vou colar todo o código aqui, você pode visualizá-lo no GitHub e você pode fazer o que quiser com isso.

Sessão Express-socket.io

é uma solução pronta para o seu problema. Normalmente, a session criada no final do socket.io tem um sid diferente daquele criado no express.js

Antes de conhecer esse fato, quando eu estava trabalhando para encontrar a solução, encontrei algo um pouco estranho. As sessões criadas a partir da instância do express.js estavam acessíveis no final do socket.io, mas o mesmo não era possível pelo contrário. E logo cheguei a saber que tenho que trabalhar o meu caminho através do gerenciamento de sid para resolver esse problema. Mas já havia um pacote escrito para resolver esse problema. Está bem documentado e faz o trabalho. Espero que ajude

Usando a resposta de Bradley Lederholz, foi assim que eu fiz isso funcionar comigo mesmo. Por favor, consulte a resposta de Bradley Lederholz, para mais explicações.

 var app = express(); var server = require('http').createServer(app); var io = require('socket.io'); var cookieParse = require('cookie-parser')(); var passport = require('passport'); var passportInit = passport.initialize(); var passportSession = passport.session(); var session = require('express-session'); var mongoStore = require('connect-mongo')(session); var mongoose = require('mongoose'); var sessionMiddleware = session({ secret: 'some secret', key: 'express.sid', resave: true, httpOnly: true, secure: true, ephemeral: true, saveUninitialized: true, cookie: {}, store:new mongoStore({ mongooseConnection: mongoose.connection, db: 'mydb' }); }); app.use(sessionMiddleware); io = io(server); io.use(function(socket, next){ socket.client.request.originalUrl = socket.client.request.url; cookieParse(socket.client.request, socket.client.request.res, next); }); io.use(function(socket, next){ socket.client.request.originalUrl = socket.client.request.url; sessionMiddleware(socket.client.request, socket.client.request.res, next); }); io.use(function(socket, next){ passportInit(socket.client.request, socket.client.request.res, next); }); io.use(function(socket, next){ passportSession(socket.client.request, socket.client.request.res, next); }); io.on('connection', function(socket){ ... }); ... server.listen(8000); 

Eu meio que resolvi isso, mas não é perfeito. Não suporta cookies assinados, etc. Eu usei a function getcookie de express-session . A function modificada é a seguinte:

  io.use(function(socket, next) { var cookie = require("cookie"); var signature = require('cookie-signature'); var debug = function() {}; var deprecate = function() {}; function getcookie(req, name, secret) { var header = req.headers.cookie; var raw; var val; // read from cookie header if (header) { var cookies = cookie.parse(header); raw = cookies[name]; if (raw) { if (raw.substr(0, 2) === 's:') { val = signature.unsign(raw.slice(2), secret); if (val === false) { debug('cookie signature invalid'); val = undefined; } } else { debug('cookie unsigned') } } } // back-compat read from cookieParser() signedCookies data if (!val && req.signedCookies) { val = req.signedCookies[name]; if (val) { deprecate('cookie should be available in req.headers.cookie'); } } // back-compat read from cookieParser() cookies data if (!val && req.cookies) { raw = req.cookies[name]; if (raw) { if (raw.substr(0, 2) === 's:') { val = signature.unsign(raw.slice(2), secret); if (val) { deprecate('cookie should be available in req.headers.cookie'); } if (val === false) { debug('cookie signature invalid'); val = undefined; } } else { debug('cookie unsigned') } } } return val; } var handshake = socket.handshake; if (handshake.headers.cookie) { var req = {}; req.headers = {}; req.headers.cookie = handshake.headers.cookie; var sessionId = getcookie(req, "connect.sid", mysecret); console.log(sessionId); myStore.get(sessionId, function(err, sess) { console.log(err); console.log(sess); if (!sess) { next(new Error("No session")); } else { console.log(sess); socket.session = sess; next(); } }); } else { next(new Error("Not even a cookie found")); } }); // Session backend config var RedisStore = connectRedis(expressSession); var myStore = new RedisStore({ client: redisClient }); var session = expressSession({ store: myStore, secret: mysecret, saveUninitialized: true, resave: true }); app.use(session); 

Agora, a resposta original aceita não funciona para mim também. Mesmo que @ Rahil051, eu usei o módulo express-socket.io-session , e ainda funciona. Este módulo usa um analisador de cookies para analisar o ID da session antes de entrar no middleware de session expressa. Eu acho que é silmiar a resposta @pootzko, @Mustafa e @ Kosar.

Eu estou usando esses módulos:

 "dependencies": { "debug": "^2.6.1", "express": "^4.14.1", "express-session": "^1.15.1", "express-socket.io-session": "^1.3.2 "socket.io": "^1.7.3" } 

confira os dados em socket.handshake:

 const debug = require('debug')('ws'); const sharedsession = require('express-socket.io-session'); module.exports = (server, session) => { const io = require('socket.io').listen(server); let connections = []; io.use(sharedsession(session, { autoSave: true, })); io.use(function (socket, next) { debug('check handshake %s', JSON.stringify(socket.handshake, null, 2)); debug('check headers %s', JSON.stringify(socket.request.headers)); debug('check socket.id %s', JSON.stringify(socket.id)); next(); }); io.sockets.on('connection', (socket) => { connections.push(socket); }); };