lib/src/process_runner.dart - third_party/process_runner - Git at Google

 // Copyright 2020 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 import 'dart:async' show Completer;
 import 'dart:convert' show Encoding;
 import 'dart:io'
     show
         Directory,
         Process,
         ProcessException,
         ProcessStartMode,
         SystemEncoding,
         stderr,
         stdout;

 import 'package:platform/platform.dart' show LocalPlatform, Platform;
 import 'package:process/process.dart' show LocalProcessManager, ProcessManager;

 import '../process_runner.dart' show ProcessPool;

 import 'process_pool.dart' show ProcessPool;

 const Platform defaultPlatform = LocalPlatform();

 /// Exception class for when a process fails to run, so we can catch
 /// it and provide something more readable than a stack trace.
 class ProcessRunnerException implements Exception {
   ProcessRunnerException(this.message, {this.result});

   final String message;
   final ProcessRunnerResult? result;

   int get exitCode => result?.exitCode ?? -1;

   @override
   String toString() {
     var output = runtimeType.toString();
     output += ': $message';
     final stderr = result?.stderr ?? '';
     if (stderr.isNotEmpty) {
       output += ':\n$stderr';
     }
     return output;
   }
 }

 /// This is the result of running a command using [ProcessRunner] or
 /// [ProcessPool].  It includes the entire stderr, stdout, and interleaved
 /// output from the command after it has completed.
 ///
 /// The [stdoutRaw], [stderrRaw], and [outputRaw] members contain the encoded
 /// output from the command as a [List<int>].
 ///
 /// The [stdout], [stderr], and [output] accessors will decode the [stdoutRaw],
 /// [stderrRaw], and [outputRaw] data automatically, using a [SystemEncoding]
 /// decoder.
 class ProcessRunnerResult {
   /// Creates a new [ProcessRunnerResult], usually created by a [ProcessRunner].
   ///
   /// If [decoder] is not supplied, it defaults to [SystemEncoding].
   ProcessRunnerResult(
     this.exitCode,
     this.stdoutRaw,
     this.stderrRaw,
     this.outputRaw, {
     this.decoder = const SystemEncoding(),
     this.pid,
   });

   /// Contains the exit code from the completed process.
   final int exitCode;

   /// Contains the raw, encoded, stdout output from the completed process.
   final List<int> stdoutRaw;

   /// Contains the raw, encoded, stderr output from the completed process.
   final List<int> stderrRaw;

   /// Contains the raw, encoded, interleaved stdout and stderr output from the
   /// process.
   ///
   /// Information appears in the order supplied by the process.
   final List<int> outputRaw;

   /// The optional encoder to use in [stdout], [stderr], and [output] accessors
   /// to decode the raw data.
   ///
   /// Defaults to using [SystemEncoding].
   final Encoding decoder;

   /// The optional PID of the invoked process.
   ///
   /// This will only be populated when [ProcessStartMode.detached] or
   /// [ProcessStartMode.detachedWithStdio] are specified as the start mode given
   /// to [ProcessRunner.runProcess].
   final int? pid;

   /// Returns a lazily-decoded version of the data in [stdoutRaw], decoded using
   /// [decoder].
   String get stdout {
     _stdout ??= decoder.decode(stdoutRaw);
     return _stdout!;
   }

   String? _stdout;

   /// Returns a lazily-decoded version of the data in [stderrRaw], decoded using
   /// [decoder].
   String get stderr {
     _stderr ??= decoder.decode(stderrRaw);
     return _stderr!;
   }

   String? _stderr;

   /// Returns a lazily-decoded version of the data in [outputRaw], decoded using
   /// [decoder].
   ///
   /// Information appears in the order supplied by the process.
   String get output {
     _output ??= decoder.decode(outputRaw);
     return _output!;
   }

   String? _output;

   /// A constant to use if there is no result data available, but the process
   /// failed.
   static final ProcessRunnerResult failed =
       ProcessRunnerResult(-1, <int>[], <int>[], <int>[]);

   /// A constant to use if there is no result data available, but the process
   /// succeeded.
   static final ProcessRunnerResult emptySuccess =
       ProcessRunnerResult(0, <int>[], <int>[], <int>[]);
 }

 /// A helper class for classes that want to run a process, optionally have the
 /// stderr and stdout printed to stdout/stderr as the process runs, and capture
 /// the stdout, stderr, and interleaved output properly without dropping any.
 class ProcessRunner {
   ProcessRunner({
     Directory? defaultWorkingDirectory,
     this.processManager = const LocalProcessManager(),
     Map<String, String>? environment,
     this.includeParentEnvironment = true,
     this.printOutputDefault = false,
     this.decoder = const SystemEncoding(),
   })  : defaultWorkingDirectory = defaultWorkingDirectory ?? Directory.current,
         environment = environment ??
             Map<String, String>.from(defaultPlatform.environment);

   /// Set the [processManager] in order to allow injecting a test instance to
   /// perform testing.
   final ProcessManager processManager;

   /// Sets the default directory used when `workingDirectory` is not specified
   /// to [runProcess].
   final Directory defaultWorkingDirectory;

   /// The environment to run processes with.
   ///
   /// Sets the environment variables for the process. If not set, the
   /// environment of the parent process is inherited. Currently, only US-ASCII
   /// environment variables are supported and errors are likely to occur if an
   /// environment variable with code-points outside the US-ASCII range are
   /// passed in.
   final Map<String, String> environment;

   /// If true, merges the given [environment] into the parent environment.
   ///
   /// If [includeParentEnvironment] is `true`, the process's environment will
   /// include the parent process's environment, with [environment] taking
   /// precedence. Default is `true`.
   ///
   /// If false, uses [environment] as the entire environment to run in.
   final bool includeParentEnvironment;

   /// If set, indicates that, by default, commands will both write the output to
   /// stdout/stderr, as well as return it in the [ProcessRunnerResult.stderr],
   /// [ProcessRunnerResult.stderr] members.
   ///
   /// This setting can be overridden on a per-run basis by providing
   /// `printOutput` to the [runProcess] function.
   ///
   /// Defaults to false.
   final bool printOutputDefault;

   /// The decoder to use for decoding result stderr, stdout, and output.
   ///
   /// Defaults to an instance of [SystemEncoding].
   final Encoding decoder;

   /// Run the command and arguments in `commandLine` as a sub-process from
   /// `workingDirectory` if set, or the [defaultWorkingDirectory] if not. Uses
   /// [Directory.current] if [defaultWorkingDirectory] is not set.
   ///
   /// Set `failOk` if [runProcess] should not throw an exception when the
   /// command completes with a a non-zero exit code.
   ///
   /// If `printOutput` is set, indicates that the command will both write the
   /// output to stdout/stderr, as well as return it in the
   /// [ProcessRunnerResult.stderr], [ProcessRunnerResult.stderr] members of the
   /// result. This overrides the setting of [printOutputDefault].
   ///
   /// The `printOutput` argument defaults to the value of [printOutputDefault].
   Future<ProcessRunnerResult> runProcess(
     List<String> commandLine, {
     Directory? workingDirectory,
     bool? printOutput,
     bool failOk = false,
     Stream<List<int>>? stdin,
     bool runInShell = false,
     ProcessStartMode startMode = ProcessStartMode.normal,
   }) async {
     workingDirectory ??= defaultWorkingDirectory;
     printOutput ??= printOutputDefault;
     if (printOutput) {
       stderr.write(
           'Running "${commandLine.join(' ')}" in ${workingDirectory.path}.\n');
     }

     final process = await _startProcess(
         commandLine, workingDirectory, runInShell, startMode);

     final stdoutOutput = <int>[];
     final stderrOutput = <int>[];
     final combinedOutput = <int>[];
     final completers = _streamProcessOutput(
       process,
       stdin,
       stdoutOutput,
       stderrOutput,
       combinedOutput,
       printOutput,
       startMode,
     );

     final exitCode =
         await _waitForProcess(process, startMode, completers, stdin);

     if (exitCode != 0 && !failOk) {
       final message =
           'Running "${commandLine.join(' ')}" in ${workingDirectory.path} '
           'exited with code $exitCode\n${decoder.decode(combinedOutput)}';
       throw ProcessRunnerException(
         message,
         result: ProcessRunnerResult(
           exitCode,
           stdoutOutput,
           stderrOutput,
           combinedOutput,
           pid: process.pid,
           decoder: decoder,
         ),
       );
     }
     return ProcessRunnerResult(
       exitCode,
       stdoutOutput,
       stderrOutput,
       combinedOutput,
       pid: process.pid,
       decoder: decoder,
     );
   }

   Future<Process> _startProcess(
     List<String> commandLine,
     Directory workingDirectory,
     bool runInShell,
     ProcessStartMode startMode,
   ) async {
     try {
       return await processManager.start(
         commandLine,
         workingDirectory: workingDirectory.absolute.path,
         environment: environment,
         includeParentEnvironment: includeParentEnvironment,
         runInShell: runInShell,
         mode: startMode,
       );
     } on ProcessException catch (e) {
       final message =
           'Running "${commandLine.join(' ')}" in ${workingDirectory.path} '
           'failed with:\n$e';
       throw ProcessRunnerException(message);
       // ignore: avoid_catching_errors
     } on ArgumentError catch (e) {
       final message =
           'Running "${commandLine.join(' ')}" in ${workingDirectory.path} '
           'failed with:\n$e';
       throw ProcessRunnerException(message);
     }
   }

   List<Completer<void>> _streamProcessOutput(
     Process process,
     Stream<List<int>>? stdin,
     List<int> stdoutOutput,
     List<int> stderrOutput,
     List<int> combinedOutput,
     bool printOutput,
     ProcessStartMode startMode,
   ) {
     final stdoutComplete = Completer<void>();
     final stderrComplete = Completer<void>();
     final stdinComplete = Completer<void>();

     if (startMode == ProcessStartMode.normal ||
         startMode == ProcessStartMode.detachedWithStdio) {
       if (stdin != null) {
         stdin.listen((List<int> data) {
           process.stdin.add(data);
         }, onDone: () async => stdinComplete.complete());
       } else {
         stdinComplete.complete();
       }
       process.stdout.listen(
         (List<int> event) {
           stdoutOutput.addAll(event);
           combinedOutput.addAll(event);
           if (printOutput) {
             stdout.add(event);
           }
         },
         onDone: () async => stdoutComplete.complete(),
       );
       process.stderr.listen(
         (List<int> event) {
           stderrOutput.addAll(event);
           combinedOutput.addAll(event);
           if (printOutput) {
             stderr.add(event);
           }
         },
         onDone: () async => stderrComplete.complete(),
       );
     } else {
       stdinComplete.complete();
       stdoutComplete.complete();
       stderrComplete.complete();
     }
     return [stdinComplete, stdoutComplete, stderrComplete];
   }

   Future<int> _waitForProcess(
     Process process,
     ProcessStartMode startMode,
     List<Completer<void>> completers,
     Stream<List<int>>? stdin,
   ) async {
     final stdinComplete = completers[0];
     final stdoutComplete = completers[1];
     final stderrComplete = completers[2];

     if (stdin != null) {
       await stdinComplete.future;
       await process.stdin.close();
     }
     await stderrComplete.future;
     await stdoutComplete.future;
     return startMode == ProcessStartMode.normal
         ? process.exitCode
         : Future<int>.value(0);
   }
 }
	// Copyright 2020 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	import 'dart:async' show Completer;
	import 'dart:convert' show Encoding;
	import 'dart:io'
	show
	Directory,
	Process,
	ProcessException,
	ProcessStartMode,
	SystemEncoding,
	stderr,
	stdout;

	import 'package:platform/platform.dart' show LocalPlatform, Platform;
	import 'package:process/process.dart' show LocalProcessManager, ProcessManager;

	import '../process_runner.dart' show ProcessPool;

	import 'process_pool.dart' show ProcessPool;

	const Platform defaultPlatform = LocalPlatform();

	/// Exception class for when a process fails to run, so we can catch
	/// it and provide something more readable than a stack trace.
	class ProcessRunnerException implements Exception {
	ProcessRunnerException(this.message, {this.result});

	final String message;
	final ProcessRunnerResult? result;

	int get exitCode => result?.exitCode ?? -1;

	@override
	String toString() {
	var output = runtimeType.toString();
	output += ': $message';
	final stderr = result?.stderr ?? '';
	if (stderr.isNotEmpty) {
	output += ':\n$stderr';
	}
	return output;
	}
	}

	/// This is the result of running a command using [ProcessRunner] or
	/// [ProcessPool]. It includes the entire stderr, stdout, and interleaved
	/// output from the command after it has completed.
	///
	/// The [stdoutRaw], [stderrRaw], and [outputRaw] members contain the encoded
	/// output from the command as a [List<int>].
	///
	/// The [stdout], [stderr], and [output] accessors will decode the [stdoutRaw],
	/// [stderrRaw], and [outputRaw] data automatically, using a [SystemEncoding]
	/// decoder.
	class ProcessRunnerResult {
	/// Creates a new [ProcessRunnerResult], usually created by a [ProcessRunner].
	///
	/// If [decoder] is not supplied, it defaults to [SystemEncoding].
	ProcessRunnerResult(
	this.exitCode,
	this.stdoutRaw,
	this.stderrRaw,
	this.outputRaw, {
	this.decoder = const SystemEncoding(),
	this.pid,
	});

	/// Contains the exit code from the completed process.
	final int exitCode;

	/// Contains the raw, encoded, stdout output from the completed process.
	final List<int> stdoutRaw;

	/// Contains the raw, encoded, stderr output from the completed process.
	final List<int> stderrRaw;

	/// Contains the raw, encoded, interleaved stdout and stderr output from the
	/// process.
	///
	/// Information appears in the order supplied by the process.
	final List<int> outputRaw;

	/// The optional encoder to use in [stdout], [stderr], and [output] accessors
	/// to decode the raw data.
	///
	/// Defaults to using [SystemEncoding].
	final Encoding decoder;

	/// The optional PID of the invoked process.
	///
	/// This will only be populated when [ProcessStartMode.detached] or
	/// [ProcessStartMode.detachedWithStdio] are specified as the start mode given
	/// to [ProcessRunner.runProcess].
	final int? pid;

	/// Returns a lazily-decoded version of the data in [stdoutRaw], decoded using
	/// [decoder].
	String get stdout {
	_stdout ??= decoder.decode(stdoutRaw);
	return _stdout!;
	}

	String? _stdout;

	/// Returns a lazily-decoded version of the data in [stderrRaw], decoded using
	/// [decoder].
	String get stderr {
	_stderr ??= decoder.decode(stderrRaw);
	return _stderr!;
	}

	String? _stderr;

	/// Returns a lazily-decoded version of the data in [outputRaw], decoded using
	/// [decoder].
	///
	/// Information appears in the order supplied by the process.
	String get output {
	_output ??= decoder.decode(outputRaw);
	return _output!;
	}

	String? _output;

	/// A constant to use if there is no result data available, but the process
	/// failed.
	static final ProcessRunnerResult failed =
	ProcessRunnerResult(-1, <int>[], <int>[], <int>[]);

	/// A constant to use if there is no result data available, but the process
	/// succeeded.
	static final ProcessRunnerResult emptySuccess =
	ProcessRunnerResult(0, <int>[], <int>[], <int>[]);
	}

	/// A helper class for classes that want to run a process, optionally have the
	/// stderr and stdout printed to stdout/stderr as the process runs, and capture
	/// the stdout, stderr, and interleaved output properly without dropping any.
	class ProcessRunner {
	ProcessRunner({
	Directory? defaultWorkingDirectory,
	this.processManager = const LocalProcessManager(),
	Map<String, String>? environment,
	this.includeParentEnvironment = true,
	this.printOutputDefault = false,
	this.decoder = const SystemEncoding(),
	}) : defaultWorkingDirectory = defaultWorkingDirectory ?? Directory.current,
	environment = environment ??
	Map<String, String>.from(defaultPlatform.environment);

	/// Set the [processManager] in order to allow injecting a test instance to
	/// perform testing.
	final ProcessManager processManager;

	/// Sets the default directory used when `workingDirectory` is not specified
	/// to [runProcess].
	final Directory defaultWorkingDirectory;

	/// The environment to run processes with.
	///
	/// Sets the environment variables for the process. If not set, the
	/// environment of the parent process is inherited. Currently, only US-ASCII
	/// environment variables are supported and errors are likely to occur if an
	/// environment variable with code-points outside the US-ASCII range are
	/// passed in.
	final Map<String, String> environment;

	/// If true, merges the given [environment] into the parent environment.
	///
	/// If [includeParentEnvironment] is `true`, the process's environment will
	/// include the parent process's environment, with [environment] taking
	/// precedence. Default is `true`.
	///
	/// If false, uses [environment] as the entire environment to run in.
	final bool includeParentEnvironment;

	/// If set, indicates that, by default, commands will both write the output to
	/// stdout/stderr, as well as return it in the [ProcessRunnerResult.stderr],
	/// [ProcessRunnerResult.stderr] members.
	///
	/// This setting can be overridden on a per-run basis by providing
	/// `printOutput` to the [runProcess] function.
	///
	/// Defaults to false.
	final bool printOutputDefault;

	/// The decoder to use for decoding result stderr, stdout, and output.
	///
	/// Defaults to an instance of [SystemEncoding].
	final Encoding decoder;

	/// Run the command and arguments in `commandLine` as a sub-process from
	/// `workingDirectory` if set, or the [defaultWorkingDirectory] if not. Uses
	/// [Directory.current] if [defaultWorkingDirectory] is not set.
	///
	/// Set `failOk` if [runProcess] should not throw an exception when the
	/// command completes with a a non-zero exit code.
	///
	/// If `printOutput` is set, indicates that the command will both write the
	/// output to stdout/stderr, as well as return it in the
	/// [ProcessRunnerResult.stderr], [ProcessRunnerResult.stderr] members of the
	/// result. This overrides the setting of [printOutputDefault].
	///
	/// The `printOutput` argument defaults to the value of [printOutputDefault].
	Future<ProcessRunnerResult> runProcess(
	List<String> commandLine, {
	Directory? workingDirectory,
	bool? printOutput,
	bool failOk = false,
	Stream<List<int>>? stdin,
	bool runInShell = false,
	ProcessStartMode startMode = ProcessStartMode.normal,
	}) async {
	workingDirectory ??= defaultWorkingDirectory;
	printOutput ??= printOutputDefault;
	if (printOutput) {
	stderr.write(
	'Running "${commandLine.join(' ')}" in ${workingDirectory.path}.\n');
	}

	final process = await _startProcess(
	commandLine, workingDirectory, runInShell, startMode);

	final stdoutOutput = <int>[];
	final stderrOutput = <int>[];
	final combinedOutput = <int>[];
	final completers = _streamProcessOutput(
	process,
	stdin,
	stdoutOutput,
	stderrOutput,
	combinedOutput,
	printOutput,
	startMode,
	);

	final exitCode =
	await _waitForProcess(process, startMode, completers, stdin);

	if (exitCode != 0 && !failOk) {
	final message =
	'Running "${commandLine.join(' ')}" in ${workingDirectory.path} '
	'exited with code $exitCode\n${decoder.decode(combinedOutput)}';
	throw ProcessRunnerException(
	message,
	result: ProcessRunnerResult(
	exitCode,
	stdoutOutput,
	stderrOutput,
	combinedOutput,
	pid: process.pid,
	decoder: decoder,
	),
	);
	}
	return ProcessRunnerResult(
	exitCode,
	stdoutOutput,
	stderrOutput,
	combinedOutput,
	pid: process.pid,
	decoder: decoder,
	);
	}

	Future<Process> _startProcess(
	List<String> commandLine,
	Directory workingDirectory,
	bool runInShell,
	ProcessStartMode startMode,
	) async {
	try {
	return await processManager.start(
	commandLine,
	workingDirectory: workingDirectory.absolute.path,
	environment: environment,
	includeParentEnvironment: includeParentEnvironment,
	runInShell: runInShell,
	mode: startMode,
	);
	} on ProcessException catch (e) {
	final message =
	'Running "${commandLine.join(' ')}" in ${workingDirectory.path} '
	'failed with:\n$e';
	throw ProcessRunnerException(message);
	// ignore: avoid_catching_errors
	} on ArgumentError catch (e) {
	final message =
	'Running "${commandLine.join(' ')}" in ${workingDirectory.path} '
	'failed with:\n$e';
	throw ProcessRunnerException(message);
	}
	}

	List<Completer<void>> _streamProcessOutput(
	Process process,
	Stream<List<int>>? stdin,
	List<int> stdoutOutput,
	List<int> stderrOutput,
	List<int> combinedOutput,
	bool printOutput,
	ProcessStartMode startMode,
	) {
	final stdoutComplete = Completer<void>();
	final stderrComplete = Completer<void>();
	final stdinComplete = Completer<void>();

	if (startMode == ProcessStartMode.normal \|\|
	startMode == ProcessStartMode.detachedWithStdio) {
	if (stdin != null) {
	stdin.listen((List<int> data) {
	process.stdin.add(data);
	}, onDone: () async => stdinComplete.complete());
	} else {
	stdinComplete.complete();
	}
	process.stdout.listen(
	(List<int> event) {
	stdoutOutput.addAll(event);
	combinedOutput.addAll(event);
	if (printOutput) {
	stdout.add(event);
	}
	},
	onDone: () async => stdoutComplete.complete(),
	);
	process.stderr.listen(
	(List<int> event) {
	stderrOutput.addAll(event);
	combinedOutput.addAll(event);
	if (printOutput) {
	stderr.add(event);
	}
	},
	onDone: () async => stderrComplete.complete(),
	);
	} else {
	stdinComplete.complete();
	stdoutComplete.complete();
	stderrComplete.complete();
	}
	return [stdinComplete, stdoutComplete, stderrComplete];
	}

	Future<int> _waitForProcess(
	Process process,
	ProcessStartMode startMode,
	List<Completer<void>> completers,
	Stream<List<int>>? stdin,
	) async {
	final stdinComplete = completers[0];
	final stdoutComplete = completers[1];
	final stderrComplete = completers[2];

	if (stdin != null) {
	await stdinComplete.future;
	await process.stdin.close();
	}
	await stderrComplete.future;
	await stdoutComplete.future;
	return startMode == ProcessStartMode.normal
	? process.exitCode
	: Future<int>.value(0);
	}
	}