| // 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.truth.Truth.assertThat; |
| import static com.google.common.truth.Truth.assertWithMessage; |
| import static com.google.devtools.build.lib.actions.ActionInputHelper.treeFileArtifact; |
| import static org.junit.Assert.fail; |
| |
| 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.ActionInputHelper; |
| import com.google.devtools.build.lib.actions.ActionLookupValue.ActionLookupKey; |
| import com.google.devtools.build.lib.actions.Artifact; |
| import com.google.devtools.build.lib.actions.Artifact.SpecialArtifact; |
| import com.google.devtools.build.lib.actions.Artifact.SpecialArtifactType; |
| import com.google.devtools.build.lib.actions.Artifact.TreeFileArtifact; |
| import com.google.devtools.build.lib.actions.ArtifactFileMetadata; |
| import com.google.devtools.build.lib.actions.ArtifactOwner; |
| import com.google.devtools.build.lib.actions.ArtifactRoot; |
| 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.util.TestAction; |
| import com.google.devtools.build.lib.analysis.BlazeDirectories; |
| import com.google.devtools.build.lib.analysis.ServerDirectories; |
| import com.google.devtools.build.lib.cmdline.PackageIdentifier; |
| import com.google.devtools.build.lib.events.NullEventHandler; |
| import com.google.devtools.build.lib.packages.WorkspaceFileValue; |
| import com.google.devtools.build.lib.pkgcache.PathPackageLocator; |
| import com.google.devtools.build.lib.skyframe.DirtinessCheckerUtils.BasicFilesystemDirtinessChecker; |
| import com.google.devtools.build.lib.skyframe.ExternalFilesHelper.ExternalFileAction; |
| import com.google.devtools.build.lib.skyframe.PackageLookupFunction.CrossRepositoryLabelViolationStrategy; |
| import com.google.devtools.build.lib.testutil.TestConstants; |
| import com.google.devtools.build.lib.testutil.TestRuleClassProvider; |
| 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.FileStatus; |
| import com.google.devtools.build.lib.vfs.FileStatusWithDigest; |
| import com.google.devtools.build.lib.vfs.FileStatusWithDigestAdapter; |
| 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.UnixGlob; |
| import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem; |
| import com.google.devtools.build.skyframe.Differencer.Diff; |
| 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.SequentialBuildDriver; |
| 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 java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.UUID; |
| import java.util.concurrent.atomic.AtomicReference; |
| import javax.annotation.Nullable; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** |
| * Tests for {@link FilesystemValueChecker}. |
| */ |
| @RunWith(JUnit4.class) |
| public class FilesystemValueCheckerTest { |
| private static final EvaluationContext EVALUATION_OPTIONS = |
| EvaluationContext.newBuilder() |
| .setKeepGoing(false) |
| .setNumThreads(SkyframeExecutor.DEFAULT_THREAD_COUNT) |
| .setEventHander(NullEventHandler.INSTANCE) |
| .build(); |
| |
| private RecordingDifferencer differencer; |
| private MemoizingEvaluator evaluator; |
| private SequentialBuildDriver driver; |
| private MockFileSystem fs; |
| private Path pkgRoot; |
| |
| @Before |
| public final void setUp() throws Exception { |
| ImmutableMap.Builder<SkyFunctionName, SkyFunction> skyFunctions = ImmutableMap.builder(); |
| |
| fs = new MockFileSystem(); |
| pkgRoot = fs.getPath("/testroot"); |
| FileSystemUtils.createDirectoryAndParents(pkgRoot); |
| FileSystemUtils.createEmptyFile(pkgRoot.getRelative("WORKSPACE")); |
| |
| AtomicReference<PathPackageLocator> 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( |
| FileStateValue.FILE_STATE, |
| new FileStateFunction( |
| new AtomicReference<TimestampGranularityMonitor>(), |
| new AtomicReference<>(UnixGlob.DEFAULT_SYSCALLS), |
| externalFilesHelper)); |
| skyFunctions.put(FileValue.FILE, new FileFunction(pkgLocator)); |
| skyFunctions.put( |
| SkyFunctions.FILE_SYMLINK_CYCLE_UNIQUENESS, new FileSymlinkCycleUniquenessFunction()); |
| skyFunctions.put( |
| SkyFunctions.FILE_SYMLINK_INFINITE_EXPANSION_UNIQUENESS, |
| new FileSymlinkInfiniteExpansionUniquenessFunction()); |
| skyFunctions.put(SkyFunctions.PACKAGE, |
| new PackageFunction(null, null, null, null, null, null, null)); |
| skyFunctions.put( |
| SkyFunctions.PACKAGE_LOOKUP, |
| new PackageLookupFunction( |
| new AtomicReference<>(ImmutableSet.<PackageIdentifier>of()), |
| CrossRepositoryLabelViolationStrategy.ERROR, |
| BazelSkyframeExecutorConstants.BUILD_FILES_BY_PRIORITY)); |
| skyFunctions.put(SkyFunctions.WORKSPACE_AST, |
| new WorkspaceASTFunction(TestRuleClassProvider.getRuleClassProvider())); |
| skyFunctions.put( |
| WorkspaceFileValue.WORKSPACE_FILE, |
| new WorkspaceFileFunction( |
| TestRuleClassProvider.getRuleClassProvider(), |
| TestConstants.PACKAGE_FACTORY_BUILDER_FACTORY_FOR_TESTING |
| .builder(directories) |
| .build(TestRuleClassProvider.getRuleClassProvider(), fs), |
| directories, |
| /*skylarkImportLookupFunctionForInlining=*/ null)); |
| skyFunctions.put(SkyFunctions.EXTERNAL_PACKAGE, new ExternalPackageFunction()); |
| |
| differencer = new SequencedRecordingDifferencer(); |
| evaluator = new InMemoryMemoizingEvaluator(skyFunctions.build(), differencer); |
| driver = new SequentialBuildDriver(evaluator); |
| PrecomputedValue.BUILD_ID.set(differencer, UUID.randomUUID()); |
| PrecomputedValue.PATH_PACKAGE_LOCATOR.set(differencer, pkgLocator.get()); |
| } |
| |
| @Test |
| public void testEmpty() throws Exception { |
| FilesystemValueChecker checker = new FilesystemValueChecker(null, null); |
| assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); |
| } |
| |
| @Test |
| public void testSimple() throws Exception { |
| FilesystemValueChecker checker = new FilesystemValueChecker(null, null); |
| |
| 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<SkyValue> result = |
| driver.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 = driver.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(null, null); |
| |
| 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<SkyKey> allKeys = ImmutableList.of(symlinkKey, fooKey); |
| |
| // First build -- prime the graph. |
| EvaluationResult<FileValue> result = driver.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 = driver.evaluate(ImmutableList.<SkyKey>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 = driver.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(null, null); |
| |
| 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<SkyKey> skyKeys = ImmutableList.of(key1, key2); |
| EvaluationResult<SkyValue> result = driver.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 and mtime. This will update the file's ctime. |
| FileSystemUtils.writeContentAsLatin1(path1, "hello1"); |
| path1.setLastModifiedTime(27); |
| // 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 = driver.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<SkyValue> result = |
| driver.evaluate(ImmutableList.of(fileKey), EVALUATION_OPTIONS); |
| assertThat(result.hasError()).isTrue(); |
| |
| fs.readlinkThrowsIoException = false; |
| FilesystemValueChecker checker = new FilesystemValueChecker(null, null); |
| 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<SkyValue> result = |
| driver.evaluate(ImmutableList.of(fileKey1), EVALUATION_OPTIONS); |
| assertThat(result.hasError()).isTrue(); |
| |
| FilesystemValueChecker checker = new FilesystemValueChecker(null, null); |
| Diff diff = getDirtyFilesystemKeys(evaluator, checker); |
| assertThat(diff.changedKeysWithoutNewValues()).isEmpty(); |
| assertThat(diff.changedKeysWithNewValues()).isEmpty(); |
| } |
| |
| public void checkDirtyActions(BatchStat batchStatter, boolean forceDigests) throws Exception { |
| Artifact out1 = createDerivedArtifact("fiz"); |
| Artifact out2 = createDerivedArtifact("pop"); |
| |
| FileSystemUtils.writeContentAsLatin1(out1.getPath(), "hello"); |
| FileSystemUtils.writeContentAsLatin1(out2.getPath(), "fizzlepop"); |
| |
| ActionLookupKey actionLookupKey = |
| new ActionLookupKey() { |
| @Override |
| public SkyFunctionName functionName() { |
| return SkyFunctionName.FOR_TESTING; |
| } |
| }; |
| SkyKey actionKey1 = ActionExecutionValue.key(actionLookupKey, 0); |
| SkyKey actionKey2 = ActionExecutionValue.key(actionLookupKey, 1); |
| differencer.inject( |
| ImmutableMap.<SkyKey, SkyValue>of( |
| actionKey1, |
| actionValue( |
| new TestAction( |
| Runnables.doNothing(), ImmutableSet.<Artifact>of(), ImmutableSet.of(out1)), |
| forceDigests), |
| actionKey2, |
| actionValue( |
| new TestAction( |
| Runnables.doNothing(), ImmutableSet.<Artifact>of(), ImmutableSet.of(out2)), |
| forceDigests))); |
| EvaluationContext evaluationContext = |
| EvaluationContext.newBuilder() |
| .setKeepGoing(false) |
| .setNumThreads(1) |
| .setEventHander(NullEventHandler.INSTANCE) |
| .build(); |
| assertThat(driver.evaluate(ImmutableList.<SkyKey>of(), evaluationContext).hasError()).isFalse(); |
| assertThat(new FilesystemValueChecker(null, null).getDirtyActionValues(evaluator.getValues(), |
| batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED)).isEmpty(); |
| |
| FileSystemUtils.writeContentAsLatin1(out1.getPath(), "goodbye"); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED)) |
| .containsExactly(actionKey1); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder().modify(out1.getExecPath()).build())) |
| .containsExactly(actionKey1); |
| assertThat( |
| new FilesystemValueChecker(null, null).getDirtyActionValues(evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder().modify( |
| out1.getExecPath().getParentDirectory()).build())).isEmpty(); |
| assertThat( |
| new FilesystemValueChecker(null, null).getDirtyActionValues(evaluator.getValues(), |
| batchStatter, ModifiedFileSet.NOTHING_MODIFIED)).isEmpty(); |
| } |
| |
| public void checkDirtyTreeArtifactActions(BatchStat batchStatter) |
| throws Exception { |
| // Normally, an Action specifies the contents of a TreeArtifact when it executes. |
| // To decouple FileSystemValueTester checking from Action execution, we inject TreeArtifact |
| // contents into ActionExecutionValues. |
| |
| SpecialArtifact out1 = createTreeArtifact("one"); |
| TreeFileArtifact file11 = treeFileArtifact(out1, "fizz"); |
| FileSystemUtils.createDirectoryAndParents(out1.getPath()); |
| FileSystemUtils.writeContentAsLatin1(file11.getPath(), "buzz"); |
| |
| SpecialArtifact out2 = createTreeArtifact("two"); |
| FileSystemUtils.createDirectoryAndParents(out2.getPath().getChild("subdir")); |
| TreeFileArtifact file21 = treeFileArtifact(out2, "moony"); |
| TreeFileArtifact file22 = treeFileArtifact(out2, "subdir/wormtail"); |
| FileSystemUtils.writeContentAsLatin1(file21.getPath(), "padfoot"); |
| FileSystemUtils.writeContentAsLatin1(file22.getPath(), "prongs"); |
| |
| SpecialArtifact outEmpty = createTreeArtifact("empty"); |
| FileSystemUtils.createDirectoryAndParents(outEmpty.getPath()); |
| |
| SpecialArtifact outUnchanging = createTreeArtifact("untouched"); |
| FileSystemUtils.createDirectoryAndParents(outUnchanging.getPath()); |
| |
| SpecialArtifact last = createTreeArtifact("zzzzzzzzzz"); |
| FileSystemUtils.createDirectoryAndParents(last.getPath()); |
| |
| ActionLookupKey actionLookupKey = |
| new ActionLookupKey() { |
| @Override |
| public SkyFunctionName functionName() { |
| return SkyFunctionName.FOR_TESTING; |
| } |
| }; |
| SkyKey actionKey1 = ActionExecutionValue.key(actionLookupKey, 0); |
| SkyKey actionKey2 = ActionExecutionValue.key(actionLookupKey, 1); |
| SkyKey actionKeyEmpty = ActionExecutionValue.key(actionLookupKey, 2); |
| SkyKey actionKeyUnchanging = ActionExecutionValue.key(actionLookupKey, 3); |
| SkyKey actionKeyLast = ActionExecutionValue.key(actionLookupKey, 4); |
| differencer.inject( |
| ImmutableMap.<SkyKey, SkyValue>of( |
| actionKey1, |
| actionValueWithTreeArtifacts(ImmutableList.of(file11)), |
| actionKey2, |
| actionValueWithTreeArtifacts(ImmutableList.of(file21, file22)), |
| actionKeyEmpty, |
| actionValueWithEmptyDirectory(outEmpty), |
| actionKeyUnchanging, |
| actionValueWithEmptyDirectory(outUnchanging), |
| actionKeyLast, |
| actionValueWithEmptyDirectory(last))); |
| |
| EvaluationContext evaluationContext = |
| EvaluationContext.newBuilder() |
| .setKeepGoing(false) |
| .setNumThreads(1) |
| .setEventHander(NullEventHandler.INSTANCE) |
| .build(); |
| assertThat(driver.evaluate(ImmutableList.<SkyKey>of(), evaluationContext).hasError()).isFalse(); |
| assertThat(new FilesystemValueChecker(null, null).getDirtyActionValues(evaluator.getValues(), |
| batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED)).isEmpty(); |
| |
| // Touching the TreeArtifact directory should have no effect |
| FileSystemUtils.touchFile(out1.getPath()); |
| assertThat( |
| new FilesystemValueChecker(null, null).getDirtyActionValues(evaluator.getValues(), |
| batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED)).isEmpty(); |
| // Neither should touching a subdirectory. |
| FileSystemUtils.touchFile(out2.getPath().getChild("subdir")); |
| assertThat( |
| new FilesystemValueChecker(null, null).getDirtyActionValues(evaluator.getValues(), |
| batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED)).isEmpty(); |
| |
| /* **** Tests for directories **** */ |
| |
| // Removing a directory (even if empty) should have an effect |
| outEmpty.getPath().delete(); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder().modify(outEmpty.getExecPath()).build())) |
| .containsExactly(actionKeyEmpty); |
| // Symbolic links should count as dirty |
| Path dummyEmptyDir = fs.getPath("/bin").getRelative("symlink"); |
| FileSystemUtils.createDirectoryAndParents(dummyEmptyDir); |
| FileSystemUtils.ensureSymbolicLink(outEmpty.getPath(), dummyEmptyDir); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder().modify(outEmpty.getExecPath()).build())) |
| .containsExactly(actionKeyEmpty); |
| |
| // We're done fiddling with this... restore the original state |
| outEmpty.getPath().delete(); |
| dummyEmptyDir.deleteTree(); |
| FileSystemUtils.createDirectoryAndParents(outEmpty.getPath()); |
| |
| /* **** Tests for files and directory contents ****/ |
| |
| // Test that file contents matter. This is covered by existing tests already, |
| // so it's just a sanity check. |
| FileSystemUtils.writeContentAsLatin1(file11.getPath(), "goodbye"); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder().modify(file11.getExecPath()).build())) |
| .containsExactly(actionKey1); |
| |
| // Test that directory contents (and nested contents) matter |
| Artifact out1new = treeFileArtifact(out1, "julius/caesar"); |
| FileSystemUtils.createDirectoryAndParents(out1.getPath().getChild("julius")); |
| FileSystemUtils.writeContentAsLatin1(out1new.getPath(), "octavian"); |
| // even for empty directories |
| Artifact outEmptyNew = treeFileArtifact(outEmpty, "marcus"); |
| FileSystemUtils.writeContentAsLatin1(outEmptyNew.getPath(), "aurelius"); |
| // so does removing |
| file21.getPath().delete(); |
| // now, let's test our changes are actually visible |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), batchStatter, ModifiedFileSet.EVERYTHING_MODIFIED)) |
| .containsExactly(actionKey1, actionKey2, actionKeyEmpty); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder() |
| .modify(file21.getExecPath()) |
| .modify(out1new.getExecPath()) |
| .modify(outEmptyNew.getExecPath()) |
| .build())) |
| .containsExactly(actionKey1, actionKey2, actionKeyEmpty); |
| // We also check that if the modified file set does not contain our modified files on disk, |
| // we are not going to check and return them. |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder() |
| .modify(file21.getExecPath()) |
| .modify(outEmptyNew.getExecPath()) |
| .build())) |
| .containsExactly(actionKey2, actionKeyEmpty); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder() |
| .modify(file21.getExecPath()) |
| .modify(out1new.getExecPath()) |
| .build())) |
| .containsExactly(actionKey1, actionKey2); |
| // Check modifying the last (lexicographically) tree artifact. |
| last.getPath().delete(); |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder() |
| .modify(file21.getExecPath()) |
| .modify(out1new.getExecPath()) |
| .modify(last.getExecPath()) |
| .build())) |
| .containsExactly(actionKey1, actionKey2, actionKeyLast); |
| // Check ModifiedFileSet without the last (lexicographically) tree artifact. |
| assertThat( |
| new FilesystemValueChecker(null, null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| batchStatter, |
| new ModifiedFileSet.Builder() |
| .modify(file21.getExecPath()) |
| .modify(out1new.getExecPath()) |
| .build())) |
| .containsExactly(actionKey1, actionKey2); |
| // Restore |
| last.getPath().delete(); |
| FileSystemUtils.createDirectoryAndParents(last.getPath()); |
| // We add a test for NOTHING_MODIFIED, because FileSystemValueChecker doesn't |
| // pay attention to file sets for TreeArtifact directory listings. |
| assertThat( |
| new FilesystemValueChecker(null, null).getDirtyActionValues(evaluator.getValues(), |
| batchStatter, ModifiedFileSet.NOTHING_MODIFIED)).isEmpty(); |
| } |
| |
| private Artifact createDerivedArtifact(String relPath) throws IOException { |
| Path outputPath = fs.getPath("/bin"); |
| outputPath.createDirectory(); |
| return new Artifact( |
| outputPath.getRelative(relPath), ArtifactRoot.asDerivedRoot(fs.getPath("/"), outputPath)); |
| } |
| |
| private SpecialArtifact createTreeArtifact(String relPath) throws IOException { |
| Path outputDir = fs.getPath("/bin"); |
| Path outputPath = outputDir.getRelative(relPath); |
| outputDir.createDirectory(); |
| ArtifactRoot derivedRoot = ArtifactRoot.asDerivedRoot(fs.getPath("/"), outputDir); |
| return new SpecialArtifact( |
| derivedRoot, |
| derivedRoot.getExecPath().getRelative(derivedRoot.getRoot().relativize(outputPath)), |
| ArtifactOwner.NullArtifactOwner.INSTANCE, |
| SpecialArtifactType.TREE); |
| } |
| |
| @Test |
| public void testDirtyActions() throws Exception { |
| checkDirtyActions(null, false); |
| } |
| |
| @Test |
| public void testDirtyActionsBatchStat() throws Exception { |
| checkDirtyActions( |
| new BatchStat() { |
| @Override |
| public List<FileStatusWithDigest> batchStat( |
| boolean useDigest, boolean includeLinks, Iterable<PathFragment> paths) |
| throws IOException { |
| List<FileStatusWithDigest> stats = new ArrayList<>(); |
| for (PathFragment pathFrag : paths) { |
| stats.add( |
| FileStatusWithDigestAdapter.adapt( |
| fs.getPath("/").getRelative(pathFrag).statIfFound(Symlinks.NOFOLLOW))); |
| } |
| return stats; |
| } |
| }, |
| false); |
| } |
| |
| @Test |
| public void testDirtyActionsBatchStatWithDigest() throws Exception { |
| checkDirtyActions( |
| new BatchStat() { |
| @Override |
| public List<FileStatusWithDigest> batchStat( |
| boolean useDigest, boolean includeLinks, Iterable<PathFragment> paths) |
| throws IOException { |
| List<FileStatusWithDigest> stats = new ArrayList<>(); |
| for (PathFragment pathFrag : paths) { |
| final Path path = fs.getPath("/").getRelative(pathFrag); |
| stats.add(statWithDigest(path, path.statIfFound(Symlinks.NOFOLLOW))); |
| } |
| return stats; |
| } |
| }, |
| true); |
| } |
| |
| @Test |
| public void testDirtyActionsBatchStatFallback() throws Exception { |
| checkDirtyActions( |
| new BatchStat() { |
| @Override |
| public List<FileStatusWithDigest> batchStat( |
| boolean useDigest, boolean includeLinks, Iterable<PathFragment> paths) |
| throws IOException { |
| throw new IOException("try again"); |
| } |
| }, |
| false); |
| } |
| |
| @Test |
| public void testDirtyTreeArtifactActions() throws Exception { |
| checkDirtyTreeArtifactActions(null); |
| } |
| |
| @Test |
| public void testDirtyTreeArtifactActionsBatchStat() throws Exception { |
| checkDirtyTreeArtifactActions( |
| new BatchStat() { |
| @Override |
| public List<FileStatusWithDigest> batchStat( |
| boolean useDigest, boolean includeLinks, Iterable<PathFragment> paths) |
| throws IOException { |
| List<FileStatusWithDigest> stats = new ArrayList<>(); |
| for (PathFragment pathFrag : paths) { |
| stats.add( |
| FileStatusWithDigestAdapter.adapt( |
| fs.getPath("/").getRelative(pathFrag).statIfFound(Symlinks.NOFOLLOW))); |
| } |
| return stats; |
| } |
| }); |
| } |
| |
| // TODO(bazel-team): Add some tests for FileSystemValueChecker#changedKeys*() methods. |
| // Presently these appear to be untested. |
| |
| private ActionExecutionValue actionValue(Action action, boolean forceDigest) { |
| Map<Artifact, ArtifactFileMetadata> artifactData = new HashMap<>(); |
| for (Artifact output : action.getOutputs()) { |
| try { |
| Path path = output.getPath(); |
| FileStatusWithDigest stat = |
| forceDigest ? statWithDigest(path, path.statIfFound(Symlinks.NOFOLLOW)) : null; |
| artifactData.put( |
| output, ActionMetadataHandler.fileMetadataFromArtifact(output, stat, null)); |
| } catch (IOException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| return ActionExecutionValue.create( |
| artifactData, |
| ImmutableMap.<Artifact, TreeArtifactValue>of(), |
| ImmutableMap.<Artifact, FileArtifactValue>of(), |
| /*outputSymlinks=*/ null, |
| /*discoveredModules=*/ null, |
| /*actionDependsOnBuildId=*/ false); |
| } |
| |
| private ActionExecutionValue actionValueWithEmptyDirectory(Artifact emptyDir) { |
| TreeArtifactValue emptyValue = TreeArtifactValue.create |
| (ImmutableMap.<TreeFileArtifact, FileArtifactValue>of()); |
| |
| return ActionExecutionValue.create( |
| ImmutableMap.of(), |
| ImmutableMap.of(emptyDir, emptyValue), |
| ImmutableMap.<Artifact, FileArtifactValue>of(), |
| /*outputSymlinks=*/ null, |
| /*discoveredModules=*/ null, |
| /*actionDependsOnBuildId=*/ false); |
| } |
| |
| private ActionExecutionValue actionValueWithTreeArtifacts(List<TreeFileArtifact> contents) { |
| Map<Artifact, ArtifactFileMetadata> fileData = new HashMap<>(); |
| Map<Artifact, Map<TreeFileArtifact, FileArtifactValue>> directoryData = new HashMap<>(); |
| |
| for (TreeFileArtifact output : contents) { |
| try { |
| Map<TreeFileArtifact, FileArtifactValue> dirDatum = |
| directoryData.get(output.getParent()); |
| if (dirDatum == null) { |
| dirDatum = new HashMap<>(); |
| directoryData.put(output.getParent(), dirDatum); |
| } |
| ArtifactFileMetadata fileValue = |
| ActionMetadataHandler.fileMetadataFromArtifact(output, null, null); |
| dirDatum.put(output, FileArtifactValue.create(output, fileValue)); |
| fileData.put(output, fileValue); |
| } catch (IOException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| |
| Map<Artifact, TreeArtifactValue> treeArtifactData = new HashMap<>(); |
| for (Map.Entry<Artifact, Map<TreeFileArtifact, FileArtifactValue>> dirDatum : |
| directoryData.entrySet()) { |
| treeArtifactData.put(dirDatum.getKey(), TreeArtifactValue.create(dirDatum.getValue())); |
| } |
| |
| return ActionExecutionValue.create( |
| fileData, |
| treeArtifactData, |
| ImmutableMap.<Artifact, FileArtifactValue>of(), |
| /*outputSymlinks=*/ null, |
| /*discoveredModules=*/ null, |
| /*actionDependsOnBuildId=*/ false); |
| } |
| |
| private ActionExecutionValue actionValueWithRemoteTreeArtifact( |
| SpecialArtifact output, Map<PathFragment, RemoteFileArtifactValue> children) { |
| ImmutableMap.Builder<TreeFileArtifact, FileArtifactValue> childFileValues = |
| ImmutableMap.builder(); |
| for (Map.Entry<PathFragment, RemoteFileArtifactValue> child : children.entrySet()) { |
| childFileValues.put( |
| ActionInputHelper.treeFileArtifact(output, child.getKey()), child.getValue()); |
| } |
| TreeArtifactValue treeArtifactValue = TreeArtifactValue.create(childFileValues.build()); |
| return ActionExecutionValue.create( |
| Collections.emptyMap(), |
| Collections.singletonMap(output, treeArtifactValue), |
| ImmutableMap.of(), |
| /* outputSymlinks= */ null, |
| /* discoveredModules= */ null, |
| /* actionDependsOnBuildId= */ false); |
| } |
| |
| private ActionExecutionValue actionValueWithRemoteArtifact( |
| Artifact output, RemoteFileArtifactValue value) { |
| return ActionExecutionValue.create( |
| Collections.singletonMap(output, ArtifactFileMetadata.PLACEHOLDER), |
| ImmutableMap.of(), |
| Collections.singletonMap(output, value), |
| /* outputSymlinks= */ null, |
| /* discoveredModules= */ null, |
| /* actionDependsOnBuildId= */ false); |
| } |
| |
| private RemoteFileArtifactValue createRemoteFileArtifactValue(String contents) { |
| byte[] data = contents.getBytes(); |
| DigestHashFunction hashFn = fs.getDigestFunction(); |
| HashCode hash = hashFn.getHashFunction().hashBytes(data); |
| return new RemoteFileArtifactValue(hash.asBytes(), data.length, -1); |
| } |
| |
| @Test |
| public void testRemoteAndLocalArtifacts() throws Exception { |
| // Test that injected remote artifacts are trusted by the FileSystemValueChecker |
| // and that local files always takes preference over remote files. |
| ActionLookupKey actionLookupKey = |
| new ActionLookupKey() { |
| @Override |
| public SkyFunctionName functionName() { |
| return SkyFunctionName.FOR_TESTING; |
| } |
| }; |
| SkyKey actionKey1 = ActionExecutionValue.key(actionLookupKey, 0); |
| SkyKey actionKey2 = ActionExecutionValue.key(actionLookupKey, 1); |
| |
| Artifact out1 = createDerivedArtifact("foo"); |
| Artifact out2 = createDerivedArtifact("bar"); |
| Map<SkyKey, SkyValue> 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) |
| .setNumThreads(1) |
| .setEventHander(NullEventHandler.INSTANCE) |
| .build(); |
| assertThat( |
| driver.evaluate(ImmutableList.of(actionKey1, actionKey2), evaluationContext).hasError()) |
| .isFalse(); |
| assertThat( |
| new FilesystemValueChecker(/* tsgm= */ null, /* lastExecutionTimeRange= */ null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| /* batchStatter= */ null, |
| ModifiedFileSet.EVERYTHING_MODIFIED)) |
| .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, /* lastExecutionTimeRange= */ null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| /* batchStatter= */ null, |
| ModifiedFileSet.EVERYTHING_MODIFIED)) |
| .containsExactly(actionKey1); |
| } |
| |
| @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. |
| ActionLookupKey actionLookupKey = |
| new ActionLookupKey() { |
| @Override |
| public SkyFunctionName functionName() { |
| return SkyFunctionName.FOR_TESTING; |
| } |
| }; |
| SkyKey actionKey = ActionExecutionValue.key(actionLookupKey, 0); |
| |
| SpecialArtifact treeArtifact = createTreeArtifact("dir"); |
| treeArtifact.getPath().createDirectoryAndParents(); |
| Map<PathFragment, RemoteFileArtifactValue> treeArtifactMetadata = new HashMap<>(); |
| treeArtifactMetadata.put( |
| PathFragment.create("foo"), createRemoteFileArtifactValue("foo-content")); |
| treeArtifactMetadata.put( |
| PathFragment.create("bar"), createRemoteFileArtifactValue("bar-content")); |
| |
| Map<SkyKey, SkyValue> metadataToInject = new HashMap<>(); |
| metadataToInject.put( |
| actionKey, actionValueWithRemoteTreeArtifact(treeArtifact, treeArtifactMetadata)); |
| differencer.inject(metadataToInject); |
| |
| EvaluationContext evaluationContext = |
| EvaluationContext.newBuilder() |
| .setKeepGoing(false) |
| .setNumThreads(1) |
| .setEventHander(NullEventHandler.INSTANCE) |
| .build(); |
| assertThat(driver.evaluate(ImmutableList.of(actionKey), evaluationContext).hasError()) |
| .isFalse(); |
| assertThat( |
| new FilesystemValueChecker(/* tsgm= */ null, /* lastExecutionTimeRange= */ null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| /* batchStatter= */ null, |
| ModifiedFileSet.EVERYTHING_MODIFIED)) |
| .isEmpty(); |
| |
| // Create dir/foo on the local disk and test that it invalidates the associated sky key. |
| TreeFileArtifact fooArtifact = treeFileArtifact(treeArtifact, "foo"); |
| FileSystemUtils.writeContentAsLatin1(fooArtifact.getPath(), "new-foo-content"); |
| assertThat( |
| new FilesystemValueChecker(/* tsgm= */ null, /* lastExecutionTimeRange= */ null) |
| .getDirtyActionValues( |
| evaluator.getValues(), |
| /* batchStatter= */ null, |
| ModifiedFileSet.EVERYTHING_MODIFIED)) |
| .containsExactly(actionKey); |
| } |
| |
| @Test |
| public void testPropagatesRuntimeExceptions() throws Exception { |
| Collection<SkyKey> values = |
| ImmutableList.of( |
| FileValue.key( |
| RootedPath.toRootedPath(Root.fromPath(pkgRoot), PathFragment.create("foo")))); |
| driver.evaluate(values, EVALUATION_OPTIONS); |
| FilesystemValueChecker checker = new FilesystemValueChecker(null, null); |
| |
| assertEmptyDiff(getDirtyFilesystemKeys(evaluator, checker)); |
| |
| fs.statThrowsRuntimeException = true; |
| try { |
| getDirtyFilesystemKeys(evaluator, checker); |
| fail(); |
| } catch (RuntimeException e) { |
| assertThat(e).hasMessageThat().isEqualTo("bork"); |
| } |
| } |
| |
| 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 class MockFileSystem extends InMemoryFileSystem { |
| |
| boolean statThrowsRuntimeException; |
| boolean readlinkThrowsIoException; |
| |
| MockFileSystem() { |
| super(); |
| } |
| |
| @Override |
| public FileStatus statIfFound(Path path, boolean followSymlinks) throws IOException { |
| if (statThrowsRuntimeException) { |
| throw new RuntimeException("bork"); |
| } |
| return super.statIfFound(path, followSymlinks); |
| } |
| |
| @Override |
| protected PathFragment readSymbolicLink(Path path) throws IOException { |
| if (readlinkThrowsIoException) { |
| throw new IOException("readlink failed"); |
| } |
| return super.readSymbolicLink(path); |
| } |
| } |
| |
| 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(), new BasicFilesystemDirtinessChecker()); |
| } |
| } |
