Comment puis-je trouver le temps de réponse (temps de latence) d'un client en NodeJS avec des sockets (socket.io)?

Je suis en train de créer un jeu multijoueur avec NodeJS et je veux synchroniser l'action entre les clients.

Quelle serait la meilleure façon de trouver le temps de latence (le temps qu'une demande pour venir au client) entre le client et le serveur?

Ma première idée était que le client n ° 1 pourrait envoyer un timestamp est la demande, de sorte que lorsque client #2 recevra l'action de la client #1, il va le régler, c'est l'action de la vitesse de supprimer le délai de la demande.
Mais le problème, c'est que peut-être le système date et heure de la deux clients ne sont pas identiques, de sorte qu'il n'est pas possible de deux savoir le rouleau de retard sur la demande de client #1.

L'autre solution était d'utiliser le timestamp du serveur, mais maintenant, comment je sais que la latence de la client?

InformationsquelleAutor FR6 | 2010-11-01
  1. 22

    Je vais supposer que vous utilisez les WebSockets ou Socket.IO puisque vous êtes à la mise en œuvre d'un jeu où la latence des questions (et marqués comme tels).

    Je pense que le serveur doit probablement de mesurer et de garder trace de ce pour chaque client.

    Vous voulez probablement mettre en œuvre une sorte de ping action que le serveur demande du client. Dès que le client reçoit la demande, il renvoie une réponse au serveur. Le serveur puis divise par 2 et met à jour le temps de latence pour que le client. Vous voulez probablement le serveur pour le faire régulièrement avec chaque client et probablement à la moyenne de la dernière plusieurs de sorte que vous n'obtenez pas le comportement étrange d'un coup de façon temporaire, mais les pointes.

    Puis, quand il y a un message d'un client qui doit être envoyé (ou de diffusion) à un autre client, le serveur peut ajouter client1 latence du client2 de latence et de communiquer ce que le temps de latence de décalage du client2 dans le cadre du message. client2 sait alors que l'événement sur client1 est arrivé que le nombre de millisecondes plus tôt.

    Une raison de plus de le faire sur le serveur, c'est que certains navigateur Javascript horodatages sont inexactes: http://ejohn.org/blog/accuracy-of-javascript-time/. Je soupçonne node.js les horodatages sont tout aussi précis (ou plus) que les V8 (qui est l'un des rares exacte ones).

    • Oui, je suis en utilisant le "socket.io". C'est exactement ce que j'ai mis en œuvre, la chose que j'ai oublier, c'est de diviser le temps de latence de 2! Merci pour vos conseils!
    • Hey FR6, en fait je viens de mis en œuvre une prise de courant.io test de ping parce que moi aussi je suis intéressé à faire de navigateur web à l'aide de jeux node.js en tant que serveur. Je vais écrire un billet de blog à ce sujet et de le lier ici, j'espère que ça va aider. Pour une raison quelconque, j'ai obtenu des temps de ping d'environ 220 ms en moyenne pour les websocket ping (aller-retour du temps), mais
    • le code open source (et le blog) pour ce serait génial. Je suis sûr que beaucoup de gens seront intéressés par ce qui va suivre.
    • +1 pour une exploration de ce. Serais ravi de voir quelques temps de latence et de déterminer si la réponse des applications critiques sont enfin possible en js côté client (im penser comme pilon bouton, un style street fighter jeux et autres joyeusetés)
    InformationsquelleAutor kanaka
  2. 20

    Vue d'ensemble:

    Après la prise.io connexion a été établie, vous créez un nouveau Date objet sur le client, nous allons l'appeler startTime. C'est votre temps initial avant de faire une demande au serveur. Vous puis émet un ping événement de la part du client. Convention de nommage est totalement à vous. En attendant, le serveur doit être à l'écoute pour une ping événement, et quand elle reçoit la ping, il émet immédiatement un pong événement. Client puis attrape la pong événement. À ce moment, vous voulez créer un autre objet date qui représente Date.now(). Donc, à ce stade, vous avez deux objets date - date initiale avant de faire une demande au serveur, et un autre objet date, après vous faites une demande pour le serveur, et il a répondu. Soustraire le startTime le temps courant et vous avez le latency.

    Client

    var socket = io.connect('http://localhost');
var startTime;

setInterval(function() {
  startTime = Date.now();
  socket.emit('ping');
}, 2000);

