pot-js/lib/utils/SocketsHelpers.js

Process management module

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.startClient = exports.startServer = exports.getSocketPath = exports.removeDomainSocketFile = exports.getSocketFiles = undefined;

let getSocketFiles = exports.getSocketFiles = (() => {
	var _ref = _asyncToGenerator(function* () {
		const runDir = yield _workspace2.default.getRunDir();

		// DEPRECATED: workspace.DEPRECATED_getSocketsDir()
		const deprecatedSocketsDir = yield _workspace2.default.DEPRECATED_getSocketsDir();

		const patterns = [`${runDir}/**/*.sock`, `${deprecatedSocketsDir}/**/*`];

		const socketPaths = yield (0, _globby2.default)(patterns, {
			absolute: true,
			expandDirectories: false,
			onlyFiles: false
		});

		return socketPaths.map(function (socketPath) {
			return {
				socketPath,
				key: (0, _path.basename)(socketPath, '.sock')
			};
		});
	});

	return function getSocketFiles() {
		return _ref.apply(this, arguments);
	};
})();

let removeDomainSocketFile = exports.removeDomainSocketFile = (() => {
	var _ref2 = _asyncToGenerator(function* (socketPath) {
		if (_isWin2.default) {
			return;
		}
		if ((0, _lodash.isObject)(socketPath)) {
			socketPath = socketPath.socketPath;
		}
		_potLogger.logger.trace('remove socket file', socketPath);
		return (0, _fsExtra.remove)(socketPath).catch(_lodash.noop);
	});

	return function removeDomainSocketFile(_x) {
		return _ref2.apply(this, arguments);
	};
})();

let getSocketPath = exports.getSocketPath = (() => {
	var _ref3 = _asyncToGenerator(function* (keyOrMonitor) {
		const runDir = yield _workspace2.default.getRunDir();
		const key = (0, _getKey2.default)(keyOrMonitor);
		return (0, _createLocalDomainSocket.ensureLocalDomainPath)((0, _path.join)(runDir, key) + '.sock');
	});

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

let startServer = exports.startServer = (() => {
	var _ref4 = _asyncToGenerator(function* (masterMonitor, workerMonitor) {
		const socketPath = workerMonitor.data.socketPath;


		_potLogger.logger.trace('unix domain socket path', _chalk2.default.gray(socketPath));
		const socketServer = yield (0, _ipc.createServer)(socketPath);

		socketServer.onReplyClose(_asyncToGenerator(function* () {
			process.nextTick(_asyncToGenerator(function* () {
				yield masterMonitor.requestShutDown(workerMonitor);
			}));
			return true;
		}));

		socketServer.reply(_SocketEventTypes.CALL, (() => {
			var _ref7 = _asyncToGenerator(function* (data) {
				if (data && data.method) {
					var _data$args = data.args;
					const args = _data$args === undefined ? [] : _data$args,
					      method = data.method;

					masterMonitor.currentWorkerMonitor = workerMonitor;
					if ((0, _lodash.isFunction)(masterMonitor[method])) {
						return masterMonitor[method](...args);
					} else {
						_potLogger.logger.warn(`Received API call "${method}", but it's not supported`);
					}
				}
			});

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

		return socketServer;
	});

	return function startServer(_x3, _x4) {
		return _ref4.apply(this, arguments);
	};
})();

let startClient = exports.startClient = (() => {
	var _ref8 = _asyncToGenerator(function* (socketPath) {
		let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
		const silence = options.silence;


		try {
			const clientSocket = yield (0, _ipc.createClient)(socketPath);
			silence || _potLogger.logger.trace('start client socket', socketPath);
			return clientSocket;
		} catch (err) {
			if (err && ~['ECONNRESET', 'ECONNREFUSED', 'ENOENT'].indexOf(err.code)) {
				yield removeDomainSocketFile(socketPath);
			} else {
				silence || _potLogger.logger.error('socket error', err);
			}
		}
	});

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

var _fsExtra = require('fs-extra');

var _path = require('path');

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

var _workspace2 = _interopRequireDefault(_workspace);

var _ipc = require('./ipc');

var _createLocalDomainSocket = require('create-local-domain-socket');

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

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _globby = require('globby');

var _globby2 = _interopRequireDefault(_globby);

var _lodash = require('lodash');

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

var _isWin2 = _interopRequireDefault(_isWin);

var _getKey = require('./getKey');

var _getKey2 = _interopRequireDefault(_getKey);

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

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