Quale libreria di websocket da utilizzare con Node.js? [chiuso]

Attualmente esiste una pletora di librerie di websocket per node.js, le più popolari sembrano essere:

• 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

Tuttavia non riesco a trovare alcun solido confronto concreto tra nessuno di essi ... Apparentemente Socket.io è stato fantastico, ma è diventato piuttosto datato e ha build fallite. Sia ws che websocket-node affermano di essere i più veloci. E engine.io sembra nuovo, ma molto più pesante degli aletarntives più leggeri.

Sarebbe sorprendente se noi o qualcuno potessimo mettere insieme una risposta che serva da guida su quale libreria socket utilizzare e quando, nonché un confronto tra di loro.

Fai rotolare la palla con questa risposta wiki della community . Sentiti libero di modificarmi con i tuoi miglioramenti.

• ws WebSocket server e client per node.js. Una delle librerie più veloci se non la più veloce.

• server WebSocket e client websocket-node per node.js

• websocket-driver-node Server WebSocket e parser del protocollo client node.js - utilizzato in faye-websocket-node

• server e client WebSocket faye-websocket-node per node.js - utilizzato in faye e sockjs

• socket.io Server e client WebSocket per node.js + client per browser + (v0 ha fallback più recenti o meno recenti, v1 di Socket.io utilizza engine.io) + canali - utilizzati in stack.io. La libreria client tenta di riconnettersi al momento della disconnessione.

• server e client WebSocket sockjs per node.js e altri + client per browser + fallback dal più recente al meno recente

• faye WebSocket server e client per node.js e altri + client per browser + fallback + supporto per altre lingue lato server

• deepstream.io server in tempo reale clusterizzabile che gestisce WebSocket e connessioni TCP e fornisce sincronizzazione dei dati, pub / sub e richiesta / risposta

• cluster di server socketcluster WebSocket che utilizza tutti i core della CPU sul computer. Ad esempio, se dovessi utilizzare un'istanza Amazon EC2 xlarge con 32 core, sarai in grado di gestire quasi 32 volte il traffico su una singola istanza.

• primus Fornisce un'API comune per la maggior parte delle librerie di cui sopra per un facile passaggio + miglioramenti della stabilità per tutte.

Quando usare:

• utilizzare i server WebSocket di base quando si desidera utilizzare le implementazioni WebSocket native sul lato client, fare attenzione alle incompatibilità del browser

• usa le librerie di fallback quando ti preoccupi dei fallback del browser

• usa le librerie complete quando ti preoccupi dei canali

• usa primus quando non hai idea di cosa usare, non hai voglia di riscrivere la tua applicazione quando devi cambiare framework a causa dei cambiamenti dei requisiti del progetto o se hai bisogno di stabilità di connessione aggiuntiva.

Dove testare:

Firecamp è un ambiente di test GUI per SocketIO, WS e tutte le principali tecnologie in tempo reale. Effettua il debug degli eventi in tempo reale mentre lo stai sviluppando.

Aggiornamento: questa risposta non è aggiornata poiché le versioni più recenti delle librerie citate sono state rilasciate da allora.

Socket.IO v0.9 è obsoleto e un po 'difettoso e Engine.IO è il successore temporaneo. Socket.IO v1.0 (che sarà rilasciato a breve) utilizzerà Engine.IO e sarà molto meglio di v0.9. Ti consiglierei di usare Engine.IO fino al rilascio di Socket.IO v1.0.

"ws" non supporta il fallback, quindi se il browser client non supporta i websocket, non funzionerà, a differenza di Socket.IO e Engine.IO che utilizza polling lungo ecc. se i websocket non sono disponibili. Tuttavia, "ws" sembra la libreria più veloce al momento.

Vedi il mio articolo che confronta Socket.IO, Engine.IO e Primus: https://medium.com/p/b63bfca0539

npm ws è stata la risposta per me. L'ho trovato meno invadente e più diretto. Con esso era anche banale mescolare i websocket con i servizi di riposo. Codice semplice condiviso su questo post.

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");