From: Julien HENRY Date: Mon, 7 Aug 2017 16:11:58 +0000 (+0200) Subject: Fix regression introduced during previous scanner hardening X-Git-Tag: 6.6-RC1~729 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=45cbb08cf2cfcdbe6f755e875cf54ce1ce04c196;p=sonarqube.git Fix regression introduced during previous scanner hardening Module workDir is deleted when cleaning root module work dir when they are nested. --- diff --git a/sonar-plugin-api/src/main/java/org/sonar/api/batch/fs/internal/DefaultInputModule.java b/sonar-plugin-api/src/main/java/org/sonar/api/batch/fs/internal/DefaultInputModule.java index e5d8a5c060b..d499e8e0adf 100644 --- a/sonar-plugin-api/src/main/java/org/sonar/api/batch/fs/internal/DefaultInputModule.java +++ b/sonar-plugin-api/src/main/java/org/sonar/api/batch/fs/internal/DefaultInputModule.java @@ -30,7 +30,6 @@ import java.util.List; import java.util.Map; import javax.annotation.CheckForNull; import javax.annotation.concurrent.Immutable; -import org.apache.commons.io.FileUtils; import org.sonar.api.batch.bootstrap.ProjectDefinition; import org.sonar.api.batch.fs.InputModule; @@ -93,11 +92,6 @@ public class DefaultInputModule extends DefaultInputComponent implements InputMo private static Path initWorkingDir(ProjectDefinition module) { File workingDirAsFile = module.getWorkDir(); - try { - FileUtils.forceMkdir(workingDirAsFile); - } catch (Exception e) { - throw new IllegalStateException("Fail to create working dir: " + workingDirAsFile.getAbsolutePath(), e); - } return workingDirAsFile.getAbsoluteFile().toPath().normalize(); } diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ProjectScanContainer.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ProjectScanContainer.java index 4049d49014e..d4ff556e8ae 100644 --- a/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ProjectScanContainer.java +++ b/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ProjectScanContainer.java @@ -108,7 +108,7 @@ public class ProjectScanContainer extends ComponentContainer { addBatchExtensions(); ProjectLock lock = getComponentByType(ProjectLock.class); lock.tryLock(); - getComponentByType(WorkDirectoryCleaner.class).execute(); + getComponentByType(WorkDirectoriesInitializer.class).execute(); Settings settings = getComponentByType(Settings.class); if (settings != null && settings.getBoolean(CoreProperties.PROFILING_LOG_PROPERTY)) { add(PhasesSumUpTimeProfiler.class); @@ -122,7 +122,7 @@ public class ProjectScanContainer extends ComponentContainer { add( props, ProjectReactorBuilder.class, - WorkDirectoryCleaner.class, + WorkDirectoriesInitializer.class, new MutableProjectReactorProvider(), ProjectBuildersExecutor.class, ProjectLock.class, diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/WorkDirectoriesInitializer.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/WorkDirectoriesInitializer.java new file mode 100644 index 00000000000..3ee70e9baa3 --- /dev/null +++ b/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/WorkDirectoriesInitializer.java @@ -0,0 +1,84 @@ +/* + * SonarQube + * Copyright (C) 2009-2017 SonarSource SA + * mailto:info 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.scanner.scan; + +import java.io.IOException; +import java.nio.file.DirectoryStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Iterator; +import org.sonar.api.batch.fs.internal.DefaultInputModule; +import org.sonar.api.batch.fs.internal.InputModuleHierarchy; +import org.sonar.core.util.FileUtils; +import org.sonar.home.cache.DirectoryLock; + +/** + * Clean and create working directories of each module. + * Be careful that sub module work dir might be nested in parent working directory. + */ +public class WorkDirectoriesInitializer { + + private InputModuleHierarchy moduleHierarchy; + + public WorkDirectoriesInitializer(InputModuleHierarchy moduleHierarchy) { + this.moduleHierarchy = moduleHierarchy; + } + + public void execute() { + cleanAllWorkingDirs(moduleHierarchy.root()); + mkdirsAllWorkingDirs(moduleHierarchy.root()); + } + + private void cleanAllWorkingDirs(DefaultInputModule module) { + for (DefaultInputModule sub : moduleHierarchy.children(module)) { + cleanAllWorkingDirs(sub); + } + if (Files.exists(module.getWorkDir())) { + deleteAllRecursivelyExceptLockFile(module.getWorkDir()); + } + } + + private void mkdirsAllWorkingDirs(DefaultInputModule module) { + for (DefaultInputModule sub : moduleHierarchy.children(module)) { + mkdirsAllWorkingDirs(sub); + } + try { + Files.createDirectories(module.getWorkDir()); + } catch (Exception e) { + throw new IllegalStateException("Fail to create working dir: " + module.getWorkDir(), e); + } + } + + private static void deleteAllRecursivelyExceptLockFile(Path dirToDelete) { + try (DirectoryStream stream = list(dirToDelete)) { + + Iterator it = stream.iterator(); + while (it.hasNext()) { + FileUtils.deleteQuietly(it.next().toFile()); + } + } catch (IOException e) { + throw new IllegalStateException("Failed to clean working directory: " + dirToDelete.toString(), e); + } + } + + private static DirectoryStream list(Path dir) throws IOException { + return Files.newDirectoryStream(dir, entry -> !DirectoryLock.LOCK_FILE_NAME.equals(entry.getFileName().toString())); + } +} diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/WorkDirectoryCleaner.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/WorkDirectoryCleaner.java deleted file mode 100644 index 83a9e8650f3..00000000000 --- a/sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/WorkDirectoryCleaner.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2017 SonarSource SA - * mailto:info 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.scanner.scan; - -import java.io.IOException; -import java.nio.file.DirectoryStream; -import java.nio.file.Files; -import java.nio.file.Path; -import java.util.Iterator; -import org.sonar.api.batch.fs.internal.InputModuleHierarchy; -import org.sonar.core.util.FileUtils; -import org.sonar.home.cache.DirectoryLock; - -public class WorkDirectoryCleaner { - private final Path workDir; - - public WorkDirectoryCleaner(InputModuleHierarchy moduleHierarchy) { - workDir = moduleHierarchy.root().getWorkDir(); - } - - public void execute() { - if (!workDir.toFile().exists()) { - return; - } - - try (DirectoryStream stream = list()) { - - Iterator it = stream.iterator(); - while (it.hasNext()) { - FileUtils.deleteQuietly(it.next().toFile()); - } - } catch (IOException e) { - throw new IllegalStateException("Failed to clean working directory: " + workDir.toString(), e); - } - } - - private DirectoryStream list() throws IOException { - return Files.newDirectoryStream(workDir, entry -> !DirectoryLock.LOCK_FILE_NAME.equals(entry.getFileName().toString())); - } -} diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/WorkDirectoriesInitializerTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/WorkDirectoriesInitializerTest.java new file mode 100644 index 00000000000..3000f931503 --- /dev/null +++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/WorkDirectoriesInitializerTest.java @@ -0,0 +1,101 @@ +/* + * SonarQube + * Copyright (C) 2009-2017 SonarSource SA + * mailto:info 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.scanner.scan; + +import java.io.File; +import java.io.IOException; +import java.util.Arrays; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.sonar.api.batch.fs.internal.DefaultInputModule; +import org.sonar.api.batch.fs.internal.InputModuleHierarchy; +import org.sonar.home.cache.DirectoryLock; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class WorkDirectoriesInitializerTest { + private WorkDirectoriesInitializer initializer; + @Rule + public TemporaryFolder temp = new TemporaryFolder(); + + private File rootWorkDir; + private File lock; + private InputModuleHierarchy hierarchy; + private DefaultInputModule root; + + @Before + public void setUp() throws IOException { + rootWorkDir = temp.newFolder(); + // create files to clean + new File(rootWorkDir, "foo.txt").createNewFile(); + File newFolder = new File(rootWorkDir, "foo"); + newFolder.mkdir(); + File fileInFolder = new File(newFolder, "test"); + fileInFolder.createNewFile(); + + lock = new File(rootWorkDir, DirectoryLock.LOCK_FILE_NAME); + lock.createNewFile(); + + hierarchy = mock(InputModuleHierarchy.class); + root = mock(DefaultInputModule.class); + when(hierarchy.root()).thenReturn(root); + when(root.getWorkDir()).thenReturn(rootWorkDir.toPath()); + + assertThat(rootWorkDir.list().length).isGreaterThan(1); + initializer = new WorkDirectoriesInitializer(hierarchy); + } + + @Test + public void testNonExisting() { + temp.delete(); + initializer.execute(); + } + + @Test + public void testClean() { + initializer.execute(); + + assertThat(rootWorkDir).exists(); + assertThat(lock).exists(); + assertThat(rootWorkDir.list()).containsOnly(DirectoryLock.LOCK_FILE_NAME); + } + + @Test + public void cleaningRootModuleShouldNotDeleteChildrenWorkDir() throws IOException { + DefaultInputModule moduleA = mock(DefaultInputModule.class); + when(hierarchy.children(root)).thenReturn(Arrays.asList(moduleA)); + File moduleAWorkdir = new File(rootWorkDir, "moduleA"); + when(moduleA.getWorkDir()).thenReturn(moduleAWorkdir.toPath()); + moduleAWorkdir.mkdir(); + new File(moduleAWorkdir, "fooA.txt").createNewFile(); + + initializer.execute(); + + assertThat(rootWorkDir).exists(); + assertThat(lock).exists(); + assertThat(rootWorkDir.list()).containsOnly(DirectoryLock.LOCK_FILE_NAME, "moduleA"); + assertThat(moduleAWorkdir).exists(); + } + +} diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/WorkDirectoryCleanerTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/WorkDirectoryCleanerTest.java deleted file mode 100644 index 82886823190..00000000000 --- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/WorkDirectoryCleanerTest.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2017 SonarSource SA - * mailto:info 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.scanner.scan; - -import java.io.File; -import java.io.IOException; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; -import org.sonar.api.batch.fs.internal.DefaultInputModule; -import org.sonar.api.batch.fs.internal.InputModuleHierarchy; -import org.sonar.home.cache.DirectoryLock; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -public class WorkDirectoryCleanerTest { - private WorkDirectoryCleaner cleaner; - @Rule - public TemporaryFolder temp = new TemporaryFolder(); - - @Before - public void setUp() throws IOException { - // create files to clean - temp.newFile(); - File newFolder = temp.newFolder(); - File fileInFolder = new File(newFolder, "test"); - fileInFolder.createNewFile(); - - File lock = new File(temp.getRoot(), DirectoryLock.LOCK_FILE_NAME); - lock.createNewFile(); - - // mock project - InputModuleHierarchy hierarchy = mock(InputModuleHierarchy.class); - DefaultInputModule root = mock(DefaultInputModule.class); - when(hierarchy.root()).thenReturn(root); - when(root.getWorkDir()).thenReturn(temp.getRoot().toPath()); - - assertThat(temp.getRoot().list().length).isGreaterThan(1); - cleaner = new WorkDirectoryCleaner(hierarchy); - } - - @Test - public void testNonExisting() { - temp.delete(); - cleaner.execute(); - } - - @Test - public void testClean() { - File lock = new File(temp.getRoot(), DirectoryLock.LOCK_FILE_NAME); - cleaner.execute(); - - assertThat(temp.getRoot()).exists(); - assertThat(lock).exists(); - assertThat(temp.getRoot().list()).containsOnly(DirectoryLock.LOCK_FILE_NAME); - } - -}