Cache WarningActions (#1226)

Author: timja

src/main/java/io/jenkins/plugins/pipelinegraphview/analysis/StatusAndTiming.java

@@ -31,6 +31,8 @@
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import hudson.model.Action;
 import hudson.model.Result;
+import io.jenkins.plugins.pipelinegraphview.livestate.LiveGraphRegistry;
+import io.jenkins.plugins.pipelinegraphview.livestate.WarningActionCache;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -349,7 +351,18 @@ public static GenericStatus computeChunkStatus2(
         if (DISABLE_WARNING_ACTION_LOOKUP) {
             return null;
         }
-        // TODO: Cache the result?
+        // Only memoise closed blocks: once a BlockEndNode exists, the set of inner nodes is
+        // fixed and WarningActions on them don't change. For open-ended chunks (start == end,
+        // or end isn't a block end) the scan is either trivial or the result may still change.
+        boolean cacheable = start != end && end instanceof BlockEndNode<?>;
+        WarningActionCache cache = cacheable ? LiveGraphRegistry.get().warningActionCache(start.getExecution()) : null;
+        if (cache != null) {
+            return cache.getOrCompute(start.getId(), end.getId(), () -> scanForWarning(start, end));
+        }
+        return scanForWarning(start, end);
+    }
+
+    private static @CheckForNull WarningAction scanForWarning(@NonNull FlowNode start, @NonNull FlowNode end) {
         DepthFirstScanner scanner = new DepthFirstScanner();
         if (!scanner.setup(end, Collections.singletonList(start))) {
             return null;

src/main/java/io/jenkins/plugins/pipelinegraphview/livestate/LiveGraphRegistry.java

@@ -2,6 +2,7 @@
 
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
+import edu.umd.cs.findbugs.annotations.CheckForNull;
 import io.jenkins.plugins.pipelinegraphview.utils.PipelineGraph;
 import io.jenkins.plugins.pipelinegraphview.utils.PipelineStepList;
 import java.time.Duration;
@@ -140,7 +141,7 @@ public void cacheAllSteps(WorkflowRun run, long version, PipelineStepList steps)
      * Returns a per-run monitor that callers can synchronise on to dedup concurrent graph
      * rebuilds. Null when the live state isn't present (caller just computes directly).
      */
-    @edu.umd.cs.findbugs.annotations.CheckForNull
+    @CheckForNull
     public Object graphComputeLock(WorkflowRun run) {
         if (disabled()) {
             return null;
@@ -150,7 +151,7 @@ public Object graphComputeLock(WorkflowRun run) {
     }
 
     /** See {@link #graphComputeLock(WorkflowRun)} — the matching lock for the steps path. */
-    @edu.umd.cs.findbugs.annotations.CheckForNull
+    @CheckForNull
     public Object allStepsComputeLock(WorkflowRun run) {
         if (disabled()) {
             return null;
@@ -159,6 +160,23 @@ public Object allStepsComputeLock(WorkflowRun run) {
         return state == null ? null : state.allStepsComputeLock();
     }
 
+    /**
+     * Returns the {@link WarningActionCache} for this execution, or {@code null} when the
+     * live state isn't present. Callers fall back to uncached scans on null.
+     */
+    @CheckForNull
+    public WarningActionCache warningActionCache(FlowExecution execution) {
+        if (disabled()) {
+            return null;
+        }
+        String key = keyFor(execution);
+        if (key == null) {
+            return null;
+        }
+        LiveGraphState state = states.getIfPresent(key);
+        return state == null ? null : state.warningActionCache();
+    }
+
     private static String keyFor(FlowExecution execution) {
         try {
             Object exec = execution.getOwner().getExecutable();

src/main/java/io/jenkins/plugins/pipelinegraphview/livestate/LiveGraphState.java

@@ -46,6 +46,8 @@ final class LiveGraphState {
     private VersionedCache<PipelineGraph> cachedGraph;
     private VersionedCache<PipelineStepList> cachedAllSteps;
 
+    private final WarningActionCache warningActionCache = new WarningActionCache();
+
     // Serialise concurrent rebuilds so N HTTP readers don't each do the same O(nodes) work.
     // Separate locks for tree vs steps — a slow tree rebuild must not starve steps.
     private final Object graphComputeLock = new Object();
@@ -172,5 +174,9 @@ Object allStepsComputeLock() {
         return allStepsComputeLock;
     }
 
+    WarningActionCache warningActionCache() {
+        return warningActionCache;
+    }
+
     private record VersionedCache<T>(long version, T value) {}
 }

src/main/java/io/jenkins/plugins/pipelinegraphview/livestate/WarningActionCache.java

@@ -0,0 +1,47 @@
+package io.jenkins.plugins.pipelinegraphview.livestate;
+
+import edu.umd.cs.findbugs.annotations.CheckForNull;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+import org.jenkinsci.plugins.workflow.actions.WarningAction;
+
+/**
+ * Per-run cache of {@link WarningAction} lookups between two flow nodes. The underlying scan
+ * in {@code StatusAndTiming.findWorstWarningBetween} walks every node between a stage's start
+ * and end, which dominates {@code /allSteps} on large completed runs. WarningActions don't
+ * change after attach, so once both endpoints exist (and for completed blocks, the set of
+ * inner nodes is fixed) the result is stable and can be memoised.
+ */
+public final class WarningActionCache {
+
+    // ConcurrentHashMap disallows null values, so we wrap each result in Optional — the
+    // Optional is never itself null, it's either present (a WarningAction) or empty
+    // (cached: no warning on this range). Map.get returning null means "not yet cached".
+    private final Map<String, Optional<WarningAction>> byRange = new ConcurrentHashMap<>();
+
+    WarningActionCache() {}
+
+    /**
+     * Returns the cached result for {@code (startId, endId)}, or invokes {@code computer} to
+     * resolve and caches the result before returning.
+     */
+    @CheckForNull
+    public WarningAction getOrCompute(
+            @NonNull String startId, @NonNull String endId, @NonNull Supplier<WarningAction> computer) {
+        String k = key(startId, endId);
+        Optional<WarningAction> cached = byRange.get(k);
+        if (cached != null) {
+            return cached.orElse(null);
+        }
+        WarningAction computed = computer.get();
+        byRange.put(k, Optional.ofNullable(computed));
+        return computed;
+    }
+
+    private static String key(String startId, String endId) {
+        return startId + ':' + endId;
+    }
+}