289 lines
9.6 KiB
JavaScript
289 lines
9.6 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
exports.default = function (tasks, concurrency, callback) {
|
|
if (typeof concurrency === 'function') {
|
|
// concurrency is optional, shift the args.
|
|
callback = concurrency;
|
|
concurrency = null;
|
|
}
|
|
callback = (0, _once2.default)(callback || _noop2.default);
|
|
var keys = (0, _keys2.default)(tasks);
|
|
var numTasks = keys.length;
|
|
if (!numTasks) {
|
|
return callback(null);
|
|
}
|
|
if (!concurrency) {
|
|
concurrency = numTasks;
|
|
}
|
|
|
|
var results = {};
|
|
var runningTasks = 0;
|
|
var hasError = false;
|
|
|
|
var listeners = Object.create(null);
|
|
|
|
var readyTasks = [];
|
|
|
|
// for cycle detection:
|
|
var readyToCheck = []; // tasks that have been identified as reachable
|
|
// without the possibility of returning to an ancestor task
|
|
var uncheckedDependencies = {};
|
|
|
|
(0, _baseForOwn2.default)(tasks, function (task, key) {
|
|
if (!(0, _isArray2.default)(task)) {
|
|
// no dependencies
|
|
enqueueTask(key, [task]);
|
|
readyToCheck.push(key);
|
|
return;
|
|
}
|
|
|
|
var dependencies = task.slice(0, task.length - 1);
|
|
var remainingDependencies = dependencies.length;
|
|
if (remainingDependencies === 0) {
|
|
enqueueTask(key, task);
|
|
readyToCheck.push(key);
|
|
return;
|
|
}
|
|
uncheckedDependencies[key] = remainingDependencies;
|
|
|
|
(0, _arrayEach2.default)(dependencies, function (dependencyName) {
|
|
if (!tasks[dependencyName]) {
|
|
throw new Error('async.auto task `' + key + '` has a non-existent dependency `' + dependencyName + '` in ' + dependencies.join(', '));
|
|
}
|
|
addListener(dependencyName, function () {
|
|
remainingDependencies--;
|
|
if (remainingDependencies === 0) {
|
|
enqueueTask(key, task);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
checkForDeadlocks();
|
|
processQueue();
|
|
|
|
function enqueueTask(key, task) {
|
|
readyTasks.push(function () {
|
|
runTask(key, task);
|
|
});
|
|
}
|
|
|
|
function processQueue() {
|
|
if (readyTasks.length === 0 && runningTasks === 0) {
|
|
return callback(null, results);
|
|
}
|
|
while (readyTasks.length && runningTasks < concurrency) {
|
|
var run = readyTasks.shift();
|
|
run();
|
|
}
|
|
}
|
|
|
|
function addListener(taskName, fn) {
|
|
var taskListeners = listeners[taskName];
|
|
if (!taskListeners) {
|
|
taskListeners = listeners[taskName] = [];
|
|
}
|
|
|
|
taskListeners.push(fn);
|
|
}
|
|
|
|
function taskComplete(taskName) {
|
|
var taskListeners = listeners[taskName] || [];
|
|
(0, _arrayEach2.default)(taskListeners, function (fn) {
|
|
fn();
|
|
});
|
|
processQueue();
|
|
}
|
|
|
|
function runTask(key, task) {
|
|
if (hasError) return;
|
|
|
|
var taskCallback = (0, _onlyOnce2.default)(function (err, result) {
|
|
runningTasks--;
|
|
if (arguments.length > 2) {
|
|
result = (0, _slice2.default)(arguments, 1);
|
|
}
|
|
if (err) {
|
|
var safeResults = {};
|
|
(0, _baseForOwn2.default)(results, function (val, rkey) {
|
|
safeResults[rkey] = val;
|
|
});
|
|
safeResults[key] = result;
|
|
hasError = true;
|
|
listeners = Object.create(null);
|
|
|
|
callback(err, safeResults);
|
|
} else {
|
|
results[key] = result;
|
|
taskComplete(key);
|
|
}
|
|
});
|
|
|
|
runningTasks++;
|
|
var taskFn = (0, _wrapAsync2.default)(task[task.length - 1]);
|
|
if (task.length > 1) {
|
|
taskFn(results, taskCallback);
|
|
} else {
|
|
taskFn(taskCallback);
|
|
}
|
|
}
|
|
|
|
function checkForDeadlocks() {
|
|
// Kahn's algorithm
|
|
// https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm
|
|
// http://connalle.blogspot.com/2013/10/topological-sortingkahn-algorithm.html
|
|
var currentTask;
|
|
var counter = 0;
|
|
while (readyToCheck.length) {
|
|
currentTask = readyToCheck.pop();
|
|
counter++;
|
|
(0, _arrayEach2.default)(getDependents(currentTask), function (dependent) {
|
|
if (--uncheckedDependencies[dependent] === 0) {
|
|
readyToCheck.push(dependent);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (counter !== numTasks) {
|
|
throw new Error('async.auto cannot execute tasks due to a recursive dependency');
|
|
}
|
|
}
|
|
|
|
function getDependents(taskName) {
|
|
var result = [];
|
|
(0, _baseForOwn2.default)(tasks, function (task, key) {
|
|
if ((0, _isArray2.default)(task) && (0, _baseIndexOf2.default)(task, taskName, 0) >= 0) {
|
|
result.push(key);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
};
|
|
|
|
var _arrayEach = require('lodash/_arrayEach');
|
|
|
|
var _arrayEach2 = _interopRequireDefault(_arrayEach);
|
|
|
|
var _baseForOwn = require('lodash/_baseForOwn');
|
|
|
|
var _baseForOwn2 = _interopRequireDefault(_baseForOwn);
|
|
|
|
var _baseIndexOf = require('lodash/_baseIndexOf');
|
|
|
|
var _baseIndexOf2 = _interopRequireDefault(_baseIndexOf);
|
|
|
|
var _isArray = require('lodash/isArray');
|
|
|
|
var _isArray2 = _interopRequireDefault(_isArray);
|
|
|
|
var _keys = require('lodash/keys');
|
|
|
|
var _keys2 = _interopRequireDefault(_keys);
|
|
|
|
var _noop = require('lodash/noop');
|
|
|
|
var _noop2 = _interopRequireDefault(_noop);
|
|
|
|
var _slice = require('./internal/slice');
|
|
|
|
var _slice2 = _interopRequireDefault(_slice);
|
|
|
|
var _once = require('./internal/once');
|
|
|
|
var _once2 = _interopRequireDefault(_once);
|
|
|
|
var _onlyOnce = require('./internal/onlyOnce');
|
|
|
|
var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
|
|
|
|
var _wrapAsync = require('./internal/wrapAsync');
|
|
|
|
var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
module.exports = exports['default'];
|
|
|
|
/**
|
|
* Determines the best order for running the {@link AsyncFunction}s in `tasks`, based on
|
|
* their requirements. Each function can optionally depend on other functions
|
|
* being completed first, and each function is run as soon as its requirements
|
|
* are satisfied.
|
|
*
|
|
* If any of the {@link AsyncFunction}s pass an error to their callback, the `auto` sequence
|
|
* will stop. Further tasks will not execute (so any other functions depending
|
|
* on it will not run), and the main `callback` is immediately called with the
|
|
* error.
|
|
*
|
|
* {@link AsyncFunction}s also receive an object containing the results of functions which
|
|
* have completed so far as the first argument, if they have dependencies. If a
|
|
* task function has no dependencies, it will only be passed a callback.
|
|
*
|
|
* @name auto
|
|
* @static
|
|
* @memberOf module:ControlFlow
|
|
* @method
|
|
* @category Control Flow
|
|
* @param {Object} tasks - An object. Each of its properties is either a
|
|
* function or an array of requirements, with the {@link AsyncFunction} itself the last item
|
|
* in the array. The object's key of a property serves as the name of the task
|
|
* defined by that property, i.e. can be used when specifying requirements for
|
|
* other tasks. The function receives one or two arguments:
|
|
* * a `results` object, containing the results of the previously executed
|
|
* functions, only passed if the task has any dependencies,
|
|
* * a `callback(err, result)` function, which must be called when finished,
|
|
* passing an `error` (which can be `null`) and the result of the function's
|
|
* execution.
|
|
* @param {number} [concurrency=Infinity] - An optional `integer` for
|
|
* determining the maximum number of tasks that can be run in parallel. By
|
|
* default, as many as possible.
|
|
* @param {Function} [callback] - An optional callback which is called when all
|
|
* the tasks have been completed. It receives the `err` argument if any `tasks`
|
|
* pass an error to their callback. Results are always returned; however, if an
|
|
* error occurs, no further `tasks` will be performed, and the results object
|
|
* will only contain partial results. Invoked with (err, results).
|
|
* @returns undefined
|
|
* @example
|
|
*
|
|
* async.auto({
|
|
* // this function will just be passed a callback
|
|
* readData: async.apply(fs.readFile, 'data.txt', 'utf-8'),
|
|
* showData: ['readData', function(results, cb) {
|
|
* // results.readData is the file's contents
|
|
* // ...
|
|
* }]
|
|
* }, callback);
|
|
*
|
|
* async.auto({
|
|
* get_data: function(callback) {
|
|
* console.log('in get_data');
|
|
* // async code to get some data
|
|
* callback(null, 'data', 'converted to array');
|
|
* },
|
|
* make_folder: function(callback) {
|
|
* console.log('in make_folder');
|
|
* // async code to create a directory to store a file in
|
|
* // this is run at the same time as getting the data
|
|
* callback(null, 'folder');
|
|
* },
|
|
* write_file: ['get_data', 'make_folder', function(results, callback) {
|
|
* console.log('in write_file', JSON.stringify(results));
|
|
* // once there is some data and the directory exists,
|
|
* // write the data to a file in the directory
|
|
* callback(null, 'filename');
|
|
* }],
|
|
* email_link: ['write_file', function(results, callback) {
|
|
* console.log('in email_link', JSON.stringify(results));
|
|
* // once the file is written let's email a link to it...
|
|
* // results.write_file contains the filename returned by write_file.
|
|
* callback(null, {'file':results.write_file, 'email':'user@example.com'});
|
|
* }]
|
|
* }, function(err, results) {
|
|
* console.log('err = ', err);
|
|
* console.log('results = ', results);
|
|
* });
|
|
*/ |