jenkinsci · jglick · Oct 17, 2022 · Nov 16, 2021 · Nov 16, 2021 · Nov 16, 2021
@@ -81,7 +81,6 @@
 import org.jenkinsci.plugins.workflow.steps.StepExecution;
 import org.jenkinsci.plugins.workflow.support.concurrent.Timeout;
 import org.jenkinsci.plugins.workflow.support.concurrent.WithThreadName;
-import org.jenkinsci.plugins.workflow.support.pickles.ExecutorPickle;
 import org.jenkinsci.plugins.workflow.support.steps.ExecutorStepExecution;
 import org.kohsuke.accmod.Restricted;
 import org.kohsuke.accmod.restrictions.DoNotUse;
@@ -306,6 +305,9 @@ static final class Execution extends AbstractStepExecutionImpl implements Runnab
             returnStatus = step.returnStatus;
             StepContext context = getContext();
             ws = context.get(FilePath.class);
+            if (ws == null) {
+                throw new AbortException("No workspace currently accessible");
+            }
             node = FilePathUtils.getNodeName(ws);
             DurableTask durableTask = step.task();
             if (returnStdout) {
@@ -356,11 +358,12 @@ static final class Execution extends AbstractStepExecutionImpl implements Runnab
                             LOGGER.fine(() -> "discovered that " + node + " has been removed");
                             removedNodeDiscovered = System.nanoTime();
                             return null;
-                        } else if (System.nanoTime() - removedNodeDiscovered < TimeUnit.MILLISECONDS.toNanos(ExecutorPickle.TIMEOUT_WAITING_FOR_NODE_MILLIS)) {
+                        } else if (System.nanoTime() - removedNodeDiscovered < TimeUnit.MILLISECONDS.toNanos(ExecutorStepExecution.TIMEOUT_WAITING_FOR_NODE_MILLIS)) {
                             LOGGER.fine(() -> "rediscovering that " + node + " has been removed");
                             return null;
                         } else {
-                            LOGGER.fine(() -> node + " has been removed for a while, assuming it is not coming back");
+                            LOGGER.fine(() -> "rediscovering that " + node + " has been removed and timeout has expired");
+                            listener().getLogger().println(node + " has been removed for " + Util.getTimeSpanString(ExecutorStepExecution.TIMEOUT_WAITING_FOR_NODE_MILLIS) + ", assuming it is not coming back");
                             throw new FlowInterruptedException(Result.ABORTED, new ExecutorStepExecution.RemovedNodeCause());
                         }
                     }

@@ -31,12 +31,14 @@
 import hudson.model.Computer;
 import jenkins.model.Jenkins;
 import org.jenkinsci.plugins.workflow.flow.FlowExecutionOwner;
+import org.jenkinsci.plugins.workflow.support.steps.ExecutorStepDynamicContext;
 
 /**
  * Reference to {@link Computer}
  *
- * @author Kohsuke Kawaguchi
+ * @deprecated Normally now done via {@link ExecutorStepDynamicContext}.
  */
