Feat/exec stdio

doc/api/child_process.md

@@ -168,6 +168,12 @@ changes:
 * `options` {Object}
   * `cwd` {string|URL} Current working directory of the child process.
     **Default:** `process.cwd()`.
+  * `input` {string|Buffer|TypedArray|DataView} The value which will be passed
+    as stdin to the spawned process. Supplying this value will override
+    `stdio[0]`.
+  * `stdio` {string|Array} Child's stdio configuration. `stderr` by default will
+    be output to the parent process' stderr unless `stdio` is specified.
+    **Default:** `'pipe'`.
   * `env` {Object} Environment key-value pairs. **Default:** `process.env`.
   * `encoding` {string} **Default:** `'utf8'`
   * `shell` {string} Shell to execute the command with. See
@@ -302,6 +308,12 @@ changes:
 * `args` {string\[]} List of string arguments.
 * `options` {Object}
   * `cwd` {string|URL} Current working directory of the child process.
+  * `input` {string|Buffer|TypedArray|DataView} The value which will be passed
+    as stdin to the spawned process. Supplying this value will override
+    `stdio[0]`.
+  * `stdio` {string|Array} Child's stdio configuration. `stderr` by default will
+    be output to the parent process' stderr unless `stdio` is specified.
+    **Default:** `'pipe'`.
   * `env` {Object} Environment key-value pairs. **Default:** `process.env`.
   * `encoding` {string} **Default:** `'utf8'`
   * `timeout` {number} **Default:** `0`
@@ -563,6 +575,9 @@ changes:
 * `args` {string\[]} List of string arguments.
 * `options` {Object}
   * `cwd` {string|URL} Current working directory of the child process.
+  * `input` {string|Buffer|TypedArray|DataView} The value which will be passed
+    as stdin to the spawned process. Supplying this value will override
+    `stdio[0]`.
   * `env` {Object} Environment key-value pairs. **Default:** `process.env`.
   * `argv0` {string} Explicitly set the value of `argv[0]` sent to the child
     process. This will be set to `command` if not specified.

lib/child_process.js

