Remove the timeout for downloading packages.

lib/src/io.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.
 
 /// Helper functionality to make working with IO easier.
 library pub.io;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
@@ skipping 811 matching lines @@
     executable = "cmd";
   }
 
   log.process(executable, args, workingDir == null ? '.' : workingDir);
 
   return fn(executable, args,
       workingDirectory: workingDir,
       environment: environment);
 }
 
-/// Wraps [input], an asynchronous network operation to provide a timeout.
-///
-/// If [input] completes before [milliseconds] have passed, then the return
-/// value completes in the same way. However, if [milliseconds] pass before
-/// [input] has completed, it completes with a [TimeoutException] with
-/// [description] (which should be a fragment describing the action that timed
-/// out).
-///
-/// [url] is the URL being accessed asynchronously.
-///
-/// Note that timing out will not cancel the asynchronous operation behind
-/// [input].
-Future timeout(Future input, int milliseconds, Uri url, String description) {
-  // TODO(nwiez): Replace this with [Future.timeout].
-  var completer = new Completer();
-  var duration = new Duration(milliseconds: milliseconds);
-  var timer = new Timer(duration, () {
-    // Include the duration ourselves in the message instead of passing it to
-    // TimeoutException since we show nicer output.
-    var message = 'Timed out after ${niceDuration(duration)} while '
-                  '$description.';
-
-    if (url.host == "pub.dartlang.org" ||
-        url.host == "storage.googleapis.com") {
-      message += "\nThis is likely a transient error. Please try again later.";
-    }
-
-    completer.completeError(new TimeoutException(message), new Chain.current());
-  });
-  input.then((value) {
-    if (completer.isCompleted) return;
-    timer.cancel();
-    completer.complete(value);
-  }).catchError((e, stackTrace) {
-    if (completer.isCompleted) return;
-    timer.cancel();
-    completer.completeError(e, stackTrace);
-  });
-  return completer.future;
-}
-
 /// Creates a temporary directory and passes its path to [fn].
 ///
 /// Once the [Future] returned by [fn] completes, the temporary directory and
 /// all its contents are deleted. [fn] can also return `null`, in which case
 /// the temporary directory is deleted immediately afterwards.
 ///
 /// Returns a future that completes to the value that the future returned from
 /// [fn] completes to.
 Future withTempDir(Future fn(String path)) {
   return new Future.sync(() {
     var tempDir = createSystemTempDir();
     return new Future.sync(() => fn(tempDir))
         .whenComplete(() => deleteEntry(tempDir));
   });
 }
 
 /// Binds an [HttpServer] to [host] and [port].
 ///
 /// If [host] is "localhost", this will automatically listen on both the IPv4
 /// and IPv6 loopback addresses.
 Future<HttpServer> bindServer(String host, int port) {
   if (host == 'localhost') return HttpMultiServer.loopback(port);
   return HttpServer.bind(host, port);
 }
 
 /// Extracts a `.tar.gz` file from [stream] to [destination].
