Provisionally stop working around issues 9252 and 9253.

utils/pub/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 io;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
@@ skipping 110 matching lines @@
 /// Creates a temp directory whose name will be based on [dir] with a unique
 /// suffix appended to it. If [dir] is not provided, a temp directory will be
 /// created in a platform-dependent temporary location. Returns the path of the
 /// created directory.
 String createTempDir([dir = '']) {
   var tempDir = new Directory(dir).createTempSync();
   log.io("Created temp directory ${tempDir.path}");
   return tempDir.path;
 }
 
-// TODO(nweiz): Remove this when issue 9252 is fixed.
-/// Asynchronously recursively deletes [dir]. Returns a [Future] that completes
-/// when the deletion is done.
-Future<String> deleteDir(String dir) {
-  return _attemptRetryable(() => log.ioAsync("delete directory $dir",
-      new Directory(dir).delete(recursive: true).then((_) => dir)));
+/// Recursively deletes [dir].
+void deleteDir(String dir) {
+  log.io("Deleting directory $dir.");
+  new Directory(dir).deleteSync(recursive: true);
 }
 
 /// Asynchronously lists the contents of [dir]. If [recursive] is `true`, lists
 /// subdirectory contents (defaults to `false`). If [includeHiddenFiles] is
 /// `true`, includes files and directories beginning with `.` (defaults to
 /// `false`).
 ///
 /// If [dir] is a string, the returned paths are guaranteed to begin with it.
 Future<List<String>> listDir(String dir,
     {bool recursive: false, bool includeHiddenFiles: false}) {
@@ skipping 54 matching lines @@
     });
   }
 
   return doList(dir, new Set<String>());
 }
 
 /// Determines if [dir] exists on the file system.
 bool dirExists(String dir) => new Directory(dir).existsSync();
 
 /// "Cleans" [dir]. If that directory already exists, it will be deleted. Then a
-/// new empty directory will be created. Returns a [Future] that completes when
-/// the new clean directory is created.
-Future<String> cleanDir(String dir) {
-  return defer(() {
-    if (dirExists(dir)) {
-      // Delete it first.
-      return deleteDir(dir).then((_) => createDir(dir));
-    }
+/// new empty directory will be created.
+void cleanDir(String dir) {
+  if (dirExists(dir)) {
+    // Delete it first.
+    deleteDir(dir);
+  } else if (fileExists(dir)) {
+    // If there is a non-directory there (file or symlink), delete it.
+    deleteFile(dir);
+  }
 
-    if (fileExists(dir)) {
-      // If there is a non-directory there (file or symlink), delete it.
-      deleteFile(dir);
-      return createDir(dir);
-    }
-
-    // Just create it.
-    return createDir(dir);
-  });
+  // Just create it.
+  createDir(dir);
 }
 
-// TODO(nweiz): remove this when issue 9253 is fixed.
-/// Renames (i.e. moves) the directory [from] to [to]. Returns a [Future] with
-/// the destination directory.
-Future<String> renameDir(String from, String to) {
+/// Renames (i.e. moves) the directory [from] to [to].
+void renameDir(String from, String to) {
   log.io("Renaming directory $from to $to.");
-
-  return _attemptRetryable(() => new Directory(from).rename(to)).then((dir) {
-    log.fine("Renamed directory $from to $to.");
-    return to;
-  });
-}
-
-/// 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().catchError((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).then(makeAttempt);
-    });
-  }
-
-  return makeAttempt(null);
+  new Directory(from).renameSync(to);
 }
 
 /// Creates a new symlink at path [symlink] that points to [target]. Returns a
 /// [Future] which completes to the path to the symlink file.
 ///
 /// If [relative] is true, creates a symlink with a relative path from the
 /// symlink to the target. Otherwise, uses the [target] path unmodified.
 ///
 /// Note that on Windows, only directories may be symlinked to.
 Future<String> createSymlink(String target, String symlink,
@@ skipping 332 matching lines @@
   }).catchError((e) {
     if (completer.isCompleted) return;
     timer.cancel();
     completer.completeError(e);
   });
   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
-/// will be deleted.
+/// will be 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 defer(() {
     var tempDir = createTempDir();
-    return fn(tempDir).whenComplete(() {
-      return deleteDir(tempDir);
-    });
+    return new Future.of(() => fn(tempDir))
+        .whenComplete(() => deleteDir(tempDir));
   });
 }
 
 /// 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) {
   log.fine("Extracting .tar.gz stream to $destination.");
 
   if (Platform.operatingSystem == "windows") {
     return _extractTarGzWindows(stream, destination);
@@ skipping 169 matching lines @@
   const PubProcessResult(this.stdout, this.stderr, this.exitCode);
 
   bool get success => exitCode == 0;
 }
 
 /// 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 Uri.parse(uri);
 }