// Copyright 2015 The Bazel Authors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.devtools.build.lib.skyframe; import static com.google.common.collect.ImmutableList.toImmutableList; import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertWithMessage; import static java.util.concurrent.TimeUnit.SECONDS; import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.mock; import com.google.common.base.Suppliers; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.hash.HashCode; import com.google.common.util.concurrent.Runnables; import com.google.devtools.build.lib.actions.Action; import com.google.devtools.build.lib.actions.ActionLookupData; import com.google.devtools.build.lib.actions.ActionLookupKey; import com.google.devtools.build.lib.actions.Artifact; import com.google.devtools.build.lib.actions.Artifact.ArchivedTreeArtifact; import com.google.devtools.build.lib.actions.Artifact.SpecialArtifact; import com.google.devtools.build.lib.actions.Artifact.TreeFileArtifact; import com.google.devtools.build.lib.actions.ArtifactRoot; import com.google.devtools.build.lib.actions.ArtifactRoot.RootType; import com.google.devtools.build.lib.actions.FileArtifactValue; import com.google.devtools.build.lib.actions.FileArtifactValue.RemoteFileArtifactValue; import com.google.devtools.build.lib.actions.FileStateValue; import com.google.devtools.build.lib.actions.FileValue; import com.google.devtools.build.lib.actions.RemoteArtifactChecker; import com.google.devtools.build.lib.actions.ThreadStateReceiver; import com.google.devtools.build.lib.actions.util.ActionsTestUtil; import com.google.devtools.build.lib.actions.util.TestAction; import com.google.devtools.build.lib.analysis.BlazeDirectories; import com.google.devtools.build.lib.analysis.ServerDirectories; import com.google.devtools.build.lib.clock.BlazeClock; import com.google.devtools.build.lib.cmdline.Label; import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder; import com.google.devtools.build.lib.collect.nestedset.Order; import com.google.devtools.build.lib.events.NullEventHandler; import com.google.devtools.build.lib.io.FileSymlinkCycleUniquenessFunction; import com.google.devtools.build.lib.io.FileSymlinkInfiniteExpansionUniquenessFunction; import com.google.devtools.build.lib.packages.WorkspaceFileValue; import com.google.devtools.build.lib.pkgcache.PathPackageLocator; import com.google.devtools.build.lib.skyframe.ExternalFilesHelper.ExternalFileAction; import com.google.devtools.build.lib.skyframe.FilesystemValueChecker.ModifiedOutputsReceiver; import com.google.devtools.build.lib.skyframe.PackageFunction.GlobbingStrategy; import com.google.devtools.build.lib.skyframe.PackageLookupFunction.CrossRepositoryLabelViolationStrategy; import com.google.devtools.build.lib.testutil.ManualClock; import com.google.devtools.build.lib.testutil.TestConstants; import com.google.devtools.build.lib.testutil.TestPackageFactoryBuilderFactory; import com.google.devtools.build.lib.testutil.TestRuleClassProvider; import com.google.devtools.build.lib.testutil.TestUtils; import com.google.devtools.build.lib.testutil.TimestampGranularityUtils; import com.google.devtools.build.lib.util.io.OutErr; import com.google.devtools.build.lib.util.io.TimestampGranularityMonitor; import com.google.devtools.build.lib.vfs.BatchStat; import com.google.devtools.build.lib.vfs.DigestHashFunction; import com.google.devtools.build.lib.vfs.FileStateKey; import com.google.devtools.build.lib.vfs.FileStatus; import com.google.devtools.build.lib.vfs.FileStatusWithDigest; import com.google.devtools.build.lib.vfs.FileStatusWithDigestAdapter; import com.google.devtools.build.lib.vfs.FileSystem; import com.google.devtools.build.lib.vfs.FileSystemUtils; import com.google.devtools.build.lib.vfs.ModifiedFileSet; import com.google.devtools.build.lib.vfs.Path; import com.google.devtools.build.lib.vfs.PathFragment; import com.google.devtools.build.lib.vfs.Root; import com.google.devtools.build.lib.vfs.RootedPath; import com.google.devtools.build.lib.vfs.Symlinks; import com.google.devtools.build.lib.vfs.SyscallCache; import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem; import com.google.devtools.build.skyframe.Differencer.Diff; import com.google.devtools.build.skyframe.Differencer.DiffWithDelta.Delta; import com.google.devtools.build.skyframe.EvaluationContext; import com.google.devtools.build.skyframe.EvaluationResult; import com.google.devtools.build.skyframe.InMemoryMemoizingEvaluator; import com.google.devtools.build.skyframe.MemoizingEvaluator; import com.google.devtools.build.skyframe.RecordingDifferencer; import com.google.devtools.build.skyframe.SequencedRecordingDifferencer; import com.google.devtools.build.skyframe.SkyFunction; import com.google.devtools.build.skyframe.SkyFunctionName; import com.google.devtools.build.skyframe.SkyKey; import com.google.devtools.build.skyframe.SkyValue; import com.google.testing.junit.testparameterinjector.TestParameter; import com.google.testing.junit.testparameterinjector.TestParameterInjector; import java.io.IOException; import java.time.Instant; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicReference; import javax.annotation.Nullable; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; /** Tests for {@link FilesystemValueChecker}. */ @RunWith(TestParameterInjector.class) public final class FilesystemValueCheckerTest { private static final RemoteArtifactChecker CHECK_TTL = (file, metadata) -> metadata.isAlive(Instant.now()); private static final int FSVC_THREADS_FOR_TEST = 200; private static final ActionLookupKey ACTION_LOOKUP_KEY = new ActionLookupKey() { @Override public SkyFunctionName functionName() { return SkyFunctionName.FOR_TESTING; } @Nullable @Override public Label getLabel() { return null; } @Nullable @Override public BuildConfigurationKey getConfigurationKey() { return null; } }; private static final ActionLookupData ACTION_LOOKUP_DATA = actionLookupData(0); private static final EvaluationContext EVALUATION_OPTIONS = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(SkyframeExecutor.DEFAULT_THREAD_COUNT) .setEventHandler(NullEventHandler.INSTANCE) .build(); private final MockFileSystem fs = new MockFileSystem(); private RecordingDifferencer differencer; private MemoizingEvaluator evaluator; private Path pkgRoot; @TestParameter private BatchStatMode batchStat; private final ModifiedOutputsReceiver mockModifiedOutputsReceiver = mock(ModifiedOutputsReceiver.class); private final ArgumentCaptor modifiedOutputsCaptor = ArgumentCaptor.forClass(Artifact.class); private SpecialArtifact createTreeArtifact(String relPath) throws IOException { String outSegment = "bin"; Path outputDir = fs.getPath("/" + outSegment); Path outputPath = outputDir.getRelative(relPath); outputDir.createDirectory(); ArtifactRoot derivedRoot = ArtifactRoot.asDerivedRoot(fs.getPath("/"), RootType.Output, outSegment); return ActionsTestUtil.createTreeArtifactWithGeneratingAction( derivedRoot, derivedRoot.getExecPath().getRelative(derivedRoot.getRoot().relativize(outputPath))); } private static Delta actionValueWithTreeArtifacts(List contents) throws IOException { return Delta.justNew(actionValueWithTreeArtifacts(contents, ImmutableList.of())); } private static ActionExecutionValue actionValueWithTreeArtifacts( Iterable contents, Iterable archivedTreeArtifacts) throws IOException { TreeArtifactValue.MultiBuilder treeArtifacts = TreeArtifactValue.newMultiBuilder(); for (TreeFileArtifact output : contents) { treeArtifacts.putChild(output, createMetadataFromFileSystem(output)); } for (ArchivedTreeArtifact archivedTreeArtifact : archivedTreeArtifacts) { treeArtifacts.setArchivedRepresentation( archivedTreeArtifact, createMetadataFromFileSystem(archivedTreeArtifact)); } Map treeArtifactData = new HashMap<>(); treeArtifacts.injectTo(treeArtifactData::put); return ActionsTestUtil.createActionExecutionValue( /* artifactData= */ ImmutableMap.of(), ImmutableMap.copyOf(treeArtifactData)); } private static FileArtifactValue createMetadataFromFileSystem(Artifact artifact) throws IOException { Path path = artifact.getPath(); FileArtifactValue noDigest = ActionMetadataHandler.fileArtifactValueFromArtifact( artifact, FileStatusWithDigestAdapter.maybeAdapt(path.statIfFound(Symlinks.NOFOLLOW)), SyscallCache.NO_CACHE, null); return FileArtifactValue.createFromInjectedDigest(noDigest, path.getDigest()); } private void writeFile(Path path, String... lines) throws IOException { // Make sure we advance the clock to detect modifications which do not change the size, which // rely on ctime. fs.advanceClockMillis(1); FileSystemUtils.writeIsoLatin1(path, lines); } private static final class MockFileSystem extends InMemoryFileSystem { boolean statThrowsRuntimeException; boolean readlinkThrowsIoException; MockFileSystem() { this(new ManualClock()); } private MockFileSystem(ManualClock clock) { super(clock, DigestHashFunction.SHA256); } @Override public FileStatus statIfFound(PathFragment path, boolean followSymlinks) throws IOException { if (statThrowsRuntimeException) { throw new RuntimeException("bork"); } return super.statIfFound(path, followSymlinks); } @Override public PathFragment readSymbolicLink(PathFragment path) throws IOException { if (readlinkThrowsIoException) { throw new IOException("readlink failed"); } return super.readSymbolicLink(path); } void advanceClockMillis(int millis) { ((ManualClock) clock).advanceMillis(millis); } } private enum BatchStatMode { DISABLED { @Nullable @Override BatchStat getBatchStat(FileSystem fileSystem) { return null; } }, ENABLED { @Override BatchStat getBatchStat(FileSystem fileSystem) { return (useDigest, includeLinks, paths) -> { List stats = new ArrayList<>(); for (PathFragment pathFrag : paths) { stats.add( FileStatusWithDigestAdapter.maybeAdapt( fileSystem.getPath("/").getRelative(pathFrag).statIfFound(Symlinks.NOFOLLOW))); } return stats; }; } }; @Nullable abstract BatchStat getBatchStat(FileSystem fileSystem); } @Before public void setUp() throws Exception { ImmutableMap.Builder skyFunctions = ImmutableMap.builder(); pkgRoot = fs.getPath("/testroot"); pkgRoot.createDirectoryAndParents(); FileSystemUtils.createEmptyFile(pkgRoot.getRelative("WORKSPACE")); AtomicReference pkgLocator = new AtomicReference<>( new PathPackageLocator( fs.getPath("/output_base"), ImmutableList.of(Root.fromPath(pkgRoot)), BazelSkyframeExecutorConstants.BUILD_FILES_BY_PRIORITY)); BlazeDirectories directories = new BlazeDirectories( new ServerDirectories(pkgRoot, pkgRoot, pkgRoot), pkgRoot, /* defaultSystemJavabase= */ null, TestConstants.PRODUCT_NAME); ExternalFilesHelper externalFilesHelper = ExternalFilesHelper.createForTesting( pkgLocator, ExternalFileAction.DEPEND_ON_EXTERNAL_PKG_FOR_EXTERNAL_REPO_PATHS, directories); skyFunctions.put( FileStateKey.FILE_STATE, new FileStateFunction( Suppliers.ofInstance(new TimestampGranularityMonitor(BlazeClock.instance())), SyscallCache.NO_CACHE, externalFilesHelper)); skyFunctions.put(FileValue.FILE, new FileFunction(pkgLocator, directories)); skyFunctions.put( FileSymlinkCycleUniquenessFunction.NAME, new FileSymlinkCycleUniquenessFunction()); skyFunctions.put( FileSymlinkInfiniteExpansionUniquenessFunction.NAME, new FileSymlinkInfiniteExpansionUniquenessFunction()); skyFunctions.put( SkyFunctions.PACKAGE, new PackageFunction( null, null, null, null, null, /* packageProgress= */ null, PackageFunction.ActionOnIOExceptionReadingBuildFile.UseOriginalIOException.INSTANCE, /* shouldUseRepoDotBazel= */ true, GlobbingStrategy.SKYFRAME_HYBRID, k -> ThreadStateReceiver.NULL_INSTANCE)); skyFunctions.put( SkyFunctions.PACKAGE_LOOKUP, new PackageLookupFunction( new AtomicReference<>(ImmutableSet.of()), CrossRepositoryLabelViolationStrategy.ERROR, BazelSkyframeExecutorConstants.BUILD_FILES_BY_PRIORITY, BazelSkyframeExecutorConstants.EXTERNAL_PACKAGE_HELPER)); skyFunctions.put( WorkspaceFileValue.WORKSPACE_FILE, new WorkspaceFileFunction( TestRuleClassProvider.getRuleClassProvider(), TestPackageFactoryBuilderFactory.getInstance() .builder(directories) .build(TestRuleClassProvider.getRuleClassProvider(), fs), directories, /* bzlLoadFunctionForInlining= */ null)); skyFunctions.put( SkyFunctions.EXTERNAL_PACKAGE, new ExternalPackageFunction(BazelSkyframeExecutorConstants.EXTERNAL_PACKAGE_HELPER)); differencer = new SequencedRecordingDifferencer(); evaluator = new InMemoryMemoizingEvaluator(skyFunctions.buildOrThrow(), differencer); PrecomputedValue.BUILD_ID.set(differencer, UUID.randomUUID()); PrecomputedValue.PATH_PACKAGE_LOCATOR.set(differencer, pkgLocator.get()); } @Before public void setupModifiedOutputReceiverMock() { doNothing() .when(mockModifiedOutputsReceiver) .reportModifiedOutputFile(anyLong(), modifiedOutputsCaptor.capture()); } public static ImmutableList batchStatModes() { return Arrays.stream(BatchStatMode.values()) .map(mode -> new BatchStatMode[] {mode}) .collect(toImmutableList()); } @Test public void getDirtyActionValues_unchangedEmptyTreeArtifactWithArchivedFile_noDirtyKeys() throws Exception { SpecialArtifact treeArtifact = createTreeArtifact("dir"); treeArtifact.getPath().createDirectoryAndParents(); ActionExecutionValue actionExecutionValue = actionValueWithTreeArtifacts( ImmutableList.of(), ImmutableList.of(createArchivedTreeArtifactWithContent(treeArtifact))); assertThat(getDirtyActionValues(actionExecutionValue)).isEmpty(); } @Test public void getDirtyActionValues_unchangedTreeArtifactWithArchivedFile_noDirtyKeys() throws Exception { SpecialArtifact treeArtifact = createTreeArtifact("dir"); ActionExecutionValue actionExecutionValue = actionValueWithTreeArtifacts( ImmutableList.of( createTreeFileArtifactWithContent(treeArtifact, "file1", "content"), createTreeFileArtifactWithContent(treeArtifact, "file2", "content2")), ImmutableList.of(createArchivedTreeArtifactWithContent(treeArtifact))); assertThat(getDirtyActionValues(actionExecutionValue)).isEmpty(); } @Test public void getDirtyActionValues_editedArchivedFileForEmptyTreeArtifact_reportsChange() throws Exception { SpecialArtifact treeArtifact = createTreeArtifact("dir"); treeArtifact.getPath().createDirectoryAndParents(); ArchivedTreeArtifact archivedTreeArtifact = createArchivedTreeArtifactWithContent(treeArtifact, "old content"); ActionExecutionValue actionExecutionValue = actionValueWithTreeArtifacts(ImmutableList.of(), ImmutableList.of(archivedTreeArtifact)); writeFile(archivedTreeArtifact.getPath(), "new content"); assertThat(getDirtyActionValues(actionExecutionValue)).containsExactly(ACTION_LOOKUP_DATA); } @Test public void getDirtyActionValues_editedArchivedFileForTreeArtifact_reportsChange() throws Exception { SpecialArtifact treeArtifact = createTreeArtifact("dir"); ArchivedTreeArtifact archivedTreeArtifact = createArchivedTreeArtifactWithContent(treeArtifact, "old content"); ActionExecutionValue actionExecutionValue = actionValueWithTreeArtifacts( ImmutableList.of( createTreeFileArtifactWithContent( treeArtifact, /* parentRelativePath= */ "file1", "content"), createTreeFileArtifactWithContent( treeArtifact, /* parentRelativePath= */ "file2", "content2")), ImmutableList.of(archivedTreeArtifact)); writeFile(archivedTreeArtifact.getPath(), "new content"); assertThat(getDirtyActionValues(actionExecutionValue)).containsExactly(ACTION_LOOKUP_DATA); } @Test public void getDirtyActionValues_deletedArchivedFileForTreeArtifact_reportsChange() throws Exception { SpecialArtifact treeArtifact = createTreeArtifact("dir"); ArchivedTreeArtifact archivedTreeArtifact = createArchivedTreeArtifactWithContent(treeArtifact); ActionExecutionValue actionExecutionValue = actionValueWithTreeArtifacts( ImmutableList.of( createTreeFileArtifactWithContent( treeArtifact, /* parentRelativePath= */ "file1", "content"), createTreeFileArtifactWithContent( treeArtifact, /* parentRelativePath= */ "file2", "content2")), ImmutableList.of(archivedTreeArtifact)); archivedTreeArtifact.getPath().delete(); assertThat(getDirtyActionValues(actionExecutionValue)).containsExactly(ACTION_LOOKUP_DATA); } @Test public void getDirtyActionValues_deletedArchivedFileForEmptyTreeArtifact_reportsChange() throws Exception { SpecialArtifact treeArtifact = createTreeArtifact("dir"); ArchivedTreeArtifact archivedTreeArtifact = createArchivedTreeArtifactWithContent(treeArtifact); ActionExecutionValue actionExecutionValue = actionValueWithTreeArtifacts(ImmutableList.of(), ImmutableList.of(archivedTreeArtifact)); archivedTreeArtifact.getPath().delete(); assertThat(getDirtyActionValues(actionExecutionValue)).containsExactly(ACTION_LOOKUP_DATA); } @Test public void getDirtyActionValues_editedFileForTreeArtifactWithArchivedFile_reportsChange() throws Exception { SpecialArtifact treeArtifact = createTreeArtifact("dir"); TreeFileArtifact child1 = createTreeFileArtifactWithContent( treeArtifact, /* parentRelativePath= */ "file1", "old content"); ActionExecutionValue actionExecutionValue = actionValueWithTreeArtifacts( ImmutableList.of( child1, createTreeFileArtifactWithContent( treeArtifact, /* parentRelativePath= */ "file2", "content2")), ImmutableList.of(createArchivedTreeArtifactWithContent(treeArtifact))); writeFile(child1.getPath(), "new content"); assertThat(getDirtyActionValues(actionExecutionValue)).containsExactly(ACTION_LOOKUP_DATA); } @Test public void getDirtyActionValues_treeArtifactWithArchivedArtifact_reportsOnlyChangedKey() throws Exception { SpecialArtifact unchangedTreeArtifact = createTreeArtifact("dir1"); ActionExecutionValue unchangedValue = actionValueWithTreeArtifacts( ImmutableList.of(createTreeFileArtifactWithContent(unchangedTreeArtifact, "child")), ImmutableList.of(createArchivedTreeArtifactWithContent(unchangedTreeArtifact))); SpecialArtifact changedTreeArtifact = createTreeArtifact("dir2"); ArchivedTreeArtifact changedArchivedTreeArtifact = createArchivedTreeArtifactWithContent(changedTreeArtifact, "old content"); ActionExecutionValue changedValue = actionValueWithTreeArtifacts( ImmutableList.of( createTreeFileArtifactWithContent(changedTreeArtifact, "file", "content")), ImmutableList.of(changedArchivedTreeArtifact)); writeFile(changedArchivedTreeArtifact.getPath(), "new content"); assertThat( getDirtyActionValues( ImmutableMap.of( actionLookupData(0), unchangedValue, actionLookupData(1), changedValue))) .containsExactly(actionLookupData(1)); } private Collection getDirtyActionValues(ActionExecutionValue actionExecutionValue) throws InterruptedException { return getDirtyActionValues(ImmutableMap.of(ACTION_LOOKUP_DATA, actionExecutionValue)); } private Collection getDirtyActionValues(ImmutableMap valuesMap) throws InterruptedException { return new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( valuesMap, batchStat.getBatchStat(fs), ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {}); } private TreeFileArtifact createTreeFileArtifactWithContent( SpecialArtifact treeArtifact, String parentRelativePath, String... contentLines) throws IOException { TreeFileArtifact artifact = TreeFileArtifact.createTreeOutput(treeArtifact, parentRelativePath); writeFile(artifact.getPath(), contentLines); return artifact; } private ArchivedTreeArtifact createArchivedTreeArtifactWithContent( SpecialArtifact treeArtifact, String... contentLines) throws IOException { ArchivedTreeArtifact artifact = ArchivedTreeArtifact.createForTree(treeArtifact); writeFile(artifact.getPath(), contentLines); return artifact; } private static ActionLookupData actionLookupData(int actionIndex) { return ActionLookupData.create(ACTION_LOOKUP_KEY, actionIndex); } @Test public void testEmpty() throws Exception { FilesystemValueChecker checker = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); } @Test public void testSimple() throws Exception { FilesystemValueChecker checker = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST); Path path = fs.getPath("/foo"); FileSystemUtils.createEmptyFile(path); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); SkyKey skyKey = FileStateValue.key( RootedPath.toRootedPath(Root.absoluteRoot(fs), PathFragment.create("/foo"))); EvaluationResult result = evaluator.evaluate(ImmutableList.of(skyKey), EVALUATION_OPTIONS); assertThat(result.hasError()).isFalse(); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); FileSystemUtils.writeContentAsLatin1(path, "hello"); assertDiffWithNewValues(getDirtyFilesystemKeys(evaluator, checker), skyKey); // The dirty bits are not reset until the FileValues are actually revalidated. assertDiffWithNewValues(getDirtyFilesystemKeys(evaluator, checker), skyKey); differencer.invalidate(ImmutableList.of(skyKey)); result = evaluator.evaluate(ImmutableList.of(skyKey), EVALUATION_OPTIONS); assertThat(result.hasError()).isFalse(); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); } /** * Tests that an already-invalidated value can still be marked changed: symlink points at sym1. * Invalidate symlink by changing sym1 from pointing at path to point to sym2. This only dirties * (rather than changes) symlink because sym2 still points at path, so all symlink stats remain * the same. Then do a null build, change sym1 back to point at path, and change symlink to not be * a symlink anymore. The fact that it is not a symlink should be detected. */ @Test public void testDirtySymlink() throws Exception { FilesystemValueChecker checker = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST); Path path = fs.getPath("/foo"); FileSystemUtils.writeContentAsLatin1(path, "foo contents"); // We need the intermediate sym1 and sym2 so that we can dirty a child of symlink without // actually changing the FileValue calculated for symlink (if we changed the contents of foo, // the FileValue created for symlink would notice, since it stats foo). Path sym1 = fs.getPath("/sym1"); Path sym2 = fs.getPath("/sym2"); Path symlink = fs.getPath("/bar"); FileSystemUtils.ensureSymbolicLink(symlink, sym1); FileSystemUtils.ensureSymbolicLink(sym1, path); FileSystemUtils.ensureSymbolicLink(sym2, path); SkyKey fooKey = FileValue.key(RootedPath.toRootedPath(Root.absoluteRoot(fs), PathFragment.create("/foo"))); RootedPath symlinkRootedPath = RootedPath.toRootedPath(Root.absoluteRoot(fs), PathFragment.create("/bar")); SkyKey symlinkKey = FileValue.key(symlinkRootedPath); SkyKey symlinkFileStateKey = FileStateValue.key(symlinkRootedPath); RootedPath sym1RootedPath = RootedPath.toRootedPath(Root.absoluteRoot(fs), PathFragment.create("/sym1")); SkyKey sym1FileStateKey = FileStateValue.key(sym1RootedPath); Iterable allKeys = ImmutableList.of(symlinkKey, fooKey); // First build -- prime the graph. EvaluationResult result = evaluator.evaluate(allKeys, EVALUATION_OPTIONS); assertThat(result.hasError()).isFalse(); FileValue symlinkValue = result.get(symlinkKey); FileValue fooValue = result.get(fooKey); assertWithMessage(symlinkValue.toString()).that(symlinkValue.isSymlink()).isTrue(); // Digest is not always available, so use size as a proxy for contents. assertThat(symlinkValue.getSize()).isEqualTo(fooValue.getSize()); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); // Before second build, move sym1 to point to sym2. assertThat(sym1.delete()).isTrue(); FileSystemUtils.ensureSymbolicLink(sym1, sym2); assertDiffWithNewValues(getDirtyFilesystemKeys(evaluator, checker), sym1FileStateKey); differencer.invalidate(ImmutableList.of(sym1FileStateKey)); result = evaluator.evaluate(ImmutableList.of(), EVALUATION_OPTIONS); assertThat(result.hasError()).isFalse(); assertDiffWithNewValues(getDirtyFilesystemKeys(evaluator, checker), sym1FileStateKey); // Before third build, move sym1 back to original (so change pruning will prevent signaling of // its parents, but change symlink for real. assertThat(sym1.delete()).isTrue(); FileSystemUtils.ensureSymbolicLink(sym1, path); assertThat(symlink.delete()).isTrue(); FileSystemUtils.writeContentAsLatin1(symlink, "new symlink contents"); assertDiffWithNewValues(getDirtyFilesystemKeys(evaluator, checker), symlinkFileStateKey); differencer.invalidate(ImmutableList.of(symlinkFileStateKey)); result = evaluator.evaluate(allKeys, EVALUATION_OPTIONS); assertThat(result.hasError()).isFalse(); symlinkValue = result.get(symlinkKey); assertWithMessage(symlinkValue.toString()).that(symlinkValue.isSymlink()).isFalse(); assertThat(result.get(fooKey)).isEqualTo(fooValue); assertThat(symlinkValue.getSize()).isNotEqualTo(fooValue.getSize()); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); } @Test public void testExplicitFiles() throws Exception { FilesystemValueChecker checker = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST); Path path1 = fs.getPath("/foo1"); Path path2 = fs.getPath("/foo2"); FileSystemUtils.createEmptyFile(path1); FileSystemUtils.createEmptyFile(path2); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); SkyKey key1 = FileStateValue.key( RootedPath.toRootedPath(Root.absoluteRoot(fs), PathFragment.create("/foo1"))); SkyKey key2 = FileStateValue.key( RootedPath.toRootedPath(Root.absoluteRoot(fs), PathFragment.create("/foo2"))); Iterable skyKeys = ImmutableList.of(key1, key2); EvaluationResult result = evaluator.evaluate(skyKeys, EVALUATION_OPTIONS); assertThat(result.hasError()).isFalse(); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); // Wait for the timestamp granularity to elapse, so updating the files will observably advance // their ctime. TimestampGranularityUtils.waitForTimestampGranularity( System.currentTimeMillis(), OutErr.SYSTEM_OUT_ERR); // Update path1's contents. This will update the file's ctime with current time indicated by the // clock. fs.advanceClockMillis(1); FileSystemUtils.writeContentAsLatin1(path1, "hello1"); // Update path2's mtime but not its contents. We expect that an mtime change suffices to update // the ctime. path2.setLastModifiedTime(42); // Assert that both files changed. The change detection relies, among other things, on ctime // change. assertDiffWithNewValues(getDirtyFilesystemKeys(evaluator, checker), key1, key2); differencer.invalidate(skyKeys); result = evaluator.evaluate(skyKeys, EVALUATION_OPTIONS); assertThat(result.hasError()).isFalse(); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); } @Test public void testFileWithIOExceptionNotConsideredDirty() throws Exception { Path path = fs.getPath("/testroot/foo"); path.getParentDirectory().createDirectory(); path.createSymbolicLink(PathFragment.create("bar")); fs.readlinkThrowsIoException = true; SkyKey fileKey = FileStateValue.key( RootedPath.toRootedPath(Root.fromPath(pkgRoot), PathFragment.create("foo"))); EvaluationResult result = evaluator.evaluate(ImmutableList.of(fileKey), EVALUATION_OPTIONS); assertThat(result.hasError()).isTrue(); fs.readlinkThrowsIoException = false; FilesystemValueChecker checker = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST); Diff diff = getDirtyFilesystemKeys(evaluator, checker); assertThat(diff.changedKeysWithoutNewValues()).isEmpty(); assertThat(diff.changedKeysWithNewValues()).isEmpty(); } @Test public void testFilesInCycleNotConsideredDirty() throws Exception { Path path1 = pkgRoot.getRelative("foo1"); Path path2 = pkgRoot.getRelative("foo2"); Path path3 = pkgRoot.getRelative("foo3"); FileSystemUtils.ensureSymbolicLink(path1, path2); FileSystemUtils.ensureSymbolicLink(path2, path3); FileSystemUtils.ensureSymbolicLink(path3, path1); SkyKey fileKey1 = FileValue.key(RootedPath.toRootedPath(Root.fromPath(pkgRoot), path1)); EvaluationResult result = evaluator.evaluate(ImmutableList.of(fileKey1), EVALUATION_OPTIONS); assertThat(result.hasError()).isTrue(); FilesystemValueChecker checker = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST); Diff diff = getDirtyFilesystemKeys(evaluator, checker); assertThat(diff.changedKeysWithoutNewValues()).isEmpty(); assertThat(diff.changedKeysWithNewValues()).isEmpty(); } public void checkDirtyActions(BatchStat batchStatter) throws Exception { Artifact out1 = createDerivedArtifact("fiz"); Artifact out2 = createDerivedArtifact("pop"); FileSystemUtils.writeContentAsLatin1(out1.getPath(), "hello"); FileSystemUtils.writeContentAsLatin1(out2.getPath(), "fizzlepop"); TimestampGranularityMonitor tsgm = new TimestampGranularityMonitor(BlazeClock.instance()); SkyKey actionKey1 = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SkyKey actionKey2 = ActionLookupData.create(ACTION_LOOKUP_KEY, 1); pretendBuildTwoArtifacts(out1, actionKey1, out2, actionKey2, batchStatter, tsgm); // Change the file but not its size FileSystemUtils.writeContentAsLatin1(out1.getPath(), "hallo"); checkActionDirtiedByFile(out1, actionKey1, batchStatter, tsgm); pretendBuildTwoArtifacts(out1, actionKey1, out2, actionKey2, batchStatter, tsgm); // Now try with a different size FileSystemUtils.writeContentAsLatin1(out1.getPath(), "hallo2"); checkActionDirtiedByFile(out1, actionKey1, batchStatter, tsgm); } private void pretendBuildTwoArtifacts( Artifact out1, SkyKey actionKey1, Artifact out2, SkyKey actionKey2, BatchStat batchStatter, TimestampGranularityMonitor tsgm) throws InterruptedException { EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); tsgm.setCommandStartTime(); differencer.inject( ImmutableMap.of( actionKey1, Delta.justNew( actionValue( new TestAction( Runnables.doNothing(), NestedSetBuilder.emptySet(Order.STABLE_ORDER), ImmutableSet.of(out1)))), actionKey2, Delta.justNew( actionValue( new TestAction( Runnables.doNothing(), NestedSetBuilder.emptySet(Order.STABLE_ORDER), ImmutableSet.of(out2)))))); assertThat(evaluator.evaluate(ImmutableList.of(), evaluationContext).hasError()).isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {})) .isEmpty(); tsgm.waitForTimestampGranularity(OutErr.SYSTEM_OUT_ERR); } private void checkActionDirtiedByFile( Artifact file, SkyKey actionKey, BatchStat batchStatter, TimestampGranularityMonitor tsgm) throws InterruptedException { assertThat( new FilesystemValueChecker(tsgm, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {})) .containsExactly(actionKey); assertThat( new FilesystemValueChecker(tsgm, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStatter, ModifiedFileSet.EVERYTHING_DELETED, RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {})) .containsExactly(actionKey); assertThat( new FilesystemValueChecker(tsgm, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStatter, new ModifiedFileSet.Builder().modify(file.getExecPath()).build(), RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {})) .containsExactly(actionKey); assertThat( new FilesystemValueChecker(tsgm, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStatter, new ModifiedFileSet.Builder() .modify(file.getExecPath().getParentDirectory()) .build(), RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {})) .isEmpty(); assertThat( new FilesystemValueChecker(tsgm, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStatter, ModifiedFileSet.NOTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {})) .isEmpty(); } enum ModifiedSetReporting { EVERYTHING_MODIFIED { @Override ModifiedFileSet getModifiedFileSet(PathFragment path) { return ModifiedFileSet.EVERYTHING_MODIFIED; } }, EVERYTHING_DELETED { @Override ModifiedFileSet getModifiedFileSet(PathFragment path) { return ModifiedFileSet.EVERYTHING_DELETED; } }, SINGLE_PATH { @Override ModifiedFileSet getModifiedFileSet(PathFragment path) { return ModifiedFileSet.builder().modify(path).build(); } }; abstract ModifiedFileSet getModifiedFileSet(PathFragment path); } @Test public void getDirtyActionValues_touchedTreeDirectory_returnsEmptyDiff( @TestParameter({"", "subdir"}) String touchedTreePath, @TestParameter ModifiedSetReporting modifiedSet) throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); TreeFileArtifact treeFile = TreeFileArtifact.createTreeOutput(tree, "subdir/file"); FileSystemUtils.writeIsoLatin1(treeFile.getPath(), "text"); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifacts(ImmutableList.of(treeFile)))); evaluate(); FileSystemUtils.touchFile(tree.getPath().getRelative(touchedTreePath)); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), modifiedSet.getModifiedFileSet(tree.getExecPath()), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).isEmpty(); assertThat(modifiedOutputsCaptor.getAllValues()).isEmpty(); } @Test public void getDirtyActionValues_deleteEmptyTreeDirectory_returnsTreeKey( @TestParameter ModifiedSetReporting modifiedSet) throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); tree.getPath().createDirectoryAndParents(); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifact(tree, TreeArtifactValue.empty()))); evaluate(); assertThat(tree.getPath().delete()).isTrue(); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), modifiedSet.getModifiedFileSet(tree.getExecPath()), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(actionKey); assertThat(modifiedOutputsCaptor.getAllValues()).containsExactly(tree); } @Test public void getDirtyActionValues_treeDirectoryReplacedWithSymlink_returnsTreeKey() throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); tree.getPath().createDirectoryAndParents(); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifact(tree, TreeArtifactValue.empty()))); evaluate(); Path dummyEmptyDir = fs.getPath("/bin").getRelative("dir"); dummyEmptyDir.createDirectoryAndParents(); assertThat(tree.getPath().delete()).isTrue(); tree.getPath().createSymbolicLink(dummyEmptyDir); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(actionKey); assertThat(modifiedOutputsCaptor.getAllValues()).containsExactly(tree); } @Test public void getDirtyActionValues_modifiedTreeFile_returnsTreeKey( @TestParameter ModifiedSetReporting modifiedSet) throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); TreeFileArtifact treeFile = TreeFileArtifact.createTreeOutput(tree, "file"); FileSystemUtils.writeIsoLatin1(treeFile.getPath(), "text"); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifacts(ImmutableList.of(treeFile)))); evaluate(); FileSystemUtils.writeIsoLatin1(treeFile.getPath(), "other text"); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), modifiedSet.getModifiedFileSet(treeFile.getExecPath()), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(actionKey); assertThat(modifiedOutputsCaptor.getAllValues()).containsExactly(treeFile); } @Test public void getDirtyActionValues_addedTreeFile_returnsTreeKey( @TestParameter ModifiedSetReporting modifiedSet) throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); TreeFileArtifact treeFile = TreeFileArtifact.createTreeOutput(tree, "file1"); FileSystemUtils.writeIsoLatin1(treeFile.getPath()); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifacts(ImmutableList.of(treeFile)))); evaluate(); TreeFileArtifact newFile = TreeFileArtifact.createTreeOutput(tree, "file2"); FileSystemUtils.writeIsoLatin1(newFile.getPath()); Collection dirtyActionValues = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), modifiedSet.getModifiedFileSet(newFile.getExecPath()), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionValues).containsExactly(actionKey); assertThat(modifiedOutputsCaptor.getAllValues()).containsExactly(tree); } @Test public void getDirtyActionValues_addedTreeFileToEmptyTree_returnsTreeKey( @TestParameter ModifiedSetReporting modifiedSet) throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); tree.getPath().createDirectoryAndParents(); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifact(tree, TreeArtifactValue.empty()))); evaluate(); TreeFileArtifact newFile = TreeFileArtifact.createTreeOutput(tree, "file"); FileSystemUtils.writeIsoLatin1(newFile.getPath()); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), modifiedSet.getModifiedFileSet(newFile.getExecPath()), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(actionKey); assertThat(modifiedOutputsCaptor.getAllValues()).containsExactly(tree); } @Test public void getDirtyActionValues_deletedTreeFile_returnsTreeKey( @TestParameter ModifiedSetReporting modifiedSet) throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); TreeFileArtifact treeFile = TreeFileArtifact.createTreeOutput(tree, "file"); FileSystemUtils.writeIsoLatin1(treeFile.getPath()); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifacts(ImmutableList.of(treeFile)))); evaluate(); assertThat(treeFile.getPath().delete()).isTrue(); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), modifiedSet.getModifiedFileSet(treeFile.getExecPath()), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(actionKey); assertThat(modifiedOutputsCaptor.getAllValues()).containsExactly(treeFile, tree); } @Test public void getDirtyActionValues_everythingModified_returnsAllKeys() throws Exception { SpecialArtifact tree1 = createTreeArtifact("tree1"); TreeFileArtifact tree1File = TreeFileArtifact.createTreeOutput(tree1, "file"); FileSystemUtils.writeIsoLatin1(tree1File.getPath(), "text"); SpecialArtifact tree2 = createTreeArtifact("tree2"); TreeFileArtifact tree2File = TreeFileArtifact.createTreeOutput(tree2, "file"); FileSystemUtils.writeIsoLatin1(tree2File.getPath()); SkyKey actionKey1 = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SkyKey actionKey2 = ActionLookupData.create(ACTION_LOOKUP_KEY, 1); differencer.inject( ImmutableMap.of( actionKey1, actionValueWithTreeArtifacts(ImmutableList.of(tree1File)), actionKey2, actionValueWithTreeArtifacts(ImmutableList.of(tree2File)))); evaluate(); FileSystemUtils.writeIsoLatin1(tree1File.getPath(), "new text"); assertThat(tree2File.getPath().delete()).isTrue(); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(actionKey1, actionKey2); assertThat(modifiedOutputsCaptor.getAllValues()).containsExactly(tree1File, tree2, tree2File); } @Test public void getDirtyActionValues_changedFileNotInModifiedSet_returnsKeysFromSetOnly( @TestParameter boolean reportFirst) throws Exception { SpecialArtifact tree1 = createTreeArtifact("tree1"); TreeFileArtifact tree1File = TreeFileArtifact.createTreeOutput(tree1, "file"); FileSystemUtils.writeIsoLatin1(tree1File.getPath(), "text"); SpecialArtifact tree2 = createTreeArtifact("tree2"); TreeFileArtifact tree2File = TreeFileArtifact.createTreeOutput(tree2, "file"); FileSystemUtils.writeIsoLatin1(tree2File.getPath()); SkyKey actionKey1 = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SkyKey actionKey2 = ActionLookupData.create(ACTION_LOOKUP_KEY, 1); differencer.inject( ImmutableMap.of( actionKey1, actionValueWithTreeArtifacts(ImmutableList.of(tree1File)), actionKey2, actionValueWithTreeArtifacts(ImmutableList.of(tree2File)))); evaluate(); FileSystemUtils.writeIsoLatin1(tree1File.getPath(), "new text"); assertThat(tree2File.getPath().delete()).isTrue(); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), ModifiedFileSet.builder() .modify((reportFirst ? tree1File : tree2File).getExecPath()) .build(), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(reportFirst ? actionKey1 : actionKey2); assertThat(modifiedOutputsCaptor.getAllValues()) .containsExactlyElementsIn( reportFirst ? ImmutableList.of(tree1File) : ImmutableList.of(tree2File, tree2)); } @Test public void getDirtyActionValues_middleFileSkippedInModifiedFileSet_returnsKeysFromSetOnly() throws Exception { SpecialArtifact treeA = createTreeArtifact("a_tree"); TreeFileArtifact treeAFile = TreeFileArtifact.createTreeOutput(treeA, "file"); FileSystemUtils.writeIsoLatin1(treeAFile.getPath()); SpecialArtifact treeB = createTreeArtifact("b_tree"); TreeFileArtifact treeBFile = TreeFileArtifact.createTreeOutput(treeB, "file"); FileSystemUtils.writeIsoLatin1(treeBFile.getPath()); SpecialArtifact treeC = createTreeArtifact("c_tree"); TreeFileArtifact treeCFile = TreeFileArtifact.createTreeOutput(treeC, "file"); FileSystemUtils.writeIsoLatin1(treeCFile.getPath()); SkyKey actionKey1 = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SkyKey actionKey2 = ActionLookupData.create(ACTION_LOOKUP_KEY, 1); SkyKey actionKey3 = ActionLookupData.create(ACTION_LOOKUP_KEY, 2); differencer.inject( ImmutableMap.of( actionKey1, actionValueWithTreeArtifacts(ImmutableList.of(treeAFile)), actionKey2, actionValueWithTreeArtifacts(ImmutableList.of(treeBFile)), actionKey3, actionValueWithTreeArtifacts(ImmutableList.of(treeCFile)))); evaluate(); assertThat(treeAFile.getPath().delete()).isTrue(); assertThat(treeBFile.getPath().delete()).isTrue(); assertThat(treeCFile.getPath().delete()).isTrue(); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), ModifiedFileSet.builder() .modify(treeAFile.getExecPath()) .modify(treeCFile.getExecPath()) .build(), RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).containsExactly(actionKey1, actionKey3); assertThat(modifiedOutputsCaptor.getAllValues()) .containsExactly(treeAFile, treeA, treeCFile, treeC); } @Test public void getDirtyActionValues_nothingModified_returnsEmptyDiff() throws Exception { SpecialArtifact tree = createTreeArtifact("tree"); TreeFileArtifact treeFile = TreeFileArtifact.createTreeOutput(tree, "file"); FileSystemUtils.writeIsoLatin1(treeFile.getPath()); SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); differencer.inject( ImmutableMap.of(actionKey, actionValueWithTreeArtifacts(ImmutableList.of(treeFile)))); evaluate(); assertThat(treeFile.getPath().delete()).isTrue(); Collection dirtyActionKeys = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), batchStat.getBatchStat(fs), ModifiedFileSet.NOTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, mockModifiedOutputsReceiver); assertThat(dirtyActionKeys).isEmpty(); assertThat(modifiedOutputsCaptor.getAllValues()).isEmpty(); } private void evaluate() throws InterruptedException { EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat(evaluator.evaluate(ImmutableList.of(), evaluationContext).hasError()).isFalse(); } private Artifact createDerivedArtifact(String relPath) throws IOException { String outSegment = "bin"; Path outputPath = fs.getPath("/" + outSegment); outputPath.createDirectory(); return ActionsTestUtil.createArtifact( ArtifactRoot.asDerivedRoot(fs.getPath("/"), RootType.Output, outSegment), outputPath.getRelative(relPath)); } @Test // TODO(b/154337187): Remove the following annotation to re-enable once this test is de-flaked. @Ignore("b/154337187") public void testDirtyActions() throws Exception { checkDirtyActions(null); } @Test // TODO(b/154337187): Remove the following annotation to re-enable once this test is de-flaked. @Ignore("b/154337187") public void testDirtyActionsBatchStat() throws Exception { checkDirtyActions( new BatchStat() { @Override public List batchStat( boolean useDigest, boolean includeLinks, Iterable paths) throws IOException { List stats = new ArrayList<>(); for (PathFragment pathFrag : paths) { stats.add( FileStatusWithDigestAdapter.maybeAdapt( fs.getPath("/").getRelative(pathFrag).statIfFound(Symlinks.NOFOLLOW))); } return stats; } }); } @Test // TODO(b/154337187): Remove the following annotation to re-enable once this test is de-flaked. @Ignore("b/154337187") public void testDirtyActionsBatchStatWithDigest() throws Exception { checkDirtyActions( new BatchStat() { @Override public List batchStat( boolean useDigest, boolean includeLinks, Iterable paths) throws IOException { List stats = new ArrayList<>(); for (PathFragment pathFrag : paths) { final Path path = fs.getPath("/").getRelative(pathFrag); stats.add(statWithDigest(path, path.statIfFound(Symlinks.NOFOLLOW))); } return stats; } }); } @Test // TODO(b/154337187): Remove the following annotation to re-enable once this test is de-flaked. @Ignore("b/154337187") public void testDirtyActionsBatchStatFallback() throws Exception { checkDirtyActions( new BatchStat() { @Override public List batchStat( boolean useDigest, boolean includeLinks, Iterable paths) throws IOException { throw new IOException("try again"); } }); } // TODO(bazel-team): Add some tests for FileSystemValueChecker#changedKeys*() methods. // Presently these appear to be untested. private static ActionExecutionValue actionValue(Action action) { Map artifactData = new HashMap<>(); for (Artifact output : action.getOutputs()) { try { Path path = output.getPath(); FileArtifactValue noDigest = ActionMetadataHandler.fileArtifactValueFromArtifact( output, FileStatusWithDigestAdapter.maybeAdapt(path.statIfFound(Symlinks.NOFOLLOW)), SyscallCache.NO_CACHE, null); FileArtifactValue withDigest = FileArtifactValue.createFromInjectedDigest(noDigest, path.getDigest()); artifactData.put(output, withDigest); } catch (IOException e) { throw new IllegalStateException(e); } } return ActionsTestUtil.createActionExecutionValue(ImmutableMap.copyOf(artifactData)); } private static Delta actionValueWithTreeArtifact(SpecialArtifact output, TreeArtifactValue tree) { return Delta.justNew( ActionsTestUtil.createActionExecutionValue( /* artifactData= */ ImmutableMap.of(), ImmutableMap.of(output, tree))); } private static Delta actionValueWithRemoteArtifact( Artifact output, RemoteFileArtifactValue value) { return Delta.justNew( ActionsTestUtil.createActionExecutionValue(ImmutableMap.of(output, value))); } private RemoteFileArtifactValue createRemoteFileArtifactValue(String contents) { return createRemoteFileArtifactValue(contents, /* expireAtEpochMilli= */ -1); } private RemoteFileArtifactValue createRemoteFileArtifactValue( String contents, long expireAtEpochMilli) { byte[] data = contents.getBytes(); DigestHashFunction hashFn = fs.getDigestFunction(); HashCode hash = hashFn.getHashFunction().hashBytes(data); return RemoteFileArtifactValue.create(hash.asBytes(), data.length, -1, expireAtEpochMilli); } @Test public void testRemoteAndLocalArtifacts() throws Exception { // Test that injected remote artifacts are trusted by the FileSystemValueChecker // if it is configured to trust remote artifacts, and that local files always take precedence // over remote files. SkyKey actionKey1 = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SkyKey actionKey2 = ActionLookupData.create(ACTION_LOOKUP_KEY, 1); Artifact out1 = createDerivedArtifact("foo"); Artifact out2 = createDerivedArtifact("bar"); Map metadataToInject = new HashMap<>(); metadataToInject.put( actionKey1, actionValueWithRemoteArtifact(out1, createRemoteFileArtifactValue("foo-content"))); metadataToInject.put( actionKey2, actionValueWithRemoteArtifact(out2, createRemoteFileArtifactValue("bar-content"))); differencer.inject(metadataToInject); EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat( evaluator .evaluate(ImmutableList.of(actionKey1, actionKey2), evaluationContext) .hasError()) .isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.TRUST_ALL, (ignored, ignored2) -> {})) .isEmpty(); // Create the "out1" artifact on the filesystem and test that it invalidates the generating // action's SkyKey. FileSystemUtils.writeContentAsLatin1(out1.getPath(), "new-foo-content"); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.TRUST_ALL, (ignored, ignored2) -> {})) .containsExactly(actionKey1); } @Test public void testRemoteAndLocalArtifacts_identicalContent() throws Exception { // Test that even if injected remote artifacts and local files are identical, the generating // actions are marked as dirty. SkyKey actionKey1 = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SkyKey actionKey2 = ActionLookupData.create(ACTION_LOOKUP_KEY, 1); Artifact out1 = createDerivedArtifact("foo"); Artifact out2 = createDerivedArtifact("bar"); Map metadataToInject = new HashMap<>(); metadataToInject.put( actionKey1, actionValueWithRemoteArtifact(out1, createRemoteFileArtifactValue("foo-content"))); metadataToInject.put( actionKey2, actionValueWithRemoteArtifact(out2, createRemoteFileArtifactValue("bar-content"))); differencer.inject(metadataToInject); EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat( evaluator .evaluate(ImmutableList.of(actionKey1, actionKey2), evaluationContext) .hasError()) .isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.TRUST_ALL, (ignored, ignored2) -> {})) .isEmpty(); // Create identical "out1" artifact on the filesystem and test that it invalidates the // generating action's SkyKey. FileSystemUtils.writeContentAsLatin1(out1.getPath(), "foo-content"); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.TRUST_ALL, (ignored, ignored2) -> {})) .containsExactly(actionKey1); } @Test public void testRemoteArtifactsExpired() throws Exception { // Test that if injected remote artifacts expired, they are considered as dirty. SkyKey actionKey1 = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SkyKey actionKey2 = ActionLookupData.create(ACTION_LOOKUP_KEY, 1); Artifact out1 = createDerivedArtifact("foo"); Artifact out2 = createDerivedArtifact("bar"); Map metadataToInject = new HashMap<>(); metadataToInject.put( actionKey1, actionValueWithRemoteArtifact(out1, createRemoteFileArtifactValue("foo-content"))); metadataToInject.put( actionKey2, actionValueWithRemoteArtifact( out2, createRemoteFileArtifactValue("bar-content", /* expireAtEpochMilli= */ 0))); differencer.inject(metadataToInject); EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat( evaluator .evaluate(ImmutableList.of(actionKey1, actionKey2), evaluationContext) .hasError()) .isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, CHECK_TTL, (ignored, ignored2) -> {})) .containsExactly(actionKey2); } @Test public void testRemoteAndLocalTreeArtifacts() throws Exception { // Test that injected remote tree artifacts are trusted by the FileSystemValueChecker // and that local files always takes preference over remote files. SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SpecialArtifact treeArtifact = createTreeArtifact("dir"); treeArtifact.getPath().createDirectoryAndParents(); TreeArtifactValue tree = TreeArtifactValue.newBuilder(treeArtifact) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "foo"), createRemoteFileArtifactValue("foo-content")) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "bar"), createRemoteFileArtifactValue("bar-content")) .build(); differencer.inject(ImmutableMap.of(actionKey, actionValueWithTreeArtifact(treeArtifact, tree))); EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat(evaluator.evaluate(ImmutableList.of(actionKey), evaluationContext).hasError()) .isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.TRUST_ALL, (ignored, ignored2) -> {})) .isEmpty(); // Create dir/foo on the local disk and test that it invalidates the associated sky key. TreeFileArtifact fooArtifact = TreeFileArtifact.createTreeOutput(treeArtifact, "foo"); FileSystemUtils.writeContentAsLatin1(fooArtifact.getPath(), "new-foo-content"); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.IGNORE_ALL, (ignored, ignored2) -> {})) .containsExactly(actionKey); } @Test public void testRemoteAndLocalTreeArtifacts_identicalContent() throws Exception { // Test that even if injected remote tree artifacts and local files are identical, the // generating actions are marked as dirty. SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SpecialArtifact treeArtifact = createTreeArtifact("dir"); treeArtifact.getPath().createDirectoryAndParents(); TreeArtifactValue tree = TreeArtifactValue.newBuilder(treeArtifact) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "foo"), createRemoteFileArtifactValue("foo-content")) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "bar"), createRemoteFileArtifactValue("bar-content")) .build(); differencer.inject(ImmutableMap.of(actionKey, actionValueWithTreeArtifact(treeArtifact, tree))); EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat(evaluator.evaluate(ImmutableList.of(actionKey), evaluationContext).hasError()) .isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.TRUST_ALL, (ignored, ignored2) -> {})) .isEmpty(); // Create identical dir/foo on the local disk and test that it invalidates the associated sky // key. TreeFileArtifact fooArtifact = TreeFileArtifact.createTreeOutput(treeArtifact, "foo"); FileSystemUtils.writeContentAsLatin1(fooArtifact.getPath(), "foo-content"); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, RemoteArtifactChecker.TRUST_ALL, (ignored, ignored2) -> {})) .containsExactly(actionKey); } @Test public void testRemoteTreeArtifactsExpired() throws Exception { // Test that if injected remote tree artifacts are expired, they are considered as dirty. SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SpecialArtifact treeArtifact = createTreeArtifact("dir"); treeArtifact.getPath().createDirectoryAndParents(); TreeArtifactValue tree = TreeArtifactValue.newBuilder(treeArtifact) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "foo"), createRemoteFileArtifactValue("foo-content")) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "bar"), createRemoteFileArtifactValue("bar-content", /* expireAtEpochMilli= */ 0)) .build(); differencer.inject(ImmutableMap.of(actionKey, actionValueWithTreeArtifact(treeArtifact, tree))); EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat(evaluator.evaluate(ImmutableList.of(actionKey), evaluationContext).hasError()) .isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, CHECK_TTL, (ignored, ignored2) -> {})) .containsExactly(actionKey); } @Test public void testRemoteTreeArtifacts_archivedRepresentationExpired() throws Exception { // Test that if archived representation of injected remote tree artifacts are expired, they are // considered as dirty. SkyKey actionKey = ActionLookupData.create(ACTION_LOOKUP_KEY, 0); SpecialArtifact treeArtifact = createTreeArtifact("dir"); treeArtifact.getPath().createDirectoryAndParents(); TreeArtifactValue tree = TreeArtifactValue.newBuilder(treeArtifact) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "foo"), createRemoteFileArtifactValue("foo-content")) .putChild( TreeFileArtifact.createTreeOutput(treeArtifact, "bar"), createRemoteFileArtifactValue("bar-content")) .setArchivedRepresentation( createArchivedTreeArtifactWithContent(treeArtifact), createRemoteFileArtifactValue("archived", /* expireAtEpochMilli= */ 0)) .build(); differencer.inject(ImmutableMap.of(actionKey, actionValueWithTreeArtifact(treeArtifact, tree))); EvaluationContext evaluationContext = EvaluationContext.newBuilder() .setKeepGoing(false) .setParallelism(1) .setEventHandler(NullEventHandler.INSTANCE) .build(); assertThat(evaluator.evaluate(ImmutableList.of(actionKey), evaluationContext).hasError()) .isFalse(); assertThat( new FilesystemValueChecker( /* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST) .getDirtyActionValues( evaluator.getValues(), /* batchStatter= */ null, ModifiedFileSet.EVERYTHING_MODIFIED, CHECK_TTL, (ignored, ignored2) -> {})) .containsExactly(actionKey); } @Test public void testPropagatesRuntimeExceptions() throws Exception { Collection values = ImmutableList.of( FileValue.key( RootedPath.toRootedPath(Root.fromPath(pkgRoot), PathFragment.create("foo")))); evaluator.evaluate(values, EVALUATION_OPTIONS); AtomicReference uncaughtRef = new AtomicReference<>(); CountDownLatch throwableCaught = new CountDownLatch(1); Thread.UncaughtExceptionHandler uncaughtExceptionHandler = (t, e) -> { uncaughtRef.compareAndSet(null, e); throwableCaught.countDown(); }; Thread.setDefaultUncaughtExceptionHandler(uncaughtExceptionHandler); FilesystemValueChecker checker = new FilesystemValueChecker(/* tsgm= */ null, SyscallCache.NO_CACHE, FSVC_THREADS_FOR_TEST); assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); fs.statThrowsRuntimeException = true; getDirtyFilesystemKeys(evaluator, checker); // Wait for exception handler to trigger (FVC doesn't clean up crashing threads on its own). assertThat(throwableCaught.await(TestUtils.WAIT_TIMEOUT_SECONDS, SECONDS)).isTrue(); Throwable thrown = uncaughtRef.get(); assertThat(thrown).isNotNull(); assertThat(thrown).hasMessageThat().isEqualTo("bork"); assertThat(thrown).isInstanceOf(RuntimeException.class); } private static void assertEmptyDiff(Diff diff) { assertDiffWithNewValues(diff); } private static void assertDiffWithNewValues(Diff diff, SkyKey... keysWithNewValues) { assertThat(diff.changedKeysWithoutNewValues()).isEmpty(); assertThat(diff.changedKeysWithNewValues().keySet()) .containsExactlyElementsIn(Arrays.asList(keysWithNewValues)); } private static FileStatusWithDigest statWithDigest(final Path path, final FileStatus stat) { return new FileStatusWithDigest() { @Nullable @Override public byte[] getDigest() throws IOException { return path.getDigest(); } @Override public boolean isFile() { return stat.isFile(); } @Override public boolean isSpecialFile() { return stat.isSpecialFile(); } @Override public boolean isDirectory() { return stat.isDirectory(); } @Override public boolean isSymbolicLink() { return stat.isSymbolicLink(); } @Override public long getSize() throws IOException { return stat.getSize(); } @Override public long getLastModifiedTime() throws IOException { return stat.getLastModifiedTime(); } @Override public long getLastChangeTime() throws IOException { return stat.getLastChangeTime(); } @Override public long getNodeId() throws IOException { return stat.getNodeId(); } }; } private static Diff getDirtyFilesystemKeys( MemoizingEvaluator evaluator, FilesystemValueChecker checker) throws InterruptedException { return checker.getDirtyKeys( evaluator.getValues(), DirtinessCheckerUtils.createBasicFilesystemDirtinessChecker()); } }