crossover/lib/crossover.js

// Generated by CoffeeScript 1.3.3
(function() {
  var Crossover, cluster, domain, express, fs, os, rest, spawn, temp, util, uuid, wrench,
    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

  cluster = require("cluster");

  domain = require("domain");

  express = require("express");

  fs = require("fs");

  os = require("os");

  rest = require("restler");

  spawn = require("child_process").spawn;

  temp = require("temp");

  util = require("util");

  uuid = require("node-uuid");

  wrench = require("wrench");

  module.exports.version = require("../package.json").version;

  Crossover = (function() {

    function Crossover(options) {
      this.options = options;
      this.execute = __bind(this.execute, this);

      this.slave = __bind(this.slave, this);

      this.master = __bind(this.master, this);

      this.listen = __bind(this.listen, this);

      this.test_worker = __bind(this.test_worker, this);

      this.spawn_worker = __bind(this.spawn_worker, this);

      this.prepare_npm = __bind(this.prepare_npm, this);

      this.prepare_worker = __bind(this.prepare_worker, this);

      this.app = null;
      this.listening = false;
      this.stopping = false;
      this.workers = [];
      this.root = temp.mkdirSync("crossover");
    }

    Crossover.prototype.prepare_worker = function(slug, env, cb) {
      var target,
        _this = this;
      target = this.root + "/" + uuid.v1();
      this.log("preparing worker: " + slug);
      return this.read_env(env, function(env) {
        if (slug.substring(0, 4) === "http") {
          return rest.get(slug, {
            decoding: "buffer"
          }).on("complete", function(result) {
            return fs.mkdir(target, function(err) {
              return fs.writeFile(target + "/app.tgz", result, "binary", function(err) {
                return _this.execute("tar", ["xzf", "app.tgz"], {
                  cwd: target
                }, function() {
                  return _this.prepare_npm(target, function(target) {
                    return cb(target, env);
                  });
                });
              });
            });
          });
        } else {
          wrench.copyDirSyncRecursive(slug, target);
          return _this.prepare_npm(target, function(target) {
            return cb(target, env);
          });
        }
      });
    };

    Crossover.prototype.read_env = function(env, cb) {
      var _this = this;
      if (!env) {
        return cb({});
      } else if (env.substring(0, 4) === "http") {
        return rest.get(env).on("complete", function(result) {
          return cb(_this.read_env_data(result));
        });
      } else {
        return fs.readFile(env, function(err, data) {
          return cb(_this.read_env_data(data.toString()));
        });
      }
    };

    Crossover.prototype.read_env_data = function(data) {
      var env, line, parts, _i, _len, _ref;
      env = {};
      _ref = data.split("\n");
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        line = _ref[_i];
        parts = line.split("=");
        env[parts.shift()] = parts.join("=");
      }
      return env;
    };

    Crossover.prototype.prepare_npm = function(target, cb) {
      var _this = this;
      this.log("resolving dependencies");
      return this.execute("npm", ["install"], {
        cwd: target
      }, function() {
        return _this.execute("npm", ["rebuild"], {
          cwd: target
        }, function() {
          return cb(target);
        });
      });
    };

    Crossover.prototype.spawn_worker = function(dir, cb) {
      var old_cwd, old_env, worker;
      old_env = process.env;
      old_cwd = process.cwd();
      process.env = this.env || {};
      process.chdir(dir);
      worker = cluster.fork();
      process.chdir(old_cwd);
      process.env = old_env;
      this.log("forked worker " + worker.process.pid);
      return worker.on("message", function(msg) {
        if (msg.cmd === "ready") {
          this.send({
            cmd: "start",
            dir: dir
          });
          if (cb) {
            return cb(this);
          }
        }
      });
    };

    Crossover.prototype.test_worker = function(dir, env, cb) {
      var old_cwd, old_env, worker;
      old_env = process.env;
      old_cwd = process.cwd();
      process.env = this.env || {};
      process.chdir(dir);
      worker = cluster.fork();
      process.chdir(old_cwd);
      process.env = old_env;
      this.log("forked worker " + worker.process.pid);
      return worker.on("message", function(msg) {
        if (msg.cmd === "ready") {
          return this.send({
            cmd: "test",
            dir: dir
          });
        } else if (msg.cmd === "success") {
          return cb(null);
        } else if (msg.cmd === "failure") {
          return cb(msg.err);
        }
      });
    };

    Crossover.prototype.listen = function(slug, env, port) {
      var _this = this;
      if (!slug) {
        this.error("Must specify a slug.");
      }
      if (cluster.isMaster) {
        this.admin().listen(this.options["managementPort"], function() {
          return console.log("[master] listening on management port: " + _this.options["managementPort"]);
        });
        return this.prepare_worker(slug, env, function(slug, env) {
          _this.slug = slug;
          _this.env = env;
          return _this.master();
        });
      } else {
        return this.slave(port);
      }
    };

    Crossover.prototype.master = function() {
      var num, _i, _ref,
        _this = this;
      for (num = _i = 1, _ref = this.options.concurrency; 1 <= _ref ? _i <= _ref : _i >= _ref; num = 1 <= _ref ? ++_i : --_i) {
        this.spawn_worker(this.slug, function(worker) {
          return _this.workers.push(worker);
        });
      }
      return cluster.on("exit", function(worker) {
        _this.log("worker " + worker.pid + " died");
        _this.workers.splice(_this.workers.indexOf(worker), 1);
        return _this.spawn_worker(_this.slug, function(worker) {
          return _this.workers.push(worker);
        });
      });
    };

    Crossover.prototype.slave = function(port) {
      var _this = this;
      process.on("message", function(msg) {
        switch (msg.cmd) {
          case "start":
            _this.log("starting app");
            _this.listening = false;
            _this.app = require(msg.dir + "/index");
            _this.app.on("close", function() {
              _this.log("requests completed, exiting");
              return process.exit(0);
            });
            return _this.app.listen(port, function() {
              _this.log("listening on port: " + port);
              return _this.listening = true;
            });
          case "test":
            _this.log("launching test app from slug");
            try {
              _this.app = require(msg.dir + "/index");
              return _this.app.listen(0, function() {
                return process.send({
                  cmd: "success"
                });
              });
            } catch (err) {
              return process.send({
                cmd: "failure",
                err: err.toString()
              });
            }
            break;
          case "stop":
            if (!_this.stopping) {
              _this.stopping = true;
              if (_this.listening) {
                _this.log("turning off new connections to app");
                _this.app.close();
                return setTimeout((function() {
                  _this.log("giving up on remaining connections");
                  return process.exit(0);
                }), 30000);
              } else {
                _this.log("app not listening yet, exiting");
                return process.exit(0);
              }
            }
        }
      });
      return process.send({
        cmd: "ready"
      });
    };

    Crossover.prototype.admin = function() {
      var admin,
        _this = this;
      admin = require("express").createServer(express.bodyParser(), express.basicAuth("admin", (this.options['auth'] || "").toString()));
      admin.get("/status", function(req, res) {
        res.contentType("application/json");
        return res.send(JSON.stringify({
          version: module.exports.version
        }));
      });
      admin.post("/release", function(req, res) {
        var dom;
        dom = domain.create();
        dom.on("error", function(err) {
          _this.log("failed to launch: " + err);
          res.writeHead(403);
          return res.end("error");
        });
        return dom.run(function() {
          var env, slug;
          slug = req.body.slug;
          env = req.body.env;
          _this.log("releasing: " + slug + " " + env);
          return _this.prepare_worker(slug, env, function(slug, env) {
            return _this.test_worker(slug, env, function(err) {
              var worker, _i, _len, _ref;
              if (err) {
                _this.log("error in slug, aborting spawn: " + err);
                res.writeHead(403);
                return res.end("error");
              } else {
                _this.log("test successful");
                _this.slug = slug;
                _this.env = env;
                _ref = _this.workers;
                for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                  worker = _ref[_i];
                  worker.send({
                    cmd: "stop"
                  });
                }
                return res.send("ok");
              }
            });
          });
        });
      });
      return admin;
    };

    Crossover.prototype.format_log = function(args) {
      var arg, formatted, pid, _i, _len;
      pid = cluster.isMaster ? "master" : "worker:" + process.pid;
      formatted = ["[" + pid + "]"];
      for (_i = 0, _len = args.length; _i < _len; _i++) {
        arg = args[_i];
        formatted.push(arg);
      }
      return formatted;
    };

    Crossover.prototype.log = function() {
      return console.log.apply(console, this.format_log(arguments));
    };

    Crossover.prototype.error = function() {
      var arg, args, _i, _len;
      args = ["[" + process.pid + "]"];
      for (_i = 0, _len = arguments.length; _i < _len; _i++) {
        arg = arguments[_i];
        args.push(arg);
      }
      console.error.apply(console, args);
      return process.exit(1);
    };

    Crossover.prototype.execute = function(command, args, options, cb) {
      var child,
        _this = this;
      child = spawn(command, args, options);
      child.stdout.on("data", function(data) {
        var part, _i, _len, _ref, _results;
        _ref = data.toString().replace(/\n$/, '').split("\n");
        _results = [];
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          part = _ref[_i];
          if (process.env.DEBUG) {
            _results.push(console.log("[compiler] " + part));
          } else {
            _results.push(void 0);
          }
        }
        return _results;
      });
      child.stderr.on("data", function(data) {
        var part, _i, _len, _ref, _results;
        _ref = data.toString().replace(/\n$/, '').split("\n");
        _results = [];
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          part = _ref[_i];
          if (process.env.DEBUG) {
            _results.push(console.log("[compiler] " + part));
          } else {
            _results.push(void 0);
          }
        }
        return _results;
      });
      return child.on("exit", function(code) {
        return cb(code);
      });
    };

    return Crossover;

  })();

  module.exports.create = function(slug) {
    return new Crossover(slug);
  };

}).call(this);