dev/bots/run_command.dart - mirrors/flutter - Git at Google

 // Copyright 2014 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';
 import 'dart:convert';
 import 'dart:core' hide print;
 import 'dart:io' as io;

 import 'package:path/path.dart' as path;

 import 'utils.dart';

 /// Runs the `executable` and returns standard output as a stream of lines.
 ///
 /// The returned stream reaches its end immediately after the command exits.
 ///
 /// If `expectNonZeroExit` is false and the process exits with a non-zero exit
 /// code fails the test immediately by exiting the test process with exit code
 /// 1.
 Stream<String> runAndGetStdout(String executable, List<String> arguments, {
   String workingDirectory,
   Map<String, String> environment,
   bool expectNonZeroExit = false,
 }) async* {
   final StreamController<String> output = StreamController<String>();
   final Future<CommandResult> command = runCommand(
     executable,
     arguments,
     workingDirectory: workingDirectory,
     environment: environment,
     expectNonZeroExit: expectNonZeroExit,
     // Capture the output so it's not printed to the console by default.
     outputMode: OutputMode.capture,
     outputListener: (String line, io.Process process) {
       output.add(line);
     },
   );

   // Close the stream controller after the command is complete. Otherwise,
   // the yield* will never finish.
   command.whenComplete(output.close);

   yield* output.stream;
 }

 /// Represents a running process launched using [startCommand].
 class Command {
   Command._(this.process, this._time, this._savedStdout, this._savedStderr);

   /// The raw process that was launched for this command.
   final io.Process process;

   final Stopwatch _time;
   final Future<List<List<int>>> _savedStdout;
   final Future<List<List<int>>> _savedStderr;

   /// Evaluates when the [process] exits.
   ///
   /// Returns the result of running the command.
   Future<CommandResult> get onExit async {
     final int exitCode = await process.exitCode;
     _time.stop();

     // Saved output is null when OutputMode.print is used.
     final String flattenedStdout = _savedStdout != null ? _flattenToString(await _savedStdout) : null;
     final String flattenedStderr = _savedStderr != null ? _flattenToString(await _savedStderr) : null;
     return CommandResult._(exitCode, _time.elapsed, flattenedStdout, flattenedStderr);
   }
 }

 /// The result of running a command using [startCommand] and [runCommand];
 class CommandResult {
   CommandResult._(this.exitCode, this.elapsedTime, this.flattenedStdout, this.flattenedStderr);

   /// The exit code of the process.
   final int exitCode;

   /// The amount of time it took the process to complete.
   final Duration elapsedTime;

   /// Standard output decoded as a string using UTF8 decoder.
   final String flattenedStdout;

   /// Standard error output decoded as a string using UTF8 decoder.
   final String flattenedStderr;
 }

 /// Starts the `executable` and returns a command object representing the
 /// running process.
 ///
 /// `outputListener` is called for every line of standard output from the
 /// process, and is given the [Process] object. This can be used to interrupt
 /// an indefinitely running process, for example, by waiting until the process
 /// emits certain output.
 ///
 /// `outputMode` controls where the standard output from the command process
 /// goes. See [OutputMode].
 Future<Command> startCommand(String executable, List<String> arguments, {
   String workingDirectory,
   Map<String, String> environment,
   OutputMode outputMode = OutputMode.print,
   bool Function(String) removeLine,
   void Function(String, io.Process) outputListener,
 }) async {
   final String commandDescription = '${path.relative(executable, from: workingDirectory)} ${arguments.join(' ')}';
   final String relativeWorkingDir = path.relative(workingDirectory ?? io.Directory.current.path);
   printProgress('RUNNING', relativeWorkingDir, commandDescription);

   final Stopwatch time = Stopwatch()..start();
   final io.Process process = await io.Process.start(executable, arguments,
     workingDirectory: workingDirectory,
     environment: environment,
   );

   Future<List<List<int>>> savedStdout, savedStderr;
   final Stream<List<int>> stdoutSource = process.stdout
     .transform<String>(const Utf8Decoder())
     .transform(const LineSplitter())
     .where((String line) => removeLine == null || !removeLine(line))
     .map((String line) {
       final String formattedLine = '$line\n';
       if (outputListener != null) {
         outputListener(formattedLine, process);
       }
       return formattedLine;
     })
     .transform(const Utf8Encoder());
   switch (outputMode) {
     case OutputMode.print:
       stdoutSource.listen(io.stdout.add);
       process.stderr.listen(io.stderr.add);
       break;
     case OutputMode.capture:
       savedStdout = stdoutSource.toList();
       savedStderr = process.stderr.toList();
       break;
   }

   return Command._(process, time, savedStdout, savedStderr);
 }

 /// Runs the `executable` and waits until the process exits.
 ///
 /// If the process exits with a non-zero exit code, exits this process with
 /// exit code 1, unless `expectNonZeroExit` is set to true.
 ///
 /// `outputListener` is called for every line of standard output from the
 /// process, and is given the [Process] object. This can be used to interrupt
 /// an indefinitely running process, for example, by waiting until the process
 /// emits certain output.
 ///
 /// Returns the result of the finished process, or null if `skip` is true.
 ///
 /// `outputMode` controls where the standard output from the command process
 /// goes. See [OutputMode].
 Future<CommandResult> runCommand(String executable, List<String> arguments, {
   String workingDirectory,
   Map<String, String> environment,
   bool expectNonZeroExit = false,
   int expectedExitCode,
   String failureMessage,
   OutputMode outputMode = OutputMode.print,
   bool skip = false,
   bool Function(String) removeLine,
   void Function(String, io.Process) outputListener,
 }) async {
   final String commandDescription = '${path.relative(executable, from: workingDirectory)} ${arguments.join(' ')}';
   final String relativeWorkingDir = path.relative(workingDirectory ?? io.Directory.current.path);
   if (skip) {
     printProgress('SKIPPING', relativeWorkingDir, commandDescription);
     return null;
   }

   final Command command = await startCommand(executable, arguments,
     workingDirectory: workingDirectory,
     environment: environment,
     outputMode: outputMode,
     removeLine: removeLine,
     outputListener: outputListener,
   );

   final CommandResult result = await command.onExit;

   if ((result.exitCode == 0) == expectNonZeroExit || (expectedExitCode != null && result.exitCode != expectedExitCode)) {
     // Print the output when we get unexpected results (unless output was
     // printed already).
     switch (outputMode) {
       case OutputMode.print:
         break;
       case OutputMode.capture:
         io.stdout.writeln(result.flattenedStdout);
         io.stderr.writeln(result.flattenedStderr);
         break;
     }
     exitWithError(<String>[
       if (failureMessage != null)
         failureMessage
       else
         '${bold}ERROR: ${red}Last command exited with ${result.exitCode} (expected: ${expectNonZeroExit ? (expectedExitCode ?? 'non-zero') : 'zero'}).$reset',
       '${bold}Command: $green$commandDescription$reset',
       '${bold}Relative working directory: $cyan$relativeWorkingDir$reset',
     ]);
   }
   print('$clock ELAPSED TIME: ${prettyPrintDuration(result.elapsedTime)} for $green$commandDescription$reset in $cyan$relativeWorkingDir$reset');
   return result;
 }

 /// Flattens a nested list of UTF-8 code units into a single string.
 String _flattenToString(List<List<int>> chunks) =>
   utf8.decode(chunks.expand<int>((List<int> ints) => ints).toList());

 /// Specifies what to do with the command output from [runCommand] and [startCommand].
 enum OutputMode {
   /// Forwards standard output and standard error streams to the test process'
   /// respective standard streams.
   ///
   /// Use this mode if all you want is print the output of the command to the
   /// console. The output is no longer available after the process exits.
   print,

   /// Saves standard output and standard error streams in memory.
   ///
   /// Captured output can be retrieved from the [CommandResult] object.
   ///
   /// Use this mode in tests that need to inspect the output of a command, or
   /// when the output should not be printed to console.
   capture,
 }
	// Copyright 2014 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';
	import 'dart:convert';
	import 'dart:core' hide print;
	import 'dart:io' as io;

	import 'package:path/path.dart' as path;

	import 'utils.dart';

	/// Runs the `executable` and returns standard output as a stream of lines.
	///
	/// The returned stream reaches its end immediately after the command exits.
	///
	/// If `expectNonZeroExit` is false and the process exits with a non-zero exit
	/// code fails the test immediately by exiting the test process with exit code
	/// 1.
	Stream<String> runAndGetStdout(String executable, List<String> arguments, {
	String workingDirectory,
	Map<String, String> environment,
	bool expectNonZeroExit = false,
	}) async* {
	final StreamController<String> output = StreamController<String>();
	final Future<CommandResult> command = runCommand(
	executable,
	arguments,
	workingDirectory: workingDirectory,
	environment: environment,
	expectNonZeroExit: expectNonZeroExit,
	// Capture the output so it's not printed to the console by default.
	outputMode: OutputMode.capture,
	outputListener: (String line, io.Process process) {
	output.add(line);
	},
	);

	// Close the stream controller after the command is complete. Otherwise,
	// the yield* will never finish.
	command.whenComplete(output.close);

	yield* output.stream;
	}

	/// Represents a running process launched using [startCommand].
	class Command {
	Command._(this.process, this._time, this._savedStdout, this._savedStderr);

	/// The raw process that was launched for this command.
	final io.Process process;

	final Stopwatch _time;
	final Future<List<List<int>>> _savedStdout;
	final Future<List<List<int>>> _savedStderr;

	/// Evaluates when the [process] exits.
	///
	/// Returns the result of running the command.
	Future<CommandResult> get onExit async {
	final int exitCode = await process.exitCode;
	_time.stop();

	// Saved output is null when OutputMode.print is used.
	final String flattenedStdout = _savedStdout != null ? _flattenToString(await _savedStdout) : null;
	final String flattenedStderr = _savedStderr != null ? _flattenToString(await _savedStderr) : null;
	return CommandResult._(exitCode, _time.elapsed, flattenedStdout, flattenedStderr);
	}
	}

	/// The result of running a command using [startCommand] and [runCommand];
	class CommandResult {
	CommandResult._(this.exitCode, this.elapsedTime, this.flattenedStdout, this.flattenedStderr);

	/// The exit code of the process.
	final int exitCode;

	/// The amount of time it took the process to complete.
	final Duration elapsedTime;

	/// Standard output decoded as a string using UTF8 decoder.
	final String flattenedStdout;

	/// Standard error output decoded as a string using UTF8 decoder.
	final String flattenedStderr;
	}

	/// Starts the `executable` and returns a command object representing the
	/// running process.
	///
	/// `outputListener` is called for every line of standard output from the
	/// process, and is given the [Process] object. This can be used to interrupt
	/// an indefinitely running process, for example, by waiting until the process
	/// emits certain output.
	///
	/// `outputMode` controls where the standard output from the command process
	/// goes. See [OutputMode].
	Future<Command> startCommand(String executable, List<String> arguments, {
	String workingDirectory,
	Map<String, String> environment,
	OutputMode outputMode = OutputMode.print,
	bool Function(String) removeLine,
	void Function(String, io.Process) outputListener,
	}) async {
	final String commandDescription = '${path.relative(executable, from: workingDirectory)} ${arguments.join(' ')}';
	final String relativeWorkingDir = path.relative(workingDirectory ?? io.Directory.current.path);
	printProgress('RUNNING', relativeWorkingDir, commandDescription);

	final Stopwatch time = Stopwatch()..start();
	final io.Process process = await io.Process.start(executable, arguments,
	workingDirectory: workingDirectory,
	environment: environment,
	);

	Future<List<List<int>>> savedStdout, savedStderr;
	final Stream<List<int>> stdoutSource = process.stdout
	.transform<String>(const Utf8Decoder())
	.transform(const LineSplitter())
	.where((String line) => removeLine == null \|\| !removeLine(line))
	.map((String line) {
	final String formattedLine = '$line\n';
	if (outputListener != null) {
	outputListener(formattedLine, process);
	}
	return formattedLine;
	})
	.transform(const Utf8Encoder());
	switch (outputMode) {
	case OutputMode.print:
	stdoutSource.listen(io.stdout.add);
	process.stderr.listen(io.stderr.add);
	break;
	case OutputMode.capture:
	savedStdout = stdoutSource.toList();
	savedStderr = process.stderr.toList();
	break;
	}

	return Command._(process, time, savedStdout, savedStderr);
	}

	/// Runs the `executable` and waits until the process exits.
	///
	/// If the process exits with a non-zero exit code, exits this process with
	/// exit code 1, unless `expectNonZeroExit` is set to true.
	///
	/// `outputListener` is called for every line of standard output from the
	/// process, and is given the [Process] object. This can be used to interrupt
	/// an indefinitely running process, for example, by waiting until the process
	/// emits certain output.
	///
	/// Returns the result of the finished process, or null if `skip` is true.
	///
	/// `outputMode` controls where the standard output from the command process
	/// goes. See [OutputMode].
	Future<CommandResult> runCommand(String executable, List<String> arguments, {
	String workingDirectory,
	Map<String, String> environment,
	bool expectNonZeroExit = false,
	int expectedExitCode,
	String failureMessage,
	OutputMode outputMode = OutputMode.print,
	bool skip = false,
	bool Function(String) removeLine,
	void Function(String, io.Process) outputListener,
	}) async {
	final String commandDescription = '${path.relative(executable, from: workingDirectory)} ${arguments.join(' ')}';
	final String relativeWorkingDir = path.relative(workingDirectory ?? io.Directory.current.path);
	if (skip) {
	printProgress('SKIPPING', relativeWorkingDir, commandDescription);
	return null;
	}

	final Command command = await startCommand(executable, arguments,
	workingDirectory: workingDirectory,
	environment: environment,
	outputMode: outputMode,
	removeLine: removeLine,
	outputListener: outputListener,
	);

	final CommandResult result = await command.onExit;

	if ((result.exitCode == 0) == expectNonZeroExit \|\| (expectedExitCode != null && result.exitCode != expectedExitCode)) {
	// Print the output when we get unexpected results (unless output was
	// printed already).
	switch (outputMode) {
	case OutputMode.print:
	break;
	case OutputMode.capture:
	io.stdout.writeln(result.flattenedStdout);
	io.stderr.writeln(result.flattenedStderr);
	break;
	}
	exitWithError(<String>[
	if (failureMessage != null)
	failureMessage
	else
	'${bold}ERROR: ${red}Last command exited with ${result.exitCode} (expected: ${expectNonZeroExit ? (expectedExitCode ?? 'non-zero') : 'zero'}).$reset',
	'${bold}Command: $green$commandDescription$reset',
	'${bold}Relative working directory: $cyan$relativeWorkingDir$reset',
	]);
	}
	print('$clock ELAPSED TIME: ${prettyPrintDuration(result.elapsedTime)} for $green$commandDescription$reset in $cyan$relativeWorkingDir$reset');
	return result;
	}

	/// Flattens a nested list of UTF-8 code units into a single string.
	String _flattenToString(List<List<int>> chunks) =>
	utf8.decode(chunks.expand<int>((List<int> ints) => ints).toList());

	/// Specifies what to do with the command output from [runCommand] and [startCommand].
	enum OutputMode {
	/// Forwards standard output and standard error streams to the test process'
	/// respective standard streams.
	///
	/// Use this mode if all you want is print the output of the command to the
	/// console. The output is no longer available after the process exits.
	print,

	/// Saves standard output and standard error streams in memory.
	///
	/// Captured output can be retrieved from the [CommandResult] object.
	///
	/// Use this mode in tests that need to inspect the output of a command, or
	/// when the output should not be printed to console.
	capture,
	}