Htykuut

The script below allows having a single handler for all exit conditions. It uses an app specific callback function to perform custom cleanup code.

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

  });

};

This code intercepts uncaught exceptions, Ctrl-C and normal exit events. It then calls a single optional user cleanup callback function before exiting, handling all exit conditions with a single object.

The module simply extends the process object instead of defining another event emitter. Without an app specific callback the cleanup defaults to a no op function. This was sufficient for my use where child processes were left running when exiting by Ctrl-C.

You can easily add other exit events such as SIGHUP as desired. Note: per NodeJS manual, SIGKILL cannot have a listener. The test code below demonstrates various ways of using 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 

"exit" is an event that gets triggered when node finish it's event loop internally, it's not triggered when you terminate the process externally.

What you're looking for is executing something on a SIGINT.

The docs at http://nodejs.org/api/process.html#process_signal_events give an example:

Example of listening for 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.');

});

Note: this seems to interrupt the sigint and you would need to call process.exit() when you finish with your code.

This catches every exit event I can find that can be handled. Seems quite reliable and clean so far.

[`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `SIGTERM`].forEach((eventType) => {

  process.on(eventType, cleanUpServer.bind(null, eventType));

})

Just wanted to mention death package here: https://github.com/jprichardson/node-death

Example:

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



ON_DEATH(function(signal, err) {

  //clean up code here

})

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

io.js has an exit and a beforeExit event, which do what you want.

In the case where the process was spawned by another node process, like:

var child = spawn('gulp', ['watch'], {

    stdio: 'inherit',

});

And you try to kill it later, via:

child.kill();

This is how you handle the event [on the child]:

process.on('SIGTERM', function() {

    console.log('Goodbye!');

});