push.rocks/smartshell
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BREAKING CHANGE(core): switched to ES syntax and added support for interactivity

Browse Source
This commit is contained in:
Philipp Kunz
2023-06-22 11:51:44 +02:00
parent 730a4a05a4
commit e4e08910c7
13 changed files with 4587 additions and 26822 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
ts/00_commitinfo_data.ts Normal file
View File

@ -0,0 +1,8 @@
/**
* autocreated commitinfo by @pushrocks/commitinfo
*/
export const commitinfo = {
name: '@pushrocks/smartshell',
version: '3.0.0',
description: 'shell actions designed as promises'
}

4
ts/index.ts
View File

@ -1,2 +1,2 @@
export * from './smartshell.classes.smartshell';
export { which } from './smartshell.plugins';
export * from './smartshell.classes.smartshell.js';
export { which } from './smartshell.plugins.js';

2
ts/smartshell.classes.shelllog.ts
View File

@ -1,4 +1,4 @@
import * as plugins from './smartshell.plugins';
import * as plugins from './smartshell.plugins.js';
/**
* a log handler for spawned logs

189
ts/smartshell.classes.smartshell.ts
View File

@ -1,37 +1,23 @@
// -- imports --
import * as plugins from './smartshell.plugins';
import { ShellEnv, IShellEnvContructorOptions, TExecutor } from './smartshell.classes.shellenv';
import { ShellLog } from './smartshell.classes.shelllog';
import * as plugins from './smartshell.plugins.js';
import { ShellEnv } from './smartshell.classes.shellenv.js';
import type { IShellEnvContructorOptions, TExecutor } from './smartshell.classes.shellenv.js';
import { ShellLog } from './smartshell.classes.shelllog.js';
import * as cp from 'child_process';
import { Deferred } from '@pushrocks/smartpromise';
// -- interfaces --
/**
* interface for ExecResult
*/
export interface IExecResult {
exitCode: number;
stdout: string;
}
/**
* interface for streaming ExecResult
*/
export interface IExecResultStreaming {
childProcess: cp.ChildProcess;
finalPromise: Promise<IExecResult>;
/**
* sends SIGKILL
*/
kill: () => void;
/**
* sends SIGTERM
*/
terminate: () => void;
}
// -- SmartShell --
export class Smartshell {
public shellEnv: ShellEnv;
public smartexit = new plugins.smartexit.SmartExit();
@ -42,20 +28,56 @@ export class Smartshell {
/**
* executes a given command async
* @param commandStringArg
*/
private async _exec(
commandStringArg: string,
silentArg: boolean = false,
strictArg = false,
streamingArg = false
): Promise<IExecResult | IExecResultStreaming> {
// flow control promises
private async _exec(options: {
commandString: string,
silent?: boolean,
strict?: boolean,
streaming?: boolean,
interactive?: boolean
}): Promise<IExecResult | IExecResultStreaming | void> {
if (options.interactive) {
if (process.env.CI) {
return;
}
const done = plugins.smartpromise.defer();
const shell = cp.spawn('sh', [], { stdio: 'pipe' });
this.smartexit.addProcess(shell);
const stdInStream = process.stdin.pipe(shell.stdin);
const stdOutStream = shell.stdout.pipe(process.stdout);
shell.on('close', (code) => {
console.log(`interactive shell terminated with code ${code}`);
stdInStream.removeAllListeners();
stdInStream.uncork();
stdOutStream.removeAllListeners();
stdOutStream.unpipe();
shell.kill('SIGTERM');
process.stdin.pause();
done.resolve();
});
let commandString = options.commandString;
if (process.env.CI) {
commandString += ' && exit';
}
commandString += '\n';
shell.stdin.write(commandString);
await done.promise;
return;
}
const done = plugins.smartpromise.defer<IExecResult | IExecResultStreaming>();
const childProcessEnded = plugins.smartpromise.defer<IExecResult>();
// build commandToExecute
let commandToExecute = commandStringArg;
commandToExecute = this.shellEnv.createEnvExecString(commandStringArg);
let commandToExecute = options.commandString;
commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
const spawnlogInstance = new ShellLog();
const execChildProcess = cp.spawn(commandToExecute, [], {
shell: true,
@ -67,13 +89,14 @@ export class Smartshell {
this.smartexit.addProcess(execChildProcess);
execChildProcess.stdout.on('data', (data) => {
if (!silentArg) {
if (!options.silent) {
spawnlogInstance.writeToConsole(data);
}
spawnlogInstance.addToBuffer(data);
});
execChildProcess.stderr.on('data', (data) => {
if (!silentArg) {
if (!options.silent) {
spawnlogInstance.writeToConsole(data);
}
spawnlogInstance.addToBuffer(data);
@ -81,7 +104,7 @@ export class Smartshell {
execChildProcess.on('exit', (code, signal) => {
this.smartexit.removeProcess(execChildProcess);
if (strictArg && code === 1) {
if (options.strict && code === 1) {
done.reject();
}
@ -90,82 +113,61 @@ export class Smartshell {
stdout: spawnlogInstance.logStore.toString(),
};
if (!streamingArg) {
if (!options.streaming) {
done.resolve(execResult);
}
childProcessEnded.resolve(execResult);
});
if (streamingArg) {
if (options.streaming) {
done.resolve({
childProcess: execChildProcess,
finalPromise: childProcessEnded.promise,
kill: () => {
// this notation with the - kills the whole process group
console.log(`running tree kill with SIGKILL on process ${execChildProcess.pid}`);
plugins.treeKill(execChildProcess.pid, 'SIGKILL');
},
terminate: () => {
// this notation with the - kills the whole process group
console.log(`running tree kill with SIGTERM on process ${execChildProcess.pid}`);
plugins.treeKill(execChildProcess.pid, 'SIGTERM');
},
});
}
const result = await done.promise;
return result;
return await done.promise;
}
public async exec(commandStringArg: string): Promise<IExecResult> {
return (await this._exec(commandStringArg, false)) as IExecResult;
public async exec(commandString: string): Promise<IExecResult> {
return (await this._exec({ commandString })) as IExecResult;
}
/**
* executes a given command async and silent
* @param commandStringArg
*/
public async execSilent(commandStringArg: string): Promise<IExecResult> {
return (await this._exec(commandStringArg, true)) as IExecResult;
public async execSilent(commandString: string): Promise<IExecResult> {
return (await this._exec({ commandString, silent: true })) as IExecResult;
}
/**
* executes a command async and strict, meaning it rejects the promise if something happens
*/
public async execStrict(commandStringArg: string): Promise<IExecResult> {
return (await this._exec(commandStringArg, false, true)) as IExecResult;
public async execStrict(commandString: string): Promise<IExecResult> {
return (await this._exec({ commandString, strict: true })) as IExecResult;
}
public async execStrictSilent(commandStringArg: string): Promise<IExecResult> {
return (await this._exec(commandStringArg, true, true)) as IExecResult;
public async execStrictSilent(commandString: string): Promise<IExecResult> {
return (await this._exec({ commandString, silent: true, strict: true })) as IExecResult;
}
/**
* executes a command and allows you to stream output
*/
public async execStreaming(
commandStringArg: string,
silentArg: boolean = false
): Promise<IExecResultStreaming> {
return (await this._exec(commandStringArg, silentArg, false, true)) as IExecResultStreaming;
public async execStreaming(commandString: string, silent: boolean = false): Promise<IExecResultStreaming> {
return (await this._exec({ commandString, silent, streaming: true })) as IExecResultStreaming;
}
public async execStreamingSilent(commandStringArg: string) {
return (await this.execStreaming(commandStringArg, true)) as IExecResultStreaming;
public async execStreamingSilent(commandString: string): Promise<IExecResultStreaming> {
return (await this._exec({ commandString, silent: true, streaming: true })) as IExecResultStreaming;
}
/**
* executes a command and returns promise that will be fullfilled once an putput line matches RegexArg
* @param commandStringArg
* @param regexArg
*/
public async execAndWaitForLine(
commandStringArg: string,
regexArg: RegExp,
silentArg: boolean = false
) {
public async execInteractive(commandString: string) {
await this._exec({ commandString, interactive: true });
}
public async execAndWaitForLine(commandString: string, regexArg: RegExp, silentArg: boolean = false) {
let done = plugins.smartpromise.defer();
let execStreamingResult = await this.execStreaming(commandStringArg, silentArg);
let execStreamingResult = await this.execStreaming(commandString, silentArg);
execStreamingResult.childProcess.stdout.on('data', (stdOutChunk: string) => {
if (regexArg.test(stdOutChunk)) {
done.resolve();
@ -174,42 +176,7 @@ export class Smartshell {
return done.promise;
}
public async execAndWaitForLineSilent(commandStringArg: string, regexArg: RegExp) {
this.execAndWaitForLine(commandStringArg, regexArg, true);
}
/**
* execs an command and then enters interactive CLI
* @param commandStringArg
* @param regexArg
*/
public async execInteractive(commandStringArg: string) {
if (process.env.CI) {
return;
}
const done = plugins.smartpromise.defer();
const shell = cp.spawn('sh', [], { stdio: 'pipe' });
this.smartexit.addProcess(shell);
const shellLog = new ShellLog();
const stdInStream = process.stdin.pipe(shell.stdin);
const stdOutStream = shell.stdout.pipe(process.stdout);
shell.on('close', (code) => {
console.log(`interactive shell terminated with code ${code}`);
stdInStream.removeAllListeners();
stdInStream.uncork();
stdOutStream.removeAllListeners();
stdOutStream.unpipe();
shell.kill('SIGTERM');
process.stdin.pause();
done.resolve();
});
let commandString = commandStringArg;
if (process.env.CI) {
commandString += ' && exit';
}
commandString += '\n';
shell.stdin.write(commandString);
await done.promise;
public async execAndWaitForLineSilent(commandString: string, regexArg: RegExp) {
return this.execAndWaitForLine(commandString, regexArg, true);
}
}