script-launcher
Version:
Script Launcher
264 lines (263 loc) • 12.5 kB
JavaScript
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var spawn_process_1 = require("./spawn-process");
var stringArgv = require("string-argv");
var fs = require("fs");
var path = require("path");
var logger_1 = require("./logger");
var common_1 = require("./common");
var Order;
(function (Order) {
Order[Order["concurrent"] = 0] = "concurrent";
Order[Order["sequential"] = 1] = "sequential";
})(Order || (Order = {}));
var Executor = /** @class */ (function () {
function Executor(shell, args, environment, scripts) {
this.shell = shell;
this.args = args;
this.environment = environment;
this.scripts = scripts;
}
Executor.expandArguments = function (text, args) {
for (var index = 0; index < args.length; index++) {
var regexp = new RegExp('\\$' + index, 'g');
text = text.replace(regexp, args[index]);
if (!text.includes('$'))
break;
}
return text;
};
Executor.expandEnvironment = function (text, environment) {
for (var _i = 0, _a = Object.entries(environment); _i < _a.length; _i++) {
var _b = _a[_i], name_1 = _b[0], value = _b[1];
var regexp = new RegExp('\\$' + name_1 + '([^\\w]|$)', 'g');
text = text.replace(regexp, value + '$1');
if (!text.includes('$'))
break;
}
return text.replace(/\$\w+/g, '');
};
Executor.getCommandParams = function (command, options) {
options = __assign({}, options);
if (!options.cwd)
options.cwd = '';
var args = [];
if (!options.shell) {
args = stringArgv(command);
command = args[0];
args.shift();
}
var fullPath = path.join(path.resolve(options.cwd), command);
if (fs.existsSync(fullPath)) {
options.cwd = fullPath;
command = null;
}
return { command: command, args: args, options: options };
};
Executor.wait = function (processes) {
return __awaiter(this, void 0, void 0, function () {
var exitCode, _i, processes_1, item, _a, _b, _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
exitCode = 0;
_i = 0, processes_1 = processes;
_d.label = 1;
case 1:
if (!(_i < processes_1.length)) return [3 /*break*/, 7];
item = processes_1[_i];
if (!(item instanceof Promise)) return [3 /*break*/, 4];
_a = exitCode;
_b = this.wait;
return [4 /*yield*/, item];
case 2: return [4 /*yield*/, _b.apply(this, [_d.sent()])];
case 3:
exitCode = _a + _d.sent();
return [3 /*break*/, 6];
case 4:
_c = exitCode;
return [4 /*yield*/, item.wait()];
case 5:
exitCode = _c + _d.sent();
_d.label = 6;
case 6:
_i++;
return [3 /*break*/, 1];
case 7: return [2 /*return*/, exitCode];
}
});
});
};
Executor.prototype.execute = function (scriptInfo) {
return __awaiter(this, void 0, void 0, function () {
var tasks, options, processes, _a, _b, _c, _d, _e, _f;
return __generator(this, function (_g) {
switch (_g.label) {
case 0:
tasks = this.expand(scriptInfo);
options = {
stdio: 'inherit',
env: this.environment,
shell: this.shell,
};
logger_1.Logger.info('Script name :', scriptInfo.name);
logger_1.Logger.info('Script params :', scriptInfo.parameters);
logger_1.Logger.log('Script object : ' + common_1.stringify(scriptInfo.script));
logger_1.Logger.log('Script expanded : ' + common_1.stringify(tasks));
logger_1.Logger.info();
processes = [];
_b = (_a = processes.push).apply;
_c = [processes];
return [4 /*yield*/, this.executeTasks(tasks.concurrent, options, Order.concurrent)];
case 1:
_b.apply(_a, _c.concat([_g.sent()]));
_e = (_d = processes.push).apply;
_f = [processes];
return [4 /*yield*/, this.executeTasks(tasks.sequential, options, Order.sequential)];
case 2:
_e.apply(_d, _f.concat([_g.sent()]));
return [2 /*return*/, Executor.wait(processes)];
}
});
});
};
Executor.prototype.expand = function (scriptInfo) {
var concurrent = [];
var sequential = [];
var script = scriptInfo.script;
if (script instanceof Array)
sequential.push.apply(sequential, script);
if (typeof script === 'string')
sequential.push(script);
if (script instanceof String)
sequential.push(script.toString());
if (script.concurrent)
concurrent.push.apply(concurrent, script.concurrent);
if (script.sequential)
sequential.push.apply(sequential, script.sequential);
var environment = __assign({}, this.environment, scriptInfo.parameters);
return {
concurrent: this.expandTasks(concurrent, environment),
sequential: this.expandTasks(sequential, environment),
};
};
Executor.prototype.executeTasks = function (tasks, options, order) {
return __awaiter(this, void 0, void 0, function () {
var processes, _i, tasks_1, task, params, process_1, _a, _b, _c, _d, _e, _f, _g;
return __generator(this, function (_h) {
switch (_h.label) {
case 0:
processes = [];
_i = 0, tasks_1 = tasks;
_h.label = 1;
case 1:
if (!(_i < tasks_1.length)) return [3 /*break*/, 10];
task = tasks_1[_i];
if (!(typeof task === 'string')) return [3 /*break*/, 5];
params = Executor.getCommandParams(task, options);
options = params.options;
if (!params.command) return [3 /*break*/, 4];
logger_1.Logger.log('Spawn order : ' + common_1.Colors.Cyan + Order[order] + common_1.Colors.Normal);
process_1 = spawn_process_1.Process.spawn(params.command, params.args, params.options);
processes.push(process_1);
_a = order === Order.sequential;
if (!_a) return [3 /*break*/, 3];
return [4 /*yield*/, process_1.wait()];
case 2:
_a = (_h.sent()) !== 0;
_h.label = 3;
case 3:
if (_a)
return [3 /*break*/, 10];
_h.label = 4;
case 4: return [3 /*break*/, 9];
case 5:
if (!(order === Order.sequential)) return [3 /*break*/, 8];
_c = (_b = processes.push).apply;
_d = [processes];
return [4 /*yield*/, this.executeTasks(task.concurrent, options, Order.concurrent)];
case 6:
_c.apply(_b, _d.concat([_h.sent()]));
_f = (_e = processes.push).apply;
_g = [processes];
return [4 /*yield*/, this.executeTasks(task.sequential, options, Order.sequential)];
case 7:
_f.apply(_e, _g.concat([_h.sent()]));
return [3 /*break*/, 9];
case 8:
processes.push(this.executeTasks(task.concurrent, options, Order.concurrent));
processes.push(this.executeTasks(task.sequential, options, Order.sequential));
_h.label = 9;
case 9:
_i++;
return [3 /*break*/, 1];
case 10: return [2 /*return*/, processes];
}
});
});
};
Executor.prototype.expandTasks = function (tasks, environment) {
var result = [];
for (var _i = 0, tasks_2 = tasks; _i < tasks_2.length; _i++) {
var task = tasks_2[_i];
task = Executor.expandArguments(task, this.args);
task = Executor.expandEnvironment(task, environment);
var script = this.scripts.find(task);
if (script) {
result.push(this.expand(script));
}
else {
result.push(task);
}
}
return result;
};
return Executor;
}());
exports.Executor = Executor;