pot-js/lib/Connection/Connection.js

Process management module

'use strict';

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

var _lodash = require('lodash');

var _potLogger = require('pot-logger');

var _Instance = require('./Instance');

var _Instance2 = _interopRequireDefault(_Instance);

var _delay = require('delay');

var _delay2 = _interopRequireDefault(_delay);

var _flushOfflineDirs = require('../utils/flushOfflineDirs');

var _flushOfflineDirs2 = _interopRequireDefault(_flushOfflineDirs);

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

class Connection {
	static getNames(options) {
		return _asyncToGenerator(function* () {
			const instances = yield _Instance2.default.getAllInstances(options);
			const names = yield Promise.all(instances.map((() => {
				var _ref = _asyncToGenerator(function* (instance) {
					const state = yield instance.getState();
					return state && state.name;
				});

				return function (_x) {
					return _ref.apply(this, arguments);
				};
			})()));
			return (0, _lodash.uniq)(names).filter(Boolean);
		})();
	}

	static getByName(name, options) {
		return _asyncToGenerator(function* () {
			const instances = yield _Instance2.default.getInstancesByName(name, options);
			return instances.length ? new Connection(name, instances) : null;
		})();
	}

	static getState(name) {
		var _arguments = arguments;
		return _asyncToGenerator(function* () {
			let options = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {};

			const connection = yield Connection.getByName(name, options);
			if (!connection) return {};
			return connection.getState(options.instanceIndex);
		})();
	}

	static flushOffline(onlinesNames) {
		return _asyncToGenerator(function* () {
			if (!onlinesNames) onlinesNames = yield Connection.getNames();
			return (0, _flushOfflineDirs2.default)(onlinesNames);
		})();
	}

	constructor(name) {
		let instances = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

		this._name = name;
		this.instances = instances;
	}

	getState() {
		var _arguments2 = arguments,
		    _this = this;

		return _asyncToGenerator(function* () {
			let instanceIndex = _arguments2.length > 0 && _arguments2[0] !== undefined ? _arguments2[0] : 0;

			const instance = _this.instances[instanceIndex];
			if (!instance) return {};
			const state = yield instance.getState();
			yield _this.disconnect();
			return state;
		})();
	}

	each(method) {
		var _arguments3 = arguments,
		    _this2 = this;

		return _asyncToGenerator(function* () {
			for (var _len = _arguments3.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
				args[_key - 1] = _arguments3[_key];
			}

			return Promise.all(_this2.instances.map(function (instance) {
				return instance[method](...args);
			}));
		})();
	}

	restart() {
		var _this3 = this;

		return _asyncToGenerator(function* () {
			return _this3.each('restart');
		})();
	}

	reload() {
		var _arguments4 = arguments,
		    _this4 = this;

		return _asyncToGenerator(function* () {
			let options = _arguments4.length > 0 && _arguments4[0] !== undefined ? _arguments4[0] : {};
			const instances = _this4.instances;
			const length = instances.length;
			const timeout = options.delay,
			      onProgress = options.onProgress;

			const eachTimeout = length > 1 ? Math.max(100, timeout / length) : 0;
			for (const instance of instances) {
				const state = yield instance.getState();
				if (!state) continue;
				const ok = yield instance.restart();
				if ((0, _lodash.isFunction)(onProgress)) onProgress(ok, state);
				yield instance.disconnect();
				yield (0, _delay2.default)(eachTimeout);
			}
		})();
	}

	scale(number) {
		var _this5 = this;

		return _asyncToGenerator(function* () {
			const res = yield _this5.instances[0].scale(number);
			yield _this5.disconnect();
			return res;
		})();
	}

	flush() {
		var _this6 = this;

		return _asyncToGenerator(function* () {
			const stateList = yield _this6.each('getState');
			const logs = stateList.filter(function (_ref2) {
				let logsDir = _ref2.logsDir;
				return !!logsDir;
			}).map(function (_ref3) {
				let logsDir = _ref3.logsDir,
				    monitor = _ref3.monitor;
				return {
					logsDir,
					removeDir: monitor.status !== 'running'
				};
			});
			return Promise.all(logs.map(_potLogger.flush));
		})();
	}

	disconnect() {
		var _this7 = this;

		return _asyncToGenerator(function* () {
			return _this7.each('disconnect');
		})();
	}

	requestStopServer() {
		var _arguments5 = arguments,
		    _this8 = this;

		return _asyncToGenerator(function* () {
			let options = _arguments5.length > 0 && _arguments5[0] !== undefined ? _arguments5[0] : {};

			options.shouldLog && _potLogger.logger.info(`"${_this8._name}" stopped`);
			return _this8.each('requestStopServer');
		})();
	}
}
exports.default = Connection;
Connection.getAllInstances = _Instance2.default.getAllInstances;
Connection.getList = Connection.getAllInstances;