Question

假设我有以下情况-

async.series(
  [
    function (cbi) {
      students.getAll('student', function (err, response) {
        if (err) {
          logger.error(err);
        }
        cbi(err, response);
      });
    },
    function (cbi) {
      students.deleteAll('student', function (err, response) {
        if (err) {
          logger.error(err);
        }
        cbi(err, response);
      });
    },
    function (cbi) {
      teachers.getAll('teacher', function (err, response) {
        if (err) {
          logger.error(err);
        }
        cbi(err, response);
      });
    },
    function (cbi) {
      teachers.deleteAll('teacher', function (err, response) {
        if (err) {
          logger.error(err);
        }
        cbi(err, response);
      });
    };
  ]
);

我想在发送SIGTERM时进行优美的清理。这是对所有学生或所有教师的清理，无论发送信号时正在进行的任何人都应完成，而下一个不应开始。

function (cbi) {
  students.getAll('student', function (err, response) {
    if (err || GLOBAL_VAR_SIGTERM === true) {
      logger.error(err);
    }
    cbi(err, response);
  });
}

我当时在想应该设置一个全局变量来跟踪SIGTERM信号。

process.on('SIGTERM', function onSigterm () {
  GLOBAL_VAR_SIGTERM = true;
}

有没有更好的方法来打破异步序列来打破SIGTERM信号？

Answer 1

如果您想从SIGTERM内部响应async.series()事件，那么您是正确的，最简单的方法是使用全局变量进行跟踪。

但是您需要将cbi(err, response)函数中的第一个参数（错误优先回调）设置为true，以中断序列。

所以：

if (err || GLOBAL_VAR_SIGTERM === true) {
  logger.error(err);
}

应该更像：

if (err) logger.error(err);
if (GLOBAL_VAR_SIGTERM) err = new Error("SIGTERM: Aborting remaining tasks");
// You could just do err = true
// But best practice is to use an Error instance.

然后，因为将使用cbi(err, response)值等于err的{{1}}来调用，其余任务将不会运行。

Answer 2

正如@adamrights在his answer中指出的那样，代码中的主要问题是您没有使用真实的cbi(err, response)第一个参数调用err，这对于停止{{ 1}}继续执行队列中的下一个任务。

现在您的代码应该可以使用了，但是您的代码中有一个重复的模式：

async.series

您传递给每个异步任务的回调始终执行相同的3层处理。我们知道DRY规则，将重复模式提取到另一个函数中以尽可能地重用它总是一个好主意。

因此，应该重复声明工厂函数。而不是重复声明匿名函数。

function (cbi) {
  students.getAll('student', function (err, response) {
    // these 3 lines appear in every callback function
    if (GLOBAL_VAR_SIGTERM) err = new Error("SIGTERM: Aborting remaining tasks");
    if (err) logger.error(err);
    cbi(err, response);
    // end of repeat pattern
  });
}

高级主题：使用装饰器处理横切关注点

让我们进一步探讨这个主题。显然，在收到function callbackFactory(cbi) { return function(err, response) { if (GLOBAL_VAR_SIGTERM) err = new Error("SIGTERM: Aborting remaining tasks"); if (err) logger.error(err); cbi(err, response); } } // use arrow function to write more concise code async.series( [ cbi => students.getAll('student', callbackFactory(cbi)), cbi => students.deleteAll('student', callbackFactory(cbi)), cbi => teachers.getAll('teacher', callbackFactory(cbi)), cbi => teachers.deleteAll('teacher', callbackFactory(cbi)), ] );时提早中止是一个横切关注点，应与业务逻辑分开。假设您的业务逻辑因任务而异：

SIGTERM

由于回调是变化的，因此像以前一样很难提取到工厂函数中。从这个角度来看，我们最好将早期中止的行为注入到每个任务中，使编写常规业务逻辑变得容易。

这是装饰器模式派上用场的地方。但是全局变量并不是实现它的最佳工具，我们将使用事件侦听器。

装饰器的基本界面如下：

async.series(
  [
    cbi => students.getAll('student', (err, response) => {
      if (err) {
        logger.error(err);
        return cbi(err);
      }
      updateStudentCount(response.data.length)  // <- extra work
      cbi(err, response);
    }),
    cbi => teachers.getAll('student', (err, response) => {
      if (err) {
        logger.error(err);
        return cbi(err);
      }
      updateTeacherCount(response.data.length)  // <- different extra work
      cbi(err, response);
    })
  ]
);

以下是我们的实施清单：

如果收到// `task` will be things like `cbi => students.getAll('student', ... )` function decorateTaskAbortEarly(task) { return (originalCbi) => { ... task(originalCbi) } }，我们将致电originalCbi
但是当我们没有收到SIGTERM时，SIGTERM仍然可以在任何异步任务（如正常）的回调中调用
如果曾经一次调用过originalCbi，我们应该退订originalCbi以防止内存泄漏

实现：

SIGTERM

Answer 3

我喜欢其他答案。这是达到相同目的的另一种方法。我使用自己的示例：

var async = require('async');
var ifAsync = require('if-async')
var GLOBAL_VAR_SIGTERM = false;

async.series({
    one: ifAsync(notsigterm).then(function (callback) {
        setTimeout(function () {
            console.log('one');
            callback(null, 1);
        }, 1000);
    }),
    two: ifAsync(notsigterm).then(function (callback) {
        setTimeout(function () {
            console.log('two');
            callback(null, 2);
        }, 1000);
    }),
    three: ifAsync(notsigterm).then(function (callback) {
        setTimeout(function () {
            console.log('three');
            callback(null, 3);
        }, 1000);
    }),
    four: ifAsync(notsigterm).then(function (callback) {
        setTimeout(function () {
            console.log('four');
            callback(null, 4);
        }, 1000);
    }),
}, function (err, results) {
    if (err) {
        //Handle the error in some way. Here we simply throw it
        //Other options: pass it on to an outer callback, log it etc.
        throw err;
    }
    console.log('Results are ' + JSON.stringify(results));
});

process.on('SIGTERM', function onSigterm () {
    console.log('SIGTERM caught');

  GLOBAL_VAR_SIGTERM = true;
});

function notsigterm(callback) {
    if (!GLOBAL_VAR_SIGTERM) return callback(null, true)
    else return callback(null, false)
}

我正在使用一个名为ifAsync的软件包，该软件包允许您使用谓词notsigterm来决定是否应调用回调。如果notsigterm返回true，则将调用回调，否则将跳过该回调。这与其他人的答案相似，但我以某种方式找到了这种清洁剂。如果您有任何问题，请告诉我。

如何打破SIGTERM上的Async系列？

3 个答案:

高级主题：使用装饰器处理横切关注点