| // Copyright 2017 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.remote; | |
| import static com.google.common.truth.Truth.assertThat; | |
| import static org.mockito.ArgumentMatchers.any; | |
| import static org.mockito.ArgumentMatchers.anyCollection; | |
| import static org.mockito.ArgumentMatchers.eq; | |
| import static org.mockito.Mockito.doThrow; | |
| import static org.mockito.Mockito.never; | |
| import static org.mockito.Mockito.verify; | |
| import static org.mockito.Mockito.verifyNoMoreInteractions; | |
| import static org.mockito.Mockito.when; | |
| import build.bazel.remote.execution.v2.Action; | |
| import build.bazel.remote.execution.v2.ActionResult; | |
| import build.bazel.remote.execution.v2.Command; | |
| import build.bazel.remote.execution.v2.Digest; | |
| import build.bazel.remote.execution.v2.OutputFile; | |
| import build.bazel.remote.execution.v2.RequestMetadata; | |
| import com.google.common.collect.ImmutableList; | |
| import com.google.common.collect.ImmutableMap; | |
| import com.google.common.collect.ImmutableSet; | |
| import com.google.common.eventbus.EventBus; | |
| import com.google.devtools.build.lib.actions.ActionContext; | |
| import com.google.devtools.build.lib.actions.ActionInput; | |
| import com.google.devtools.build.lib.actions.ActionInputHelper; | |
| import com.google.devtools.build.lib.actions.Artifact; | |
| import com.google.devtools.build.lib.actions.Artifact.ArtifactExpander; | |
| import com.google.devtools.build.lib.actions.Artifact.TreeFileArtifact; | |
| import com.google.devtools.build.lib.actions.ArtifactPathResolver; | |
| import com.google.devtools.build.lib.actions.ExecutionRequirements; | |
| import com.google.devtools.build.lib.actions.FileArtifactValue.RemoteFileArtifactValue; | |
| import com.google.devtools.build.lib.actions.MetadataProvider; | |
| import com.google.devtools.build.lib.actions.ResourceSet; | |
| import com.google.devtools.build.lib.actions.SimpleSpawn; | |
| import com.google.devtools.build.lib.actions.SpawnResult; | |
| import com.google.devtools.build.lib.actions.SpawnResult.Status; | |
| import com.google.devtools.build.lib.actions.cache.MetadataInjector; | |
| import com.google.devtools.build.lib.clock.JavaClock; | |
| 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.Event; | |
| import com.google.devtools.build.lib.events.EventKind; | |
| import com.google.devtools.build.lib.events.Reporter; | |
| import com.google.devtools.build.lib.events.StoredEventHandler; | |
| import com.google.devtools.build.lib.exec.SpawnCache.CacheHandle; | |
| import com.google.devtools.build.lib.exec.SpawnInputExpander; | |
| import com.google.devtools.build.lib.exec.SpawnRunner.ProgressStatus; | |
| import com.google.devtools.build.lib.exec.SpawnRunner.SpawnExecutionContext; | |
| import com.google.devtools.build.lib.exec.util.FakeOwner; | |
| import com.google.devtools.build.lib.remote.common.CacheNotFoundException; | |
| import com.google.devtools.build.lib.remote.common.RemoteCacheClient.ActionKey; | |
| import com.google.devtools.build.lib.remote.options.RemoteOptions; | |
| import com.google.devtools.build.lib.remote.options.RemoteOutputsMode; | |
| import com.google.devtools.build.lib.remote.util.DigestUtil; | |
| import com.google.devtools.build.lib.remote.util.TracingMetadataUtils; | |
| import com.google.devtools.build.lib.util.Pair; | |
| import com.google.devtools.build.lib.util.io.FileOutErr; | |
| import com.google.devtools.build.lib.vfs.DigestHashFunction; | |
| import com.google.devtools.build.lib.vfs.FileStatus; | |
| import com.google.devtools.build.lib.vfs.FileSystem; | |
| import com.google.devtools.build.lib.vfs.FileSystemUtils; | |
| import com.google.devtools.build.lib.vfs.Path; | |
| import com.google.devtools.build.lib.vfs.PathFragment; | |
| import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem; | |
| import com.google.devtools.common.options.Options; | |
| import java.io.IOException; | |
| import java.time.Duration; | |
| import java.util.ArrayList; | |
| import java.util.Collection; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.SortedMap; | |
| import org.junit.Before; | |
| import org.junit.Test; | |
| import org.junit.runner.RunWith; | |
| import org.junit.runners.JUnit4; | |
| import org.mockito.Mock; | |
| import org.mockito.Mockito; | |
| import org.mockito.MockitoAnnotations; | |
| import org.mockito.invocation.InvocationOnMock; | |
| import org.mockito.stubbing.Answer; | |
| /** Tests for {@link RemoteSpawnCache}. */ | |
| @RunWith(JUnit4.class) | |
| public class RemoteSpawnCacheTest { | |
| private static final ArtifactExpander SIMPLE_ARTIFACT_EXPANDER = | |
| new ArtifactExpander() { | |
| @Override | |
| public void expand(Artifact artifact, Collection<? super Artifact> output) { | |
| output.add(artifact); | |
| } | |
| }; | |
| private FileSystem fs; | |
| private DigestUtil digestUtil; | |
| private Path execRoot; | |
| private SimpleSpawn simpleSpawn; | |
| private FakeActionInputFileCache fakeFileCache; | |
| @Mock private RemoteCache remoteCache; | |
| private RemoteSpawnCache cache; | |
| private FileOutErr outErr; | |
| private final List<Pair<ProgressStatus, String>> progressUpdates = new ArrayList<>(); | |
| private StoredEventHandler eventHandler = new StoredEventHandler(); | |
| private Reporter reporter; | |
| private final SpawnExecutionContext simplePolicy = | |
| new SpawnExecutionContext() { | |
| @Override | |
| public int getId() { | |
| return 0; | |
| } | |
| @Override | |
| public void prefetchInputs() {} | |
| @Override | |
| public void lockOutputFiles() throws InterruptedException { | |
| throw new UnsupportedOperationException(); | |
| } | |
| @Override | |
| public boolean speculating() { | |
| return false; | |
| } | |
| @Override | |
| public MetadataProvider getMetadataProvider() { | |
| return fakeFileCache; | |
| } | |
| @Override | |
| public ArtifactExpander getArtifactExpander() { | |
| throw new UnsupportedOperationException(); | |
| } | |
| @Override | |
| public Duration getTimeout() { | |
| return Duration.ZERO; | |
| } | |
| @Override | |
| public FileOutErr getFileOutErr() { | |
| return outErr; | |
| } | |
| @Override | |
| public SortedMap<PathFragment, ActionInput> getInputMapping( | |
| boolean expandTreeArtifactsInRunfiles) throws IOException { | |
| return new SpawnInputExpander(execRoot, /*strict*/ false) | |
| .getInputMapping( | |
| simpleSpawn, | |
| SIMPLE_ARTIFACT_EXPANDER, | |
| ArtifactPathResolver.IDENTITY, | |
| fakeFileCache, | |
| true); | |
| } | |
| @Override | |
| public void report(ProgressStatus state, String name) { | |
| progressUpdates.add(Pair.of(state, name)); | |
| } | |
| @Override | |
| public MetadataInjector getMetadataInjector() { | |
| return new MetadataInjector() { | |
| @Override | |
| public void injectRemoteFile( | |
| Artifact output, byte[] digest, long size, int locationIndex) { | |
| throw new UnsupportedOperationException(); | |
| } | |
| @Override | |
| public void injectRemoteDirectory( | |
| Artifact.SpecialArtifact output, | |
| Map<PathFragment, RemoteFileArtifactValue> children) { | |
| throw new UnsupportedOperationException(); | |
| } | |
| @Override | |
| public void markOmitted(ActionInput output) { | |
| throw new UnsupportedOperationException(); | |
| } | |
| @Override | |
| public void addExpandedTreeOutput(TreeFileArtifact output) { | |
| throw new UnsupportedOperationException(); | |
| } | |
| @Override | |
| public void injectDigest(ActionInput output, FileStatus statNoFollow, byte[] digest) { | |
| throw new UnsupportedOperationException(); | |
| } | |
| }; | |
| } | |
| @Override | |
| public void checkForLostInputs() {} | |
| @Override | |
| public <T extends ActionContext> T getContext(Class<T> identifyingType) { | |
| throw new UnsupportedOperationException(); | |
| } | |
| }; | |
| private static SimpleSpawn simpleSpawnWithExecutionInfo( | |
| ImmutableMap<String, String> executionInfo) { | |
| return new SimpleSpawn( | |
| new FakeOwner("Mnemonic", "Progress Message"), | |
| ImmutableList.of("/bin/echo", "Hi!"), | |
| ImmutableMap.of("VARIABLE", "value"), | |
| executionInfo, | |
| /* inputs= */ NestedSetBuilder.create( | |
| Order.STABLE_ORDER, ActionInputHelper.fromPath("input")), | |
| /* outputs= */ ImmutableSet.of(ActionInputHelper.fromPath("/random/file")), | |
| ResourceSet.ZERO); | |
| } | |
| private RemoteSpawnCache remoteSpawnCacheWithOptions(RemoteOptions options) { | |
| return new RemoteSpawnCache( | |
| execRoot, | |
| options, | |
| remoteCache, | |
| "build-req-id", | |
| "command-id", | |
| reporter, | |
| digestUtil, | |
| /* filesToDownload= */ ImmutableSet.of()); | |
| } | |
| @Before | |
| public final void setUp() throws Exception { | |
| MockitoAnnotations.initMocks(this); | |
| fs = new InMemoryFileSystem(new JavaClock(), DigestHashFunction.SHA256); | |
| digestUtil = new DigestUtil(DigestHashFunction.SHA256); | |
| execRoot = fs.getPath("/exec/root"); | |
| FileSystemUtils.createDirectoryAndParents(execRoot); | |
| fakeFileCache = new FakeActionInputFileCache(execRoot); | |
| simpleSpawn = simpleSpawnWithExecutionInfo(ImmutableMap.of()); | |
| Path stdout = fs.getPath("/tmp/stdout"); | |
| Path stderr = fs.getPath("/tmp/stderr"); | |
| FileSystemUtils.createDirectoryAndParents(stdout.getParentDirectory()); | |
| FileSystemUtils.createDirectoryAndParents(stderr.getParentDirectory()); | |
| outErr = new FileOutErr(stdout, stderr); | |
| RemoteOptions options = Options.getDefaults(RemoteOptions.class); | |
| reporter = new Reporter(new EventBus()); | |
| eventHandler = new StoredEventHandler(); | |
| reporter.addHandler(eventHandler); | |
| cache = remoteSpawnCacheWithOptions(options); | |
| fakeFileCache.createScratchInput(simpleSpawn.getInputFiles().getSingleton(), "xyz"); | |
| } | |
| @SuppressWarnings("unchecked") | |
| @Test | |
| public void cacheHit() throws Exception { | |
| ActionResult actionResult = ActionResult.getDefaultInstance(); | |
| when(remoteCache.downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false))) | |
| .thenAnswer( | |
| new Answer<ActionResult>() { | |
| @Override | |
| public ActionResult answer(InvocationOnMock invocation) { | |
| RequestMetadata meta = TracingMetadataUtils.fromCurrentContext(); | |
| assertThat(meta.getCorrelatedInvocationsId()).isEqualTo("build-req-id"); | |
| assertThat(meta.getToolInvocationId()).isEqualTo("command-id"); | |
| return actionResult; | |
| } | |
| }); | |
| Mockito.doAnswer( | |
| new Answer<Void>() { | |
| @Override | |
| public Void answer(InvocationOnMock invocation) { | |
| RequestMetadata meta = TracingMetadataUtils.fromCurrentContext(); | |
| assertThat(meta.getCorrelatedInvocationsId()).isEqualTo("build-req-id"); | |
| assertThat(meta.getToolInvocationId()).isEqualTo("command-id"); | |
| return null; | |
| } | |
| }) | |
| .when(remoteCache) | |
| .download(eq(actionResult), eq(execRoot), eq(outErr), any()); | |
| CacheHandle entry = cache.lookup(simpleSpawn, simplePolicy); | |
| assertThat(entry.hasResult()).isTrue(); | |
| SpawnResult result = entry.getResult(); | |
| // All other methods on RemoteActionCache have side effects, so we verify all of them. | |
| verify(remoteCache).download(eq(actionResult), eq(execRoot), eq(outErr), any()); | |
| verify(remoteCache, never()) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| any(Collection.class), | |
| any(FileOutErr.class)); | |
| assertThat(result.setupSuccess()).isTrue(); | |
| assertThat(result.exitCode()).isEqualTo(0); | |
| assertThat(result.isCacheHit()).isTrue(); | |
| // We expect the CachedLocalSpawnRunner to _not_ write to outErr at all. | |
| assertThat(outErr.hasRecordedOutput()).isFalse(); | |
| assertThat(outErr.hasRecordedStderr()).isFalse(); | |
| assertThat(progressUpdates) | |
| .containsExactly(Pair.of(ProgressStatus.CHECKING_CACHE, "remote-cache")); | |
| } | |
| @Test | |
| public void cacheMiss() throws Exception { | |
| CacheHandle entry = cache.lookup(simpleSpawn, simplePolicy); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(0) | |
| .setStatus(Status.SUCCESS) | |
| .setRunnerName("test") | |
| .build(); | |
| ImmutableList<Path> outputFiles = ImmutableList.of(fs.getPath("/random/file")); | |
| Mockito.doAnswer( | |
| new Answer<Void>() { | |
| @Override | |
| public Void answer(InvocationOnMock invocation) { | |
| RequestMetadata meta = TracingMetadataUtils.fromCurrentContext(); | |
| assertThat(meta.getCorrelatedInvocationsId()).isEqualTo("build-req-id"); | |
| assertThat(meta.getToolInvocationId()).isEqualTo("command-id"); | |
| return null; | |
| } | |
| }) | |
| .when(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| entry.store(result); | |
| verify(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| assertThat(progressUpdates) | |
| .containsExactly(Pair.of(ProgressStatus.CHECKING_CACHE, "remote-cache")); | |
| } | |
| @Test | |
| public void noCacheSpawns() throws Exception { | |
| // Checks that spawns satisfying Spawns.mayBeCached=false are not looked up in the cache | |
| // (even if it is a local cache) and that the results/artifacts are not uploaded to the cache. | |
| RemoteOptions withLocalCache = Options.getDefaults(RemoteOptions.class); | |
| withLocalCache.diskCache = PathFragment.create("/etc/something/cache/here"); | |
| for (RemoteSpawnCache remoteSpawnCache : | |
| ImmutableList.of(cache, remoteSpawnCacheWithOptions(withLocalCache))) { | |
| for (String requirement : | |
| ImmutableList.of(ExecutionRequirements.NO_CACHE, ExecutionRequirements.LOCAL)) { | |
| SimpleSpawn uncacheableSpawn = | |
| simpleSpawnWithExecutionInfo(ImmutableMap.of(requirement, "")); | |
| CacheHandle entry = remoteSpawnCache.lookup(uncacheableSpawn, simplePolicy); | |
| verify(remoteCache, never()) | |
| .downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false)); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(0) | |
| .setStatus(Status.SUCCESS) | |
| .setRunnerName("test") | |
| .build(); | |
| entry.store(result); | |
| verifyNoMoreInteractions(remoteCache); | |
| assertThat(progressUpdates).isEmpty(); | |
| } | |
| } | |
| } | |
| @Test | |
| public void noRemoteCacheSpawns_remoteCache() throws Exception { | |
| // Checks that spawns satisfying Spawns.mayBeCachedRemotely=false are not looked up in the | |
| // remote cache, and that the results/artifacts are not uploaded to the remote cache. | |
| RemoteOptions remoteCacheOptions = Options.getDefaults(RemoteOptions.class); | |
| remoteCacheOptions.remoteCache = "https://somecache.com"; | |
| RemoteSpawnCache remoteSpawnCache = remoteSpawnCacheWithOptions(remoteCacheOptions); | |
| for (String requirement : | |
| ImmutableList.of( | |
| ExecutionRequirements.NO_CACHE, | |
| ExecutionRequirements.LOCAL, | |
| ExecutionRequirements.NO_REMOTE_CACHE, | |
| ExecutionRequirements.NO_REMOTE)) { | |
| SimpleSpawn uncacheableSpawn = simpleSpawnWithExecutionInfo(ImmutableMap.of(requirement, "")); | |
| CacheHandle entry = remoteSpawnCache.lookup(uncacheableSpawn, simplePolicy); | |
| verify(remoteCache, never()) | |
| .downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false)); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(0) | |
| .setStatus(Status.SUCCESS) | |
| .setRunnerName("test") | |
| .build(); | |
| entry.store(result); | |
| verifyNoMoreInteractions(remoteCache); | |
| assertThat(progressUpdates).isEmpty(); | |
| } | |
| } | |
| @Test | |
| public void noRemoteCacheSpawns_combinedCache() throws Exception { | |
| // Checks that spawns satisfying Spawns.mayBeCachedRemotely=false are not looked up in the | |
| // remote cache, and that the results/artifacts are not uploaded to the remote cache. | |
| // For the purposes of execution requirements, a combined cache with a remote component | |
| // is considered a remote cache | |
| RemoteOptions combinedCacheOptions = Options.getDefaults(RemoteOptions.class); | |
| combinedCacheOptions.remoteCache = "https://somecache.com"; | |
| combinedCacheOptions.diskCache = PathFragment.create("/etc/something/cache/here"); | |
| RemoteSpawnCache remoteSpawnCache = remoteSpawnCacheWithOptions(combinedCacheOptions); | |
| for (String requirement : | |
| ImmutableList.of( | |
| ExecutionRequirements.NO_CACHE, | |
| ExecutionRequirements.LOCAL, | |
| ExecutionRequirements.NO_REMOTE_CACHE, | |
| ExecutionRequirements.NO_REMOTE)) { | |
| SimpleSpawn uncacheableSpawn = simpleSpawnWithExecutionInfo(ImmutableMap.of(requirement, "")); | |
| CacheHandle entry = remoteSpawnCache.lookup(uncacheableSpawn, simplePolicy); | |
| verify(remoteCache, never()) | |
| .downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false)); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(0) | |
| .setStatus(Status.SUCCESS) | |
| .setRunnerName("test") | |
| .build(); | |
| entry.store(result); | |
| verifyNoMoreInteractions(remoteCache); | |
| assertThat(progressUpdates).isEmpty(); | |
| } | |
| } | |
| @Test | |
| public void noRemoteCacheStillUsesLocalCache() throws Exception { | |
| RemoteOptions remoteOptions = Options.getDefaults(RemoteOptions.class); | |
| remoteOptions.diskCache = PathFragment.create("/etc/something/cache/here"); | |
| cache = remoteSpawnCacheWithOptions(remoteOptions); | |
| SimpleSpawn cacheableSpawn = | |
| simpleSpawnWithExecutionInfo(ImmutableMap.of(ExecutionRequirements.NO_REMOTE_CACHE, "")); | |
| cache.lookup(cacheableSpawn, simplePolicy); | |
| verify(remoteCache).downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false)); | |
| } | |
| @Test | |
| public void noRemoteExecStillUsesCache() throws Exception { | |
| SimpleSpawn cacheableSpawn = | |
| simpleSpawnWithExecutionInfo(ImmutableMap.of(ExecutionRequirements.NO_REMOTE_EXEC, "")); | |
| cache.lookup(cacheableSpawn, simplePolicy); | |
| verify(remoteCache).downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false)); | |
| } | |
| @Test | |
| public void failedActionsAreNotUploaded() throws Exception { | |
| // Only successful action results are uploaded to the remote cache. | |
| CacheHandle entry = cache.lookup(simpleSpawn, simplePolicy); | |
| verify(remoteCache).downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false)); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(1) | |
| .setStatus(Status.NON_ZERO_EXIT) | |
| .setRunnerName("test") | |
| .build(); | |
| ImmutableList<Path> outputFiles = ImmutableList.of(fs.getPath("/random/file")); | |
| entry.store(result); | |
| verify(remoteCache, never()) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| assertThat(progressUpdates) | |
| .containsExactly(Pair.of(ProgressStatus.CHECKING_CACHE, "remote-cache")); | |
| } | |
| @Test | |
| public void printWarningIfUploadFails() throws Exception { | |
| CacheHandle entry = cache.lookup(simpleSpawn, simplePolicy); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(0) | |
| .setStatus(Status.SUCCESS) | |
| .setRunnerName("test") | |
| .build(); | |
| ImmutableList<Path> outputFiles = ImmutableList.of(fs.getPath("/random/file")); | |
| doThrow(new IOException("cache down")) | |
| .when(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| entry.store(result); | |
| verify(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| assertThat(eventHandler.getEvents()).hasSize(1); | |
| Event evt = eventHandler.getEvents().get(0); | |
| assertThat(evt.getKind()).isEqualTo(EventKind.WARNING); | |
| assertThat(evt.getMessage()).contains("cache down"); | |
| assertThat(progressUpdates) | |
| .containsExactly(Pair.of(ProgressStatus.CHECKING_CACHE, "remote-cache")); | |
| } | |
| @Test | |
| public void printWarningIfDownloadFails() throws Exception { | |
| doThrow(new IOException(io.grpc.Status.UNAVAILABLE.asRuntimeException())) | |
| .when(remoteCache) | |
| .downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false)); | |
| CacheHandle entry = cache.lookup(simpleSpawn, simplePolicy); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(0) | |
| .setStatus(Status.SUCCESS) | |
| .setRunnerName("test") | |
| .build(); | |
| ImmutableList<Path> outputFiles = ImmutableList.of(fs.getPath("/random/file")); | |
| Mockito.doAnswer( | |
| new Answer<Void>() { | |
| @Override | |
| public Void answer(InvocationOnMock invocation) { | |
| RequestMetadata meta = TracingMetadataUtils.fromCurrentContext(); | |
| assertThat(meta.getCorrelatedInvocationsId()).isEqualTo("build-req-id"); | |
| assertThat(meta.getToolInvocationId()).isEqualTo("command-id"); | |
| return null; | |
| } | |
| }) | |
| .when(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| entry.store(result); | |
| verify(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| assertThat(eventHandler.getEvents()).hasSize(1); | |
| Event evt = eventHandler.getEvents().get(0); | |
| assertThat(evt.getKind()).isEqualTo(EventKind.WARNING); | |
| assertThat(evt.getMessage()).contains("UNAVAILABLE"); | |
| assertThat(progressUpdates) | |
| .containsExactly(Pair.of(ProgressStatus.CHECKING_CACHE, "remote-cache")); | |
| } | |
| @Test | |
| public void orphanedCachedResultIgnored() throws Exception { | |
| Digest digest = digestUtil.computeAsUtf8("bla"); | |
| ActionResult actionResult = | |
| ActionResult.newBuilder() | |
| .addOutputFiles(OutputFile.newBuilder().setPath("/random/file").setDigest(digest)) | |
| .build(); | |
| when(remoteCache.downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false))) | |
| .thenAnswer( | |
| new Answer<ActionResult>() { | |
| @Override | |
| public ActionResult answer(InvocationOnMock invocation) { | |
| RequestMetadata meta = TracingMetadataUtils.fromCurrentContext(); | |
| assertThat(meta.getCorrelatedInvocationsId()).isEqualTo("build-req-id"); | |
| assertThat(meta.getToolInvocationId()).isEqualTo("command-id"); | |
| return actionResult; | |
| } | |
| }); | |
| doThrow(new CacheNotFoundException(digest)) | |
| .when(remoteCache) | |
| .download(eq(actionResult), eq(execRoot), eq(outErr), any()); | |
| CacheHandle entry = cache.lookup(simpleSpawn, simplePolicy); | |
| assertThat(entry.hasResult()).isFalse(); | |
| SpawnResult result = | |
| new SpawnResult.Builder() | |
| .setExitCode(0) | |
| .setStatus(Status.SUCCESS) | |
| .setRunnerName("test") | |
| .build(); | |
| ImmutableList<Path> outputFiles = ImmutableList.of(fs.getPath("/random/file")); | |
| Mockito.doAnswer( | |
| new Answer<Void>() { | |
| @Override | |
| public Void answer(InvocationOnMock invocation) { | |
| RequestMetadata meta = TracingMetadataUtils.fromCurrentContext(); | |
| assertThat(meta.getCorrelatedInvocationsId()).isEqualTo("build-req-id"); | |
| assertThat(meta.getToolInvocationId()).isEqualTo("command-id"); | |
| return null; | |
| } | |
| }) | |
| .when(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| entry.store(result); | |
| verify(remoteCache) | |
| .upload( | |
| any(ActionKey.class), | |
| any(Action.class), | |
| any(Command.class), | |
| any(Path.class), | |
| eq(outputFiles), | |
| eq(outErr)); | |
| assertThat(progressUpdates) | |
| .containsExactly(Pair.of(ProgressStatus.CHECKING_CACHE, "remote-cache")); | |
| assertThat(eventHandler.getEvents()).isEmpty(); // no warning is printed. | |
| } | |
| @Test | |
| public void failedCacheActionAsCacheMiss() throws Exception { | |
| ActionResult actionResult = ActionResult.newBuilder().setExitCode(1).build(); | |
| when(remoteCache.downloadActionResult(any(ActionKey.class), /* inlineOutErr= */ eq(false))) | |
| .thenReturn(actionResult); | |
| CacheHandle entry = cache.lookup(simpleSpawn, simplePolicy); | |
| assertThat(entry.hasResult()).isFalse(); | |
| } | |
| @Test | |
| public void testDownloadMinimal() throws Exception { | |
| // arrange | |
| RemoteOptions remoteOptions = Options.getDefaults(RemoteOptions.class); | |
| remoteOptions.remoteOutputsMode = RemoteOutputsMode.MINIMAL; | |
| cache = remoteSpawnCacheWithOptions(remoteOptions); | |
| ActionResult success = ActionResult.newBuilder().setExitCode(0).build(); | |
| when(remoteCache.downloadActionResult(any(), /* inlineOutErr= */ eq(false))) | |
| .thenReturn(success); | |
| // act | |
| CacheHandle cacheHandle = cache.lookup(simpleSpawn, simplePolicy); | |
| // assert | |
| assertThat(cacheHandle.hasResult()).isTrue(); | |
| assertThat(cacheHandle.getResult().exitCode()).isEqualTo(0); | |
| verify(remoteCache).downloadMinimal(any(), anyCollection(), any(), any(), any(), any(), any()); | |
| } | |
| @Test | |
| public void testDownloadMinimalIoError() throws Exception { | |
| // arrange | |
| RemoteOptions remoteOptions = Options.getDefaults(RemoteOptions.class); | |
| remoteOptions.remoteOutputsMode = RemoteOutputsMode.MINIMAL; | |
| cache = remoteSpawnCacheWithOptions(remoteOptions); | |
| IOException downloadFailure = new IOException("downloadMinimal failed"); | |
| ActionResult success = ActionResult.newBuilder().setExitCode(0).build(); | |
| when(remoteCache.downloadActionResult(any(), /* inlineOutErr= */ eq(false))) | |
| .thenReturn(success); | |
| when(remoteCache.downloadMinimal(any(), anyCollection(), any(), any(), any(), any(), any())) | |
| .thenThrow(downloadFailure); | |
| // act | |
| CacheHandle cacheHandle = cache.lookup(simpleSpawn, simplePolicy); | |
| // assert | |
| assertThat(cacheHandle.hasResult()).isFalse(); | |
| verify(remoteCache).downloadMinimal(any(), anyCollection(), any(), any(), any(), any(), any()); | |
| assertThat(eventHandler.getEvents().size()).isEqualTo(1); | |
| Event evt = eventHandler.getEvents().get(0); | |
| assertThat(evt.getKind()).isEqualTo(EventKind.WARNING); | |
| assertThat(evt.getMessage()).contains(downloadFailure.getMessage()); | |
| } | |
| } |