lugger
Version:
Lugger is an automation framework running on customizable Typescript DSL
265 lines • 11.4 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.git__ = exports.echo__ = exports.sh__ = exports.git = exports.echo = exports.sh = void 0;
const ts_basis_1 = require("ts-basis");
const child_process_1 = require("child_process");
const fs = __importStar(require("fs"));
const shell_model_1 = require("./shell.model");
const ts_dsl_1 = require("ts-dsl");
const fs_util_1 = require("../fs/fs.util");
const YAML = __importStar(require("yaml"));
function sh(command) { (0, ts_dsl_1.dslIfaceGuard)('sh', __filename); return null; }
exports.sh = sh;
function echo(command) { (0, ts_dsl_1.dslIfaceGuard)('echo', __filename); return null; }
exports.echo = echo;
var git;
(function (git) {
function cloneModel() {
}
git.clone = cloneModel;
})(git || (exports.git = git = {}));
function sh__(cce, ...args) {
const arg0 = args[0];
const arg1 = args[1];
let shArg = arg0;
if (typeof arg0 === 'string') {
if (cce.fromTaggedTemplate) {
shArg = { script: args.map(a => (0, ts_dsl_1.dedent)(a)).join('\n') };
}
else {
shArg = { script: (0, ts_dsl_1.dedent)(arg0) };
if (typeof arg1 === 'string') {
shArg.returnType = arg1;
}
}
}
else {
if (typeof arg1 === 'string') {
shArg.script = (0, ts_dsl_1.dedent)(arg1);
}
}
if (shArg.failFast === null || shArg.failFast === undefined) {
shArg.failFast = true;
}
let shRet = { canceled: false, timeCalled: Date.now() };
return (0, ts_dsl_1.getRuntime)().scopedExec(cce, 'lugger:shell:sh', { data: { shellArg: shArg } }, async (resolve, reject, scopeContext) => {
try {
const shFile = (0, fs_util_1.tempFileName)('sh');
const shSpecialReturnFile = shFile + '.ret';
const fullScript = `export RETURN='${shSpecialReturnFile}';\n${shArg.script}`;
fs.writeFile(shFile, fullScript, e => {
if (e) {
const e2 = shell_model_1.ShellCodes.error('SH_TEMP_FILE_WRITE_ERROR', e).error;
console.error(e2);
return reject(e2);
}
const flags = [];
if (shArg.printSteps) {
flags.push('x');
}
if (shArg.failFast) {
flags.push('e');
}
let willReturnOutput = false;
switch (shArg.returnType) {
case 'string':
case 'buffer':
case 'base64':
case 'hex':
case 'utf8':
case 'ucs2':
case 'ascii':
willReturnOutput = true;
break;
}
let willOutputToReturnFile = false;
switch (shArg.returnType) {
case 'object-json':
case 'object-yaml':
willOutputToReturnFile = true;
break;
}
shRet.timeStarted = Date.now();
const proc = (0, child_process_1.spawn)('bash', flags.length === 0 ? [shFile] : [`-${flags.join('')}`, shFile]);
const allBuffers = [];
let writeStream;
proc.stdout.on('data', (chunk) => {
if (shRet.timeEnded) {
return;
}
if (shArg.onStdoutData) {
shArg.onStdoutData(chunk);
}
allBuffers.push(chunk);
if (writeStream && !writeStream.closed) {
writeStream.write(chunk);
}
if (!shArg.quietConsole && (shArg.tee || !shArg.outputFile)) {
process.stdout.write(chunk);
}
});
proc.stderr.on('data', (chunk) => {
if (shRet.timeEnded) {
return;
}
if (shArg.onStderrData) {
shArg.onStderrData(chunk);
}
allBuffers.push(chunk);
if (writeStream && !writeStream.closed) {
writeStream.write(chunk);
}
if (!shArg.quietConsole && (shArg.tee || !shArg.outputFile)) {
process.stderr.write(chunk);
}
});
const outputFile = shArg.outputFile ? shArg.outputFile : (0, fs_util_1.tempFileName)('log');
const mode = shArg.outputFileMode ? shArg.outputFileMode : 'a';
writeStream = fs.createWriteStream(outputFile, { encoding: 'binary', flags: mode, emitClose: true });
proc.on('close', async (code) => {
shRet.timeEnded = Date.now();
shRet.duration = shRet.timeEnded - shRet.timeStarted;
fs.unlink(shFile, e => { });
const returnFile = willOutputToReturnFile ? shSpecialReturnFile : outputFile;
let outputBuffer;
let error;
for (let i = 0; i < 5; ++i) {
try {
outputBuffer = await readFileAwaitable(returnFile);
error = null;
break;
}
catch (e2) {
await (0, ts_basis_1.promise)(async (resolve) => setTimeout(resolve, 5));
error = e2;
}
}
const totalBuffer = Buffer.concat(allBuffers);
fs.unlink(shSpecialReturnFile, e => { });
if (writeStream) {
writeStream.close();
}
if (error) {
if (willOutputToReturnFile) {
return reject(shell_model_1.ShellCodes.error('SH_TEMP_OUTPUT_FILE_READ_ERROR', error).error);
}
else {
return reject(shell_model_1.ShellCodes.error('SH_TEMP_SPECIAL_OUTPUT_FILE_READ_ERROR', error).error);
}
}
if (shArg.returnExitCode) {
return resolve(code);
}
if (willReturnOutput) {
switch (shArg.returnType) {
case 'string':
return resolve(totalBuffer.toString('utf8'));
case 'utf8':
return resolve(totalBuffer.toString('utf8'));
case 'ucs2':
return resolve(totalBuffer.toString('ucs2'));
case 'hex':
return resolve(totalBuffer.toString('hex'));
case 'base64':
return resolve(totalBuffer.toString('base64'));
case 'ascii':
return resolve(totalBuffer.toString('ascii'));
case 'buffer':
return resolve(totalBuffer);
}
return reject(shell_model_1.ShellCodes.error('SH_RETURN_TYPE_ERROR_SERIALIZABLE_TYPE').error);
}
if (willOutputToReturnFile) {
switch (shArg.returnType) {
case 'object-json':
try {
return resolve(JSON.parse(outputBuffer.toString('utf8')));
}
catch (e2) {
return reject(shell_model_1.ShellCodes.error('SH_RETURN_PARSE_ERROR_BAD_JSON_FORMAT', e2).error);
}
case 'object-yaml':
try {
return resolve(YAML.parse(outputBuffer.toString('utf8')));
}
catch (e2) {
return reject(shell_model_1.ShellCodes.error('SH_RETURN_PARSE_ERROR_BAD_YAML_FORMAT', e2).error);
}
}
return reject(shell_model_1.ShellCodes.error('SH_RETURN_TYPE_ERROR_OBJECT_TYPE').error);
}
if (shArg.returnOutput) {
return resolve(totalBuffer.toString('utf8'));
}
if (code === 0) {
shRet.exitcode = code;
shRet.outputBuffer = totalBuffer;
shRet.outputText = totalBuffer.toString('utf8');
shRet.callArgs = shArg;
return resolve(shRet);
}
return reject(new Error(`sh returned non-zero exit code (${code}) while running:\n${shArg.script}`));
});
if (shArg.onProcess) {
shArg.onProcess(proc, shArg);
}
});
}
catch (e) {
reject(e);
}
});
}
exports.sh__ = sh__;
function echo__(cce, ...args) {
if (typeof args[0] === 'string') {
if (cce.fromTaggedTemplate) {
for (const arg of args) {
console.log(arg);
}
}
else {
console.log(args[0]);
}
}
}
exports.echo__ = echo__;
var git__;
(function (git__) {
function clone() { }
git__.clone = clone;
})(git__ || (exports.git__ = git__ = {}));
function readFileAwaitable(file) {
return (0, ts_basis_1.promise)(async (resolve, reject) => {
fs.readFile(file, (e, outputBuffer) => {
if (e) {
return reject(e);
}
return resolve(outputBuffer);
});
});
}
//# sourceMappingURL=shell.js.map