mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 23:34:47 -05:00
139 lines
3.6 KiB
TypeScript
139 lines
3.6 KiB
TypeScript
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
|
|
|
import { File } from "./files.ts";
|
|
import { close } from "./ops/resources.ts";
|
|
import { Closer, Reader, Writer } from "./io.ts";
|
|
import { readAll } from "./buffer.ts";
|
|
import { kill, runStatus as runStatusOp, run as runOp } from "./ops/process.ts";
|
|
|
|
// TODO Maybe extend VSCode's 'CommandOptions'?
|
|
// See https://code.visualstudio.com/docs/editor/tasks-appendix#_schema-for-tasksjson
|
|
export interface RunOptions {
|
|
cmd: string[];
|
|
cwd?: string;
|
|
env?: Record<string, string>;
|
|
stdout?: "inherit" | "piped" | "null" | number;
|
|
stderr?: "inherit" | "piped" | "null" | number;
|
|
stdin?: "inherit" | "piped" | "null" | number;
|
|
}
|
|
|
|
async function runStatus(rid: number): Promise<ProcessStatus> {
|
|
const res = await runStatusOp(rid);
|
|
|
|
if (res.gotSignal) {
|
|
const signal = res.exitSignal;
|
|
return { success: false, code: 128 + signal, signal };
|
|
} else if (res.exitCode != 0) {
|
|
return { success: false, code: res.exitCode };
|
|
} else {
|
|
return { success: true, code: 0 };
|
|
}
|
|
}
|
|
|
|
export class Process<T extends RunOptions = RunOptions> {
|
|
readonly rid: number;
|
|
readonly pid: number;
|
|
readonly stdin!: T["stdin"] extends "piped"
|
|
? Writer & Closer
|
|
: (Writer & Closer) | null;
|
|
readonly stdout!: T["stdout"] extends "piped"
|
|
? Reader & Closer
|
|
: (Reader & Closer) | null;
|
|
readonly stderr!: T["stderr"] extends "piped"
|
|
? Reader & Closer
|
|
: (Reader & Closer) | null;
|
|
|
|
// @internal
|
|
constructor(res: RunResponse) {
|
|
this.rid = res.rid;
|
|
this.pid = res.pid;
|
|
|
|
if (res.stdinRid && res.stdinRid > 0) {
|
|
this.stdin = (new File(res.stdinRid) as unknown) as Process<T>["stdin"];
|
|
}
|
|
|
|
if (res.stdoutRid && res.stdoutRid > 0) {
|
|
this.stdout = (new File(res.stdoutRid) as unknown) as Process<
|
|
T
|
|
>["stdout"];
|
|
}
|
|
|
|
if (res.stderrRid && res.stderrRid > 0) {
|
|
this.stderr = (new File(res.stderrRid) as unknown) as Process<
|
|
T
|
|
>["stderr"];
|
|
}
|
|
}
|
|
|
|
status(): Promise<ProcessStatus> {
|
|
return runStatus(this.rid);
|
|
}
|
|
|
|
async output(): Promise<Uint8Array> {
|
|
if (!this.stdout) {
|
|
throw new TypeError("stdout was not piped");
|
|
}
|
|
try {
|
|
return await readAll(this.stdout as Reader & Closer);
|
|
} finally {
|
|
(this.stdout as Reader & Closer).close();
|
|
}
|
|
}
|
|
|
|
async stderrOutput(): Promise<Uint8Array> {
|
|
if (!this.stderr) {
|
|
throw new TypeError("stderr was not piped");
|
|
}
|
|
try {
|
|
return await readAll(this.stderr as Reader & Closer);
|
|
} finally {
|
|
(this.stderr as Reader & Closer).close();
|
|
}
|
|
}
|
|
|
|
close(): void {
|
|
close(this.rid);
|
|
}
|
|
|
|
kill(signo: number): void {
|
|
kill(this.pid, signo);
|
|
}
|
|
}
|
|
|
|
export type ProcessStatus =
|
|
| { success: true; code: 0; signal?: undefined }
|
|
| { success: false; code: number; signal?: number };
|
|
|
|
function isRid(arg: unknown): arg is number {
|
|
return !isNaN(arg as number);
|
|
}
|
|
|
|
interface RunResponse {
|
|
rid: number;
|
|
pid: number;
|
|
stdinRid: number | null;
|
|
stdoutRid: number | null;
|
|
stderrRid: number | null;
|
|
}
|
|
|
|
export function run<T extends RunOptions = RunOptions>({
|
|
cmd,
|
|
cwd = undefined,
|
|
env = {},
|
|
stdout = "inherit",
|
|
stderr = "inherit",
|
|
stdin = "inherit",
|
|
}: T): Process<T> {
|
|
const res = runOp({
|
|
cmd: cmd.map(String),
|
|
cwd,
|
|
env: Object.entries(env),
|
|
stdin: isRid(stdin) ? "" : stdin,
|
|
stdout: isRid(stdout) ? "" : stdout,
|
|
stderr: isRid(stderr) ? "" : stderr,
|
|
stdinRid: isRid(stdin) ? stdin : 0,
|
|
stdoutRid: isRid(stdout) ? stdout : 0,
|
|
stderrRid: isRid(stderr) ? stderr : 0,
|
|
}) as RunResponse;
|
|
return new Process<T>(res);
|
|
}
|