add node_modules to address #4364

1 files changed, 304 insertions, 0 deletions

diff --git a/node_modules/orchestrator/index.js b/node_modules/orchestrator/index.js
new file mode 100644
index 000000000..b13d9927d
--- /dev/null
+++ b/node_modules/orchestrator/index.js
@@ -0,0 +1,304 @@
+/*jshint node:true */
+
+"use strict";
+
+var util = require('util');
+var events = require('events');
+var EventEmitter = events.EventEmitter;
+var runTask = require('./lib/runTask');
+
+var Orchestrator = function () {
+	EventEmitter.call(this);
+	this.doneCallback = undefined; // call this when all tasks in the queue are done
+	this.seq = []; // the order to run the tasks
+	this.tasks = {}; // task objects: name, dep (list of names of dependencies), fn (the task to run)
+	this.isRunning = false; // is the orchestrator running tasks? .start() to start, .stop() to stop
+};
+util.inherits(Orchestrator, EventEmitter);
+
+	Orchestrator.prototype.reset = function () {
+		if (this.isRunning) {
+			this.stop(null);
+		}
+		this.tasks = {};
+		this.seq = [];
+		this.isRunning = false;
+		this.doneCallback = undefined;
+		return this;
+	};
+	Orchestrator.prototype.add = function (name, dep, fn) {
+		if (!fn && typeof dep === 'function') {
+			fn = dep;
+			dep = undefined;
+		}
+		dep = dep || [];
+		fn = fn || function () {}; // no-op
+		if (!name) {
+			throw new Error('Task requires a name');
+		}
+		// validate name is a string, dep is an array of strings, and fn is a function
+		if (typeof name !== 'string') {
+			throw new Error('Task requires a name that is a string');
+		}
+		if (typeof fn !== 'function') {
+			throw new Error('Task '+name+' requires a function that is a function');
+		}
+		if (!Array.isArray(dep)) {
+			throw new Error('Task '+name+' can\'t support dependencies that is not an array of strings');
+		}
+		dep.forEach(function (item) {
+			if (typeof item !== 'string') {
+				throw new Error('Task '+name+' dependency '+item+' is not a string');
+			}
+		});
+		this.tasks[name] = {
+			fn: fn,
+			dep: dep,
+			name: name
+		};
+		return this;
+	};
+	Orchestrator.prototype.task = function (name, dep, fn) {
+		if (dep || fn) {
+			// alias for add, return nothing rather than this
+			this.add(name, dep, fn);
+		} else {
+			return this.tasks[name];
+		}
+	};
+	Orchestrator.prototype.hasTask = function (name) {
+		return !!this.tasks[name];
+	};
+	// tasks and optionally a callback
+	Orchestrator.prototype.start = function() {
+		var args, arg, names = [], lastTask, i, seq = [];
+		args = Array.prototype.slice.call(arguments, 0);
+		if (args.length) {
+			lastTask = args[args.length-1];
+			if (typeof lastTask === 'function') {
+				this.doneCallback = lastTask;
+				args.pop();
+			}
+			for (i = 0; i < args.length; i++) {
+				arg = args[i];
+				if (typeof arg === 'string') {
+					names.push(arg);
+				} else if (Array.isArray(arg)) {
+					names = names.concat(arg); // FRAGILE: ASSUME: it's an array of strings
+				} else {
+					throw new Error('pass strings or arrays of strings');
+				}
+			}
+		}
+		if (this.isRunning) {
+			// reset specified tasks (and dependencies) as not run
+			this._resetSpecificTasks(names);
+		} else {
+			// reset all tasks as not run
+			this._resetAllTasks();
+		}
+		if (this.isRunning) {
+			// if you call start() again while a previous run is still in play
+			// prepend the new tasks to the existing task queue
+			names = names.concat(this.seq);
+		}
+		if (names.length < 1) {
+			// run all tasks
+			for (i in this.tasks) {
+				if (this.tasks.hasOwnProperty(i)) {
+					names.push(this.tasks[i].name);
+				}
+			}
+		}
+		seq = [];
+		try {
+			this.sequence(this.tasks, names, seq, []);
+		} catch (err) {
+			// Is this a known error?
+			if (err) {
+				if (err.missingTask) {
+					this.emit('task_not_found', {message: err.message, task:err.missingTask, err: err});
+				}
+				if (err.recursiveTasks) {
+					this.emit('task_recursion', {message: err.message, recursiveTasks:err.recursiveTasks, err: err});
+				}
+			}
+			this.stop(err);
+			return this;
+		}
+		this.seq = seq;
+		this.emit('start', {message:'seq: '+this.seq.join(',')});
+		if (!this.isRunning) {
+			this.isRunning = true;
+		}
+		this._runStep();
+		return this;
+	};
+	Orchestrator.prototype.stop = function (err, successfulFinish) {
+		this.isRunning = false;
+		if (err) {
+			this.emit('err', {message:'orchestration failed', err:err});
+		} else if (successfulFinish) {
+			this.emit('stop', {message:'orchestration succeeded'});
+		} else {
+			// ASSUME
+			err = 'orchestration aborted';
+			this.emit('err', {message:'orchestration aborted', err: err});
+		}
+		if (this.doneCallback) {
+			// Avoid calling it multiple times
+			this.doneCallback(err);
+		} else if (err && !this.listeners('err').length) {
+			// No one is listening for the error so speak louder
+			throw err;
+		}
+	};
+	Orchestrator.prototype.sequence = require('sequencify');
+	Orchestrator.prototype.allDone = function () {
+		var i, task, allDone = true; // nothing disputed it yet
+		for (i = 0; i < this.seq.length; i++) {
+			task = this.tasks[this.seq[i]];
+			if (!task.done) {
+				allDone = false;
+				break;
+			}
+		}
+		return allDone;
+	};
+	Orchestrator.prototype._resetTask = function(task) {
+		if (task) {
+			if (task.done) {
+				task.done = false;
+			}
+			delete task.start;
+			delete task.stop;
+			delete task.duration;
+			delete task.hrDuration;
+			delete task.args;
+		}
+	};
+	Orchestrator.prototype._resetAllTasks = function() {
+		var task;
+		for (task in this.tasks) {
+			if (this.tasks.hasOwnProperty(task)) {
+				this._resetTask(this.tasks[task]);
+			}
+		}
+	};
+	Orchestrator.prototype._resetSpecificTasks = function (names) {
+		var i, name, t;
+
+		if (names && names.length) {
+			for (i = 0; i < names.length; i++) {
+				name = names[i];
+				t = this.tasks[name];
+				if (t) {
+					this._resetTask(t);
+					if (t.dep && t.dep.length) {
+						this._resetSpecificTasks(t.dep); // recurse
+					}
+				//} else {
+					// FRAGILE: ignore that the task doesn't exist
+				}
+			}
+		}
+	};
+	Orchestrator.prototype._runStep = function () {
+		var i, task;
+		if (!this.isRunning) {
+			return; // user aborted, ASSUME: stop called previously
+		}
+		for (i = 0; i < this.seq.length; i++) {
+			task = this.tasks[this.seq[i]];
+			if (!task.done && !task.running && this._readyToRunTask(task)) {
+				this._runTask(task);
+			}
+			if (!this.isRunning) {
+				return; // task failed or user aborted, ASSUME: stop called previously
+			}
+		}
+		if (this.allDone()) {
+			this.stop(null, true);
+		}
+	};
+	Orchestrator.prototype._readyToRunTask = function (task) {
+		var ready = true, // no one disproved it yet
+			i, name, t;
+		if (task.dep.length) {
+			for (i = 0; i < task.dep.length; i++) {
+				name = task.dep[i];
+				t = this.tasks[name];
+				if (!t) {
+					// FRAGILE: this should never happen
+					this.stop("can't run "+task.name+" because it depends on "+name+" which doesn't exist");
+					ready = false;
+					break;
+				}
+				if (!t.done) {
+					ready = false;
+					break;
+				}
+			}
+		}
+		return ready;
+	};
+	Orchestrator.prototype._stopTask = function (task, meta) {
+		task.duration = meta.duration;
+		task.hrDuration = meta.hrDuration;
+		task.running = false;
+		task.done = true;
+	};
+	Orchestrator.prototype._emitTaskDone = function (task, message, err) {
+		if (!task.args) {
+			task.args = {task:task.name};
+		}
+		task.args.duration = task.duration;
+		task.args.hrDuration = task.hrDuration;
+		task.args.message = task.name+' '+message;
+		var evt = 'stop';
+		if (err) {
+			task.args.err = err;
+			evt = 'err';
+		}
+		// 'task_stop' or 'task_err'
+		this.emit('task_'+evt, task.args);
+	};
+	Orchestrator.prototype._runTask = function (task) {
+		var that = this;
+
+		task.args = {task:task.name, message:task.name+' started'};
+		this.emit('task_start', task.args);
+		task.running = true;
+
+		runTask(task.fn.bind(this), function (err, meta) {
+			that._stopTask.call(that, task, meta);
+			that._emitTaskDone.call(that, task, meta.runMethod, err);
+			if (err) {
+				return that.stop.call(that, err);
+			}
+			that._runStep.call(that);
+		});
+	};
+
+// FRAGILE: ASSUME: this list is an exhaustive list of events emitted
+var events = ['start','stop','err','task_start','task_stop','task_err','task_not_found','task_recursion'];
+
+var listenToEvent = function (target, event, callback) {
+	target.on(event, function (e) {
+		e.src = event;
+		callback(e);
+	});
+};
+
+	Orchestrator.prototype.onAll = function (callback) {
+		var i;
+		if (typeof callback !== 'function') {
+			throw new Error('No callback specified');
+		}
+
+		for (i = 0; i < events.length; i++) {
+			listenToEvent(this, events[i], callback);
+		}
+	};
+
+module.exports = Orchestrator;