socket.on('pong', function() {
  latency = Date.now() - startTime;
  console.log(latency);
});

    Serveur

    io.sockets.on('connection', function (socket) {
  socket.on('ping', function() {
    socket.emit('pong');
  });
});

    Également disponible en tant que Github Gist.

    • Cela ajoute un autre rappel sur le "pong" toutes les 2 secondes. Le socket.sur('pong' la substance doit être à l'extérieur de la fonction setInterval.
    • stupide erreur de ma part, merci pour l'attraper.
    • startTime doit être globale pour que le code fonctionne, juste pour info 🙂 Merci pour ce bien.
    • Pour moi, en utilisant le mot "ping" n'a pas fonctionné. Je pense que c'est déjà être utilisé par node.js. Je l'ai changé pour quelque chose de différent et cela a fonctionné.
    InformationsquelleAutor Sahat Yalkabov
  3. 4

    Ce que j'ai l'habitude de faire pour envoyer timestamp avec la demande de l':

    1. Sur le client, créer un new Date() et envoyer timestamp: date.getTime() pour le serveur, à chaque JSON demande.
    2. Sur le serveur, sur réception d'une demande, mettre un processed: (new Date()).getTime() dans l'objet.
    3. Poignée de demande.
    4. Sur la réponse, mettez le timestamp de la demande, et un nouveau traité champ: processed: (new Date()).getTime() - req.processed qui contient le nombre de millisecondes qu'il a fallu pour traiter la demande.
    5. Sur le client, lors de la réception d'une réponse, prendre la timestamp (qui est la même chose qui a été envoyé sur pt 1) et de la soustraire à l'heure actuelle, et de soustraire le temps de traitement (processed), et il est votre "réel" du temps de réponse en millisecondes.

    Je pense que vous devriez toujours inclure le temps pour à la fois la demande et la réponse au ping, même si il ya un moyen de communication. C'est parce que c'est le standard dans le sens de "ping" et "temps de latence". Et si c'est un moyen de communication et le temps de latence n'est que la moitié du réel des temps de ping, c'est juste une "bonne chose".

    • C'est ce que j'ai fait la première fois. Mais ce qui ne fonctionne pas, c'est que le client n ° 1 et le client n ° 2 peut-être n'ont pas la même date heure (sur autre fuseau horaire) ou ne sont pas synchronisés. Et comme kanaka a été dit, c'est que le JavaScript date heure est peut-être pas exacts sur le côté client.
    • Si oui ou non il est exact n'a rien à voir avec quoi que ce soit. Chaque client (ou un serveur) qui n'a jamais utilise une date que l'instance crée. L'horodatage est envoyé sur demande, est retourné au client exactement ce qu'elle était. Et le client peut ainsi voir combien de temps il a été depuis la demande a été envoyée, dans son propre temps.
    • Très bonne idée, une description complète. Merci.
    • Fait sens pour moi. Il vous évite d'avoir à faire un autre "ping" appel entre autres appels. Est-il un moyen de mise en prise.io pour inclure automatiquement?
    • vous pouvez simplement modifier la source. Il est open source.
    InformationsquelleAutor Tor Valamo
  4. 4

    Après la lecture de toutes ces réponses...

    ...Je n'étais toujours pas satisfait. J'ai visité l'officiel docs et bien, bien, bien, la solution est déjà intégré.

    Vous avez juste besoin de le mettre en œuvre - découvrez la mienne:

    Client

    //(Connect to socket).

var latency = 0;

socket.on('pong', function(ms) {
    latency = ms;

    console.log(latency);
});

//Do cool things, knowing the latency...

     Serveur

    var server = require('http').Server(app);

//"socket.io": "^1.7.1"
//Set pingInterval to whatever you want - 'pong' gets emitted for you!
var io = require('socket.io')(server, {pingInterval: 5000});
    InformationsquelleAutor Luka
  5. 1

    Heres ma vraiment rapide et sale de script pour tester le ping ... juste la tête pour http://yourserver:8080 dans votre navigateur et de regarder la console (terminal ssh pour moi).

    var http = require('http');
var io = require('socket.io');

server = http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.write('<html>\n');
  res.write('  <head>\n');
  res.write('    <title>Node Ping</title>\n');
  res.write('    <script src="/socket.io/socket.io.js"></script>\n');
  res.write('    <script>\n');
  res.write('        var socket = new io.Socket();\n');
  res.write('        socket.on("connect",function(){ });\n');
  res.write('        socket.on("message",function(){ socket.send(1); });\n');
  res.write('        socket.connect();\n');
  res.write('    </script>\n');
  res.write('  </head>\n');
  res.write('  <body>\n');
  res.write('    <h1>Node Ping</h1>\n');
  res.write('  </body>\n');
  res.write('</html>\n');
  res.end();
});
server.listen(8080);

console.log('Server running at http://127.0.0.1:8080/');

var socket = io.listen(server);

