pot-js/lib/Connection/Instance.js

Process management module

'use strict';

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _getInfoVerbose = require('./getInfoVerbose');

var _getInfoVerbose2 = _interopRequireDefault(_getInfoVerbose);

var _SocketEventTypes = require('../utils/SocketEventTypes');

var _PidHelpers = require('../utils/PidHelpers');

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

var _SocketsHelpers = require('../utils/SocketsHelpers');

var _lodash = require('lodash');

var _isWin = require('../utils/isWin');

var _isWin2 = _interopRequireDefault(_isWin);

var _workspace = require('../utils/workspace');

var _workspace2 = _interopRequireDefault(_workspace);

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"); }); }; }

const call = (() => {
	var _ref = _asyncToGenerator(function* (socket, method) {
		for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
			args[_key - 2] = arguments[_key];
		}

		const data = { method, args };
		return socket.request(_SocketEventTypes.CALL, data);
	});

	function call(_x, _x2) {
		return _ref.apply(this, arguments);
	}

	return call;
})();

const getState = (() => {
	var _ref2 = _asyncToGenerator(function* (socket) {
		try {
			for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
				args[_key2 - 1] = arguments[_key2];
			}

			return yield call(socket, 'state', ...args);
		} catch (err) {
			socket.close().catch(_lodash.noop);
			return null;
		}
	});

	function getState(_x3) {
		return _ref2.apply(this, arguments);
	}

	return getState;
})();

const getAll = (() => {
	var _ref3 = _asyncToGenerator(function* () {
		const pidRefs = yield (0, _PidHelpers.getPids)();
		const socketRefs = yield (0, _SocketsHelpers.getSocketFiles)();

		const refsList = [];
		yield Promise.all(pidRefs.map((() => {
			var _ref5 = _asyncToGenerator(function* (_ref4) {
				let pid = _ref4.pid,
				    key = _ref4.key,
				    pidFile = _ref4.pidFile;

				const socketPath = yield (0, _SocketsHelpers.getSocketPath)(key);
				const socket = yield (0, _SocketsHelpers.startClient)(socketPath);
				if (socket) {
					refsList.push({ key, socket, pid, pidFile, socketPath });
				} else {
					(0, _SocketsHelpers.removeDomainSocketFile)(socketPath);
				}
			});

			return function (_x4) {
				return _ref5.apply(this, arguments);
			};
		})()));

		// remove zombie socket files
		if (!_isWin2.default) {
			yield Promise.all((0, _lodash.differenceWith)(socketRefs, pidRefs, function (socketRef, pidRef) {
				return socketRef.key === pidRef.key;
			}).map((() => {
				var _ref6 = _asyncToGenerator(function* (socketRef) {
					const socket = yield (0, _SocketsHelpers.startClient)(socketRef.socketPath);
					if (socket) {
						const state = yield getState(socket);
						if (state) {
							const pidFile = state.pidFile,
							      pid = state.pid;

							refsList.push(_extends({
								pidFile,
								pid
							}, socketRef, {
								socket
							}));
						}
					}
				});

				return function (_x5) {
					return _ref6.apply(this, arguments);
				};
			})()));
		}
		return refsList;
	});

	function getAll() {
		return _ref3.apply(this, arguments);
	}

	return getAll;
})();

const getByName = (() => {
	var _ref7 = _asyncToGenerator(function* (name) {
		const refsList = yield getAll();
		const res = [];
		yield Promise.all(refsList.map((() => {
			var _ref8 = _asyncToGenerator(function* (ref) {
				const socket = ref.socket;

				const state = yield getState(socket);
				if (state) {
					if (name === state.name) {
						res.push(ref);
					} else {
						yield socket.close();
					}
				}
			});

			return function (_x7) {
				return _ref8.apply(this, arguments);
			};
		})()));
		return res;
	});

	function getByName(_x6) {
		return _ref7.apply(this, arguments);
	}

	return getByName;
})();

const getByKey = (() => {
	var _ref9 = _asyncToGenerator(function* (key) {
		const refsList = yield getAll();
		let res;
		yield Promise.all(refsList.map((() => {
			var _ref10 = _asyncToGenerator(function* (ref) {
				const socket = ref.socket;

				const state = yield getState(socket);
				if (state) {
					if (key === state.key) {
						res = ref;
					} else {
						yield socket.close();
					}
				}
			});

			return function (_x9) {
				return _ref10.apply(this, arguments);
			};
		})()));
		return res;
	});

	function getByKey(_x8) {
		return _ref9.apply(this, arguments);
	}

	return getByKey;
})();

class Instance {
	static getAllInstances(options) {
		return _asyncToGenerator(function* () {
			_workspace2.default.set(options);
			const refs = yield getAll();
			return refs.map(function (ref) {
				return new Instance(ref, options);
			});
		})();
	}

	static getInstanceByKey(key, options) {
		return _asyncToGenerator(function* () {
			_workspace2.default.set(options);
			const refs = yield getByKey(key);
			return refs.map(function (ref) {
				return new Instance(ref, options);
			});
		})();
	}

	static getInstancesByName(name, options) {
		return _asyncToGenerator(function* () {
			_workspace2.default.set(options);
			const refs = yield getByName(name);
			return refs.map(function (ref) {
				return new Instance(ref, options);
			});
		})();
	}

	constructor(_ref11) {
		let socket = _ref11.socket;
		let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

		this._keepAlive = options.keepAlive;
		this._socket = socket;
	}

	call(method) {
		var _arguments = arguments,
		    _this = this;

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

			const response = yield call(_this._socket, method, ...args);
			if (!_this._keepAlive) yield _this.disconnect();
			return response;
		})();
	}

	setState(newState) {
		var _this2 = this;

		return _asyncToGenerator(function* () {
			return _this2.call('state', newState);
		})();
	}

	getState() {
		var _this3 = this;

		return _asyncToGenerator(function* () {
			return _this3.call('state');
		})();
	}

	getInfo() {
		var _this4 = this;

		return _asyncToGenerator(function* () {
			return _this4.getState();
		})();
	}

	getInfoVerbose() {
		var _this5 = this;

		return _asyncToGenerator(function* () {
			const state = yield _this5.getState();
			return (0, _getInfoVerbose2.default)(state);
		})();
	}

	restart() {
		var _this6 = this;

		return _asyncToGenerator(function* () {
			return _this6.call('restart');
		})();
	}

	scale(number) {
		var _this7 = this;

		return _asyncToGenerator(function* () {
			return _this7.call('scale', number);
		})();
	}

	disconnect() {
		var _this8 = this;

		return _asyncToGenerator(function* () {
			try {
				yield _this8._socket.close();
			} catch (err) {
				_potLogger.logger.debug(err);
			}
		})();
	}

	requestStopServer(options) {
		var _this9 = this;

		return _asyncToGenerator(function* () {
			yield _this9._socket.requestClose(options);
			yield _this9.disconnect();
		})();
	}
}
exports.default = Instance;