green-light/lib/target.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _nodeFetch = require('node-fetch');

var _nodeFetch2 = _interopRequireDefault(_nodeFetch);

var _child_process = require('child_process');

var _promisePoller = require('promise-poller');

var _promisePoller2 = _interopRequireDefault(_promisePoller);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Target = function () {
  function Target(config) {
    _classCallCheck(this, Target);

    this.process = null;

    this.config = {
      verbose: config.verbose,
      command: config.command,
      cwd: config.cwd,
      checkUrl: config.checkUrl,
      checkInterval: config.checkInterval || 1000,
      checkTimeout: config.checkTimeout || 1000 * 60 * 5
    };

    if (!this.config.command) {
      throw new Error('No command or file set to run target');
    }

    if (!this.config.checkUrl) {
      throw new Error('No url set to check target');
    }
  }

  _createClass(Target, [{
    key: 'start',
    value: function start() {
      var _this = this;

      return this.check().then(function () {
        return _this.alreadyRunning();
      }).catch(function () {
        return _this.buildTarget();
      });
    }
  }, {
    key: 'stop',
    value: function stop() {
      if (this.process) {
        this.process.stdin.pause();
        this.process.kill('SIGINT');
      }
    }
  }, {
    key: 'check',
    value: function check() {
      if (this.config.verbose) {
        console.log('Checking target at: ' + this.config.checkUrl);
      }
      return (0, _nodeFetch2.default)(this.config.checkUrl);
    }
  }, {
    key: 'alreadyRunning',
    value: function alreadyRunning() {
      if (this.config.verbose) {
        console.log('Target already running');
      }
      return Promise.resolve();
    }
  }, {
    key: 'startProcess',
    value: function startProcess() {
      var splitted = this.config.command.split(' ');
      var command = splitted[0];
      var args = splitted.slice(1);
      var options = {
        cwd: this.config.cwd
      };
      this.process = (0, _child_process.spawn)(command, args, options);
    }
  }, {
    key: 'buildTarget',
    value: function buildTarget() {
      var _this2 = this;

      return new Promise(function (resolve, reject) {
        if (_this2.config.verbose) {
          console.log('Building target...');
        }

        _this2.startProcess();

        _this2.process.on('close', function (code) {
          reject(new Error('Could not build Target: ' + code));
        });

        if (_this2.config.verbose) {
          _this2.process.stdout.pipe(process.stdout);
          _this2.process.stderr.pipe(process.stderr);
        }

        (0, _promisePoller2.default)({
          taskFn: function taskFn() {
            return _this2.check();
          },
          interval: _this2.config.checkInterval,
          timeout: _this2.config.checkTimeout,
          // timeout: this.config.checkTimeout,
          retries: _this2.config.checkTimeout / _this2.config.checkInterval }).then(resolve, reject);
      });
    }
  }]);

  return Target;
}();

exports.default = Target;