Comment faire pour attraper des exceptions de requête client http dans node.js

Question

J'ai une application node.js que je veux utiliser pour vérifier si un site particulier est en place et renvoyer le code de réponse approprié. Je veux pouvoir détecter les erreurs qui surviennent lorsque le nom de domaine ne se résout pas ou que la demande expire. Le problème est que ces erreurs font que Node se cache. Je suis novice dans cette méthodologie de programmation asynchrone, donc je ne sais pas où placer mes instructions try/catch.

J'ai un appel ajax qui va à quelque chose comme/check/site1. Côté serveur qui appelle une fonction qui tente de se connecter puis retourne le statusCode. C'est une fonction très simple, et j'ai enveloppé chaque ligne dans un try/catch et ça n'attrape jamais rien. Ici, il est:

function checkSite(url){ 
    var site = http.createClient(80, url); 
    var request = site.request('GET', '/', {'host': url}); 
    request.end(); 
    return request; 
    } 

Même avec chacune de ces lignes enveloppées dans un try/catch, je vais quand même obtenir des exceptions non rattrapées comme EHOSTUNREACH et ainsi de suite. Je veux être en mesure d'attraper ceux-ci et de le renvoyer à l'appel ajax.

Des recommandations sur quoi essayer ensuite?

Answer 1

http.createClient a été déprécié.

Voici un exemple rapide de la façon de gérer les erreurs en utilisant la nouvelle http.request:

var http = require("http"); 

var options = { 
    host : "www.example.com" 
}; 

var request = http.request(options, function(req) { 
    ... 
}); 
request.on('error', function(err) { 
    // Handle error 
}); 

request.end(); 

Answer 2

Malheureusement, pour le moment, il n'y a aucun moyen d'attraper directement ces exceptions, car tout se passe de manière asynchrone en arrière-plan.

Tout ce que vous pouvez faire est d'attraper les uncaughtException « s sur votre propre:

var http = require('http'); 

function checkSite(url){ 
    var site = http.createClient(800, url); 
    var request = site.request('GET', '/', {'host': url}); 
    request.end(); 
    return request; 
} 

process.on('uncaughtException', function (err) { 
    console.log(err); 
}); 

checkSite('http://127.0.0.1'); 

dans ce cas (port préavis 800) logs:

{ message: 'ECONNREFUSED, Connection refused', 
    stack: [Getter/Setter], 
    errno: 111, 
    syscall: 'connect' } 

Node.js est toujours sous le développement lourd et il y aura certainement beaucoup de progrès au cours des deux prochains mois, en ce moment l'accent semble être sur la correction des bogues de performance pour 3.x et de rendre l'API quelque peu stable, car après tout Node.js est principalement un serveur le débit est important Cependant, vous pouvez file a bug, mais sachez que les plantages, etc. ont une priorité plus élevée que les fonctionnalités, et la plupart des nouvelles fonctionnalités le font via des demandes de pull-over.

également pour la feuille de route actuelle de Node.js regarder ce discours par Ryan Dahl (le créateur du nœud):
http://developer.yahoo.com/yui/theater/video.php?v=yuiconf2010-dahl

Answer 3

je suis tombé sur une autre solution alors que je faisais des recherches sur un problème similaire. http.Client émet un événement 'error' si une connexion ne peut pas être établie pour une raison quelconque. Si vous gérez cet événement alors l'exception ne sera pas jeté:

var http = require('http'); 
var sys = require('sys'); 

function checkSite(url) { 
    var site = http.createClient(80, url); 
    site.on('error', function(err) { 
     sys.debug('unable to connect to ' + url); 
    }); 
    var request = site.request('GET', '/', {'host': url}); 
    request.end(); 
    request.on('response', function(res) { 
     sys.debug('status code: ' + res.statusCode); 
    }); 
} 

checkSite("www.google.com"); 
checkSite("foo.bar.blrfl.org"); 

Bien sûr, l'erreur de connexion et la réponse à la demande les deux arrivent de façon asynchrone, ce qui signifie que le simple fait de retourner la demande ne fonctionnera pas. Au lieu de cela, vous devez informer l'appelant des résultats provenant des gestionnaires d'événements.