Separate RemoteAnalysisCacheManager and RemoteAnalysisCacheDeps.

The idea is that the former will be called from BuildTool/BuildView/etc., the rest, from the actual serialization/deserialization machinery.

RELNOTES: None.
PiperOrigin-RevId: 884327425
Change-Id: I677b39642db872bcbf2e91f35e288cdb3dabfb48

Author: lberki

src/main/java/com/google/devtools/build/lib/buildtool/BuildTool.java

@@ -366,7 +366,7 @@ public void buildTargets(
         applyHeuristicInstrumentationFilter(buildOptions, targetPatternPhaseValue);
       }
       var analysisDeps =
-          RemoteAnalysisCacheManager.forAnalysis(
+          RemoteAnalysisCacheManager.create(
               env,
               projectEvaluationResult.activeDirectoriesMatcher(),
               targetPatternPhaseValue.getTargetLabels(),

src/main/java/com/google/devtools/build/lib/skyframe/serialization/analysis/BUILD

@@ -364,14 +364,13 @@ java_library(
         ":analysis_cache_invalidator",
         ":client_id",
         ":dependencies_provider",
-        ":event_listener",
         ":frontier_serializer",
         ":options",
         ":remote_analysis_cache_client",
+        ":remote_analysis_cache_deps",
         ":remote_analysis_caching_server_state",
         ":remote_analysis_caching_services_supplier",
         ":remote_analysis_json_log_writer",
-        ":remote_analysis_metadata_writer",
         "//src/main/java/com/google/devtools/build/lib/actions:artifacts",
         "//src/main/java/com/google/devtools/build/lib/analysis:blaze_directories",
         "//src/main/java/com/google/devtools/build/lib/analysis:blaze_version_info",
@@ -406,3 +405,25 @@ java_library(
         "//third_party:jsr305",
     ],
 )
+
+java_library(
+    name = "remote_analysis_cache_deps",
+    srcs = ["RemoteAnalysisCacheDeps.java"],
+    deps = [
+        ":dependencies_provider",
+        ":event_listener",
+        ":options",
+        ":remote_analysis_cache_client",
+        ":remote_analysis_caching_services_supplier",
+        ":remote_analysis_json_log_writer",
+        ":remote_analysis_metadata_writer",
+        "//src/main/java/com/google/devtools/build/lib/cmdline",
+        "//src/main/java/com/google/devtools/build/lib/events",
+        "//src/main/java/com/google/devtools/build/lib/skyframe/serialization",
+        "//src/main/java/com/google/devtools/build/lib/skyframe/serialization:frontier_node_version",
+        "//src/main/java/com/google/devtools/build/skyframe:skyframe-objects",
+        "//third_party:flogger",
+        "//third_party:guava",
+        "//third_party:jsr305",
+    ],
+)

src/main/java/com/google/devtools/build/lib/skyframe/serialization/analysis/RemoteAnalysisCacheDeps.java

@@ -0,0 +1,201 @@
+// Copyright 2026 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.serialization.analysis;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.google.common.flogger.GoogleLogger;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.devtools.build.lib.cmdline.PackageIdentifier;
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.events.ExtendedEventHandler;
+import com.google.devtools.build.lib.skyframe.serialization.FingerprintValueService;
+import com.google.devtools.build.lib.skyframe.serialization.FrontierNodeVersion;
+import com.google.devtools.build.lib.skyframe.serialization.KeyValueWriter;
+import com.google.devtools.build.lib.skyframe.serialization.ObjectCodecs;
+import com.google.devtools.build.lib.skyframe.serialization.SerializationException;
+import com.google.devtools.build.lib.skyframe.serialization.SkyValueRetriever.RetrievalResult;
+import com.google.devtools.build.lib.skyframe.serialization.analysis.RemoteAnalysisCachingDependenciesProvider.SerializationDependenciesProvider;
+import com.google.devtools.build.lib.skyframe.serialization.analysis.RemoteAnalysisCachingOptions.RemoteAnalysisCacheMode;
+import com.google.devtools.build.skyframe.SkyKey;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Predicate;
+import javax.annotation.Nullable;
+
+class RemoteAnalysisCacheDeps
+    implements SerializationDependenciesProvider, RemoteAnalysisCacheReaderDepsProvider {
+  private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
+
+  private static final long CLIENT_LOOKUP_TIMEOUT_SEC = 20L;
+
+  private final RemoteAnalysisCacheMode mode;
+  private final boolean bailOutOnMissingFingerprint;
+  private final String serializedFrontierProfile;
+  private final Optional<Predicate<PackageIdentifier>> activeDirectoriesMatcher;
+  private final RemoteAnalysisCachingEventListener listener;
+  private final FrontierNodeVersion frontierNodeVersion;
+  @Nullable private final RemoteAnalysisJsonLogWriter jsonLogWriter;
+
+  private final ListenableFuture<ObjectCodecs> objectCodecs;
+  private final ListenableFuture<FingerprintValueService> fingerprintValueServiceFuture;
+  @Nullable private final ListenableFuture<? extends RemoteAnalysisCacheClient> analysisCacheClient;
+  @Nullable private final ListenableFuture<? extends RemoteAnalysisMetadataWriter> metadataWriter;
+
+  private final AtomicBoolean bailedOut = new AtomicBoolean();
+  private final ExtendedEventHandler eventHandler;
+
+  RemoteAnalysisCacheDeps(
+      ExtendedEventHandler eventHandler,
+      RemoteAnalysisCacheMode mode,
+      boolean bailOutOnMissingFingerprint,
+      RemoteAnalysisCachingServicesSupplier servicesSupplier,
+      RemoteAnalysisCachingEventListener listener,
+      RemoteAnalysisJsonLogWriter jsonLogWriter,
+      ListenableFuture<ObjectCodecs> objectCodecs,
+      FrontierNodeVersion frontierNodeVersion,
+      Optional<Predicate<PackageIdentifier>> activeDirectoriesMatcher,
+      String serializedFrontierProfile) {
+    this.mode = mode;
+    this.bailOutOnMissingFingerprint = bailOutOnMissingFingerprint;
+    this.serializedFrontierProfile = serializedFrontierProfile;
+    this.activeDirectoriesMatcher = activeDirectoriesMatcher;
+    this.eventHandler = eventHandler;
+
+    this.jsonLogWriter = jsonLogWriter;
+
+    this.objectCodecs = objectCodecs;
+    this.listener = listener;
+
+    this.frontierNodeVersion = frontierNodeVersion;
+
+    this.fingerprintValueServiceFuture = servicesSupplier.getFingerprintValueService();
+    this.metadataWriter = servicesSupplier.getMetadataWriter();
+    this.analysisCacheClient = servicesSupplier.getAnalysisCacheClient();
+  }
+
+  static <T> T resolveWithTimeout(Future<? extends T> future, String what)
+      throws InterruptedException {
+    if (future == null) {
+      return null;
+    }
+    try {
+      return future.get(CLIENT_LOOKUP_TIMEOUT_SEC, SECONDS);
+    } catch (ExecutionException | TimeoutException e) {
+      logger.atWarning().withCause(e).log("Unable to initialize %s", what);
+      return null;
+    }
+  }
+
+  @Override
+  public RemoteAnalysisCacheMode mode() {
+    return mode;
+  }
+
+  @Override
+  public String getSerializedFrontierProfile() {
+    return serializedFrontierProfile;
+  }
+
+  @Override
+  public Optional<Predicate<PackageIdentifier>> getActiveDirectoriesMatcher() {
+    return activeDirectoriesMatcher;
+  }
+
+  @Override
+  public FrontierNodeVersion getSkyValueVersion() {
+    return frontierNodeVersion;
+  }
+
+  @Override
+  public ObjectCodecs getObjectCodecs() throws InterruptedException {
+    try {
+      return objectCodecs.get();
+    } catch (ExecutionException e) {
+      throw new IllegalStateException("Failed to initialize ObjectCodecs", e);
+    }
+  }
+
+  @Override
+  public FingerprintValueService getFingerprintValueService() throws InterruptedException {
+    return resolveWithTimeout(fingerprintValueServiceFuture, "fingerprint value service");
+  }
+
+  @Override
+  public KeyValueWriter getFileInvalidationWriter() throws InterruptedException {
+    return getFingerprintValueService();
+  }
+
+  @Override
+  @Nullable
+  public RemoteAnalysisCacheClient getAnalysisCacheClient() throws InterruptedException {
+    return resolveWithTimeout(analysisCacheClient, "analysis cache client");
+  }
+
+  @Override
+  @Nullable
+  public RemoteAnalysisMetadataWriter getMetadataWriter() throws InterruptedException {
+    return resolveWithTimeout(metadataWriter, "metadata writer");
+  }
+
+  @Nullable
+  @Override
+  public RemoteAnalysisJsonLogWriter getJsonLogWriter() {
+    return jsonLogWriter;
+  }
+
+  @Override
+  public void recordRetrievalResult(RetrievalResult retrievalResult, SkyKey key) {
+    listener.recordRetrievalResult(retrievalResult, key);
+  }
+
+  @Override
+  public void recordSerializationException(SerializationException e, SkyKey key) {
+    listener.recordSerializationException(e, key);
+  }
+
+  @Override
+  public boolean shouldBailOutOnMissingFingerprint() {
+    if (!bailOutOnMissingFingerprint) {
+      return false;
+    }
+    if (bailedOut.get()) {
+      return true;
+    }
+
+    try {
+      FingerprintValueService service = getFingerprintValueService();
+      boolean retVal = service != null && service.getStats().entriesNotFound() > 0;
+      if (retVal) {
+        bailedOut.set(true);
+        eventHandler.handle(
+            Event.warn(
+                "Skycache: falling back to local evaluation due to unexpected missing cache"
+                    + " entries"));
+        analysisCacheClient.get().bailOutDueToMissingFingerprint();
+      }
+      return retVal;
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      return false;
+    } catch (ExecutionException e) {
+      throw new IllegalStateException(
+          "At this point the Skycache client should have been initialized", e);
+    }
+  }
+}