API improvements around Executor/Executable

core/src/main/java/hudson/model/Computer.java

@@ -870,15 +870,15 @@ public final long getDemandStartMilliseconds() {
     /*package*/ synchronized void removeExecutor(Executor e) {
         executors.remove(e);
         addNewExecutorIfNecessary();
-        if(!isAlive())
+        if(!isAlive()) // TODO except from interrupt/doYank this is called while the executor still isActive(), so how could !this.isAlive()?
         {
             AbstractCIBase ciBase = Jenkins.getInstance();
             ciBase.removeComputer(this);
         }
     }
 
     /**
-     * Returns true if any of the executors are functioning.
+     * Returns true if any of the executors are {@linkplain Executor#isActive active}.
      *
      * Note that if an executor dies, we'll leave it in {@link #executors} until
      * the administrator yanks it out, so that we can see why it died.
@@ -894,10 +894,11 @@ protected boolean isAlive() {
 
     /**
      * Interrupt all {@link Executor}s.
+     * Called from {@link Jenkins#cleanUp}.
      */
     public void interrupt() {
         for (Executor e : executors) {
-            e.interrupt();
+            e.interruptForShutdown();
         }
     }
 

core/src/main/java/hudson/model/Executor.java

@@ -60,13 +60,15 @@
 import static java.util.logging.Level.*;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
+import jenkins.model.queue.AsynchronousExecution;
+import org.kohsuke.accmod.Restricted;
+import org.kohsuke.accmod.restrictions.NoExternalUse;
 
 
 /**
  * Thread that executes builds.
  * Since 1.536, {@link Executor}s start threads on-demand.
- * The entire logic should use {@link #isActive()} instead of {@link #isAlive()}
- * in order to check if the {@link Executor} it ready to take tasks.
+ * <p>Callers should use {@link #isActive()} instead of {@link #isAlive()}.
  * @author Kohsuke Kawaguchi
  */
 @ExportedBean
@@ -89,6 +91,12 @@ public class Executor extends Thread implements ModelObject {
      */
     private volatile Queue.Executable executable;
 
+    /**
+     * Used to mark that the execution is continuing asynchronously even though {@link Executor} as {@link Thread}
+     * has finished.
+     */
+    private AsynchronousExecution asynchronousExecution;
+
     /**
      * When {@link Queue} allocates a work for this executor, this field is set
      * and the executor is {@linkplain Thread#start() started}.
@@ -124,27 +132,38 @@ public void interrupt() {
         interrupt(Result.ABORTED);
     }
 
+    void interruptForShutdown() {
+        interrupt(Result.ABORTED, true);
+    }
     /**
      * Interrupt the execution,
      * but instead of marking the build as aborted, mark it as specified result.
      *
      * @since 1.417
      */
     public void interrupt(Result result) {
+        interrupt(result, false);
+    }
+
+    private void interrupt(Result result, boolean forShutdown) {
         Authentication a = Jenkins.getAuthentication();
         if (a == ACL.SYSTEM)
-            interrupt(result, new CauseOfInterruption[0]);
+            interrupt(result, forShutdown, new CauseOfInterruption[0]);
         else {
             // worth recording who did it
             // avoid using User.get() to avoid deadlock.
-            interrupt(result, new UserInterruption(a.getName()));
+            interrupt(result, forShutdown, new UserInterruption(a.getName()));
         }
     }
 
     /**
      * Interrupt the execution. Mark the cause and the status accordingly.
      */
     public void interrupt(Result result, CauseOfInterruption... causes) {
+        interrupt(result, false, causes);
+    }
+
+    private void interrupt(Result result, boolean forShutdown, CauseOfInterruption... causes) {
         if (LOGGER.isLoggable(FINE))
             LOGGER.log(FINE, String.format("%s is interrupted(%s): %s", getDisplayName(), result, Util.join(Arrays.asList(causes),",")), new InterruptedException());
 
@@ -163,7 +182,11 @@ public void interrupt(Result result, CauseOfInterruption... causes) {
                     this.causes.add(c);
             }
         }
-        super.interrupt();
+        if (asynchronousExecution != null) {
+            asynchronousExecution.interrupt(forShutdown);
+        } else {
+            super.interrupt();
+        }
     }
 
     public Result abortResult() {
@@ -238,23 +261,14 @@ public void run() {
                 if (LOGGER.isLoggable(FINE))
                     LOGGER.log(FINE, getName()+" is now executing "+executable);
                 queue.execute(executable, task);
+            } catch (AsynchronousExecution x) {
+                x.setExecutor(this);
+                this.asynchronousExecution = x;
             } catch (Throwable e) {
-                // for some reason the executor died. this is really
-                // a bug in the code, but we don't want the executor to die,
-                // so just leave some info and go on to build other things
-                LOGGER.log(Level.SEVERE, "Executor threw an exception", e);
-                workUnit.context.abort(e);
                 problems = e;
             } finally {
-                long time = System.currentTimeMillis()-startTime;
-                if (LOGGER.isLoggable(FINE))
-                    LOGGER.log(FINE, getName()+" completed "+executable+" in "+time+"ms");
-                try {
-                    workUnit.context.synchronizeEnd(executable,problems,time);
-                } catch (InterruptedException e) {
-                    workUnit.context.abort(e);
-                } finally {
-                    workUnit.setExecutor(null);
+                if (asynchronousExecution == null) {
+                    finish1(problems);
                 }
             }
         } catch (InterruptedException e) {
@@ -267,12 +281,49 @@ public void run() {
             causeOfDeath = e;
             LOGGER.log(SEVERE, "Unexpected executor death", e);
         } finally {
-            if (causeOfDeath==null)
-                // let this thread die and be replaced by a fresh unstarted instance
-                owner.removeExecutor(this);
+            if (asynchronousExecution == null) {
+                finish2();
+            }
+        }
+    }
+
+    private void finish1(@CheckForNull Throwable problems) {
+        if (problems != null) {
+            // for some reason the executor died. this is really
+            // a bug in the code, but we don't want the executor to die,
+            // so just leave some info and go on to build other things
+            LOGGER.log(Level.SEVERE, "Executor threw an exception", problems);
+            workUnit.context.abort(problems);
+        }
+       long time = System.currentTimeMillis() - startTime;
+        LOGGER.log(FINE, "{0} completed {1} in {2}ms", new Object[] {getName(), executable, time});
+        try {
+            workUnit.context.synchronizeEnd(this, executable, problems, time);
+        } catch (InterruptedException e) {
+            workUnit.context.abort(e);
+        } finally {
+            workUnit.setExecutor(null);
+        }
+    }
 
-            queue.scheduleMaintenance();
+    private void finish2() {
+        if (causeOfDeath == null) {// let this thread die and be replaced by a fresh unstarted instance
+            owner.removeExecutor(this);
+        }
+        if (this instanceof OneOffExecutor) {
+            owner.remove((OneOffExecutor) this);
         }
+        queue.scheduleMaintenance();
+    }
+
+    @Restricted(NoExternalUse.class)
+    public void completedAsynchronous(@CheckForNull Throwable error) {
+        try {
+            finish1(error);
+        } finally {
+            finish2();
+        }
+        asynchronousExecution = null;
     }
 
     /**
@@ -357,14 +408,22 @@ public boolean isBusy() {
     /**
      * Check if executor is ready to accept tasks.
      * This method becomes the critical one since 1.536, which introduces the
-     * on-demand creation of executor threads. The entire logic should use
-     * this method instead of {@link #isAlive()}, because it provides wrong
-     * information for non-started threads.
+     * on-demand creation of executor threads. Callers should use
+     * this method instead of {@link #isAlive()}, which would be incorrect for
+     * non-started threads or running {@link AsynchronousExecution}.
      * @return True if the executor is available for tasks
      * @since 1.536
      */
     public boolean isActive() {
-        return !started || isAlive();
+        return !started || asynchronousExecution != null || isAlive();
+    }
+
+    /**
+     * If currently running in asynchronous mode, returns that handle.
+     * @since TODO
+     */
+    public @CheckForNull AsynchronousExecution getAsynchronousExecution() {
+        return asynchronousExecution;
     }
 
     /**
@@ -377,7 +436,7 @@ public boolean isParking() {
     /**
      * If this thread dies unexpectedly, obtain the cause of the failure.
      *
-     * @return null if the death is expected death or the thread is {@link #isAlive() still alive}.
+     * @return null if the death is expected death or the thread {@link #isActive}.
      * @since 1.142
      */
     public Throwable getCauseOfDeath() {
@@ -529,7 +588,7 @@ public HttpResponse doStop() {
     @RequirePOST
     public HttpResponse doYank() {
         Jenkins.getInstance().checkPermission(Jenkins.ADMINISTER);
-        if (isAlive())
+        if (isActive())
             throw new Failure("Can't yank a live executor");
         owner.removeExecutor(this);
         return HttpResponses.redirectViaContextPath("/");
@@ -593,6 +652,32 @@ protected Object call(Object o, Method m, Object[] args) throws Throwable {
         return IMPERSONATION.get();
     }
 
+    /**
+     * Finds the executor running a given process.
+     * @param executable a possibly running executable
+     * @return the executor (possibly a {@link OneOffExecutor}) whose {@link Executor#getCurrentExecutable} matches that, or null
+     * @since TODO
+     */
+    public static Executor of(Executable executable) {
+        Jenkins jenkins = Jenkins.getInstance();
+        if (jenkins == null) {
+            return null;
+        }
+        for (Computer computer : jenkins.getComputers()) {
+            for (Executor executor : computer.getExecutors()) {
+                if (executor.getCurrentExecutable() == executable) {
+                    return executor;
+                }
+            }
+            for (Executor executor : computer.getOneOffExecutors()) {
+                if (executor.getCurrentExecutable() == executable) {
+                    return executor;
+                }
+            }
+        }
+        return null;
+    }
+
     /**
      * Returns the estimated duration for the executable.
      * Protects against {@link AbstractMethodError}s if the {@link Executable} implementation

core/src/main/java/hudson/model/OneOffExecutor.java

@@ -36,13 +36,4 @@ public class OneOffExecutor extends Executor {
     public OneOffExecutor(Computer owner) {
         super(owner,-1);
     }
-
-    @Override
-    public void run() {
-        try {
-            super.run();
-        } finally {
-            owner.remove(this);
-        }
-    }
 }

core/src/main/java/hudson/model/Queue.java

@@ -95,7 +95,6 @@
 import java.util.TreeSet;
 import java.util.concurrent.Callable;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.logging.Level;
@@ -121,6 +120,7 @@
 import com.thoughtworks.xstream.XStream;
 import com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter;
 import javax.annotation.CheckForNull;
+import jenkins.model.queue.AsynchronousExecution;
 import org.kohsuke.stapler.QueryParameter;
 import org.kohsuke.stapler.interceptor.RequirePOST;
 
@@ -1478,9 +1478,10 @@ public interface Executable extends Runnable {
         @Nonnull SubTask getParent();
 
         /**
-         * Called by {@link Executor} to perform the task
+         * Called by {@link Executor} to perform the task.
+         * @throws AsynchronousExecution if you would like to continue without consuming a thread
          */
-        void run();
+        @Override void run() throws AsynchronousExecution;
 
         /**
          * Estimate of how long will it take to execute this executable.

core/src/main/java/hudson/model/ResourceController.java

@@ -88,6 +88,7 @@ public void execute(@Nonnull Runnable task, ResourceActivity activity ) throws I
         try {
             task.run();
         } finally {
+            // TODO if AsynchronousExecution, do that later
             synchronized(this) {
                 inProgress.remove(activity);
                 inUse = ResourceList.union(resourceView);

core/src/main/java/hudson/model/RestartListener.java

@@ -6,6 +6,7 @@
 import jenkins.model.Jenkins;
 
 import java.io.IOException;
+import jenkins.model.queue.AsynchronousExecution;
 
 /**
  * Extension point that allows plugins to veto the restart.
@@ -46,12 +47,39 @@ public static boolean isAllReady() throws IOException, InterruptedException {
 
     /**
      * Default logic. Wait for all the executors to become idle.
+     * @see AsynchronousExecution#blocksRestart
      */
     @Extension
     public static class Default extends RestartListener {
         @Override
         public boolean isReadyToRestart() throws IOException, InterruptedException {
-            return new ComputerSet().getBusyExecutors() == 0;
+            for (Computer c : Jenkins.getInstance().getComputers()) {
+                if (c.isOnline()) {
+                    for (Executor e : c.getExecutors()) {
+                        if (blocksRestart(e)) {
+                            return false;
+                        }
+                    }
+                    for (Executor e : c.getOneOffExecutors()) {
+                        if (blocksRestart(e)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        private static boolean blocksRestart(Executor e) {
+            if (e.isBusy()) {
+                AsynchronousExecution execution = e.getAsynchronousExecution();
+                if (execution != null) {
+                    return execution.blocksRestart();
+                } else {
+                    return true;
+                }
+            } else {
+                return false;
+            }
         }
     }
 }