The Tor Browser: comparison addon-sdk/source/lib/sdk/system/child_process.js

comparison: addon-sdk/source/lib/sdk/system/child_process.js

addon-sdk/source/lib/sdk/system/child_process.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:2a6e1ac91eea
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+module.metadata = {
+'stability': 'experimental'
+};
+let { Ci } = require('chrome');
+let subprocess = require('./child_process/subprocess');
+let { EventTarget } = require('../event/target');
+let { Stream } = require('../io/stream');
+let { on, emit, off } = require('../event/core');
+let { Class } = require('../core/heritage');
+let { platform } = require('../system');
+let { isFunction, isArray } = require('../lang/type');
+let { delay } = require('../lang/functional');
+let { merge } = require('../util/object');
+let { setTimeout, clearTimeout } = require('../timers');
+let isWindows = platform.indexOf('win') === 0;
+let processes = WeakMap();
+/**
+* The `Child` class wraps a subprocess command, exposes
+* the stdio streams, and methods to manipulate the subprocess
+*/
+let Child = Class({
+implements: [EventTarget],
+initialize: function initialize (options) {
+let child = this;
+let proc;
+this.killed = false;
+this.exitCode = undefined;
+this.signalCode = undefined;
+this.stdin = Stream();
+this.stdout = Stream();
+this.stderr = Stream();
+try {
+proc = subprocess.call({
+command: options.file,
+arguments: options.cmdArgs,
+environment: serializeEnv(options.env),
+workdir: options.cwd,
+charset: options.encoding,
+stdout: data => emit(child.stdout, 'data', data),
+stderr: data => emit(child.stderr, 'data', data),
+stdin: stream => {
+child.stdin.on('data', pumpStdin);
+child.stdin.on('end', function closeStdin () {
+child.stdin.off('data', pumpStdin);
+child.stdin.off('end', closeStdin);
+stream.close();
+});
+function pumpStdin (data) {
+stream.write(data);
+}
+},
+done: function (result) {
+// Only emit if child is not killed; otherwise,
+// the `kill` method will handle this
+if (!child.killed) {
+child.exitCode = result.exitCode;
+child.signalCode = null;
+// If process exits with < 0, there was an error
+if (child.exitCode < 0) {
+handleError(new Error('Process exited with exit code ' + child.exitCode));
+}
+else {
+// Also do 'exit' event as there's not much of
+// a difference in our implementation as we're not using
+// node streams
+emit(child, 'exit', child.exitCode, child.signalCode);
+}
+// Emit 'close' event with exit code and signal,
+// which is `null`, as it was not a killed process
+emit(child, 'close', child.exitCode, child.signalCode);
+}
+}
+});
+processes.set(child, proc);
+} catch (e) {
+// Delay the error handling so an error handler can be set
+// during the same tick that the Child was created
+delay(() => handleError(e));
+}
+// `handleError` is called when process could not even
+// be spawned
+function handleError (e) {
+// If error is an nsIObject, make a fresh error object
+// so we're not exposing nsIObjects, and we can modify it
+// with additional process information, like node
+let error = e;
+if (e instanceof Ci.nsISupports) {
+error = new Error(e.message, e.filename, e.lineNumber);
+}
+emit(child, 'error', error);
+child.exitCode = -1;
+child.signalCode = null;
+emit(child, 'close', child.exitCode, child.signalCode);
+}
+},
+kill: function kill (signal) {
+let proc = processes.get(this);
+proc.kill(signal);
+this.killed = true;
+this.exitCode = null;
+this.signalCode = signal;
+emit(this, 'exit', this.exitCode, this.signalCode);
+emit(this, 'close', this.exitCode, this.signalCode);
+},
+get pid() { return processes.get(this, {}).pid || -1; }
+});
+function spawn (file, ...args) {
+let cmdArgs = [];
+// Default options
+let options = {
+cwd: null,
+env: null,
+encoding: 'UTF-8'
+};
+if (args[1]) {
+merge(options, args[1]);
+cmdArgs = args[0];
+}
+else {
+if (isArray(args[0]))
+cmdArgs = args[0];
+else
+merge(options, args[0]);
+}
+if ('gid' in options)
+console.warn('`gid` option is not yet supported for `child_process`');
+if ('uid' in options)
+console.warn('`uid` option is not yet supported for `child_process`');
+if ('detached' in options)
+console.warn('`detached` option is not yet supported for `child_process`');
+options.file = file;
+options.cmdArgs = cmdArgs;
+return Child(options);
+}
+exports.spawn = spawn;
+/**
+* exec(command, options, callback)
+*/
+function exec (cmd, ...args) {
+let file, cmdArgs, callback, options = {};
+if (isFunction(args[0]))
+callback = args[0];
+else {
+merge(options, args[0]);
+callback = args[1];
+}
+if (isWindows) {
+file = 'C:\\Windows\\System32\\cmd.exe';
+cmdArgs = ['/s', '/c', (cmd || '').split(' ')];
+}
+else {
+file = '/bin/sh';
+cmdArgs = ['-c', cmd];
+}
+// Undocumented option from node being able to specify shell
+if (options && options.shell)
+file = options.shell;
+return execFile(file, cmdArgs, options, callback);
+}
+exports.exec = exec;
+/**
+* execFile (file, args, options, callback)
+*/
+function execFile (file, ...args) {
+let cmdArgs = [], callback;
+// Default options
+let options = {
+cwd: null,
+env: null,
+encoding: 'utf8',
+timeout: 0,
+maxBuffer: 200 * 1024,
+killSignal: 'SIGTERM'
+};
+if (isFunction(args[args.length - 1]))
+callback = args[args.length - 1];
+if (isArray(args[0])) {
+cmdArgs = args[0];
+merge(options, args[1]);
+} else if (!isFunction(args[0]))
+merge(options, args[0]);
+let child = spawn(file, cmdArgs, options);
+let exited = false;
+let stdout = '';
+let stderr = '';
+let error = null;
+let timeoutId = null;
+child.stdout.setEncoding(options.encoding);
+child.stderr.setEncoding(options.encoding);
+on(child.stdout, 'data', pumpStdout);
+on(child.stderr, 'data', pumpStderr);
+on(child, 'close', exitHandler);
+on(child, 'error', errorHandler);
+if (options.timeout > 0) {
+setTimeout(() => {
+kill();
+timeoutId = null;
+}, options.timeout);
+}
+function exitHandler (code, signal) {
+// Return if exitHandler called previously, occurs
+// when multiple maxBuffer errors thrown and attempt to kill multiple
+// times
+if (exited) return;
+exited = true;
+if (!isFunction(callback)) return;
+if (timeoutId) {
+clearTimeout(timeoutId);
+timeoutId = null;
+}
+if (!error && (code !== 0 || signal !== null))
+error = createProcessError(new Error('Command failed: ' + stderr), {
+code: code,
+signal: signal,
+killed: !!child.killed
+});
+callback(error, stdout, stderr);
+off(child.stdout, 'data', pumpStdout);
+off(child.stderr, 'data', pumpStderr);
+off(child, 'close', exitHandler);
+off(child, 'error', errorHandler);
+}
+function errorHandler (e) {
+error = e;
+exitHandler();
+}
+function kill () {
+try {
+child.kill(options.killSignal);
+} catch (e) {
+// In the scenario where the kill signal happens when
+// the process is already closing, just abort the kill fail
+if (/library is not open/.test(e))
+return;
+error = e;
+exitHandler(-1, options.killSignal);
+}
+}
+function pumpStdout (data) {
+stdout += data;
+if (stdout.length > options.maxBuffer) {
+error = new Error('stdout maxBuffer exceeded');
+kill();
+}
+}
+function pumpStderr (data) {
+stderr += data;
+if (stderr.length > options.maxBuffer) {
+error = new Error('stderr maxBuffer exceeded');
+kill();
+}
+}
+return child;
+}
+exports.execFile = execFile;
+exports.fork = function fork () {
+throw new Error("child_process#fork is not currently supported");
+};
+function serializeEnv (obj) {
+return Object.keys(obj || {}).map(prop => prop + '=' + obj[prop]);
+}
+function createProcessError (err, options = {}) {
+// If code and signal look OK, this was probably a failure
+// attempting to spawn the process (like ENOENT in node) -- use
+// the code from the error message
+if (!options.code && !options.signal) {
+let match = err.message.match(/(NS_ERROR_\w*)/);
+if (match && match.length > 1)
+err.code = match[1];
+else {
+// If no good error message found, use the passed in exit code;
+// this occurs when killing a process that's already closing,
+// where we want both a valid exit code (0) and the error
+err.code = options.code != null ? options.code : null;
+}
+}
+else
+err.code = options.code != null ? options.code : null;
+err.signal = options.signal || null;
+err.killed = options.killed || false;
+return err;
+}