nodemiral/lib/taskList.js

var EventEmitter = require('events').EventEmitter;
var util = require('util');
var Session = require('./session');

function TaskList(name, options) {
  if(!(this instanceof TaskList)) {
    return new TaskList(name, options);
  }
  this._name = name;
  this._options = options || {};

  this._pretty = (this._options.pretty === false)? false: true;
  this._ignoreErrors = this._options.ignoreErrors;
  this._taskQueue = [];
}

util.inherits(TaskList, EventEmitter);

TaskList.prototype.run = function(sessions, options, callback) {
  var self = this;
  
  if(sessions instanceof Session) {
    sessions = [sessions];
  } else if(!(sessions instanceof Array)) {
    throw new Error('first param should be either a session or a list of sessions');
  }

  if(typeof(options) == 'function') {
    callback = options;
    options = {};
  }
  options = options || {};
  var summeryMap = {};
  var completed = 0;

  self.log('info', '\nStarted TaskList: ' + this._name);
  Array.prototype.forEach.call(sessions, function(session) {
    self._runTaskQueue(session, function(err, history) {
      summeryMap[session._host] = {error: err, history: history};

      if(++completed == sessions.length) {
        self.log('info', 'Completed TaskList: ' + self._name);
        if(callback) callback(summeryMap);
      }
    });
  });
};

TaskList.prototype.concat = function(taskLists, name, options) {
  if(typeof(name) == 'object') {
    options = name;
    name = null;
  }

  name = name || this._name + '+';
  options = options || this._options;
  var newTaskList = new TaskList(name, options);

  //merge content of _taskQueue of all taskLists into the new one
  var actionQueueList = taskLists.map(function(taskList) { return taskList._taskQueue; });
  actionQueueList.unshift(this._taskQueue);
  newTaskList._taskQueue = newTaskList._taskQueue.concat.apply(newTaskList._taskQueue, actionQueueList);

  return newTaskList;
};

TaskList.prototype._runTaskQueue = function(session, callback) {
  var self = this;
  var cnt = 0;
  var taskHistory = [];
  
  runTask();

  function runTask() {
    var task = self._taskQueue[cnt++];
    if(task) {
      self.emit('started', task.id);
      self.log('info', util.format('[%s] %s', session._host, task.id));
      TaskList._registeredTasks[task.type](session, task.options, function(err) {
        if(err) {
          taskHistory.push({
            task: task.id,
            status: 'FAILED',
            error: err.message
          });
          self.emit('failed', err, task.id);
          self.log('info', util.format('[%s] %s: FAILED\n\t%s', session._host, task.id, err.message.replace(/\n/g, '\n\t')));

          if(self._ignoreErrors) {
            runTask();
          } else {
            callback(err, taskHistory);
          }
        } else {
          taskHistory.push({
            task: task.id,
            status: 'SUCCESS'
          })
          self.log('info', util.format('[%s] %s: SUCCESS', session._host, task.id));
          self.emit('success', task.id);
          runTask();
        }
      });
    } else {
      callback(null, taskHistory);
    }
  }
};

TaskList.prototype.log = function(type, message) {
  if(this._pretty) {
    console[type](message);
  }
};

TaskList._registeredTasks = {};

TaskList.registerTask = function(name, callback) {
  TaskList._registeredTasks[name] = callback;
  TaskList.prototype[name] = function(id, options) {
    this._taskQueue.push({
      type: name, 
      id: id,
      options: options
    });
  };
};

module.exports = TaskList;