Effectuer une action de nettoyage juste avant la fermeture de Node.js

Je veux dire à Node.js de toujours faire quelque chose juste avant sa sortie, pour une raison quelconque - Ctrl+ C, une exception ou toute autre raison.

J'ai essayé ceci:

process.on('exit', function (){
    console.log('Goodbye!');
});

J'ai commencé le processus, je l'ai tué et rien ne s'est produit. Je l'ai recommencé, j'ai appuyé sur Ctrl+ C, et il ne s'est toujours rien passé ...

METTRE À JOUR:

Vous pouvez enregistrer un gestionnaire pour process.on('exit')et dans tout autre cas ( SIGINTou exception non gérée) appelerprocess.exit()

process.stdin.resume();//so the program will not close instantly

function exitHandler(options, exitCode) {
    if (options.cleanup) console.log('clean');
    if (exitCode || exitCode === 0) console.log(exitCode);
    if (options.exit) process.exit();
}

//do something when app is closing
process.on('exit', exitHandler.bind(null,{cleanup:true}));

//catches ctrl+c event
process.on('SIGINT', exitHandler.bind(null, {exit:true}));

// catches "kill pid" (for example: nodemon restart)
process.on('SIGUSR1', exitHandler.bind(null, {exit:true}));
process.on('SIGUSR2', exitHandler.bind(null, {exit:true}));

//catches uncaught exceptions
process.on('uncaughtException', exitHandler.bind(null, {exit:true}));

Le script ci-dessous permet d'avoir un seul gestionnaire pour toutes les conditions de sortie. Il utilise une fonction de rappel spécifique à l'application pour effectuer un code de nettoyage personnalisé.

cleanup.js

// Object to capture process exits and call app specific cleanup function

function noOp() {};

exports.Cleanup = function Cleanup(callback) {

  // attach user callback to the process event emitter
  // if no callback, it will still exit gracefully on Ctrl-C
  callback = callback || noOp;
  process.on('cleanup',callback);

  // do app specific cleaning before exiting
  process.on('exit', function () {
    process.emit('cleanup');
  });

  // catch ctrl+c event and exit normally
  process.on('SIGINT', function () {
    console.log('Ctrl-C...');
    process.exit(2);
  });

  //catch uncaught exceptions, trace, then exit normally
  process.on('uncaughtException', function(e) {
    console.log('Uncaught Exception...');
    console.log(e.stack);
    process.exit(99);
  });
};

Ce code intercepte les exceptions non capturées, Ctrl+ Cet les événements de sortie normaux. Il appelle ensuite une seule fonction de rappel de nettoyage utilisateur facultatif avant de quitter, gérant toutes les conditions de sortie avec un seul objet.

Le module étend simplement l'objet de processus au lieu de définir un autre émetteur d'événement. Sans rappel spécifique à l'application, le nettoyage par défaut est une fonction no op. Cela était suffisant pour mon utilisation où les processus enfants étaient laissés en cours d'exécution lors de la fermeture par Ctrl+ C.

Vous pouvez facilement ajouter d'autres événements de sortie tels que SIGHUP comme vous le souhaitez. Remarque: selon le manuel NodeJS, SIGKILL ne peut pas avoir d'écouteur. Le code de test ci-dessous illustre différentes façons d'utiliser cleanup.js

// test cleanup.js on version 0.10.21

// loads module and registers app specific cleanup callback...
var cleanup = require('./cleanup').Cleanup(myCleanup);
//var cleanup = require('./cleanup').Cleanup(); // will call noOp

// defines app specific callback...
function myCleanup() {
  console.log('App specific cleanup code...');
};

// All of the following code is only needed for test demo

// Prevents the program from closing instantly
process.stdin.resume();

// Emits an uncaught exception when called because module does not exist
function error() {
  console.log('error');
  var x = require('');
};

// Try each of the following one at a time:

// Uncomment the next line to test exiting on an uncaught exception
//setTimeout(error,2000);

// Uncomment the next line to test exiting normally
//setTimeout(function(){process.exit(3)}, 2000);

// Type Ctrl-C to test forced exit 

Cela intercepte tous les événements de sortie que je peux trouver qui peuvent être gérés. Semble assez fiable et propre jusqu'à présent.

