Node.js - Module de domaine

Node.js domainLe module est utilisé pour intercepter les erreurs non gérées. Ces erreurs non gérées peuvent être interceptées à l'aide d'une liaison interne ou externe. Si les erreurs ne sont pas du tout gérées, elles planteront simplement l'application Node.

  • Internal Binding - L'émetteur d'erreur exécute son code dans la méthode d'exécution d'un domaine.

  • External Binding - L'émetteur d'erreur est ajouté explicitement à un domaine en utilisant sa méthode add.

Ce module peut être importé en utilisant la syntaxe suivante.

var domain = require("domain")

La classe de domaine du module de domaine est utilisée pour fournir des fonctionnalités d'erreurs de routage et d'exceptions non interceptées à l'objet de domaine actif. Il s'agit d'une classe enfant d'EventEmitter. Pour gérer les erreurs détectées, écoutez son événement d'erreur. Il est créé en utilisant la syntaxe suivante -

var domain = require("domain");
var child = domain.create();

Méthodes

N ° Sr. Méthode et description
1

domain.run(function)

Exécutez la fonction fournie dans le contexte du domaine, en liant implicitement tous les émetteurs d'événements, minuteries et demandes de bas niveau créés dans ce contexte. C'est la manière la plus simple d'utiliser un domaine.
2

domain.add(emitter)

Ajoute explicitement un émetteur au domaine. Si des gestionnaires d'événements appelés par l'émetteur lancent une erreur, ou si l'émetteur émet un événement d'erreur, il sera acheminé vers l'événement d'erreur du domaine, tout comme avec une liaison implicite.
3

domain.remove(emitter)

Le contraire de domain.add (émetteur). Supprime la gestion de domaine de l'émetteur spécifié.
4

domain.bind(callback)

La fonction retournée sera un wrapper autour de la fonction de rappel fournie. Lorsque la fonction retournée est appelée, toutes les erreurs levées seront acheminées vers l'événement d'erreur du domaine.
5

domain.intercept(callback)

Cette méthode est presque identique à domain.bind (callback). Cependant, en plus de détecter les erreurs lancées, il interceptera également les objets Error envoyés comme premier argument de la fonction.
6

domain.enter()

La méthode enter est la plomberie utilisée par les méthodes d'exécution, de liaison et d'interception pour définir le domaine actif. Il définit domain.active et process.domain sur le domaine, et pousse implicitement le domaine sur la pile de domaines gérée par le module de domaine (voir domain.exit () pour plus de détails sur la pile de domaines). L'appel à enter délimite le début d'une chaîne d'appels asynchrones et d'opérations d'E / S liées à un domaine.
sept

domain.exit()

La méthode exit quitte le domaine actuel, le faisant sortir de la pile de domaines. Chaque fois que l'exécution bascule vers le contexte d'une chaîne différente d'appels asynchrones, il est important de s'assurer que le domaine actuel est quitté. L'appel à exit délimite la fin ou une interruption de la chaîne des appels asynchrones et des opérations d'E / S liées à un domaine.
8

domain.dispose()

Une fois que dispose a été appelé, le domaine ne sera plus utilisé par les rappels liés au domaine via run, bind ou intercept, et un événement de suppression est émis

Propriétés

S.No. Propriété et description
1

domain.members

Un tableau de minuteries et d'émetteurs d'événements qui ont été explicitement ajoutés au domaine.

Exemple

Créez un fichier js nommé main.js avec le code suivant -

var EventEmitter = require("events").EventEmitter;
var domain = require("domain");

var emitter1 = new EventEmitter();

// Create a domain
var domain1 = domain.create();

domain1.on('error', function(err) {
   console.log("domain1 handled this error ("+err.message+")");
});

// Explicit binding 
domain1.add(emitter1);

emitter1.on('error',function(err) {
   console.log("listener handled this error ("+err.message+")");
});

emitter1.emit('error',new Error('To be handled by listener'));
emitter1.removeAllListeners('error');
emitter1.emit('error',new Error('To be handled by domain1'));

var domain2 = domain.create();

domain2.on('error', function(err) {
   console.log("domain2 handled this error ("+err.message+")");
});

// Implicit binding
domain2.run(function() {
   var emitter2 = new EventEmitter();
   emitter2.emit('error',new Error('To be handled by domain2'));   
});

domain1.remove(emitter1);
emitter1.emit('error', new Error('Converted to exception. System will crash!'));

Maintenant, exécutez le main.js pour voir le résultat -

$ node main.js

Vérifiez la sortie.

listener handled this error (To be handled by listener)
domain1 handled this error (To be handled by domain1)
domain2 handled this error (To be handled by domain2)

events.js:72 throw er; // Unhandled 'error' event
         ^
Error: Converted to exception. System will crash!
   at Object. (/web/com/1427722220_30772/main.js:40:24)
   at Module._compile (module.js:456:26)
   at Object.Module._extensions..js (module.js:474:10)
   at Module.load (module.js:356:32)
   at Function.Module._load (module.js:312:12)
   at Function.Module.runMain (module.js:497:10)
   at startup (node.js:119:16)
   at node.js:906:3