comparison nodescore.js @ 24:22f1c38007ff

latency ping pong check added for clients

 , http = require('http')
 , fs = require('fs')
 ,  $ = require('jQuery')
 , static = require('node-static');
 
+var bla
+var pinging=0
+    console.log("ping set to 0")
 
 // run webserver serving static html
 ////////////////////////////////////////////
 
 var clientFiles = new static.Server('./www');

 ////////////////////////////////////////////
 
 var io = sio.listen(httpServer)
 , nicknames = {};
 
-io.set('log level', 2); // reduce logging
+io.set('log level', 2); // reduce loggingi
 io.sockets.on('connection', function (socket) {
 
     ////////////////////////////////////////////
     // metronome
     ////////////////////////////////////////////

     
     socket.on('startChr', function () { startChr();});
     socket.on('stopChr', function () { stopChr();});
     socket.on('resetChr', function () { resetChr();});
 
-    ////////////////////////////////////////////  
-    // some latency calculations
-    ///////////////////////////////////////////
-
-    /*
-      a ping is periodically broadcast to all connected clients each
-      connected returns a pong to the server via an "emit" and in turn
-      the server returns each unique client a report of the latency
-      via another emit - the emit only sends to the source of the
-      request, whereas the broadcast.emit..  broadcasts.. ie to all
-      connected clients
-
-      TODO: smooth range and average out results to remove erratic ping
-      times.
-
-      TODO:
-      The result then needs to be used to stagger outgoing messages to
-      compensate for latency - how much compensation is more connected
-      to the time that any audio/video feed needs to encode/decode as
-      the latency of the route from node A to node B is inavoidable?!
-      so maybe latency is irrelevant in this context - we just need to
-      stagger signals according to encoding decoding times.. hmmm
-    */
-    
-
-
-// periodically broadcast  a ping
-
-    function serverTime(freq) {
-	//	clearInterval();
-	st=setInterval(function() {
-	    var d = new Date(); var n = d.getTime(); 
-	    socket.emit("timeFromServer", n); 
-	    socket.broadcast.emit("timeFromServer", n); 
-
-	}, freq);   
-    }
-
-    // recieve the pong calculate the latency and
-    // return the response to the client
-
-    socket.on("clientTimeResponse", function(x) {
-	var d = new Date(); var n = d.getTime();
-	var latency = (n-x)/2;
-	//console.log("SERVERTIME:"+x + " LATENCY:" + latency);
-	socket.emit("latencyFromServer", latency);
-
-    });	      
-
-    // this is the trigger from the control client to start the process
-    // maybe remove this and have latency connections constantly running
-    
-    socket.on("getLatencies", function(x){
-	serverTime(x);
-    });
+
+
 
     ////////////////////////////////////////////
     // magic square sequencer
     ////////////////////////////////////////////
 

 	resetChr();
 	
     });
 
 
+
+    ////////////////////////////////////////////  
+    // some latency calculations
+    ///////////////////////////////////////////
+
+    /*
+      a ping is periodically broadcast to all connected clients each
+      connected returns a pong to the server via an "emit" and in turn
+      the server returns each unique client a report of the latency
+      via another emit - the emit only sends to the source of the
+      request, whereas the broadcast.emit..  broadcasts.. ie to all
+      connected clients
+
+      TODO: smooth range and average out results to remove erratic ping
+      times.
+
+      TODO:
+      The result then needs to be used to stagger outgoing messages to
+      compensate for latency - how much compensation is more connected
+      to the time that any audio/video feed needs to encode/decode as
+      the latency of the route from node A to node B is inavoidable?!
+      so maybe latency is irrelevant in this context - we just need to
+      stagger signals according to encoding decoding times.. hmmm
+    */
+    
+
+
+// periodically broadcast  a ping
+  
+    function serverTime(freq) {
+
+	if (pinging==0){
+	st = setInterval(function() {
+	    var pinging=1;
+	    var d = new Date(); var n = d.getTime(); 
+	    socket.emit("timeFromServer", n); 
+	    //socket.broadcast.emit("timeFromServer", n); 	    
+	}, 1000);   }
+	else console.log("already pinging")
+    }
+
+    // recieve the pong calculate the latency and
+    // return the response to the client
+
+    socket.on("clientTimeResponse", function(x) {
+	var d = new Date(); var n = d.getTime();
+	var latency = (n-x)/2;
+	//console.log("SERVERTIME:"+x + " LATENCY:" + latency);
+	socket.emit("latencyFromServer", latency);
+
+    });	      
+
+    // this is the trigger from the control client to start the process
+    // maybe remove this and have latency connections constantly running
+    /*
+    socket.on("getLatencies", function(x){
+	serverTime(x);
+    });
+    */
+
+    serverTime(1000);
+
+    socket.on('disconnect', function(client) {
+	console.log(client + " is gone..." )
+	clearInterval(st);
+    });
+    
 });
 
 
 
+