+@Deprecated
 public class ComputerPickle extends Pickle {
     private final String slave;
 

@@ -26,9 +26,7 @@
 
 import com.google.common.util.concurrent.ListenableFuture;
 import edu.umd.cs.findbugs.annotations.NonNull;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import hudson.Extension;
-import hudson.Main;
 import hudson.Util;
 import hudson.init.InitMilestone;
 import hudson.model.Executor;
@@ -41,35 +39,30 @@
 import hudson.model.queue.SubTask;
 
 import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import jenkins.model.Jenkins;
 import org.jenkinsci.plugins.workflow.flow.FlowExecutionOwner;
 import org.jenkinsci.plugins.workflow.pickles.Pickle;
 import org.jenkinsci.plugins.workflow.steps.FlowInterruptedException;
-import org.jenkinsci.plugins.workflow.steps.durable_task.Messages;
+import org.jenkinsci.plugins.workflow.support.steps.ExecutorStepDynamicContext;
 import org.jenkinsci.plugins.workflow.support.steps.ExecutorStepExecution;
-import org.kohsuke.accmod.Restricted;
-import org.kohsuke.accmod.restrictions.NoExternalUse;
 
 /**
  * Persists an {@link Executor} as the {@link hudson.model.Queue.Task} it was running.
  * That task can in turn have some way of producing a display name, a special {@link hudson.model.Queue.Executable} with a custom {@code executorCell.jelly}, and so on.
  * When rehydrated, the task is rescheduled, and when it starts executing the owning executor is produced.
  * Typically the {@link SubTask#getAssignedLabel} should be a {@link Node#getSelfLabel} so that the rehydrated executor is in fact on the same node.
+ * @deprecated Normally now done via {@link ExecutorStepDynamicContext}.
  */
+@Deprecated
 public class ExecutorPickle extends Pickle {
 
     private static final Logger LOGGER = Logger.getLogger(ExecutorPickle.class.getName());
 
     private final Queue.Task task;
 
-    @SuppressFBWarnings(value = "MS_SHOULD_BE_FINAL", justification = "deliberately mutable")
-    @Restricted(NoExternalUse.class)
-    public static long TIMEOUT_WAITING_FOR_NODE_MILLIS = Main.isUnitTest ? /* fail faster */ TimeUnit.SECONDS.toMillis(15) : Long.getLong(ExecutorPickle.class.getName()+".timeoutForNodeMillis", TimeUnit.MINUTES.toMillis(5));
-
     private ExecutorPickle(Executor executor) {
         if (executor instanceof OneOffExecutor) {
             throw new IllegalArgumentException("OneOffExecutor not currently supported");
@@ -105,7 +98,7 @@ protected Executor tryResolve() throws Exception {
                         throw new IllegalStateException("queue refused " + task);
                     }
                     itemID = item.getId();
-                    endTimeNanos = System.nanoTime() + TIMEOUT_WAITING_FOR_NODE_MILLIS*1000000;
+                    endTimeNanos = System.nanoTime() + ExecutorStepExecution.TIMEOUT_WAITING_FOR_NODE_MILLIS*1000000;
                     LOGGER.log(Level.FINE, "{0} scheduled {1}", new Object[] {ExecutorPickle.this, item});
                 } else {
                     item = Queue.getInstance().getItem(itemID);
@@ -129,7 +122,7 @@ protected Executor tryResolve() throws Exception {
                             if (System.nanoTime() > endTimeNanos) {
                                 Queue.getInstance().cancel(item);
                                 owner.getListener().getLogger().printf("Killed %s after waiting for %s because we assume unknown agent %s is never going to appear%n",
-                                        item.task.getDisplayName(), Util.getTimeSpanString(TIMEOUT_WAITING_FOR_NODE_MILLIS), placeholder.getAssignedLabel());
+                                        item.task.getDisplayName(), Util.getTimeSpanString(ExecutorStepExecution.TIMEOUT_WAITING_FOR_NODE_MILLIS), placeholder.getAssignedLabel());
                                 throw new FlowInterruptedException(Result.ABORTED, new ExecutorStepExecution.RemovedNodeCause());
                             }
                         }
@@ -159,7 +152,7 @@ protected Executor tryResolve() throws Exception {
             }
             @Override protected void printWaitingMessage(@NonNull TaskListener listener) {
                 Queue.Item item = Queue.getInstance().getItem(itemID);
-                String message = Messages.ExecutorPickle_waiting_to_resume(task.getFullDisplayName());
+                String message = "Waiting to resume " + task.getFullDisplayName();
                 if (item == null) { // ???
                     listener.getLogger().println(message);
                     return;

@@ -31,10 +31,14 @@
 import org.jenkinsci.plugins.workflow.FilePathUtils;
 import org.jenkinsci.plugins.workflow.flow.FlowExecutionOwner;
 import org.jenkinsci.plugins.workflow.pickles.Pickle;
+import org.jenkinsci.plugins.workflow.support.steps.ExecutorStepDynamicContext;
+import org.jenkinsci.plugins.workflow.support.steps.FilePathDynamicContext;
 
 /**
  * @author Kohsuke Kawaguchi
+ * @deprecated Normally now done via {@link ExecutorStepDynamicContext} or {@link FilePathDynamicContext}.
  */
+@Deprecated
 public class FilePathPickle extends Pickle {
 
     private final String slave;

@@ -35,7 +35,12 @@
 import org.jenkinsci.plugins.workflow.FilePathUtils;
 import org.jenkinsci.plugins.workflow.flow.FlowExecutionOwner;
 import org.jenkinsci.plugins.workflow.pickles.Pickle;
+import org.jenkinsci.plugins.workflow.support.steps.ExecutorStepDynamicContext;
 
+/**
+ * @deprecated Normally now done via {@link ExecutorStepDynamicContext}.
+ */
+@Deprecated
 public class WorkspaceListLeasePickle extends Pickle {
 
     // Could perhaps just store the FilePath directly (thus using FilePathPickle implicitly), but we need the Computer anyway for its WorkspaceList:

@@ -0,0 +1,246 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2021 CloudBees, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package org.jenkinsci.plugins.workflow.support.steps;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import hudson.Extension;
+import hudson.FilePath;
+import hudson.Util;
+import hudson.init.InitMilestone;
+import hudson.model.Computer;
+import hudson.model.Executor;
+import hudson.model.Node;
+import hudson.model.Queue;
+import hudson.model.Result;
+import hudson.model.TaskListener;
+import hudson.remoting.VirtualChannel;
+import hudson.slaves.OfflineCause;
+import hudson.slaves.WorkspaceList;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import jenkins.model.Jenkins;
+import org.jenkinsci.plugins.workflow.FilePathUtils;
+import org.jenkinsci.plugins.workflow.steps.DynamicContext;
+import org.jenkinsci.plugins.workflow.steps.FlowInterruptedException;
+import org.jenkinsci.plugins.workflow.steps.StepContext;
+import org.jenkinsci.plugins.workflow.support.DefaultStepContext;
+import org.kohsuke.accmod.Restricted;
+import org.kohsuke.accmod.restrictions.NoExternalUse;
+
+/**
+ * Persistent representation for context of {@link ExecutorStepExecution}.
+ * Supersedes {@link FilePathDynamicContext} (never mind {@link org.jenkinsci.plugins.workflow.support.pickles.FilePathPickle}),
+ * {@link org.jenkinsci.plugins.workflow.support.pickles.ExecutorPickle},
+ * {@link org.jenkinsci.plugins.workflow.support.pickles.ComputerPickle},
+ * and {@link org.jenkinsci.plugins.workflow.support.pickles.WorkspaceListLeasePickle}.
+ */
+@Restricted(NoExternalUse.class)
+public final class ExecutorStepDynamicContext implements Serializable {
+
+    private static final Logger LOGGER = Logger.getLogger(ExecutorStepDynamicContext.class.getName());
+
+    private static final long serialVersionUID = 1;
+
+    final @NonNull ExecutorStepExecution.PlaceholderTask task;
+    final @NonNull String node;
+    private final @NonNull String path;
+    /** Non-null after {@link #resume} if all goes well. */
+    private transient @Nullable Executor executor;
+    /** Non-null after {@link #resume} if all goes well. */
+    private transient @Nullable WorkspaceList.Lease lease;
+
+    ExecutorStepDynamicContext(ExecutorStepExecution.PlaceholderTask task, WorkspaceList.Lease lease, Executor executor) {
+        this.task = task;
+        this.node = FilePathUtils.getNodeName(lease.path);
+        this.path = lease.path.getRemote();
+        this.executor = executor;
+        this.lease = lease;
+    }
+
+    void resume(StepContext context) throws Exception {
+        if (executor != null) {
+            throw new IllegalStateException("Already resumed");
+        }
+        while (Jenkins.get().getInitLevel() != InitMilestone.COMPLETED) {
+            LOGGER.fine(() -> "waiting to schedule task for " + path + " on " + node + " until Jenkins completes startup");
+            Thread.sleep(100);
+        }
+        Queue.Item item = Queue.getInstance().schedule2(task, 0).getItem();
+        if (item == null) {
+            // TODO should also report when !ScheduleResult.created, since that is arguably an error
+            throw new IllegalStateException("queue refused " + task);
+        }
+        LOGGER.fine(() -> "scheduled " + item + " for " + path + " on " + node);
+        TaskListener listener = context.get(TaskListener.class);
+        if (!node.isEmpty()) { // unlikely to be any delay for built-in node anyway
+            listener.getLogger().println("Waiting for reconnection of " + node + " before proceeding with build");
+        }
+        Queue.Executable exec;
+        try {
+            exec = item.getFuture().getStartCondition().get(ExecutorStepExecution.TIMEOUT_WAITING_FOR_NODE_MILLIS, TimeUnit.MILLISECONDS);
+        } catch (TimeoutException x) {
+            listener.getLogger().println(node + " has been removed for " + Util.getTimeSpanString(ExecutorStepExecution.TIMEOUT_WAITING_FOR_NODE_MILLIS) + ", assuming it is not coming back");
+            throw new FlowInterruptedException(Result.ABORTED, new ExecutorStepExecution.RemovedNodeCause());
+        } catch (CancellationException x) {
+            LOGGER.log(Level.FINE, "ceased to wait for " + node, x);
+            throw new FlowInterruptedException(Result.ABORTED, new ExecutorStepExecution.QueueTaskCancelled());
+        }
+        executor = Executor.of(exec);
+        if (executor == null) {
+            // TODO this could happen as a race condition if the executable takes <1s to run; how could that be prevented?
+            // Or can we schedule a placeholder Task whose Executable does nothing but return Executor.currentExecutor and then end?
+            throw new IOException(exec + " was scheduled but no executor claimed it");
+        }
+        Computer computer = executor.getOwner();
+        VirtualChannel channel = computer.getChannel();
+        if (channel == null) {
+            throw new IOException(computer + " is offline");
+        }
+        FilePath fp = new FilePath(channel, path);
+        // Since there is no equivalent to Lock.tryLock for WorkspaceList (.record would work but throws AssertionError and swaps the holder):
+        WorkspaceList.Lease _lease = computer.getWorkspaceList().allocate(fp);
+        if (_lease.path.equals(fp)) {
+            lease = _lease;
+        } else { // @2 or other variant, not what we expected to be able to lock without contention
+            _lease.release();
+            throw new IOException("JENKINS-37121: something already locked " + fp);
+        }
+        LOGGER.fine(() -> "fully restored for " + path + " on " + node);
+    }
+
+    private static abstract class Translator<T> extends DynamicContext.Typed<T> {
+
+        @Override protected T get(DelegatedContext context) throws IOException, InterruptedException {
+            ExecutorStepDynamicContext c = context.get(ExecutorStepDynamicContext.class);
+            if (c == null || c.lease == null) {
+                return null;
+            }
+            return get(c);
+        }
+
+        abstract T get(ExecutorStepDynamicContext c) throws IOException, InterruptedException;
+
+    }
+
+    @Extension public static final class FilePathTranslator extends Translator<FilePath> {
+
+        @Override protected Class<FilePath> type() {
+            return FilePath.class;
+        }
+
+        @Override FilePath get(ExecutorStepDynamicContext c) throws IOException {
+            if (c.lease.path.toComputer() == null) {
+                FilePath f = FilePathUtils.find(c.node, c.path);
+                if (f != null) {
+                    LOGGER.fine(() -> c.node + " disconnected and reconnected; getting a new FilePath on " + c.path + " with the new Channel");
+                    return f;
+                }
+                String message = "Unable to create live FilePath for " + c.node;
+                Computer comp = Jenkins.get().getComputer(c.node);
+                if (comp != null) {
+                    OfflineCause oc = comp.getOfflineCause();
+                    if (oc != null) {
+                        message += "; " + comp.getDisplayName() + " was marked offline: " + oc;
+                    }
+                }
+                AgentOfflineException e = new AgentOfflineException(message);
+                if (comp != null) {
+                    for (Computer.TerminationRequest tr : comp.getTerminatedBy()) {
+                        e.addSuppressed(tr);
+                    }
+                }
+                throw e;
+            }
+            return c.lease.path;
+        }
+
+    }
+
+    @Extension public static final class WorkspaceListLeaseTranslator extends Translator<WorkspaceList.Lease> {
+
+        @Override protected Class<WorkspaceList.Lease> type() {
+            return WorkspaceList.Lease.class;
+        }
+
+        @Override WorkspaceList.Lease get(ExecutorStepDynamicContext c) {
+            // Do not do a liveness check as in FilePathTranslator.
+            // We could not do anything about a stale .path even if we found out about it.
+            return c.lease;
+        }
+
+    }
+
+    @Extension public static final class ExecutorTranslator extends Translator<Executor> {
+
+        @Override protected Class<Executor> type() {
+            return Executor.class;
+        }
+
+        @Override Executor get(ExecutorStepDynamicContext c) {
+            return c.executor;
+        }
+
+    }
+
+    @Extension public static final class ComputerTranslator extends Translator<Computer> {
+
+        @Override protected Class<Computer> type() {
+            return Computer.class;
+        }
+
+        @Override Computer get(ExecutorStepDynamicContext c) {
+            return c.executor.getOwner();
+        }
+
+    }
+
+    /**
+     * Need not use {@link Translator} since we can serve a {@link Node} even when offline.
+     * Overrides default behavior in {@link DefaultStepContext} which would delegate to {@link ComputerTranslator}.
+     */
+    @Extension public static final class NodeTranslator extends DynamicContext.Typed<Node> {
+
+        @Override protected Class<Node> type() {
+            return Node.class;
+        }
+
+        @Override protected Node get(DelegatedContext context) throws IOException, InterruptedException {
+            ExecutorStepDynamicContext c = context.get(ExecutorStepDynamicContext.class);
+            if (c == null) {
+                return null;
+            }
+            Jenkins j = Jenkins.get();
+            return c.node.isEmpty() ? j : j.getNode(c.node);
+        }
+
+    }
+
+}