SONAR-7125 add FileUtils in sonar-core with efficient delete methods

methods delete from Commons IO FileUtils class reimplemented with Java NIO API

2 files changed, 430 insertions, 0 deletions

diff --git a/sonar-core/src/main/java/org/sonar/core/util/FileUtils.java b/sonar-core/src/main/java/org/sonar/core/util/FileUtils.java
new file mode 100644
index 00000000000..df5e77dbe38
--- /dev/null
+++ b/sonar-core/src/main/java/org/sonar/core/util/FileUtils.java
@@ -0,0 +1,185 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2016 SonarSource SA
+ * mailto:contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.core.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileVisitOption;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.EnumSet;
+import javax.annotation.Nullable;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.lang.String.format;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * This utility class provides Java NIO based replacement for some methods of
+ * {@link org.apache.commons.io.FileUtils Common IO FileUtils} class.
+ */
+public final class FileUtils {
+
+  private static final String DIRECTORY_CAN_NOT_BE_NULL = "Directory can not be null";
+  private static final EnumSet<FileVisitOption> FOLLOW_LINKS = EnumSet.of(FileVisitOption.FOLLOW_LINKS);
+
+  private FileUtils() {
+    // prevents instantiation
+  }
+
+  /**
+   * Deletes a directory recursively.
+   *
+   * @param directory  directory to delete
+   * @throws IOException in case deletion is unsuccessful
+   */
+  public static void deleteDirectory(File directory) throws IOException {
+    requireNonNull(directory, DIRECTORY_CAN_NOT_BE_NULL);
+
+    deleteDirectoryImpl(directory.toPath());
+  }
+
+  /**
+   * Cleans a directory recursively.
+   *
+   * @param directory  directory to delete
+   * @throws IOException in case deletion is unsuccessful
+   */
+  public static void cleanDirectory(File directory) throws IOException {
+    requireNonNull(directory, DIRECTORY_CAN_NOT_BE_NULL);
+
+    Path path = directory.toPath();
+    if (!Files.exists(path)) {
+      return;
+    }
+
+    cleanDirectoryImpl(path);
+  }
+
+  /**
+   * Deletes a file, never throwing an exception. If file is a directory, delete it and all sub-directories.
+   * <p>
+   * The difference between File.delete() and this method are:
+   * <ul>
+   * <li>A directory to be deleted does not have to be empty.</li>
+   * <li>No exceptions are thrown when a file or directory cannot be deleted.</li>
+   * </ul>
+   *
+   * @param file  file or directory to delete, can be {@code null}
+   * @return {@code true} if the file or directory was deleted, otherwise {@code false}
+   */
+  public static boolean deleteQuietly(@Nullable File file) {
+    if (file == null) {
+      return false;
+    }
+
+    try {
+      if (file.isDirectory()) {
+        deleteDirectory(file);
+      } else {
+        Files.delete(file.toPath());
+      }
+      return true;
+    } catch (IOException | SecurityException ignored) {
+      return false;
+    }
+  }
+
+  private static void checkIO(boolean condition, String pattern, Object... arguments) throws IOException {
+    if (!condition) {
+      throw new IOException(format(pattern, arguments));
+    }
+  }
+
+  private static void cleanDirectoryImpl(Path path) throws IOException {
+    checkArgument(Files.isDirectory(path), "'%s' is not a directory", path);
+
+    Files.walkFileTree(path, FOLLOW_LINKS, CleanDirectoryFileVisitor.VISIT_MAX_DEPTH, new CleanDirectoryFileVisitor(path));
+  }
+
+  private static void deleteDirectoryImpl(Path path) throws IOException {
+    requireNonNull(path, DIRECTORY_CAN_NOT_BE_NULL);
+    if (!Files.exists(path)) {
+      return;
+    }
+
+    checkIO(!Files.isSymbolicLink(path), "Directory '%s' is a symbolic link", path);
+    checkIO(!Files.isRegularFile(path), "Directory '%s' is a file", path);
+
+    Files.walkFileTree(path, DeleteRecursivelyFileVisitor.INSTANCE);
+
+    checkIO(!Files.exists(path), "Unable to delete directory '%s'", path);
+  }
+
+  /**
+   * This visitor is intended to be used to visit direct children of directory <strong>or a symLink to a directory</strong>,
+   * so, with a max depth of {@link #VISIT_MAX_DEPTH 1}. Each direct children will either be directly deleted (if file)
+   * or recursively deleted (if directory).
+   */
+  private static class CleanDirectoryFileVisitor extends SimpleFileVisitor<Path> {
+    public static final int VISIT_MAX_DEPTH = 1;
+
+    private final Path path;
+    private final boolean symLink;
+
+    public CleanDirectoryFileVisitor(Path path) {
+      this.path = path;
+      this.symLink = Files.isSymbolicLink(path);
+    }
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+      if (Files.isDirectory(file)) {
+        deleteDirectoryImpl(file);
+      } else if (!symLink || !file.equals(path)) {
+        Files.delete(file);
+      }
+      return FileVisitResult.CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+      if (!dir.equals(path)) {
+        deleteDirectoryImpl(dir);
+      }
+      return FileVisitResult.CONTINUE;
+    }
+  }
+
+  private static final class DeleteRecursivelyFileVisitor extends SimpleFileVisitor<Path> {
+    public static final DeleteRecursivelyFileVisitor INSTANCE = new DeleteRecursivelyFileVisitor();
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+      Files.delete(file);
+      return FileVisitResult.CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+      Files.delete(dir);
+      return FileVisitResult.CONTINUE;
+    }
+  }
+
+}
diff --git a/sonar-core/src/test/java/org/sonar/core/util/FileUtilsTest.java b/sonar-core/src/test/java/org/sonar/core/util/FileUtilsTest.java
new file mode 100644
index 00000000000..28411c2c110
--- /dev/null
+++ b/sonar-core/src/test/java/org/sonar/core/util/FileUtilsTest.java
@@ -0,0 +1,245 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2016 SonarSource SA
+ * mailto:contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.core.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import javax.annotation.CheckForNull;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TemporaryFolder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FileUtilsTest {
+  @Rule
+  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @Rule
+  public ExpectedException expectedException = ExpectedException.none();
+
+  @Test
+  public void cleanDirectory_throws_NPE_if_file_is_null() throws IOException {
+    expectDirectoryCanNotBeNullNPE();
+
+    FileUtils.cleanDirectory(null);
+  }
+
+  @Test
+  public void cleanDirectory_does_nothing_if_argument_does_not_exist() throws IOException {
+    FileUtils.cleanDirectory(new File("/a/b/ToDoSSS"));
+  }
+
+  @Test
+  public void cleanDirectory_throws_IAE_if_argument_is_a_file() throws IOException {
+    File file = temporaryFolder.newFile();
+
+    expectedException.expect(IllegalArgumentException.class);
+    expectedException.expectMessage("'" + file.getAbsolutePath() + "' is not a directory");
+
+    FileUtils.cleanDirectory(file);
+  }
+
+  @Test
+  public void cleanDirectory_removes_directories_and_files_in_target_directory_but_not_target_directory() throws IOException {
+    Path target = temporaryFolder.newFolder().toPath();
+    Path childFile1 = Files.createFile(target.resolve("file1.txt"));
+    Path childDir1 = Files.createDirectory(target.resolve("subDir1"));
+    Path childFile2 = Files.createFile(childDir1.resolve("file2.txt"));
+    Path childDir2 = Files.createDirectory(childDir1.resolve("subDir2"));
+
+    assertThat(target).isDirectory();
+    assertThat(childFile1).isRegularFile();
+    assertThat(childDir1).isDirectory();
+    assertThat(childFile2).isRegularFile();
+    assertThat(childDir2).isDirectory();
+
+    // on supporting FileSystem, target will change if directory is recreated
+    Object targetKey = getFileKey(target);
+
+    FileUtils.cleanDirectory(target.toFile());
+
+    assertThat(target).isDirectory();
+    assertThat(childFile1).doesNotExist();
+    assertThat(childDir1).doesNotExist();
+    assertThat(childFile2).doesNotExist();
+    assertThat(childDir2).doesNotExist();
+    assertThat(getFileKey(target)).isEqualTo(targetKey);
+  }
+
+  @Test
+  public void cleanDirectory_follows_symlink_to_target_directory() throws IOException {
+    Path target = temporaryFolder.newFolder().toPath();
+    Path symToDir = Files.createSymbolicLink(temporaryFolder.newFolder().toPath().resolve("sym_to_dir"), target);
+    Path childFile1 = Files.createFile(target.resolve("file1.txt"));
+    Path childDir1 = Files.createDirectory(target.resolve("subDir1"));
+    Path childFile2 = Files.createFile(childDir1.resolve("file2.txt"));
+    Path childDir2 = Files.createDirectory(childDir1.resolve("subDir2"));
+
+    assertThat(target).isDirectory();
+    assertThat(symToDir).isSymbolicLink();
+    assertThat(childFile1).isRegularFile();
+    assertThat(childDir1).isDirectory();
+    assertThat(childFile2).isRegularFile();
+    assertThat(childDir2).isDirectory();
+
+    // on supporting FileSystem, target will change if directory is recreated
+    Object targetKey = getFileKey(target);
+    Object symLinkKey = getFileKey(symToDir);
+
+    FileUtils.cleanDirectory(symToDir.toFile());
+
+    assertThat(target).isDirectory();
+    assertThat(symToDir).isSymbolicLink();
+    assertThat(childFile1).doesNotExist();
+    assertThat(childDir1).doesNotExist();
+    assertThat(childFile2).doesNotExist();
+    assertThat(childDir2).doesNotExist();
+    assertThat(getFileKey(target)).isEqualTo(targetKey);
+    assertThat(getFileKey(symToDir)).isEqualTo(symLinkKey);
+  }
+
+  @Test
+  public void deleteQuietly_does_not_fail_if_argument_is_null() {
+    FileUtils.deleteQuietly(null);
+  }
+
+  @Test
+  public void deleteQuietly_does_not_fail_if_file_does_not_exist() throws IOException {
+    File file = new File(temporaryFolder.newFolder(), "blablabl");
+    assertThat(file).doesNotExist();
+
+    FileUtils.deleteQuietly(file);
+  }
+
+  @Test
+  public void deleteQuietly_deletes_directory_and_content() throws IOException {
+    Path target = temporaryFolder.newFolder().toPath();
+    Path childFile1 = Files.createFile(target.resolve("file1.txt"));
+    Path childDir1 = Files.createDirectory(target.resolve("subDir1"));
+    Path childFile2 = Files.createFile(childDir1.resolve("file2.txt"));
+    Path childDir2 = Files.createDirectory(childDir1.resolve("subDir2"));
+
+    assertThat(target).isDirectory();
+    assertThat(childFile1).isRegularFile();
+    assertThat(childDir1).isDirectory();
+    assertThat(childFile2).isRegularFile();
+    assertThat(childDir2).isDirectory();
+
+    FileUtils.deleteQuietly(target.toFile());
+
+    assertThat(target).doesNotExist();
+    assertThat(childFile1).doesNotExist();
+    assertThat(childDir1).doesNotExist();
+    assertThat(childFile2).doesNotExist();
+    assertThat(childDir2).doesNotExist();
+  }
+
+  @Test
+  public void deleteQuietly_deletes_symbolicLink() throws IOException {
+    Path folder = temporaryFolder.newFolder().toPath();
+    Path file1 = Files.createFile(folder.resolve("file1.txt"));
+    Path symLink = Files.createSymbolicLink(folder.resolve("link1"), file1);
+
+    assertThat(file1).isRegularFile();
+    assertThat(symLink).isSymbolicLink();
+
+    FileUtils.deleteQuietly(symLink.toFile());
+
+    assertThat(symLink).doesNotExist();
+    assertThat(file1).isRegularFile();
+  }
+
+  @Test
+  public void deleteDirectory_throws_NPE_if_argument_is_null() throws IOException {
+    expectDirectoryCanNotBeNullNPE();
+
+    FileUtils.deleteDirectory(null);
+  }
+
+  @Test
+  public void deleteDirectory_does_not_fail_if_file_does_not_exist() throws IOException {
+    File file = new File(temporaryFolder.newFolder(), "foo.d");
+
+    FileUtils.deleteDirectory(file);
+  }
+
+  @Test
+  public void deleteDirectory_throws_IOE_if_argument_is_a_file() throws IOException {
+    File file = temporaryFolder.newFile();
+
+    expectedException.expect(IOException.class);
+    expectedException.expectMessage("Directory '" + file.getAbsolutePath() + "' is a file");
+
+    FileUtils.deleteDirectory(file);
+  }
+
+  @Test
+  public void deleteDirectory_throws_IOE_if_file_is_symbolicLink() throws IOException {
+    Path folder = temporaryFolder.newFolder().toPath();
+    Path file1 = Files.createFile(folder.resolve("file1.txt"));
+    Path symLink = Files.createSymbolicLink(folder.resolve("link1"), file1);
+
+    assertThat(file1).isRegularFile();
+    assertThat(symLink).isSymbolicLink();
+
+    expectedException.expect(IOException.class);
+    expectedException.expectMessage("Directory '" + symLink.toFile().getAbsolutePath() + "' is a symbolic link");
+
+    FileUtils.deleteDirectory(symLink.toFile());
+  }
+
+  @Test
+  public void deleteDirectory_deletes_directory_and_content() throws IOException {
+    Path target = temporaryFolder.newFolder().toPath();
+    Path childFile1 = Files.createFile(target.resolve("file1.txt"));
+    Path childDir1 = Files.createDirectory(target.resolve("subDir1"));
+    Path childFile2 = Files.createFile(childDir1.resolve("file2.txt"));
+    Path childDir2 = Files.createDirectory(childDir1.resolve("subDir2"));
+
+    assertThat(target).isDirectory();
+    assertThat(childFile1).isRegularFile();
+    assertThat(childDir1).isDirectory();
+    assertThat(childFile2).isRegularFile();
+    assertThat(childDir2).isDirectory();
+
+    FileUtils.deleteQuietly(target.toFile());
+
+    assertThat(target).doesNotExist();
+    assertThat(childFile1).doesNotExist();
+    assertThat(childDir1).doesNotExist();
+    assertThat(childFile2).doesNotExist();
+    assertThat(childDir2).doesNotExist();
+  }
+
+  private void expectDirectoryCanNotBeNullNPE() {
+    expectedException.expect(NullPointerException.class);
+    expectedException.expectMessage("Directory can not be null");
+  }
+
+  @CheckForNull
+  private static Object getFileKey(Path path) throws IOException {
+    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
+    return attrs.fileKey();
+  }
+}