Робіть очищення безпосередньо перед виходом Node.js

Я хочу сказати Node.js завжди робити щось безпосередньо перед тим, як воно закінчиться, з будь-якої причини - Ctrl+ C, виняток або будь-яка інша причина.

Я спробував це:

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

Я розпочав процес, вбив його, і нічого не сталося. Я запустив його знову, натиснув Ctrl+ C, і досі нічого не сталося ...

ОНОВЛЕННЯ:

Ви можете зареєструвати обробника для дзвінка process.on('exit')та в будь-якому іншому випадку ( SIGINTабо без обліку)process.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}));

Сценарій нижче дозволяє мати один обробник для всіх умов виходу. Він використовує спеціальну функцію зворотного виклику для виконання додаткового коду очищення.

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

Цей код перехоплює невиконані винятки Ctrl+C та нормальні події виходу. Потім він викликає одну необов'язкову функцію зворотного виклику користувача очищення перед виходом, обробляючи всі умови виходу одним об'єктом.

Модуль просто розширює об'єкт процесу замість визначення іншого випромінювача подій. Без конкретного додатка зворотний виклик очищення за замовчуванням функціонує без опції. Цього було достатньо для мого використання, коли дочірні процеси залишалися запущеними при виході через Ctrl+C .

Ви можете легко додати інші події виходу, наприклад SIGHUP, за бажанням. Примітка. Відповідно до посібника з NodeJS, SIGKILL не може мати слухача. Нижче наведений тестовий код демонструє різні способи використання 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`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `SIGTERM`].forEach((eventType) => {
  process.on(eventType, cleanUpServer.bind(null, eventType));
})

"exit" - це подія, яка спрацьовує, коли вузол закінчує цикл подій внутрішньо, він не спрацьовує, коли ви завершуєте процес зовні.

Те, що ви шукаєте, - це виконати щось на SIGINT.

Документи на веб-сторінці http://nodejs.org/api/process.html#process_signal_events наводять приклад:

Приклад прослуховування для 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.');
});

Примітка: це, здається, перериває підпис і вам потрібно буде викликати process.exit (), коли закінчите свій код.

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

Я просто хотів deathтут згадати пакет: https://github.com/jprichardson/node-death

Приклад:

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

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

У io.js є exitі beforeExitподія, яка робить те, що ви хочете.

Ось приємний злом для вікон

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

Погравши з іншою відповіддю, ось моє рішення цього завдання. Реалізація цього способу допомагає мені централізувати очищення в одному місці, запобігаючи подвійному поводженню з очищенням.

1. Я хотів би спрямувати всі інші вихідні коди до коду "вихід".

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

2. Що робить exitRouter, це викликати process.exit ()

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

3. Під час виходу виконайте очищення за допомогою нової функції

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

process.on('exit', exitHandler)

Для демонстраційних цілей це посилання на мою суть. У файл я додаю setTimeout, щоб підробити процес.

Якщо ви біжите node node-exit-demo.jsі нічого не робите, то через 2 секунди ви побачите журнал:

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

Ще, якщо до завершення послуги ви припините ctrl+C, ви побачите:

^CExitCode SIGINT
ExitCode 0
Exiting finally...

Що трапилося, процес Node, який вийшов із початкового коду SIGINT, потім направляє на process.exit () і, нарешті, виходив з кодом виходу 0.

У випадку, коли процес був породжений іншим процесом вузла, наприклад:

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

І ви намагаєтеся вбити його пізніше, через:

child.kill();

Ось як ви поводитесь із подією [на дитину]:

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