piston/cli/commands/execute.js

218 lines
6.2 KiB
JavaScript
Raw Normal View History

2021-02-22 11:38:11 +01:00
const fs = require('fs');
const path = require('path');
const chalk = require('chalk');
2021-07-16 14:23:45 +02:00
const WebSocket = require('ws');
const SIGNALS = ["SIGABRT","SIGALRM","SIGBUS","SIGCHLD","SIGCLD","SIGCONT","SIGEMT","SIGFPE","SIGHUP","SIGILL","SIGINFO","SIGINT","SIGIO","SIGIOT","SIGLOST","SIGPIPE","SIGPOLL","SIGPROF","SIGPWR","SIGQUIT","SIGSEGV","SIGSTKFLT","SIGTSTP","SIGSYS","SIGTERM","SIGTRAP","SIGTTIN","SIGTTOU","SIGUNUSED","SIGURG","SIGUSR1","SIGUSR2","SIGVTALRM","SIGXCPU","SIGXFSZ","SIGWINCH"]
2021-02-22 11:38:11 +01:00
2021-04-23 05:27:50 +02:00
exports.command = ['execute <language> <file> [args..]'];
exports.aliases = ['run'];
exports.describe = 'Executes file with the specified runner';
2021-02-22 11:38:11 +01:00
exports.builder = {
2021-05-08 02:57:37 +02:00
language_version: {
2021-04-23 01:59:54 +02:00
string: true,
desc: 'Set the version of the language to use',
alias: ['l'],
default: '*'
},
2021-02-22 11:38:11 +01:00
stdin: {
boolean: true,
desc: 'Read input from stdin and pass to executor',
alias: ['i']
},
run_timeout: {
alias: ['rt', 'r'],
number: true,
desc: 'Milliseconds before killing run process',
default: 3000
},
compile_timeout: {
alias: ['ct', 'c'],
number: true,
desc: 'Milliseconds before killing compile process',
default: 10000,
},
files: {
alias: ['f'],
array: true,
desc: 'Additional files to add',
2021-07-16 14:23:45 +02:00
},
interactive: {
boolean: true,
alias: ['t'],
desc: 'Run interactively using WebSocket transport'
},
status: {
boolean: true,
alias: ['s'],
desc: 'Output additional status to stderr'
2021-02-22 11:38:11 +01:00
}
2021-04-23 05:27:50 +02:00
};
2021-02-22 11:38:11 +01:00
2021-07-16 14:23:45 +02:00
async function handle_interactive(files, argv){
const ws = new WebSocket(argv.pistonUrl.replace("http", "ws") + "/api/v2/connect")
const log_message = (process.stderr.isTTY && argv.status) ? console.error : ()=>{};
process.on("exit", ()=>{
ws.close();
process.stdin.end();
process.stdin.destroy();
process.exit();
})
for(const signal of SIGNALS){
process.on(signal, ()=>{
ws.send(JSON.stringify({type: 'signal', signal}))
})
}
ws.on('open', ()=>{
const request = {
type: "init",
language: argv.language,
version: argv['language_version'],
files: files,
args: argv.args,
compile_timeout: argv.ct,
run_timeout: argv.rt
}
ws.send(JSON.stringify(request))
log_message(chalk.white.bold("Connected"))
process.stdin.resume();
process.stdin.on("data", (data) => {
ws.send(JSON.stringify({
type: "data",
stream: "stdin",
data: data.toString()
}))
})
})
ws.on("close", (code, reason)=>{
log_message(
chalk.white.bold("Disconnected: "),
chalk.white.bold("Reason: "),
chalk.yellow(`"${reason}"`),
chalk.white.bold("Code: "),
chalk.yellow(`"${code}"`),
)
process.stdin.pause()
})
ws.on('message', function(data){
const msg = JSON.parse(data);
switch(msg.type){
case "runtime":
log_message(chalk.bold.white("Runtime:"), chalk.yellow(`${msg.language} ${msg.version}`))
break;
case "stage":
log_message(chalk.bold.white("Stage:"), chalk.yellow(msg.stage))
break;
case "data":
if(msg.stream == "stdout") process.stdout.write(msg.data)
else if(msg.stream == "stderr") process.stderr.write(msg.data)
else log_message(chalk.bold.red(`(${msg.stream}) `), msg.data)
break;
case "exit":
if(msg.signal === null)
log_message(
chalk.white.bold("Stage"),
chalk.yellow(msg.stage),
chalk.white.bold("exited with code"),
chalk.yellow(msg.code)
)
else
log_message(
chalk.white.bold("Stage"),
chalk.yellow(msg.stage),
chalk.white.bold("exited with signal"),
chalk.yellow(msg.signal)
)
break;
default:
log_message(chalk.red.bold("Unknown message:"), msg)
}
})
}
async function run_non_interactively(files, argv) {
2021-02-22 11:38:11 +01:00
2021-04-23 05:27:50 +02:00
const stdin = (argv.stdin && await new Promise((resolve, _) => {
let data = '';
process.stdin.on('data', d => data += d);
process.stdin.on('end', _ => resolve(data));
})) || '';
2021-02-22 11:38:11 +01:00
2021-03-13 04:08:35 +01:00
const request = {
2021-03-05 07:40:47 +01:00
language: argv.language,
2021-05-08 02:57:37 +02:00
version: argv['language_version'],
2021-03-05 07:40:47 +01:00
files: files,
2021-03-05 12:44:35 +01:00
args: argv.args,
2021-02-22 11:38:11 +01:00
stdin,
2021-03-05 07:40:47 +01:00
compile_timeout: argv.ct,
run_timeout: argv.rt
2021-03-13 04:08:35 +01:00
};
let { data: response } = await argv.axios.post('/api/v2/execute', request);
2021-02-22 11:38:11 +01:00
2021-04-23 05:27:50 +02:00
const step = (name, ctx) => {
console.log(chalk.bold(`== ${name} ==`));
if (ctx.stdout) {
console.log(chalk.bold(`STDOUT`))
console.log(ctx.stdout.replace(/\n/g,'\n '))
2021-02-22 11:38:11 +01:00
}
2021-04-23 05:27:50 +02:00
if (ctx.stderr) {
2021-02-22 11:38:11 +01:00
console.log(chalk.bold(`STDERR`))
2021-04-23 05:27:50 +02:00
console.log(ctx.stderr.replace(/\n/g,'\n '))
2021-02-22 11:38:11 +01:00
}
2021-04-23 05:27:50 +02:00
if (ctx.code) {
2021-02-22 11:38:11 +01:00
console.log(
chalk.bold(`Exit Code:`),
chalk.bold[ctx.code > 0 ? 'red' : 'green'](ctx.code)
2021-04-23 05:27:50 +02:00
);
}
if (ctx.signal) {
2021-02-22 11:38:11 +01:00
console.log(
chalk.bold(`Signal:`),
chalk.bold.yellow(ctx.signal)
2021-04-23 05:27:50 +02:00
);
}
2021-02-22 11:38:11 +01:00
}
2021-03-14 07:36:12 +01:00
2021-04-23 05:27:50 +02:00
if (response.compile) {
step('Compile', response.compile);
}
step('Run', response.run);
}
2021-07-16 14:23:45 +02:00
exports.handler = async (argv) => {
const files = [...(argv.files || []),argv.file]
.map(file_path => {
return {
name: path.basename(file_path),
content: fs.readFileSync(file_path).toString()
};
});
if(argv.interactive) await handle_interactive(files, argv);
else await run_non_interactively(files, argv);
}