Qual è il modo migliore per determinare che Tomcat è stato avviato con node.js

Question

Sto creando un'applicazione utilizzando node.js e tale applicazione comunica con un server Tomcat. Mentre il server tomcat è in fase di avvio, non sono sicuro che Tomcat sia pronto o no, per ora uso CURL e WGET su Windows e Mac con un timeout di 2 secondi per continuare a controllare se localhost: 8080 è uscito.

C'è un modo migliore per farlo senza fare affidamento su CURL e WGET?

Answer 1

Beh, è ​​possibile effettuare richieste da Node.JS app:

var http = require("http"); 

var options = { 
    host: "example.com", 
    port: 80, 
    path: "/foo.html" 
}; 

http.get(options, function(resp){ 

    var data = ""; 

    resp.on("data", function(chunk){ 
     data += chunk; 
    }); 

    resp.on("end", function() { 
     console.log(data); 
     // do something with data 
    }); 

}).on("error", function(e){ 
    // HANDLE ERRORS 
    console.log("Got error: " + e.message); 

}).on("socket", function(socket) { 
    // ADD TIMEOUT 
    socket.setTimeout(2000); 
    socket.on("timeout", function() { 
     req.abort(); 
     // or make the request one more time 
    }); 
}); 

Documentazione:

http://nodejs.org/docs/v0.4.11/api/http.html#http.request

Answer 2

Il modo suggerito è quello di creare un servizio di battito cardiaco sull'applicazione Tomcat (cioè un servizio semplice che invia OK quando è attivo) e esegue il polling ogni x secondi.
Un servizio heartbeat è essenziale per il monitoraggio mentre l'applicazione è in esecuzione, e ci sono anche momenti in cui l'applicazione non è pronta anche se è già in ascolto sulla porta (perché è in corso una pesante inizializzazione).

Ci sono altri modi però, se si è sullo stesso server, è possibile tail catalina.out fino a quando si riceve la riga "server avviato".
È possibile configurare l'applicazione tomcat per notificare al server che è attiva (anche se ciò significa che il tomcat deve conoscere l'URL per il server node.js), o in alternativa impostare una sorta di coda messaggi (come ApacheMq o simile) che si può registrarsi quando il tomcat è attivo, ciò consentirà anche i messaggi push tra i due servizi.

Answer 3

È possibile implementare un httpWatcher (che imita il contratto di file watcher - fs.watch). Potrebbe eseguire il polling di un endpoint http (una route di stato o un file html) e generare una richiamata quando viene restituito un 200 (o quando è stata raggiunta una corsa massima). Qualcosa di simile a questo:

var request = require('request'); 

var watch = function(uri) { 
    var options; 
    var callback; 

    if ('object' == typeof arguments[1]) { 
    options = arguments[1]; 
    callback = arguments[2]; 
    } else { 
    options = {}; 
    callback = arguments[1]; 
    } 

    if (options.interval === undefined) options.interval = 2000; 
    if (options.maxRuns === undefined) options.maxRuns = 10; 
    var runCount = 0; 

    var intervalId = setInterval(function() { 
    runCount++; 
    if(runCount > options.maxRuns) { 
     clearInterval(intervalId); 
     callback(null, false); 
    } 

    request(uri, function (error, response, body) { 
      if (!error && response.statusCode == 200) { 
      clearInterval(intervalId); 
      callback(null, true); 
      } 
     }); 
    }, options.interval); 
} 

Quindi utilizzare in questo modo:

watch('http://blah.asdfasdfasdfasdfasdfs.com/', function(err, isGood) { 
    if (!err) { 
     console.log(isGood); 
    } 
}); 

O passare opzioni ...

watch('http://www.google.com/', {interval:1000,maxRuns:3}, 
    function(err, isGood) { 
    if (!err) { 
     console.log(isGood); 
    } 
});