Wie kann man die Funktionen child_process.exec und child_process.execFile von Node mit Bluebird promiziieren?

Ich bin mit dem Bluebird Versprechen-Bibliothek unter Node.js, es ist toll! Aber ich habe eine Frage:

Wenn Sie einen Blick auf die Dokumentation des Knotens child_process.exec und child_process.execFile können Sie sehen, dass diese beiden Funktionen sind der Rückgabe einen ChildProcess Objekt.

Also, was ist der empfohlene Weg, um promisify solche Funktionen?

Beachten Sie, dass das folgende funktioniert (ich bekomme ein Promise-Objekt):

var Promise = require('bluebird');
var execAsync = Promise.promisify(require('child_process').exec);
var execFileAsync = Promise.promisify(require('child_process').execFile);

Aber wie kann man den Zugriff auf die ursprüngliche return-Wert der ursprünglichen Node.js Funktionen? (In diesen Fällen würde ich brauchen, um in der Lage sein, um Zugriff auf die ursprünglich zurückgegeben ChildProcess Objekte).

Jeder Vorschlag würde geschätzt!

EDIT:

Hier ist ein Beispiel code, der mit der return-Wert der child_process.exec-Funktion:

var exec = require('child_process').exec;
var child = exec('node ./commands/server.js');
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);
});

Aber wenn würde ich die promisified version der exec-Funktion ( execAsync von oben ), dann ist der Rückgabewert ein Versprechen, nicht eine ChildProcess Objekt. Das ist das eigentliche problem von dem ich Rede.

InformationsquelleAutor der Frage Zoltan | 2015-06-10

Klingt es wie Sie möchten, um zurückzukehren, zwei Dinge, die aus dem Aufruf:

der ChildProcess
ein Versprechen, das aufgelöst werden kann, wenn der ChildProcess abgeschlossen

Also "der empfohlene Weg, um promisify solche Funktionen"? Nicht.

Du bist außerhalb der Konvention. Versprechen der Rückkehr Funktionen werden wieder erwartet Sie ein Versprechen, und das ist es. Sie könnten ein Objekt wieder mit zwei Mitgliedern (den ChildProcess & das Versprechen), werde das aber nur die Leute verwirren.

Ich würde vorschlagen, den Aufruf der unpromisified Funktion und erstellen ein Versprechen, basierend auf der zurückgegebenen childProcess. (Vielleicht wickeln, in eine helper-Funktion)

Diese Weise, es ist sehr explizit für die nächste person, die den code liest.

Etwas wie:

var Promise = require('bluebird');
var exec = require('child_process').execFile;

function promiseFromChildProcess(child) {
    return new Promise(function (resolve, reject) {
        child.addListener("error", reject);
        child.addListener("exit", resolve);
    });
}

var child = exec('ls');

promiseFromChildProcess(child).then(function (result) {
    console.log('promise complete: ' + result);
}, function (err) {
    console.log('promise rejected: ' + err);
});

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);
});

InformationsquelleAutor der Antwort Ivan Hamilton

Wahrscheinlich gibt es nicht eine Möglichkeit, das zu tun schön, dass deckt alle Anwendungsfälle. Aber für den begrenzten Fällen, können Sie etwas wie das hier tun:

/**
 * 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);
        }
    });
}

Dieser akzeptiert opts.stdout und opts.stderr Argumente, so dass stdio erfasst werden kann von den Kind-Prozess.

Beispiel:

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!'));

Oder einfach:

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

InformationsquelleAutor der Antwort edan

Möchte nur erwähnen, dass es ein nettes tool, das löst dein problem nicht ganz:

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

Dieses Paket macht es viel einfacher zu handhaben Prozesse.

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();

oder kombinieren Sie diese Funktionen:

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 */);

InformationsquelleAutor der Antwort Tobias

Hier ist ein anderer Weg:

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

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


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

Oder mit async/await:

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

InformationsquelleAutor der Antwort Lacho Tomov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.