Simplified TemporaryDirectoryAllocator.dispose

src/main/java/org/jvnet/hudson/test/TemporaryDirectoryAllocator.java

@@ -23,19 +23,28 @@
  */
 package org.jvnet.hudson.test;
 
-import hudson.FilePath;
-
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.DirectoryNotEmptyException;
+import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Allocates temporary directories and cleans it up at the end.
  * @author Kohsuke Kawaguchi
  */
 public class TemporaryDirectoryAllocator {
+
+    private static final Logger LOGGER = Logger.getLogger(TemporaryDirectoryAllocator.class.getName());
+
     /**
      * Remember allocated directories to delete them later.
      */
@@ -85,25 +94,11 @@ public synchronized File allocate() throws IOException {
      * Deletes all allocated temporary directories.
      */
     public synchronized void dispose() throws IOException, InterruptedException {
-        // TODO when we bump the Jenkins dependency to 2.157
-        IOException x = null;
         for (File dir : tmpDirectories) {
-            try {
-                new FilePath(dir).deleteRecursive();
-            } catch (IOException e) {
-                if (x == null) { 
-                    x = e;
-                }
-                else {
-                    x.addSuppressed(e);
-                }
-            }
+            LOGGER.info(() -> "deleting " + dir);
+            delete(dir.toPath());
         }
         tmpDirectories.clear();
-        if (x != null) {
-           // do not wrap this pending JENKINS-60308
-           throw x;
-        }
     }
 
     /**
@@ -116,13 +111,34 @@ public synchronized void disposeAsync() {
         new Thread("Disposing "+base) {
             @Override
             public void run() {
-                for (File dir : tbr)
+                for (File dir : tbr) {
+                    LOGGER.info(() -> "deleting " + dir);
                     try {
-                        new FilePath(dir).deleteRecursive();
-                    } catch (IOException | InterruptedException e) {
-                        e.printStackTrace();
+                        delete(dir.toPath());
+                    } catch (IOException e) {
+                        LOGGER.log(Level.WARNING, null, e);
                     }
+                }
             }
         }.start();
     }
+
+    private void delete(Path p) throws IOException {
+        LOGGER.fine(() -> "deleting " + p);
+        if (Files.isDirectory(p, LinkOption.NOFOLLOW_LINKS)) {
+            try (DirectoryStream<Path> children = Files.newDirectoryStream(p)) {
+                for (Path child : children) {
+                    delete(child);
+                }
+            }
+        }
+        try {
+            Files.deleteIfExists(p);
+        } catch (DirectoryNotEmptyException x) {
+            try (Stream<Path> children = Files.list(p)) {
+                throw new IOException(children.map(Path::toString).collect(Collectors.joining(" ")), x);
+            }
+        }
+    }
+
 }