Get pub_lish tests running on Windows.

utils/pub/io.dart

 // Copyright (c) 2012, 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 io;
 
 import 'dart:io';
@@ skipping 245 matching lines @@
   return log.ioAsync("create temp directory ${dir.path}",
       dir.createTemp());
 }
 
 /**
  * Asynchronously recursively deletes [dir], which can be a [String] or a
  * [Directory]. Returns a [Future] that completes when the deletion is done.
  */
 Future<Directory> deleteDir(dir) {
   dir = _getDirectory(dir);
-  return log.ioAsync("delete directory ${dir.path}",
-      dir.delete(recursive: true));
+
+  return _attemptRetryable(() => log.ioAsync("delete directory ${dir.path}",
+      dir.delete(recursive: true)));
 }
 
 /**
  * Asynchronously lists the contents of [dir], which can be a [String] directory
  * path or a [Directory]. If [recursive] is `true`, lists subdirectory contents
  * (defaults to `false`). If [includeHiddenFiles] is `true`, includes files and
  * directories beginning with `.` (defaults to `false`).
  */
 Future<List<String>> listDir(dir,
     {bool recursive: false, bool includeHiddenFiles: false}) {
@@ skipping 64 matching lines @@
     }
   });
 }
 
 /// Renames (i.e. moves) the directory [from] to [to]. Returns a [Future] with
 /// the destination directory.
 Future<Directory> renameDir(from, String to) {
   from = _getDirectory(from);
   log.io("Renaming directory ${from.path} to $to.");
 
-  if (Platform.operatingSystem != 'windows') {
-    return from.rename(to).transform((dir) {
-      log.fine("Renamed directory ${from.path} to $to.");
-      return dir;
+  return _attemptRetryable(() => from.rename(to)).transform((dir) {
+    log.fine("Renamed directory ${from.path} to $to.");
+    return dir;
+  });
+}
+
+/// On Windows, we sometimes get failures where the directory is still in use
+/// when we try to do something with it. This is usually because the OS hasn't
+/// noticed yet that a process using that directory has closed. To be a bit
+/// more resilient, we wait and retry a few times.
+///
+/// Takes a [callback] which returns a future for the operation being attempted.
+/// If that future completes with an error, it will slepp and then [callback]
+/// will be invoked again to retry the operation. It will try a few times before
+/// giving up.
+Future _attemptRetryable(Future callback()) {
+  // Only do lame retry logic on Windows.
+  if (Platform.operatingSystem != 'windows') return callback();
+
+  var attempts = 0;
+  makeAttempt(_) {
+    attempts++;
+    return callback().transformException((e) {
+      if (attempts >= 10) {
+        throw 'Could not complete operation. Gave up after $attempts attempts.';
+      }
+
+      // Wait a bit and try again.
+      log.fine("Operation failed, retrying (attempt $attempts).");
+      return sleep(500).chain(makeAttempt);
     });
   }
 
-  // On Windows, we sometimes get failures where the directory is still in use
-  // when we try to move it. To be a bit more resilient, we wait and retry a
-  // few times.
-  var attempts = 0;
-  attemptRename(_) {
-    attempts++;
-    return from.rename(to).transform((dir) {
-      log.fine("Renamed directory ${from.path} to $to.");
-      return dir;
-    }).transformException((e) {
-      if (attempts >= 10) {
-        throw 'Could not move directory "${from.path}" to "$to". Gave up '
-              'after $attempts attempts.';
-      }
-
-      // Wait a bit and try again.
-      log.fine("Rename ${from.path} failed, retrying (attempt $attempts).");
-      return sleep(500).chain(attemptRename);
-    });
-
-    return from;
-  }
-
-  return attemptRename(null);
+  return makeAttempt(null);
 }
 
 /**
  * Creates a new symlink that creates an alias from [from] to [to], both of
  * which can be a [String], [File], or [Directory]. Returns a [Future] which
  * completes to the symlink file (i.e. [to]).
  */
 Future<File> createSymlink(from, to) {
   from = _getPath(from);
   to = _getPath(to);
@@ skipping 598 matching lines @@
   });
 
   if (Platform.operatingSystem != "windows") {
     var args = ["--create", "--gzip", "--directory", baseDir];
     args.addAll(contents.map(_getPath));
     // TODO(nweiz): It's possible that enough command-line arguments will make
     // the process choke, so at some point we should save the arguments to a
     // file and pass them in via --files-from for tar and -i@filename for 7zip.
     startProcess("tar", args).then((process) {
       pipeInputToInput(process.stdout, stream);
-      process.stderr.pipe(stderr, close: false);
+
+      // Drain and discard 7zip's stderr. 7zip writes its normal output to
+      // stderr. We don't want to show that since it's meaningless.
+      // TODO(rnystrom): Should log this and display it if an actual error
+      // occurs.
+      consumeInputStream(process.stderr);
     });
     return stream;
   }
 
   withTempDir((tempDir) {
     // Create the tar file.
     var tarFile = join(tempDir, "intermediate.tar");
     var args = ["a", "-w$baseDir", tarFile];
     args.addAll(contents.map((entry) => '-i!"$entry"'));
 
     // Note: This line of code gets munged by create_sdk.py to be the correct
     // relative path to 7zip in the SDK.
     var pathTo7zip = '../../third_party/7zip/7za.exe';
     var command = relativeToPub(pathTo7zip);
 
     // We're passing 'baseDir' both as '-w' and setting it as the working
     // directory explicitly here intentionally. The former ensures that the
     // files added to the archive have the correct relative path in the archive.
     // The latter enables relative paths in the "-i" args to be resolved.
     return runProcess(command, args, workingDir: baseDir).chain((_) {
       // GZIP it. 7zip doesn't support doing both as a single operation. Send
       // the output to stdout.
       args = ["a", "unused", "-tgzip", "-so", tarFile];
       return startProcess(command, args);
     }).chain((process) {
-      process.stderr.pipe(stderr, close: false);
+      // Drain and discard 7zip's stderr. 7zip writes its normal output to
+      // stderr. We don't want to show that since it's meaningless.
+      // TODO(rnystrom): Should log this and display it if an actual error
+      // occurs.
+      consumeInputStream(process.stderr);
       return pipeInputToInput(process.stdout, stream);
     });
   });
   return stream;
 }
 
 /**
  * Exception thrown when an HTTP operation fails.
  */
 class PubHttpException implements Exception {
@@ skipping 84 matching lines @@
   return new Directory(entry);
 }
 
 /**
  * Gets a [Uri] for [uri], which can either already be one, or be a [String].
  */
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return new Uri.fromString(uri);
 }