@@ -209,6 +209,8 @@ function normalizeExecArgs(command, options, callback) {
  * @param {string} command
  * @param {{
  *   cmd?: string;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   stdio?: Array | string;
  *   env?: Record<string, string>;
  *   encoding?: string;
  *   shell?: string;
@@ -229,9 +231,7 @@ function normalizeExecArgs(command, options, callback) {
  */
 function exec(command, options, callback) {
   const opts = normalizeExecArgs(command, options, callback);
-  return module.exports.execFile(opts.file,
-                                 opts.options,
-                                 opts.callback);
+  return execFile(opts.file, opts.options, opts.callback);
 }
 
 const customPromiseExecFunction = (orig) => {
@@ -304,6 +304,8 @@ function normalizeExecFileArgs(file, args, options, callback) {
  * @param {string[]} [args]
  * @param {{
  *   cwd?: string;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   stdio?: Array | string;
  *   env?: Record<string, string>;
  *   encoding?: string;
  *   timeout?: number;
@@ -347,6 +349,8 @@ function execFile(file, args, options, callback) {
 
   const child = spawn(file, args, {
     cwd: options.cwd,
+    input: options.input,
+    stdio: options.stdio,
     env: options.env,
     gid: options.gid,
     shell: options.shell,
@@ -730,6 +734,7 @@ function abortChildProcess(child, killSignal, reason) {
  * @param {string[]} [args]
  * @param {{
  *   cwd?: string;
+ *   input?: string | Buffer | TypedArray | DataView;
  *   env?: Record<string, string>;
  *   argv0?: string;
  *   stdio?: Array | string;
@@ -754,6 +759,22 @@ function spawn(file, args, options) {
   const child = new ChildProcess();
 
   debug('spawn', options);
+  let input = options.input;
+  if (options.input) {
+    if (isArrayBufferView(input)) {
+      input = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+    } else if (typeof input === 'string') {
+      input = Buffer.from(input, options.encoding);
+    } else {
+      throw new ERR_INVALID_ARG_TYPE('options.input',
+                                     ['Buffer',
+                                      'TypedArray',
+                                      'DataView',
+                                      'string'],
+                                     input);
+    }
+  }
+
   child.spawn(options);
 
   if (options.timeout > 0) {
@@ -791,6 +812,10 @@ function spawn(file, args, options) {
     }
   }
 
+  if (options.input) {
+    child.stdin.end(input);
+  }
+
   return child;
 }
 

test/parallel/test-child-process-exec-stdio-ignore.js

@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+if (process.argv[2] === 'child') {
+  process.stdout.write('this should be ignored');
+  process.stderr.write('this should not be ignored');
+
+} else {
+  const cmd = `"${process.execPath}" "${__filename}" child`;
+  cp.exec(cmd,
+          { stdio: ['pipe', 'ignore', 'pipe'] },
+          common.mustCall((err, stdout, stderr) => {
+            assert.strictEqual(stderr, 'this should not be ignored');
+            assert.strictEqual(stdout, '');
+          }));
+}

test/parallel/test-child-process-exec-stdio-inherit.js

@@ -0,0 +1,25 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const exec = require('child_process').exec;
+
+if (process.argv[2] === 'parent')
+  parent();
+else
+  grandparent();
+
+function grandparent() {
+  const cmd = `"${process.execPath}" "${__filename}" parent`;
+  const input = 'asdfasdf';
+  const child = exec(cmd, (err, stdout, stderr) => {
+    assert.strictEqual(stdout.trim(), input.trim());
+  });
+  child.stderr.pipe(process.stderr);
+
+  child.stdin.end(input);
+}
+
+function parent() {
+  // Should not immediately exit.
+  exec('cat', { stdio: 'inherit' });
+}

test/parallel/test-child-process-execfile-stdio-ignore.js

@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+if (process.argv[2] === 'child') {
+  process.stdout.write('this should be ignored');
+  process.stderr.write('this should not be ignored');
+
+} else {
+  cp.execFile(process.execPath,
+              [__filename, 'child'],
+              { stdio: ['pipe', 'ignore', 'pipe'] },
+              common.mustCall((err, stdout, stderr) => {
+                assert.strictEqual(stderr, 'this should not be ignored');
+                assert.strictEqual(stdout, '');
+              }));
+}

test/parallel/test-child-process-execfile-stdio-inherit.js

@@ -0,0 +1,24 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const execFile = require('child_process').execFile;
+
+if (process.argv[2] === 'parent')
+  parent();
+else
+  grandparent();
+
+function grandparent() {
+  const input = 'asdfasdf';
+  const child = execFile(process.execPath, [__filename, 'parent'], (err, stdout, stderr) => {
+    assert.strictEqual(stdout.trim(), input.trim());
+  });
+  child.stderr.pipe(process.stderr);
+
+  child.stdin.end(input);
+}
+
+function parent() {
+  // Should not immediately exit.
+  execFile('cat', [], { stdio: 'inherit' });
+}

test/parallel/test-child-process-spawn-input.js

@@ -0,0 +1,64 @@
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+
+const spawn = require('child_process').spawn;
+
+const badOptions = {
+  input: 1234
+};
+
+assert.throws(
+  () => spawn('cat', [], badOptions),
+  { code: 'ERR_INVALID_ARG_TYPE', name: 'TypeError' });
+
+const stringOptions = {
+  input: 'hello world'
+};
+
+const catString = spawn('cat', [], stringOptions);
+
+catString.stdout.on('data', common.mustCall((data) => {
+  assert.strictEqual(data.toString('utf8'), stringOptions.input);
+}));
+
+catString.on('close', common.mustCall((code, signal) => {
+  assert.strictEqual(code, 0);
+  assert.strictEqual(signal, null);
+}));
+
+const bufferOptions = {
+  input: Buffer.from('hello world')
+};
+
+const catBuffer = spawn('cat', [], bufferOptions);
+
+catBuffer.stdout.on('data', common.mustCall((data) => {
+  assert.deepStrictEqual(data, bufferOptions.input);
+}));
+
+catBuffer.on('close', common.mustCall((code, signal) => {
+  assert.strictEqual(code, 0);
+  assert.strictEqual(signal, null);
+}));
+
+// common.getArrayBufferViews expects a buffer
+// with length an multiple of 8
+const msgBuf = Buffer.from('hello world'.repeat(8));
+for (const arrayBufferView of common.getArrayBufferViews(msgBuf)) {
+  const options = {
+    input: arrayBufferView
+  };
+
+  const catArrayBufferView = spawn('cat', [], options);
+
+  catArrayBufferView.stdout.on('data', common.mustCall((data) => {
+    assert.deepStrictEqual(data, msgBuf);
+  }));
+
+  catArrayBufferView.on('close', common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  }));
+}