Merge pull request #5 from jglick/PPPP-JENKINS-26130

[JENKINS-26130] Way to print progress from pickles

src/main/java/org/jenkinsci/plugins/workflow/flow/FlowExecutionList.java

@@ -19,9 +19,11 @@

import java.io.File;
import java.io.IOException;
import java.nio.channels.CancelledKeyException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CancellationException;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
@@ -167,7 +169,7 @@ public static FlowExecutionList get() {

        @Override
        public void onLoaded() {
            for (FlowExecution e : list) {
            for (final FlowExecution e : list) {
                LOGGER.log(FINE, "Eager loading {0}", e);
                Futures.addCallback(e.getCurrentExecutions(false), new FutureCallback<List<StepExecution>>() {
                    @Override
@@ -180,7 +182,11 @@ public void onSuccess(List<StepExecution> result) {

                    @Override
                    public void onFailure(Throwable t) {
                        LOGGER.log(WARNING, null, t);
                        if (t instanceof CancellationException) {
                            LOGGER.log(Level.FINE, "Cancelled load of " + e, t);
                        } else {
                            LOGGER.log(WARNING, "Failed to load " + e, t);
                        }
                    }
                });
            }

src/main/java/org/jenkinsci/plugins/workflow/flow/FlowExecutionOwner.java

@@ -26,6 +26,7 @@

import hudson.model.Queue;
import hudson.model.Run;
import hudson.model.TaskListener;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
@@ -34,6 +35,7 @@
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
import jenkins.model.TransientActionFactory;
import org.jenkinsci.plugins.workflow.steps.StepContext;

/**
 * We need something that's serializable in small moniker that helps us find THE instance
@@ -100,14 +102,22 @@ public String getUrlOfExecution() throws IOException {
     * {@link FlowExecutionOwner}s are equal to one another if and only if
     * they point to the same {@link FlowExecution} object.
     */
    public abstract boolean equals(Object o);
    @Override public abstract boolean equals(Object o);

    /**
     * Needs to be overridden as the {@link #equals(Object)} method is overridden.
     */
    @Override
    public abstract int hashCode();

    /**
     * Gets a listener to which we may print general messages.
     * Normally {@link StepContext#get} should be used, but in some cases there is no associated step.
     */
    public @Nonnull TaskListener getListener() throws IOException {
        return TaskListener.NULL;
    }

    /**
     * Marker interface for queue executables from {@link #getExecutable}.
     * A reasonable target type for {@link TransientActionFactory}.
@@ -122,4 +132,33 @@ public String getUrlOfExecution() throws IOException {

    }

    /**
     * A placeholder implementation for use in compatibility stubs.
     */
    public static FlowExecutionOwner dummyOwner() {
        return new DummyOwner();
    }

    private static class DummyOwner extends FlowExecutionOwner {
        DummyOwner() {}
        @Override public FlowExecution get() throws IOException {
            throw new IOException("not implemented");
        }
        @Override public File getRootDir() throws IOException {
            throw new IOException("not implemented");
        }
        @Override public Queue.Executable getExecutable() throws IOException {
            throw new IOException("not implemented");
        }
        @Override public String getUrl() throws IOException {
            throw new IOException("not implemented");
        }
        @Override public boolean equals(Object o) {
            return o instanceof DummyOwner;
        }
        @Override public int hashCode() {
            return 0;
        }
    }

}

src/main/java/org/jenkinsci/plugins/workflow/pickles/Pickle.java

@@ -26,8 +26,10 @@

import com.google.common.util.concurrent.ListenableFuture;
import hudson.FilePath;
import hudson.Util;

import java.io.Serializable;
import org.jenkinsci.plugins.workflow.flow.FlowExecutionOwner;

/**
 * Handle value objects to replace another stateful objects that cannot be serialized on its own,
@@ -36,12 +38,27 @@
 * @author Kohsuke Kawaguchi
 */
public abstract class Pickle implements Serializable {

    @Deprecated
    public ListenableFuture<?> rehydrate() {
        return rehydrate(FlowExecutionOwner.dummyOwner());
    }

    /**
     * Start preparing rehydration of this value, and when it's ready or fail, report that to the
     * given call.
     * An implementation should return quickly and avoid acquiring locks in this method itself (as opposed to the future).
     * {@link ListenableFuture#cancel} should be implemented if possible.
     * @param owner an owner handle on which you may, for example, call {@link FlowExecutionOwner#getListener}
     */
    public abstract ListenableFuture<?> rehydrate();
    public ListenableFuture<?> rehydrate(FlowExecutionOwner owner) {
        if (Util.isOverridden(Pickle.class, getClass(), "rehydrate")) {
            return rehydrate();
        } else {
            throw new AbstractMethodError(getClass().getName() + " must implement rehydrate");
        }
    }

    private static final long serialVersionUID = 1L;

}