Esecuzione di un'azione di pulizia poco prima della chiusura di Node.js

Voglio dire a Node.js di fare sempre qualcosa prima che esca, per qualsiasi motivo - Ctrl+ C, un'eccezione o qualsiasi altro motivo.

Ho provato questo:

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

Ho iniziato il processo, l'ho ucciso e non è successo niente. L'ho riavviato, ho premuto Ctrl+ Ce ancora non è successo nulla ...

AGGIORNARE:

È possibile registrare un gestore per process.on('exit')e in qualsiasi altro caso ( SIGINTo eccezione non gestita) da chiamareprocess.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}));

Lo script seguente consente di avere un unico gestore per tutte le condizioni di uscita. Utilizza una funzione di richiamata specifica dell'app per eseguire codice di pulizia personalizzato.

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);
  });
};

Questo codice intercetta le eccezioni non rilevate, Ctrl+ Ce gli eventi di uscita normali. Quindi chiama una singola funzione di callback di pulizia utente opzionale prima di uscire, gestendo tutte le condizioni di uscita con un singolo oggetto.

Il modulo estende semplicemente l'oggetto di processo invece di definire un altro emettitore di eventi. Senza una callback specifica per l'app, la pulizia viene automaticamente impostata su una funzione no op. Questo era sufficiente per il mio uso in cui i processi figlio venivano lasciati in esecuzione all'uscita da Ctrl+ C.

Puoi facilmente aggiungere altri eventi di uscita come SIGHUP, se lo desideri. Nota: secondo il manuale di NodeJS, SIGKILL non può avere un ascoltatore. Il codice di test seguente mostra vari modi di usare 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 

Questo cattura ogni evento di uscita che posso trovare che può essere gestito. Sembra abbastanza affidabile e pulito finora.

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

"exit" è un evento che viene attivato quando il nodo termina il suo ciclo di eventi internamente, non viene attivato quando si termina il processo esternamente.

Quello che stai cercando è eseguire qualcosa su un SIGINT.

I documenti su http://nodejs.org/api/process.html#process_signal_events forniscono un esempio:

Esempio di ascolto per 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.');
});

Nota: questo sembra interrompere il sigint e dovresti chiamare process.exit () quando finisci con il tuo codice.

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

Volevo solo menzionare il deathpacchetto qui: https://github.com/jprichardson/node-death

Esempio:

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

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

io.js ha un exite un beforeExitevento, che fanno quello che vuoi.

Ecco un bel trucco per Windows

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

Dopo aver giocato con altre risposte, ecco la mia soluzione per questo compito. L'implementazione in questo modo mi aiuta a centralizzare la pulizia in un unico posto, evitando la doppia gestione della pulizia.

1. Vorrei instradare tutti gli altri codici in uscita verso il codice "exit".

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

2. Quello che fa exitRouter sta chiamando process.exit ()

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

3. All'uscita, gestisci la pulizia con una nuova funzione

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

process.on('exit', exitHandler)

Ai fini della demo, questo è il link al mio contenuto. Nel file, aggiungo un setTimeout per simulare il processo in esecuzione.

Se corri node node-exit-demo.jse non fai nulla, dopo 2 secondi viene visualizzato il registro:

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

Altrimenti se prima che il servizio finisca, si termina ctrl+C, vedrai:

^CExitCode SIGINT
ExitCode 0
Exiting finally...

Quello che è successo è il processo Node uscito inizialmente con il codice SIGINT, quindi instrada a process.exit () e infine è uscito con il codice di uscita 0.

Nel caso in cui il processo sia stato generato da un altro processo del nodo, come:

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

E cerchi di ucciderlo in seguito, tramite:

child.kill();

Ecco come gestisci l'evento [sul figlio]:

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