Qual biblioteca do websocket usar com Node.js? [fechadas]

Atualmente, existe uma infinidade de bibliotecas websocket para node.js, as mais populares parecem ser:

• https://github.com/Worlize/WebSocket-Node
• https://github.com/einaros/ws
• https://github.com/LearnBoost/engine.io
• https://github.com/learnboost/socket.io
• https://github.com/sockjs

No entanto, não consigo encontrar nenhuma comparação concreta sólida entre nenhum deles ... Aparentemente, o Socket.io foi incrível, mas tornou-se bastante antigo e apresenta falhas de compilação. Tanto o WS quanto o WebSocket afirmam que são os mais rápidos. E o engine.io parece novo, mas muito mais pesado que os mais leves.

Seria incrível se nós ou alguém pudéssemos reunir uma resposta que sirva de guia sobre qual biblioteca de soquetes usar e quando, bem como uma comparação entre eles.

Fazendo a bola rolar com esta resposta wiki da comunidade . Sinta-se livre para me editar com suas melhorias.

• ws WebSocket servidor e cliente para Node.js. Uma das bibliotecas mais rápidas, se não a mais rápida.

• servidor e cliente WebSocket -node WebSocket para node.js

• websocket-driver-node Servidor WebSocket e analisador de protocolo do cliente node.js - usado no faye-websocket-node

• servidor e cliente WebSocket faye-websocket-node para node.js - usado em faye e sockjs

• servidor e cliente socket.io WebSocket para node.js + cliente para navegadores + (a v0 tem fallbacks mais recentes para os mais antigos, a v1 do Socket.io usa engine.io) + canais - usados ​​no stack.io. A biblioteca do cliente tenta se reconectar após a desconexão.

• servidor e cliente sockjs WebSocket para node.js e outros + cliente para navegadores + fallbacks mais novos para os mais antigos

• fayeservidor e cliente WebSocket para node.js e outros + cliente para navegadores + fallbacks + suporte para outros idiomas do lado do servidor

• deepstream.ioservidor em tempo real em deepstream.io que lida com conexões WebSockets e TCP e fornece sincronização de dados, publicação / assinatura e solicitação / resposta

• socketclustercluster de servidor WebSocket que utiliza todos os núcleos da CPU em sua máquina. Por exemplo, se você usasse uma instância xlarge Amazon EC2 com 32 núcleos, seria capaz de lidar com quase 32 vezes o tráfego em uma única instância.

• primus Fornece uma API comum para a maioria das bibliotecas acima para facilitar a comutação + melhorias de estabilidade para todas elas.

Quando usar:

• use os servidores WebSocket básicos quando desejar usar as implementações nativas do WebSocket no lado do cliente, cuidado com o incompatibilidades do navegador

• use as bibliotecas de fallback quando se importar com fallbacks do navegador

• use as bibliotecas completas quando se interessar por canais

• use primus quando você não tem idéia sobre o que usar, não está disposto a reescrever seu aplicativo quando precisar alternar estruturas devido a alterações nos requisitos do projeto ou precisar de estabilidade adicional da conexão.

Onde testar:

O Firecamp é um ambiente de teste de GUI para SocketIO, WS e todas as principais tecnologias em tempo real. Depure os eventos em tempo real enquanto você o desenvolve.

Atualização: esta resposta está desatualizada, pois versões mais recentes das bibliotecas mencionadas são lançadas desde então.

O Socket.IO v0.9 está desatualizado e um pouco complicado, e o Engine.IO é o sucessor intermediário. O Socket.IO v1.0 (que será lançado em breve) usará o Engine.IO e será muito melhor que o v0.9. Eu recomendo que você use o Engine.IO até o lançamento do Socket.IO v1.0.

"ws" não suporta fallback; portanto, se o navegador do cliente não suportar websockets, ele não funcionará, diferentemente do Socket.IO e do Engine.IO, que usam pesquisas longas etc. se os websockets não estiverem disponíveis. No entanto, "ws" parece a biblioteca mais rápida no momento.

Veja meu artigo comparando Socket.IO, Engine.IO e Primus: https://medium.com/p/b63bfca0539

npm ws foi a resposta para mim. Achei menos invasivo e mais direto. Com isso, também foi trivial misturar websockets com serviços de descanso. Código simples compartilhado nesta postagem.

var WebSocketServer = require("ws").Server;
var http = require("http");
var express = require("express");
var port = process.env.PORT || 5000;

var app = express();
    app.use(express.static(__dirname+ "/../"));
    app.get('/someGetRequest', function(req, res, next) {
       console.log('receiving get request');
    });
    app.post('/somePostRequest', function(req, res, next) {
       console.log('receiving post request');
    });
    app.listen(80); //port 80 need to run as root

    console.log("app listening on %d ", 80);

var server = http.createServer(app);
    server.listen(port);

console.log("http server listening on %d", port);

var userId;
var wss = new WebSocketServer({server: server});
    wss.on("connection", function (ws) {

    console.info("websocket connection open");

    var timestamp = new Date().getTime();
    userId = timestamp;

    ws.send(JSON.stringify({msgType:"onOpenConnection", msg:{connectionId:timestamp}}));


    ws.on("message", function (data, flags) {
        console.log("websocket received a message");
        var clientMsg = data;

        ws.send(JSON.stringify({msg:{connectionId:userId}}));


    });

    ws.on("close", function () {
        console.log("websocket connection close");
    });
});
console.log("websocket server created");