socket.on('connection',function(client){
  var start = new Date().getTime();
  client.send(1);
  client.on('message',function(message){ client.send(1);  console.log( new Date$
  client.on('disconnect',function(){});
});

    Je suis très curieux à ce sujet car il semble que ma pings sont assez élevés(200-400ms aller-retour) sur des grandes vps boîtes w/consacré des ressources à la fois en californie et le new jersey. (Je suis sur la côte est), je suis de paris il y a juste beaucoup de temps de latence sur le vps cases b/c ils servent donc, beaucoup de trafic?

    La chose qui me surprend est qu'un simple ping depuis le terminal linux à partir du même client vers le serveur est 11 ms en moyenne d'un facteur de 10 baisser ... suis-je en train de faire quelque chose de mal ou est quelque chose de lent avec le noeud.js/socket.io/websockets?

    • Sur quel navigateur utilisez-vous votre test? Parce que quand j'ai fait quelques test sur Chrome le PING était autour de 40 ms et de Firefox 3.6.x c'est autour de 350 ms. Je suppose que la différence est principalement parce que Firefox 3.6 n'ont pas nativement le support des websockets de sorte que le module socket.io" va utiliser le Flash pour créer la connexion entre le serveur et le client. Et peut-être le retard est causé par le temps qu'il faut pour que le navigateur communique avec le Flash avec JavaScript. Sur les autres mains, lorsque le navigateur prend en charge les websocket en natif, il n'a pas besoin d'utiliser le Flash.
    • Je travaille dans l'une des dernières nightlies de chrome qui prend en charge les websockets option de transfert. Je vois ce que vous dites au sujet de l'firefox/flash ralentissement et n'ont même pas commencé à s'en inquiéter encore.
    • Après la plus récente mise à jour de la prise.io, il semble que le serveur de temps de réponse ont chuté vers le bas pour ~10ms!
    InformationsquelleAutor Travis
  6. 0

    À lire en premier — Due à de multiples questions: "pourquoi cela est censé fonctionner, permettez-moi de clarifier un peu.

    • Le client en fonction de rappel est exécuté sur le client, c'est pourquoi il a accès à la clôture, y compris les start variable contenant le marqueur de temps. C'est l'accusé de réception (argument) dans le support.io.
    • Le serveur ne peut naturellement pas appeler une fonction arbitraire sur le client et l'accès à la fonction de fermeture. Mais socket.io permet de définir une fonction de rappel, qui semble être exécutée par le serveur, mais cela fait juste passe les arguments de la fonction à travers le web socket, et le client appelle ensuite la fonction de rappel.

    Ce qui se passe ci-dessous (s'il vous plaît ne vérifier l'exemple de code!):

    1. Client stocke timestamp actuel 1453213686429 dans start
    2. Client envoie une ping événement pour le serveur et est en attente d'une réponse
    3. Serveur répond au ping événement avec “s'il vous Plaît appelez votre rappel avec vide d'arguments”
    4. Client reçoit la réponse et les appels clientCallback avec vide d'arguments (Vérifier le code de démonstration si vous voulez voir des arguments)
    5. clientCallback prend encore le timestamp actuel sur le client, par exemple 1453213686449, et sait que 20 ms ont passé depuis qu'il a envoyé la demande.

    Imaginer le druide (client) la tenue d'un chronomètre et en appuyant sur le bouton lorsque le messager (événement) commence à s'exécuter, et en appuyant de nouveau lorsque le messager arrive avec son défilement (les arguments de la fonction). Le druide lit ensuite les faire défiler et ajoute les noms des ingrédients de sa recette de potion et prépare la potion. (rappel)

    Ok, oubliez le paragraphe précédent, je suppose que vous avez obtenu le point.

    Bien que la question a déjà été posée, voici un bref de mise en œuvre pour la vérification de la RTT avec socket.io:

    Client

    var start = Date.now();
this.socket.emit( 'ping', function clientCallback() {
    console.log( 'Websocket RTT: ' + (Date.now() - start) + ' ms' );
} );

    Serveur

    socket.on( 'ping', function ( fn ) {
    fn(); //Simply execute the callback on the client
} );

    Le Code De Démonstration

    Le code de démonstration en tant que nœud du module: socketIO-rappel.tgz à l'installer et l'exécuter avec

    npm install
node callback.js

    puis accédez à http://localhost:5060

    • Pensez-vous vraiment, vous pouvez envoyer un rappel de référence pour le serveur en tant que données, puis de les exécuter sur le serveur et en quelque sorte que de rappel ont même la possibilité d'accéder à une fermeture de la variable sur le client? Ce ne serait même pas venu près de de travail.
    • il n'est pas le passage d'un fn à être appelé, mais plutôt d'appeler le client-rappel pour dire "je l'ai eu". ses un socket.io chose.
    • J'ai ajouté un exemple de code dans la réponse.
    • J'aime vraiment cette approche. Nous utilisons le point où le rappel est exécuté comme un lieu pour vérifier l'heure.
    • Cela ne fonctionnera pas! Vous êtes à la date de prise de temps sur le client, qui est la date et heure de pc/client, si le client établit son pc de temps pour le 01/01/2004 le ping serait plus de dix ans. Pensez à elle.
    • Nope. Vérifiez l'exemple de code. Le rappel est exécuté sur le client aussi. Notez que le serveur n'a pas accès au client, il suffit de demander au client de veuillez appeler la fonction de rappel avec les arguments fournis (le cas échéant). Il n'y a pas de magie là-dedans.
    • Mais vous définir début de la variable sur le côté client, de sorte qu'il serait l'heure réglée sur l'appareil du client
    • J'ai étendu la réponse. Espérons qu'il répond à la question maintenant. Oui, c'est toujours, le temps de l'appareil client, mais vous avez juste besoin de savoir le delta, n'importe pas si c'est en 2016 ou en 1883.

    InformationsquelleAutor Simon A. Eugster