Quelle bibliothèque Websocket utiliser avec Node.js? [fermé]

Il existe actuellement une pléthore de bibliothèques Websocket pour node.js, les plus populaires semblent être:

• 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

Cependant, je ne trouve aucune comparaison concrète solide entre l'un d'entre eux ... Apparemment, Socket.io était génial, mais est devenu assez daté et a des builds défaillants. Les deux ws et websocket-node prétendent qu'ils sont les plus rapides. Et engine.io semble nouveau, mais beaucoup plus lourd que les aletarntives plus légers.

Il serait étonnant que nous ou quelqu'un puissions préparer une réponse qui serve de guide sur la bibliothèque de socket à utiliser et quand, ainsi qu'une comparaison entre eux.

Faire bouger les choses avec cette réponse wiki communautaire . N'hésitez pas à me modifier avec vos améliorations.

• serveur et client ws WebSocket pour node.js. L'une des bibliothèques les plus rapides sinon la plus rapide.

• serveur et client WebSocket -node WebSocket pour node.js

• websocket-driver-node Serveur WebSocket et analyseur de protocole client node.js - utilisé dans faye-websocket-node

• faye-websocket-node Serveur et client WebSocket pour node.js - utilisé dans faye et sockjs

• socket.io Serveur WebSocket et client pour node.js + client pour les navigateurs + (v0 a les plus récentes aux plus anciennes solutions de repli, la v1 de Socket.io utilise engine.io) + canaux - utilisés dans stack.io. La bibliothèque cliente tente de se reconnecter lors de la déconnexion.

• serveur et client sockjs WebSocket pour node.js et autres + client pour les navigateurs + solutions de remplacement les plus récentes aux plus anciennes

• serveur et client faye WebSocket pour node.js et autres + client pour navigateurs + solutions de secours + prise en charge d'autres langues côté serveur

• serveur en temps réel clusterable deepstream.io qui gère les connexions WebSockets et TCP et fournit la synchronisation des données, la publication / sub et la demande / réponse

• socketcluster WebSocket cluster de serveurs qui utilise tous les cœurs de CPU de votre machine. Par exemple, si vous deviez utiliser une instance xlarge Amazon EC2 avec 32 cœurs, vous seriez en mesure de gérer près de 32 fois le trafic sur une seule instance.

• primus Fournit une API commune à la plupart des bibliothèques ci-dessus pour faciliter la commutation et améliorer la stabilité de chacune d'entre elles.

Quand utiliser:

• utilisez les serveurs WebSocket de base lorsque vous souhaitez utiliser les implémentations WebSocket natives côté client, attention aux incompatibilités du navigateur

• utilisez les bibliothèques de secours lorsque vous vous souciez des solutions de rechange du navigateur

• utilisez les bibliothèques complètes lorsque vous vous souciez des chaînes

• utilisez primus lorsque vous ne savez pas quoi utiliser, que vous n'êtes pas d'humeur à réécrire votre application lorsque vous devez changer de cadre en raison de l'évolution des exigences du projet ou avez besoin d'une stabilité de connexion supplémentaire.

Où tester:

Firecamp est un environnement de test GUI pour SocketIO, WS et toutes les principales technologies en temps réel. Déboguez les événements en temps réel pendant que vous le développez.

Mise à jour: Cette réponse est obsolète car de nouvelles versions des bibliothèques mentionnées sont publiées depuis lors.

Socket.IO v0.9 est obsolète et un peu bogué, et Engine.IO est le successeur intérimaire. Socket.IO v1.0 (qui sortira bientôt) utilisera Engine.IO et sera bien meilleur que v0.9. Je vous recommande d'utiliser Engine.IO jusqu'à la sortie de Socket.IO v1.0.

"ws" ne prend pas en charge le remplacement, donc si le navigateur client ne prend pas en charge les websockets, cela ne fonctionnera pas, contrairement à Socket.IO et Engine.IO qui utilise l'interrogation longue, etc. si les websockets ne sont pas disponibles. Cependant, "ws" semble être la bibliothèque la plus rapide pour le moment.

Voir mon article comparant Socket.IO, Engine.IO et Primus: https://medium.com/p/b63bfca0539

npm ws était la réponse pour moi. Je l'ai trouvé moins intrusif et plus simple. Avec, il était également trivial de mélanger les websockets avec les services de repos. Code simple partagé sur ce 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");