Faster cache (#1253)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: lewisbirks <22620804+lewisbirks@users.noreply.github.com>

Author: 3 people

src/main/java/io/jenkins/plugins/pipelinegraphview/consoleview/PipelineConsoleViewAction.java

@@ -19,6 +19,7 @@
 import io.jenkins.plugins.pipelinegraphview.cards.items.TestResultRunDetailsItem;
 import io.jenkins.plugins.pipelinegraphview.utils.PipelineGraph;
 import io.jenkins.plugins.pipelinegraphview.utils.PipelineGraphApi;
+import io.jenkins.plugins.pipelinegraphview.utils.PipelineGraphViewCache;
 import io.jenkins.plugins.pipelinegraphview.utils.PipelineJsonWriter;
 import io.jenkins.plugins.pipelinegraphview.utils.PipelineNodeUtil;
 import io.jenkins.plugins.pipelinegraphview.utils.PipelineStep;
@@ -99,9 +100,15 @@ public void getSteps(StaplerRequest2 req, StaplerResponse2 rsp) throws IOExcepti
     @WebMethod(name = "allSteps")
     public void getAllSteps(StaplerRequest2 req, StaplerResponse2 rsp) throws IOException, ServletException {
         run.checkPermission(Item.READ);
-        PipelineStepList steps = stepApi.getAllSteps();
         rsp.setStatus(200);
         rsp.setContentType("application/json;charset=UTF-8");
+        // Speculative: a cache hit always implies the run was complete when persisted.
+        // Overwritten below if we fall through to the compute path.
+        setCache(rsp, true);
+        if (PipelineGraphViewCache.get().tryServeAllSteps(run, rsp.getOutputStream())) {
+            return;
+        }
+        PipelineStepList steps = stepApi.getAllSteps();
         setCache(rsp, steps.runIsComplete);
         PipelineJsonWriter.write(steps, rsp.getOutputStream());
     }
@@ -383,10 +390,13 @@ public String getNextBuildNumber() {
     @WebMethod(name = "tree")
     public void getTree(StaplerRequest2 req, StaplerResponse2 rsp) throws IOException, ServletException {
         run.checkPermission(Item.READ);
-
-        PipelineGraph tree = graphApi.createTree();
         rsp.setStatus(200);
         rsp.setContentType("application/json;charset=UTF-8");
+        setCache(rsp, true);
+        if (PipelineGraphViewCache.get().tryServeTree(run, rsp.getOutputStream())) {
+            return;
+        }
+        PipelineGraph tree = graphApi.createTree();
         setCache(rsp, tree.complete);
         PipelineJsonWriter.write(tree, rsp.getOutputStream());
     }

src/main/java/io/jenkins/plugins/pipelinegraphview/utils/AbstractPipelineNode.java

@@ -47,6 +47,33 @@ public AbstractPipelineNode(
         this.idAsInt = Integer.parseInt(id);
     }
 
+    /**
+     * Read-back constructor for the cached wire JSON. The wire shape splits {@code TimingInfo}
+     * into three flat millis fields (and omits {@code totalDurationMillis} when in-progress);
+     * we rebuild a {@link TimingInfo} so the rest of the object behaves identically to one
+     * produced by the live compute path.
+     */
+    protected AbstractPipelineNode(
+            String id,
+            String name,
+            PipelineState state,
+            String type,
+            String title,
+            long pauseDurationMillis,
+            Long totalDurationMillis,
+            long startTimeMillis,
+            String causeOfBlockage) {
+        this(
+                id,
+                name,
+                state,
+                type,
+                title,
+                new TimingInfo(
+                        totalDurationMillis != null ? totalDurationMillis : 0L, pauseDurationMillis, startTimeMillis),
+                causeOfBlockage);
+    }
+
     public long getStartTimeMillis() {
         return timingInfo.getStartTimeMillis();
     }

src/main/java/io/jenkins/plugins/pipelinegraphview/utils/PipelineGraph.java

@@ -1,12 +1,14 @@
 package io.jenkins.plugins.pipelinegraphview.utils;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
 import java.util.List;
 
 public class PipelineGraph {
 
     final List<PipelineStage> stages;
     public final boolean complete;
 
+    @JsonCreator
     public PipelineGraph(List<PipelineStage> stages, boolean complete) {
         this.stages = stages;
         this.complete = complete;

src/main/java/io/jenkins/plugins/pipelinegraphview/utils/PipelineGraphViewCache.java

@@ -1,36 +1,60 @@
 package io.jenkins.plugins.pipelinegraphview.utils;
 
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.JsonInclude;
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
-import hudson.XmlFile;
-import hudson.util.XStream2;
-import io.jenkins.plugins.pipelinegraphview.analysis.TimingInfo;
-import java.io.File;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.function.Supplier;
 import org.jenkinsci.plugins.workflow.job.WorkflowRun;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import tools.jackson.databind.ObjectMapper;
+import tools.jackson.databind.json.JsonMapper;
 
 /**
  * Disk-backed cache for the computed pipeline graph and step list of completed runs.
  * For in-progress runs the cache is transparent (every call recomputes). Once a run is
- * no longer building, results are persisted under the run's directory, so later
- * requests — including after a Jenkins restart — are served without recomputation.
+ * no longer building, results are persisted as JSON under the run's directory and can be
+ * streamed straight back to HTTP clients without going through Jackson on the read path.
+ *
+ * <p>The on-disk format is the same wire JSON the {@code tree} / {@code allSteps} endpoints
+ * emit (the {@code data} portion of the {@code {"status":"ok","data":...}} envelope).
+ * {@link #tryServeTree(WorkflowRun, OutputStream)} / {@link #tryServeAllSteps(WorkflowRun,
+ * OutputStream)} wrap that in the envelope and copy bytes through.
+ *
+ * <p>Schema version is encoded in the file name: a future format change just bumps
+ * {@link #SCHEMA_VERSION} so old files become orphans on disk and are ignored.
  */
 public class PipelineGraphViewCache {
 
-    /**
-     * Hand-bump when any persisted DTO shape changes in a non-backwards-compatible way.
-     * Older files are ignored and recomputed on the next read.
-     */
-    static final int SCHEMA_VERSION = 1;
+    public static final int SCHEMA_VERSION = 1;
+
+    public static final String TREE_FILE_NAME = "pipeline-graph-view-tree.v" + SCHEMA_VERSION + ".json";
+    public static final String ALL_STEPS_FILE_NAME = "pipeline-graph-view-allsteps.v" + SCHEMA_VERSION + ".json";
+    public static final String LEGACY_XSTREAM_FILE_NAME = "pipeline-graph-view-cache.xml";
+
+    private static final byte[] ENVELOPE_PREFIX = "{\"status\":\"ok\",\"data\":".getBytes(StandardCharsets.UTF_8);
+    private static final byte[] ENVELOPE_SUFFIX = "}".getBytes(StandardCharsets.UTF_8);
 
-    private static final String CACHE_FILE_NAME = "pipeline-graph-view-cache.xml";
     private static final Logger logger = LoggerFactory.getLogger(PipelineGraphViewCache.class);
     private static final PipelineGraphViewCache INSTANCE = new PipelineGraphViewCache();
 
-    private final Cache<String, CachedPayload> memCache =
+    private static final ObjectMapper MAPPER = JsonMapper.builder()
+            .changeDefaultPropertyInclusion(inc -> inc.withValueInclusion(JsonInclude.Include.NON_NULL))
+            .changeDefaultVisibility(v -> v.withFieldVisibility(JsonAutoDetect.Visibility.ANY))
+            .build();
+
+    private final Cache<String, CachedValue> memCache =
             Caffeine.newBuilder().maximumSize(256).build();
 
     public static PipelineGraphViewCache get() {
@@ -39,33 +63,62 @@ public static PipelineGraphViewCache get() {
 
     PipelineGraphViewCache() {}
 
+    /**
+     * If a cached graph file exists for {@code run}, write it to {@code out} wrapped in the
+     * Stapler {@code okJSON} envelope and return {@code true}. Otherwise no bytes are written.
+     */
+    public boolean tryServeTree(WorkflowRun run, OutputStream out) throws IOException {
+        return tryServe(treeFile(run), out);
+    }
+
+    /** {@link #tryServeTree} for the all-steps payload. */
+    public boolean tryServeAllSteps(WorkflowRun run, OutputStream out) throws IOException {
+        return tryServe(allStepsFile(run), out);
+    }
+
+    private boolean tryServe(Path file, OutputStream out) throws IOException {
+        if (!Files.exists(file)) {
+            return false;
+        }
+        out.write(ENVELOPE_PREFIX);
+        try (InputStream in = new BufferedInputStream(Files.newInputStream(file))) {
+            in.transferTo(out);
+        }
+        out.write(ENVELOPE_SUFFIX);
+        return true;
+    }
+
     public PipelineGraph getGraph(WorkflowRun run, Supplier<PipelineGraph> compute) {
         if (run.isBuilding()) {
             return compute.get();
         }
-        CachedPayload payload = load(run);
-        synchronized (payload) {
-            if (payload.graph == null) {
-                payload.graph = compute.get();
-                payload.schemaVersion = SCHEMA_VERSION;
-                write(run, payload);
+        CachedValue entry = memCache.get(run.getExternalizableId(), k -> new CachedValue());
+        synchronized (entry) {
+            if (entry.graph == null) {
+                entry.graph = readJson(treeFile(run), PipelineGraph.class);
+            }
+            if (entry.graph == null) {
+                entry.graph = compute.get();
+                writeJson(treeFile(run), entry.graph);
             }
-            return payload.graph;
+            return entry.graph;
         }
     }
 
     public PipelineStepList getAllSteps(WorkflowRun run, Supplier<PipelineStepList> compute) {
         if (run.isBuilding()) {
             return compute.get();
         }
-        CachedPayload payload = load(run);
-        synchronized (payload) {
-            if (payload.allSteps == null) {
-                payload.allSteps = compute.get();
-                payload.schemaVersion = SCHEMA_VERSION;
-                write(run, payload);
+        CachedValue entry = memCache.get(run.getExternalizableId(), k -> new CachedValue());
+        synchronized (entry) {
+            if (entry.allSteps == null) {
+                entry.allSteps = readJson(allStepsFile(run), PipelineStepList.class);
             }
-            return payload.allSteps;
+            if (entry.allSteps == null) {
+                entry.allSteps = compute.get();
+                writeJson(allStepsFile(run), entry.allSteps);
+            }
+            return entry.allSteps;
         }
     }
 
@@ -76,69 +129,77 @@ public PipelineStepList getAllSteps(WorkflowRun run, Supplier<PipelineStepList>
      * {@code WorkflowRun.isBuilding()} may not have flipped yet.
      */
     public void seed(WorkflowRun run, PipelineGraph graph, PipelineStepList allSteps) {
-        CachedPayload payload = load(run);
-        synchronized (payload) {
-            payload.graph = graph;
-            payload.allSteps = allSteps;
-            payload.schemaVersion = SCHEMA_VERSION;
-            write(run, payload);
+        CachedValue entry = memCache.get(run.getExternalizableId(), k -> new CachedValue());
+        synchronized (entry) {
+            entry.graph = graph;
+            entry.allSteps = allSteps;
+            writeJson(treeFile(run), graph);
+            writeJson(allStepsFile(run), allSteps);
         }
     }
 
-    private CachedPayload load(WorkflowRun run) {
-        return memCache.get(run.getExternalizableId(), k -> readFromDisk(run));
+    /** Returns the JSON-decoded value at {@code source} or {@code null} if the file is absent or unreadable. */
+    private <T> T readJson(Path source, Class<T> type) {
+        if (!Files.exists(source)) {
+            return null;
+        }
+        try (InputStream in = new BufferedInputStream(Files.newInputStream(source))) {
+            return MAPPER.readValue(in, type);
+        } catch (IOException e) {
+            // A corrupt/older file shouldn't wedge the cache: drop it and fall back to compute.
+            logger.warn("Failed to read pipeline graph cache for {}; recomputing", source, e);
+            return null;
+        }
     }
 
-    private CachedPayload readFromDisk(WorkflowRun run) {
-        XmlFile file = cacheFile(run);
-        if (!file.exists()) {
-            return new CachedPayload();
+    private void writeJson(Path target, Object data) {
+        Path dir = target.getParent();
+        if (dir == null) {
+            throw new RuntimeException("No parent directory for " + target);
         }
+        Path tmp = null;
         try {
-            Object read = file.read();
-            if (read instanceof CachedPayload loaded && loaded.schemaVersion == SCHEMA_VERSION) {
-                return loaded;
+            tmp = Files.createTempFile(dir, target.getFileName() + ".", ".tmp");
+            try (OutputStream os = new BufferedOutputStream(Files.newOutputStream(tmp))) {
+                MAPPER.writeValue(os, data);
+            }
+            try {
+                Files.move(tmp, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            } catch (AtomicMoveNotSupportedException e) {
+                Files.move(tmp, target, StandardCopyOption.REPLACE_EXISTING);
             }
-            logger.debug("Discarding pipeline graph cache for {}: schema version mismatch", run.getExternalizableId());
+            tmp = null;
+            // Best-effort cleanup of any pre-v1 XStream cache left behind by older versions
+            // of the plugin.
+            Files.deleteIfExists(dir.resolve(LEGACY_XSTREAM_FILE_NAME));
         } catch (IOException e) {
-            logger.warn("Failed to read pipeline graph cache for {}", run.getExternalizableId(), e);
+            logger.warn("Failed to write pipeline graph cache for {}", target.getFileName(), e);
+        } finally {
+            if (tmp != null) {
+                try {
+                    Files.deleteIfExists(tmp);
+                } catch (IOException e) {
+                    logger.warn("Failed to delete temporary pipeline graph cache file", e);
+                }
+            }
         }
-        return new CachedPayload();
     }
 
-    private void write(WorkflowRun run, CachedPayload payload) {
-        try {
-            cacheFile(run).write(payload);
-        } catch (IOException e) {
-            logger.warn("Failed to write pipeline graph cache for {}", run.getExternalizableId(), e);
-        }
+    private Path treeFile(WorkflowRun run) {
+        return run.getRootDir().toPath().resolve(TREE_FILE_NAME);
     }
 
-    private XmlFile cacheFile(WorkflowRun run) {
-        return new XmlFile(XSTREAM, new File(run.getRootDir(), CACHE_FILE_NAME));
+    private Path allStepsFile(WorkflowRun run) {
+        return run.getRootDir().toPath().resolve(ALL_STEPS_FILE_NAME);
     }
 
-    /** Test hook: drop in-memory entries so the next call goes through the disk read path. */
+    /** Test hook: drop in-memory entries so the next call re-runs the supplier. */
     void invalidateMemory() {
         memCache.invalidateAll();
     }
 
-    static class CachedPayload {
-        int schemaVersion;
+    static class CachedValue {
         PipelineGraph graph;
         PipelineStepList allSteps;
     }
-
-    private static final XStream2 XSTREAM = new XStream2();
-
-    static {
-        XSTREAM.alias("pipeline-graph-view-cache", CachedPayload.class);
-        XSTREAM.alias("pipeline-graph", PipelineGraph.class);
-        XSTREAM.alias("pipeline-stage", PipelineStage.class);
-        XSTREAM.alias("pipeline-step", PipelineStep.class);
-        XSTREAM.alias("pipeline-step-list", PipelineStepList.class);
-        XSTREAM.alias("pipeline-input-step", PipelineInputStep.class);
-        XSTREAM.alias("timing-info", TimingInfo.class);
-        XSTREAM.alias("pipeline-state", PipelineState.class);
-    }
 }