[`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `SIGTERM`].forEach((eventType) => {
  process.on(eventType, cleanUpServer.bind(null, eventType));
})

"exit" est un événement qui se déclenche lorsque le nœud termine sa boucle d'événements en interne, il n'est pas déclenché lorsque vous terminez le processus en externe.

Ce que vous cherchez, c'est exécuter quelque chose sur un SIGINT.

Les documents sur http://nodejs.org/api/process.html#process_signal_events donnent un exemple:

Exemple d'écoute de SIGINT:

// Start reading from stdin so we don't exit.
process.stdin.resume();

process.on('SIGINT', function () {
  console.log('Got SIGINT.  Press Control-D to exit.');
});

Remarque: cela semble interrompre la signature et vous devrez appeler process.exit () lorsque vous aurez terminé avec votre code.

function fnAsyncTest(callback) {
    require('fs').writeFile('async.txt', 'bye!', callback);
}

function fnSyncTest() {
    for (var i = 0; i < 10; i++) {}
}

function killProcess() {

    if (process.exitTimeoutId) {
        return;
    }

    process.exitTimeoutId = setTimeout(() => process.exit, 5000);
    console.log('process will exit in 5 seconds');

    fnAsyncTest(function() {
        console.log('async op. done', arguments);
    });

    if (!fnSyncTest()) {
        console.log('sync op. done');
    }
}

// https://nodejs.org/api/process.html#process_signal_events
process.on('SIGTERM', killProcess);
process.on('SIGINT', killProcess);

process.on('uncaughtException', function(e) {

    console.log('[uncaughtException] app will be terminated: ', e.stack);

    killProcess();
    /**
     * @https://nodejs.org/api/process.html#process_event_uncaughtexception
     *  
     * 'uncaughtException' should be used to perform synchronous cleanup before shutting down the process. 
     * It is not safe to resume normal operation after 'uncaughtException'. 
     * If you do use it, restart your application after every unhandled exception!
     * 
     * You have been warned.
     */
});

console.log('App is running...');
console.log('Try to press CTRL+C or SIGNAL the process with PID: ', process.pid);

process.stdin.resume();
// just for testing

Je voulais juste mentionner death package ici: https://github.com/jprichardson/node-death

Exemple:

var ON_DEATH = require('death')({uncaughtException: true}); //this is intentionally ugly

ON_DEATH(function(signal, err) {
  //clean up code here
})

io.js a un exitet un beforeExitévénement, qui font ce que vous voulez.

Voici un bon hack pour Windows

process.on('exit', async () => {
    require('fs').writeFileSync('./tmp.js', 'crash', 'utf-8')
});

Après avoir joué avec une autre réponse, voici ma solution pour cette tâche. L'implémentation de cette manière m'aide à centraliser le nettoyage en un seul endroit, évitant une double manipulation du nettoyage.

1. Je voudrais acheminer tous les autres codes sortants vers le code «exit».

const others = [`SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `SIGTERM`]
others.forEach((eventType) => {
    process.on(eventType, exitRouter.bind(null, { exit: true }));
})

2. Ce que fait exitRouter, c'est appeler process.exit ()

function exitRouter(options, exitCode) {
   if (exitCode || exitCode === 0) console.log(`ExitCode ${exitCode}`);
   if (options.exit) process.exit();
}

3. À la «sortie», gérez le nettoyage avec une nouvelle fonction

function exitHandler(exitCode) {
  console.log(`ExitCode ${exitCode}`);
  console.log('Exiting finally...')
}

process.on('exit', exitHandler)

Aux fins de démonstration, ceci est un lien vers mon essentiel. Dans le fichier, j'ajoute un setTimeout pour simuler le processus en cours.

Si vous exécutez node node-exit-demo.jset ne faites rien, après 2 secondes, vous voyez le journal:

The service is finish after a while.
ExitCode 0
Exiting finally...

Sinon, si avant la fin du service, vous terminez par ctrl+C, vous verrez:

^CExitCode SIGINT
ExitCode 0
Exiting finally...

Ce qui s'est passé, c'est que le processus Node est sorti initialement avec le code SIGINT, puis il est dirigé vers process.exit () et finalement quitté avec le code de sortie 0.

Dans le cas où le processus a été généré par un autre processus de noeud, comme:

var child = spawn('gulp', ['watch'], {
    stdio: 'inherit',
});

Et vous essayez de le tuer plus tard, via:

child.kill();

Voici comment vous gérez l'événement [sur l'enfant]:

process.on('SIGTERM', function() {
    console.log('Goodbye!');
});