comparison basictest.js @ 72:9af4250ff7d5

added file to test why static webserver doesnt work on home machine - using connect now instead of node-static this will be pushed into the main nodescore.js once its cleaned up

+/*
+////////////////////////////////////////////
+
+nodescore server
+nodescore.kiben.net
[e-mail]
+
+////////////////////////////////////////////
+*/
+
+var sio = require('socket.io')
+, http = require('http')
+, ch = require('./chronometer')
+, url = require('url')
+, path = require('path')
+, fs = require('fs')
+, connect = require('connect')
+, static = require('node-static');
+
+var mimeTypes = {
+    "html": "text/html",
+    "jpeg": "image/jpeg",
+    "jpg": "image/jpeg",
+    "png": "image/png",
+    "js": "text/javascript",
+    "css": "text/css"};
+
+var requirejs = require('requirejs');
+
+requirejs.config({
+    //Pass the top-level main.js/index.js require
+    //function to requirejs so that node modules
+    //are loaded relative to the top-level JS file.
+    nodeRequire: require,
+    findNestedDependencies: true
+});
+
+var pinging=0
+console.log("ping set to 0")
+
+// run webserver serving static html
+////////////////////////////////////////////
+var httpServer = connect()
+  .use(connect.logger('dev'))
+  .use(connect.static('www'))
+  .use(function(req, res){
+    res.end('404\n');
+  })
+ .listen(8890);
+
+////////////////////////////////////////////
+// connect to websockets 
+////////////////////////////////////////////
+
+
+io = sio.listen(httpServer)
+, nicknames = {};
+
+//var sequencer = require('./sequencer')
+
+io.set('log level', 4); // reduce logging
+io.sockets.on('connection', function (socket) {
+
+    socket.on('nickname', function (nick, fn) {
+	if (nicknames[nick]) {
+	    fn(true);
+	} else {
+	    fn(false);
+	    nicknames[nick] = socket.nickname = nick;
+	    socket.broadcast.emit('announcement', nick + ' connected');
+	    io.sockets.emit('nicknames', nicknames);
+	}
+    });  
+    
+    /// chat user messages to screens and to log file
+    // date format for filename
+    var da = new Date(); var dtstring = da.getFullYear()+ '-' + da.getMonth()+ '-' + da.getDate();
+    ////////////////////////
+    /// log messages to file
+    socket.on('user message', function (msg) {
+	fs.open('logs/chatlog-'+dtstring+'.txt', 'a', 666, function( e, id ) {	
+	    //time format for message stamp
+	    var dt = new Date();var timestring = dt.getHours() + ':' + dt.getMinutes() + ':' + dt.getSeconds();
+	    socket.broadcast.emit('user message', socket.nickname, msg);	    
+	    var fs = require('fs'), str = msg;
+	    fs.write( id, timestring+" " + socket.nickname + ": "+ msg+"\n", null, 'utf8', function(){});
+	});	
+    });
+
+    ////////////////////////////////////////////
+    // chronometer + sequencer controls (all this should be modularised)
+    ////////////////////////////////////////////
+
+    socket.on('stopWatch', function (state) { stopWatch(state);});
+    socket.on('stopChr', function () { stopChr();  });    
+    socket.on('resetChr', function () { resetChr();});
+    socket.on('startSeq', function () { startChr(); });  
+    var chronstate=0;
+
+    // send the date/time every second
+
+    xdatetime =  setInterval(function () {
+	d =  ch.xdateTime()
+	socket.broadcast.emit('dateTime', d)
+	socket.emit('dateTime', d)	
+    }, 1000)
+              
+    //////////////////////////////
+    //    /* this should be moved to its own file chronometer.js
+    
+    function chronCtrl (state,interval){
+	if (state==1){ console.log("chronControl....onestate")
+		       var date = new Date(); var starttime = new Date().getTime() / 1000;
+		       xstopwatch =  setInterval(function () {
+			   var nowtime = new Date().getTime() / 1000;
+			   now = nowtime-starttime
+			   hours = parseInt( now / 3600 ) % 24;
+			   minutes = parseInt( now / 60 ) % 60;
+			   seconds = parseInt(now  % 60);
+			   milliseconds = Math.floor((now-seconds)*10)%60;
+			   time = 
+			       (hours < 10 ? "0" + hours : hours) + ":" + 
+			       (minutes < 10 ? "0" + minutes : minutes) + ":" + 
+			       (seconds  < 10 ? "0" + seconds : seconds) + "."+ 
+			       milliseconds;
+			   socket.broadcast.emit('chronFromServer', time)
+			   socket.emit('chronFromServer', time)
+		       }, 100)
+		     }
+	
+	if (state==0) { console.log("chronControl....zerostate") ; clearInterval(xstopwatch); }	
+   
+    }
+
+
+    // if not already started start the chronometer and sequencer    
+    function startChr(socket) { chronCtrl(1,100); step(seqA);step(seqB); step(seqC); step(seqD); }
+    // stop the chronometer   
+    function stopChr() { console.log("stop chron"); chronCtrl(0); }  
+    
+    function pad(number) { return (number < 10 ? '0' : '') + number }
+    function resetChr() {//clearInterval();
+	zecsec = 0; seconds = 0; mins = 0; hours = 0; 
+	var chron = pad(hours) +":"+pad(mins)+ ':'+ pad(seconds)+ ":"+ zecsec
+	// send 0.00.00 values to display
+	socket.broadcast.emit('chronFromServer', chron)
+	socket.emit('chronFromServer', chron)
+    }
+
+    ////////////////////////////////////////////
+    // magic square sequencer (this should be modularised)
+    ////////////////////////////////////////////
+    // all the variables this sequencer needs are in scoreB.js
+    requirejs(['scoreB'],function(scoreB) {});
+    
+    var sequencerState=0;
+    var numberoftransects=3
+    var order=8
+    var countdowntick=function(seq){
+	var unit=seq.units[seq.transect%numberoftransects][seq.counter];
+	var unitlast=seq.units[seq.transect%numberoftransects][seq.counter-1];
+	var voice=seq.voice;
+	var tempoms = Math.floor(60000/seq.mm)	
+	var timemultiplier=1000
+	var outcount=4; var incount=4;
+	var dur=srcsqr[Math.floor(unit/order)][unit%order] + 4
+	var time = dur;
+	var ztime=time; 
+	var totaltime=time
+	initPage=function(seq){
+	    // initiate first page here
+	    socket.emit("pageIni", voice, unit, time, seq.mm,seq.counter,seq.nextunit );
+	    socket.emit("pageFlipfromserver", voice, unit, time, seq.mm,seq.counter,seq.nextunit );
+	}
+
+	function sequenCer() {
+	    if (ztime >= 0 ){	
+		var counter = ztime
+		// flip the page 
+		if (counter == 0){	
+		    //increment the row position
+		    seq.counter = (seq.counter + 1) % (order)	    				
+		    //increment the transect
+		    if ( seq.counter==0 ){ seq.transect += 1 }
+		    socket.broadcast.emit("pageFlipfromserver", voice, unit, time, seq.mm,seq.counter,seq.nextunit);
+		    clearInterval(pulse)
+		    step(seq);     
+		}
+		
+		if (counter >= 0 ){
+		    socket.broadcast.emit('counterText', 
+					  voice, unit, counter,seq.counter,unitlast,seq.transect%numberoftransects);
+		    socket.emit('counterText',
+				voice, unit, counter,seq.counter,unitlast,seq.transect%numberoftransects);
+		    
+		    if (counter <= outcount ) {
+			socket.broadcast.emit('countinFromServer', 
+					      voice, counter, 
+					      "","stop in: ", "red", "transparent",unit);
+			socket.emit('countinFromServer', 
+				    voice, counter, 
+				    "","stop in: ", "red", "transparent",unit);
+		    }
+		    
+		    if (counter > (totaltime)-incount  && counter <= totaltime ) {
+			socket.broadcast.emit('countinFromServer',
+					      voice, counter-(totaltime-incount), 
+					      "","play in: ", "green","transparent",unit);
+			socket.emit('countinFromServer',
+				    voice,counter-(totaltime-incount), 
+				    "","play in: ", "green","transparent",unit);
+		    }
+		    
+		    if (counter == (totaltime)-incount ) {
+			socket.broadcast.emit('countinFromServer',
+					      voice, "+", 
+					      "","playing.. ", "green","transparent",unit);
+			socket.emit('countinFromServer',
+				    voice, "+",
+				    "","playing.. ", "green","transparent",unit);
+		    }
+		}		    
+
+		// on each beat do:		
+		// push out the pulse to metronome	
+		seq.metrobeat = (seq.metrobeat+1)%seq.beatsinbar ;
+     		socket.broadcast.emit('metroPulse', tempoms, voice,seq.metrobeat); 
+		socket.emit('metroPulse', tempoms, voice, seq.metrobeat);
+	    }
+	    
+	    // decrement the time 
+	    ztime -= 1
+
+// this shows undefined counter output - bug related	    
+//	    console.log(counter)
+	}
+	
+	var pulse = setInterval(sequenCer, tempoms);
+	
+	socket.on('stopSeq', function () {
+	    sequenCer.clearInterval
+	    console.log("sequencer stopping...")	    
+	    // grrr why wont this clearInterval work
+	    sequencerState = 0
+	    clearInterval(pulse)
+	    sequenCer.clearInterval(pulse)
+	    stopChr();	    
+	});
+    };
+    
+    step = function (seq) {
+	clearInterval(countdowntick);
+	countdowntick(seq)
+	sequencerState=1;
+	initPage(seq)
+    };
+    
+    socket.on('resetSeq', 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) {
+	if (pinging==0){ st = setInterval(function() {
+	    var pinging=1;
+	    var d = new Date(); var n = d.getTime(); 
+	    socket.emit("timeFromServer", n); 
+	}, 1000);   } else console.log("already pinging")
+    }
+    // receive 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);
+    });	      
+    
+
+    
+    serverTime(1000);
+    
+    socket.on('disconnect', function(client) {	
+	console.log(socket.nickname + " is gone..." )
+	clearInterval(st);
+	
+	if (!socket.nickname) return;
+	
+	delete nicknames[socket.nickname];
+	socket.broadcast.emit('announcement', socket.nickname + ' disconnected');
+	socket.broadcast.emit('nicknames', nicknames);
+    });
+
+});
+
+exports.socket= io.sockets;
+exports.httpServer = httpServer;
+
+