pot-js/lib/utils/ipc.js

Process management module

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.createClient = exports.createServer = undefined;

let createServer = exports.createServer = (() => {
	var _ref = _asyncToGenerator(function* (socketPath) {
		const server = _http2.default.createServer(function (req, res) {
			const body = _http2.default.STATUS_CODES[426];
			res.writeHead(426, {
				'Content-Length': body.length,
				'Content-Type': 'text/plain'
			});
			res.end(body);
		});

		yield (0, _createLocalDomainSocket2.default)(server, socketPath);
		const wsServer = yield _promiseWs.Server.create({ server });

		wsServer.reply('close', wsServer.close.bind(wsServer));
		return wsServer;
	});

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

let createClient = exports.createClient = (() => {
	var _ref2 = _asyncToGenerator(function* (socketPath) {
		const timeoutPromise = (0, _delay2.default)(40000);
		const timeout = (() => {
			var _ref3 = _asyncToGenerator(function* () {
				yield timeoutPromise;
				throw new Error('TIMEOUT');
			});

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

		const socketBase = (0, _path.basename)((0, _path.dirname)(socketPath));
		const createClientPromise = function () {
			if (socketBase === 'sockets') {
				(0, _deprecated2.default)('"$name" has been deprecated', (0, _path.basename)(socketPath));
				return deprecatedIpcAdapter.createClient(socketPath);
			}
			return _promiseWs.Client.create(`ws+unix://${socketPath}`);
		}();

		try {
			const res = yield Promise.race([createClientPromise, timeout()]);
			timeoutPromise.cancel();
			return res;
		} catch (err) {
			timeoutPromise.cancel();
			throw err;
		}
	});

	return function createClient(_x2) {
		return _ref2.apply(this, arguments);
	};
})();

var _promiseWs = require('promise-ws');

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

var _createLocalDomainSocket2 = _interopRequireDefault(_createLocalDomainSocket);

var _http = require('http');

var _http2 = _interopRequireDefault(_http);

var _deprecatedIpcAdapter = require('./deprecatedIpcAdapter');

var deprecatedIpcAdapter = _interopRequireWildcard(_deprecatedIpcAdapter);

var _delay = require('delay');

var _delay2 = _interopRequireDefault(_delay);

var _path = require('path');

var _deprecated = require('../utils/deprecated');

var _deprecated2 = _interopRequireDefault(_deprecated);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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