Jak promisify proces potomny węzła.exec i proces potomny.funkcje execFile z Bluebird?

Zalecałbym użycie standardowego js promises wbudowanego w Język poprzez dodatkową zależność biblioteki, taką jak Bluebird.

Jeśli używasz węzła 10+, węzeł.js docs zaleca użycie util.promisify, które zwraca obiekt Promise<{ stdout, stderr }>. Zobacz przykład poniżej:

const util = require('util');
const exec = util.promisify(require('child_process').exec);

async function lsExample() {
  try {
    const { stdout, stderr } = await exec('ls');
    console.log('stdout:', stdout);
    console.log('stderr:', stderr);
  } catch (e) {
    console.error(e); // should contain code (exit code) and signal (that caused the termination).
  }
}
lsExample()

Obsługa błędów najpierw z stderr.

Oto inny sposób:

function execPromise(command) {
    return new Promise(function(resolve, reject) {
        exec(command, (error, stdout, stderr) => {
            if (error) {
                reject(error);
                return;
            }

            resolve(stdout.trim());
        });
    });
}

Użyj funkcji:

execPromise(command).then(function(result) {
    console.log(result);
}).catch(function(e) {
    console.error(e.message);
});

Lub z asynchronicznym / oczekującym:

try {
    var result = await execPromise(command);
} catch (e) {
    console.error(e.message);
}

Od Node v12 wbudowany util.promisify umożliwia dostęp do obiektu ChildProcess w zwracanym Promise dla wbudowanych funkcji, w których został zwrócony przez nie-promisified wywołanie. Z docs :

Zwracana instancja ChildProcess jest dołączona do Promise jako właściwość child.

To poprawnie i po prostu zaspokaja potrzebę dostępu ChildProcess w pytaniu pierwotnym i sprawia, że Inne odpowiedzi są nieaktualne pod warunkiem, że węzeł v12+ może być używany.

Dostosowując przykład (izwięzły styl ) dostarczony przez pytającego, dostęp do ChildProcess można uzyskać w następujący sposób:

const util = require('util');
const exec = util.promisify(require('child_process').exec);
const promise = exec('node ./commands/server.js');
const child = promise.child; 

child.stdout.on('data', function(data) {
    console.log('stdout: ' + data);
});
child.stderr.on('data', function(data) {
    console.log('stderr: ' + data);
});
child.on('close', function(code) {
    console.log('closing code: ' + code);
});

// i.e. can then await for promisified exec call to complete
const { stdout, stderr } = await promise;

Prawdopodobnie nie ma sposobu, aby zrobić ładnie, który obejmuje wszystkie przypadki użycia. Ale w ograniczonych przypadkach możesz zrobić coś takiego:

/**
 * Promisified child_process.exec
 *
 * @param cmd
 * @param opts See child_process.exec node docs
 * @param {stream.Writable} opts.stdout If defined, child process stdout will be piped to it.
 * @param {stream.Writable} opts.stderr If defined, child process stderr will be piped to it.
 *
 * @returns {Promise<{ stdout: string, stderr: stderr }>}
 */
function execp(cmd, opts) {
    opts || (opts = {});
    return new Promise((resolve, reject) => {
        const child = exec(cmd, opts,
            (err, stdout, stderr) => err ? reject(err) : resolve({
                stdout: stdout,
                stderr: stderr
            }));

        if (opts.stdout) {
            child.stdout.pipe(opts.stdout);
        }
        if (opts.stderr) {
            child.stderr.pipe(opts.stderr);
        }
    });
}

To akceptuje argumenty opts.stdout i opts.stderr, dzięki czemu stdio może zostać przechwycone z procesu potomnego.

Na przykład:

execp('ls ./', {
    stdout: new stream.Writable({
        write: (chunk, enc, next) => {
            console.log(chunk.toString(enc));
            next();
        }
    }),
    stderr: new stream.Writable({
        write: (chunk, enc, next) => {
            console.error(chunk.toString(enc));
            next();
        }
    })
}).then(() => console.log('done!'));

Lub po prostu:

execp('ls ./', {
    stdout: process.stdout,
    stderr: process.stderr
}).then(() => console.log('done!'));

Chcę tylko wspomnieć, że istnieje fajne narzędzie, które całkowicie rozwiąże twój problem:

Https://www.npmjs.com/package/core-worker

Ten pakiet znacznie ułatwia obsługę procesów.

import { process } from "CoreWorker";
import fs from "fs";

const result = await process("node Server.js", "Server is ready.").ready(1000);
const result = await process("cp path/to/file /newLocation/newFile").death();

Lub połączyć te funkcje:

import { process } from "core-worker";

const simpleChat = process("node chat.js", "Chat ready");

setTimeout(() => simpleChat.kill(), 360000); // wait an hour and close the chat

simpleChat.ready(500)
    .then(console.log.bind(console, "You are now able to send messages."))
    .then(::simpleChat.death)
    .then(console.log.bind(console, "Chat closed"))
    .catch(() => /* handle err */);

To moje. Nie dotyczy to stdin ani stdout, więc jeśli ich potrzebujesz, użyj jednej z innych odpowiedzi na tej stronie. :)

// promisify `child_process`
// This is a very nice trick :-)
this.promiseFromChildProcess = function (child) {
    return new Promise((resolve, reject) => {
        child.addListener('error', (code, signal) => {
            console.log('ChildProcess error', code, signal);
            reject(code);
        });
        child.addListener('exit', (code, signal) => {
            if (code === 0) {
                resolve(code);
            } else {
                console.log('ChildProcess error', code, signal);
                reject(code);
            }
        });
    });
};