-///
-/// Returns whether or not the extraction was successful.
-Future<bool> extractTarGz(Stream<List<int>> stream, String destination) {
+Future extractTarGz(Stream<List<int>> stream, String destination) async {
   log.fine("Extracting .tar.gz stream to $destination.");
 
   if (Platform.operatingSystem == "windows") {
-    return _extractTarGzWindows(stream, destination);
+    return await _extractTarGzWindows(stream, destination);
   }
 
   var args = ["--extract", "--gunzip", "--directory", destination];
   if (_noUnknownKeyword) {
     // BSD tar (the default on OS X) can insert strange headers to a tarfile
     // that GNU tar (the default on Linux) is unable to understand. This will
     // cause GNU tar to emit a number of harmless but scary-looking warnings
     // which are silenced by this flag.
     args.insert(0, "--warning=no-unknown-keyword");
   }
 
-  return startProcess("tar", args).then((process) {
-    // Ignore errors on process.std{out,err}. They'll be passed to
-    // process.exitCode, and we don't want them being top-levelled by
-    // std{out,err}Sink.
-    store(process.stdout.handleError((_) {}), stdout, closeSink: false);
-    store(process.stderr.handleError((_) {}), stderr, closeSink: false);
-    return Future.wait([
-      store(stream, process.stdin),
-      process.exitCode
-    ]);
-  }).then((results) {
-    var exitCode = results[1];
-    if (exitCode != exit_codes.SUCCESS) {
-      throw new Exception("Failed to extract .tar.gz stream to $destination "
-          "(exit code $exitCode).");
-    }
-    log.fine("Extracted .tar.gz stream to $destination. Exit code $exitCode.");
-  });
+  var process = await startProcess("tar", args);
+
+  // Ignore errors on process.std{out,err}. They'll be passed to
+  // process.exitCode, and we don't want them being top-levelled by
+  // std{out,err}Sink.
+  store(process.stdout.handleError((_) {}), stdout, closeSink: false);
+  store(process.stderr.handleError((_) {}), stderr, closeSink: false);
+  var results = await Future.wait([
+    store(stream, process.stdin),
+    process.exitCode
+  ]);
+
+  var exitCode = results[1];
+  if (exitCode != exit_codes.SUCCESS) {
+    throw new Exception("Failed to extract .tar.gz stream to $destination "
+        "(exit code $exitCode).");
+  }
+  log.fine("Extracted .tar.gz stream to $destination. Exit code $exitCode.");
 }
 
 /// Whether to include "--warning=no-unknown-keyword" when invoking tar.
 ///
 /// This flag quiets warnings that come from opening OS X-generated tarballs on
 /// Linux, but only GNU tar >= 1.26 supports it.
 final bool _noUnknownKeyword = _computeNoUnknownKeyword();
 bool _computeNoUnknownKeyword() {
   if (!Platform.isLinux) return false;
   var result = Process.runSync("tar", ["--version"]);
   if (result.exitCode != 0) {
     throw new ApplicationException(
         "Failed to run tar (exit code ${result.exitCode}):\n${result.stderr}");
   }
 
   var match = new RegExp(r"^tar \(GNU tar\) (\d+).(\d+)\n")
       .firstMatch(result.stdout);
   if (match == null) return false;
 
   var major = int.parse(match[1]);
   var minor = int.parse(match[2]);
   return major >= 2 || (major == 1 && minor >= 23);
 }
 
 final String pathTo7zip = (() {
   if (!runningFromDartRepo) return sdkAssetPath(path.join('7zip', '7za.exe'));
   return path.join(dartRepoRoot, 'third_party', '7zip', '7za.exe');
 })();
 
-Future<bool> _extractTarGzWindows(Stream<List<int>> stream,
-    String destination) {
+Future _extractTarGzWindows(Stream<List<int>> stream, String destination) {
   // TODO(rnystrom): In the repo's history, there is an older implementation of
   // this that does everything in memory by piping streams directly together
   // instead of writing out temp files. The code is simpler, but unfortunately,
   // 7zip seems to periodically fail when we invoke it from Dart and tell it to
   // read from stdin instead of a file. Consider resurrecting that version if
   // we can figure out why it fails.
 
-  return withTempDir((tempDir) {
+  return withTempDir((tempDir) async {
     // Write the archive to a temp file.
     var dataFile = path.join(tempDir, 'data.tar.gz');
-    return createFileFromStream(stream, dataFile).then((_) {
-      // 7zip can't unarchive from gzip -> tar -> destination all in one step
-      // first we un-gzip it to a tar file.
-      // Note: Setting the working directory instead of passing in a full file
-      // path because 7zip says "A full path is not allowed here."
-      return runProcess(pathTo7zip, ['e', 'data.tar.gz'], workingDir: tempDir);
-    }).then((result) {
-      if (result.exitCode != exit_codes.SUCCESS) {
-        throw new Exception('Could not un-gzip (exit code ${result.exitCode}). '
-                'Error:\n'
-            '${result.stdout.join("\n")}\n'
-            '${result.stderr.join("\n")}');
-      }
+    await createFileFromStream(stream, dataFile);
 
-      // Find the tar file we just created since we don't know its name.
-      var tarFile = listDir(tempDir).firstWhere(
-          (file) => path.extension(file) == '.tar',
-          orElse: () {
-        throw new FormatException('The gzip file did not contain a tar file.');
-      });
+    // 7zip can't unarchive from gzip -> tar -> destination all in one step
+    // first we un-gzip it to a tar file.
+    // Note: Setting the working directory instead of passing in a full file
+    // path because 7zip says "A full path is not allowed here."
+    var unzipResult = await runProcess(pathTo7zip, ['e', 'data.tar.gz'],
+        workingDir: tempDir);
 
-      // Untar the archive into the destination directory.
-      return runProcess(pathTo7zip, ['x', tarFile], workingDir: destination);
-    }).then((result) {
-      if (result.exitCode != exit_codes.SUCCESS) {
-        throw new Exception('Could not un-tar (exit code ${result.exitCode}). '
-                'Error:\n'
-            '${result.stdout.join("\n")}\n'
-            '${result.stderr.join("\n")}');
-      }
-      return true;
+    if (unzipResult.exitCode != exit_codes.SUCCESS) {
+      throw new Exception(
+          'Could not un-gzip (exit code ${unzipResult.exitCode}). Error:\n'
+          '${unzipResult.stdout.join("\n")}\n'
+          '${unzipResult.stderr.join("\n")}');
+    }
+
+    // Find the tar file we just created since we don't know its name.
+    var tarFile = listDir(tempDir).firstWhere(
+        (file) => path.extension(file) == '.tar',
+        orElse: () {
+      throw new FormatException('The gzip file did not contain a tar file.');
     });
+
+    // Untar the archive into the destination directory.
+    var untarResult = await runProcess(pathTo7zip, ['x', tarFile],
+        workingDir: destination);
+    if (untarResult.exitCode != exit_codes.SUCCESS) {
+      throw new Exception(
+          'Could not un-tar (exit code ${untarResult.exitCode}). Error:\n'
+          '${untarResult.stdout.join("\n")}\n'
+          '${untarResult.stderr.join("\n")}');
+    }
   });
 }
 
 /// Create a .tar.gz archive from a list of entries.
 ///
 /// Each entry can be a [String], [Directory], or [File] object. The root of
 /// the archive is considered to be [baseDir], which defaults to the current
 /// working directory.
 ///
 /// Returns a [ByteStream] that emits the contents of the archive.
@@ skipping 75 matching lines @@
 
   // TODO(rnystrom): Remove this and change to returning one string.
   static List<String> _toLines(String output) {
     var lines = splitLines(output);
     if (!lines.isEmpty && lines.last == "") lines.removeLast();
     return lines;
   }
 
   bool get success => exitCode == exit_codes.SUCCESS;
 }