--- /dev/null
+/*
+ * 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.process;
+
+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 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
+ }
+
+ /**
+ * 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);
+ if (!directory.exists()) {
+ return;
+ }
+
+ cleanDirectoryImpl(directory.toPath());
+ }
+
+ /**
+ * 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;
+ }
+ }
+
+ /**
+ * Deletes a directory recursively. Does not support symbolic link to directories.
+ *
+ * @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);
+
+ Path path = directory.toPath();
+ if (!Files.exists(path)) {
+ return;
+ }
+
+ if (Files.isSymbolicLink(path)) {
+ throw new IOException(format("Directory '%s' is a symbolic link", directory));
+ }
+ if (Files.isRegularFile(path)) {
+ throw new IOException(format("Directory '%s' is a file", directory));
+ }
+ deleteDirectoryImpl(path);
+
+ if (Files.exists(path)) {
+ throw new IOException(format("Unable to delete directory '%s'", directory));
+ }
+ }
+
+ private static void cleanDirectoryImpl(Path path) throws IOException {
+ if (!Files.isDirectory(path)) {
+ throw new IllegalArgumentException(format("'%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 {
+ Files.walkFileTree(path, DeleteRecursivelyFileVisitor.INSTANCE);
+ }
+
+ /**
+ * 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;
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.process;
+
+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();
+ }
+}
projects / sonarqube.git / commitdiff