Method exec

src/platform/common/process/proc.node.ts:156–213

(file: string, args: string[], options: SpawnOptions = {})

        };
    }
    public exec(file: string, args: string[], options: SpawnOptions = {}): Promise<ExecutionResult<string>> {
        const spawnOptions = this.getDefaultOptions(options);
        const proc = spawn(file, args, spawnOptions);
        const deferred = createDeferred<ExecutionResult<string>>();
        const disposable: IDisposable = {
            dispose: () => {
                if (!proc.killed && !deferred.completed) {
                    ProcessService.kill(proc.pid);
                }
            }
        };
        this.processesToKill.add(disposable);
        const disposables: IDisposable[] = [];

        const on = (ee: NodeJS.EventEmitter, name: string, fn: Function) => {
            ee.on(name, fn as any);
            disposables.push({ dispose: () => ee.removeListener(name, fn as any) as any });
        };

        if (options.token) {
            disposables.push(options.token.onCancellationRequested(disposable.dispose));
        }

        const stdoutBuffers: Buffer[] = [];
        on(proc.stdout!, 'data', (data: Buffer) => stdoutBuffers.push(data));
        const stderrBuffers: Buffer[] = [];
        on(proc.stderr!, 'data', (data: Buffer) => {
            if (options.mergeStdOutErr) {
                stdoutBuffers.push(data);
                stderrBuffers.push(data);
            } else {
                stderrBuffers.push(data);
            }
        });

        proc.once('close', () => {
            if (deferred.completed) {
                return;
            }
            const stderr: string | undefined =
                stderrBuffers.length === 0 ? undefined : this.decoder.decode(stderrBuffers);
            if (stderr && stderr.length > 0 && options.throwOnStdErr) {
                deferred.reject(new StdErrError(stderr));
            } else {
                const stdout = this.decoder.decode(stdoutBuffers);
                deferred.resolve({ stdout, stderr });
            }
            disposables.forEach((d) => d.dispose());
        });
        proc.once('error', (ex) => {
            deferred.reject(ex);
            disposables.forEach((d) => d.dispose());
        });

        logProcess(file, args, options);

        return deferred.promise;
    }