gistfile1.js

// sharlot-ping.js
var deployController = require("./service/deploy-controller")
var Watcher = require("./service/task-watcher-service").Watcher
module.exports = function(robot) {
  robot.respond(/awesome regex/, function(arg){
    deployController.blueGreanDeploy(arg, new Watcher("deploy"));
  })
}

// sharlot-status.js
var statusController = require("./service/status-controller");
module.exports = function(robot) {
  robot.respond(/awesome regex/, function(msg){
    statusController.notifyAllTask(msg, function(err){
        
    })
  })
}
// status-controller.js
var watcherService = require("./service/task-watcher-service")
var slackService = require("./service/slack-service")
module.exports = {
  notifyAllTask(msg): function(callback){
    Async.waterfall([
      function(next){
        watcherService.tasks(function(err,tasks){
          next(null, tasks)
        })
      }

    ], function(err, result){
      slackService.notify(msg, result)
    })
  }
}


// deploy-controller.js
var eb = require("./aws/eb-service.js");
var configServive = require("./pfx/config-service");

module.exports = {
  blueGreanDeploy: function(arg, watcher) {
    watcher.state("task start");
    Async.waterFall([
      function(next){
        eb.createEnv(arg.envName, watcher, function(err, env){
          watcher.state("create end.")
          next(env)
        }
      },
      function(env, next){
        eb.deploy(env, arg.commitHash, watcher, function(err, env, next) {
          watcher.state("deploy end.")
          next(env)
        })
      },
      function(env, next){
        configService.minInstances(arg.envName, function(err, instanceNum){
          next(env, instanceNum)
        })
      },
      function(env, instanceNum, next){
        eb.scaleOut(env, instanceNum, watcher, function(err, env){
          watcher.state("scaleout end.")
          next("success")
        })
      }
    ],function(err, data){
        watcher.end("success message", {slack: true});
    })

  }
}
// eb-service.js
var lowLevelAwsClient = require("aws")
module.exports = {
  createEnv: function(envName, watcher, callback){
    Async.waterFall([
      function(next){
        lowLevelAwsClient.create({
          envName: envName,
          region: "ap-northeast-1"
        }, function(err, env){
          watcher.state("end create api")
          next(null, err)
        })
      }
      // other task 
    ], function(err, result){
      watcher.state("done")
      callback(null, result)
    })
  }
}
// task-watcher-service
var tasks = {}
var EventEmitter = require('events').EventEmitter;
var slackService = require("./service/slack-service");
function Watcher(taskName){
  if(!(this instanceof Wathcer)) return new Watcher(taskName);
  this.taskName = taskName;
  tasks[taskName] = this;
}

Watcher.prototype = EventEmitter.prototype;
Watcher.prototype.state = function(state, slackFlg){
  this.state = state;
  if(slackFlg){
    slackService.notify({
      taskName: this.taskName,
      state: this.state
      })
  }
}
module.exports = {
  Watcher: Watcher,
  tasks: function(callback){
    var length = Object.keys(tasks);
    if(length === 0){
      callback(null, "tasks is empty")
    }else{
      callback(null, tasks.map(function(task){
        return {
          taskName: task.taskName,
          state: task.state
          }
      }))
    }
    
  }
}