Add support for timeouts when using AdbPrecompilationCommand

tools/testing/dart/android.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library android;
 
 import "dart:async";
 import "dart:convert" show LineSplitter, UTF8;
 import "dart:core";
 import "dart:collection";
 import "dart:io";
 
 import "path.dart";
 import "utils.dart";
 
 class AdbCommandResult {
   final String command;
   final String stdout;
   final String stderr;
   final int exitCode;
+  final bool timedOut;
 
-  AdbCommandResult(this.command, this.stdout, this.stderr, this.exitCode);
+  AdbCommandResult(this.command, this.stdout, this.stderr, this.exitCode,
+                   this.timedOut);
 
   void throwIfFailed() {
     if (exitCode != 0) {
       var error = "Running: $command failed:"
-                  "stdout: \n $stdout"
-                  "stderr: \n $stderr"
-                  "exitCode: \n $exitCode";
+                  "stdout:\n  ${stdout.trim()}\n"
+                  "stderr:\n  ${stderr.trim()}\n"
+                  "exitCode: $exitCode\n"
+                  "timedOut: $timedOut";
       throw new Exception(error);
     }
   }
 }
 
 /**
  * [_executeCommand] will write [stdin] to the standard input of the created
  * process and will return a tuple (stdout, stderr).
  *
  * If the exit code of the process was nonzero it will complete with an error.
  * If starting the process failed, it will complete with an error as well.
  */
 Future<AdbCommandResult> _executeCommand(
-    String executable, List<String> args, [String stdin = ""]) {
+    String executable, List<String> args,
+    [String stdin = "", Duration timeout]) {

[Bill Hesse, 2016/05/02 11:54:17]

Should these now be named, not positional, optional arguments?

[kustermann, 2016/05/02 11:59:40]

Done.

   Future<String> getOutput(Stream<List<int>> stream) {
     return stream
         .transform(UTF8.decoder)
         .toList()
         .then((data) => data.join(""));
   }
 
   return Process.start(executable, args).then((Process process) async {
     if (stdin != null && stdin != '') {
       process.stdin.write(stdin);
     }
     process.stdin.close();
 
+    Timer timer;
+    bool timedOut = false;
+    if (timeout != null) {
+      timer = new Timer(timeout, () {
+        timedOut = true;
+        process.kill(ProcessSignal.SIGTERM);
+        timer = null;
+      });
+    }
+
     var results = await Future.wait([
         getOutput(process.stdout),
         getOutput(process.stderr),
         process.exitCode
     ]);
+    if (timer != null) timer.cancel();
+
     String command = "$executable ${args.join(' ')}";
-    return new AdbCommandResult(command, results[0], results[1], results[2]);
+    return new AdbCommandResult(
+        command, results[0], results[1], results[2], timedOut);
   });
 }
 
 /**
  * Helper class to loop through all adb ports.
  *
  * The ports come in pairs:
  *  - even number: console connection
  *  - odd number: adb connection
  * Note that this code doesn't check if the ports are used.
@@ skipping 207 matching lines @@
   }
 
   /**
    * Kill all background processes.
    */
   Future killAll() {
     var arguments = ['shell', 'am', 'kill-all'];
     return _adbCommand(arguments);
   }
 
-  Future<AdbCommandResult> runAdbCommand(List<String> adbArgs) {
-    return _executeCommand("adb", _deviceSpecificArgs(adbArgs));
+  Future<AdbCommandResult> runAdbCommand(List<String> adbArgs,
+                                         {Duration timeout}) {
+    return _executeCommand("adb", _deviceSpecificArgs(adbArgs), '', timeout);
   }
 
-  Future<AdbCommandResult> runAdbShellCommand(List<String> shellArgs) async {
+  Future<AdbCommandResult> runAdbShellCommand(List<String> shellArgs,
+                                              {Duration timeout}) async {
     const MARKER = 'AdbShellExitCode: ';
 
     // The exitcode of 'adb shell ...' can be 0 even though the command failed
     // with a non-zero exit code. We therefore explicitly print it to stdout and
     // search for it.
 
     var args = ['shell',
                 "${shellArgs.join(' ')} ; echo $MARKER \$?"];
     AdbCommandResult result = await _executeCommand(
-        "adb", _deviceSpecificArgs(args));
+        "adb", _deviceSpecificArgs(args), '', timeout);
     int exitCode = result.exitCode;
     var lines = result
         .stdout.split('\n')
         .where((line) => line.trim().length > 0)
         .toList();
     if (lines.length > 0) {
       int index = lines.last.indexOf(MARKER);
-      assert(index >= 0);
-      exitCode = int.parse(lines.last.substring(index + MARKER.length).trim());
+      if (index >= 0) {
+        exitCode = int.parse(
+            lines.last.substring(index + MARKER.length).trim());
+      } else {
+        // In case of timeouts, for example, we won't get the exitcode marker.
+        assert(result.exitCode != 0);
+      }
     }
     return new AdbCommandResult(
-        result.command, result.stdout, result.stderr, exitCode);
+        result.command, result.stdout, result.stderr, exitCode,
+        result.timedOut);
   }
 
   Future<AdbCommandResult> _adbCommand(List<String> adbArgs) async {
     var result = await _executeCommand("adb", _deviceSpecificArgs(adbArgs));
     result.throwIfFailed();
     return result;
   }
 
   List<String> _deviceSpecificArgs(List<String> adbArgs) {
     if (_deviceId != null) {
@@ skipping 72 matching lines @@
 
   void releaseDevice(AdbDevice device) {
     if (_waiter.length > 0) {
       Completer completer = _waiter.removeFirst();
       completer.complete(device);
     } else {
       _idleDevices.add(device);
     }
   }
 }