Re-do shutdownWorkerFactory design with chain

Author: donald-pinckney

temporal-sdk/src/main/java/io/temporal/common/plugin/WorkerPlugin.java

@@ -156,15 +156,28 @@ default void runWorkerFactory(@Nonnull WorkerFactory factory, @Nonnull Runnable
   }
 
   /**
-   * Called when the worker factory is shutting down. Plugins are notified in forward (registration)
-   * order during shutdown.
+   * Allows the plugin to wrap worker factory shutdown. Called during shutdown phase in reverse
+   * order (first plugin wraps all others).
+   *
+   * <p>This method is called when {@link WorkerFactory#shutdown()} or {@link
+   * WorkerFactory#shutdownNow()} is invoked. The plugin can perform actions before and after the
+   * actual shutdown occurs.
    *
-   * <p>This is called during both {@link WorkerFactory#shutdown()} and {@link
-   * WorkerFactory#shutdownNow()}.
+   * <p>Example:
+   *
+   * <pre>{@code
+   * @Override
+   * public void shutdownWorkerFactory(WorkerFactory factory, Runnable next) {
+   *     logger.info("Shutting down workers...");
+   *     next.run();
+   *     logger.info("Workers shut down");
+   * }
+   * }</pre>
    *
    * @param factory the worker factory being shut down
+   * @param next runnable that shuts down the next in chain (eventually shuts down actual workers)
    */
-  default void onWorkerFactoryShutdown(@Nonnull WorkerFactory factory) {
-    // Default: no-op
+  default void shutdownWorkerFactory(@Nonnull WorkerFactory factory, @Nonnull Runnable next) {
+    next.run();
   }
 }

temporal-sdk/src/main/java/io/temporal/worker/WorkerFactory.java

@@ -170,7 +170,8 @@ public synchronized Worker newWorker(String taskQueue, WorkerOptions options) {
               workflowClient.getOptions().getContextPropagators());
       workers.put(taskQueue, worker);
 
-      // Go through the plugins to call plugin initializeWorker hooks (e.g. register workflows, activities, etc.)
+      // Go through the plugins to call plugin initializeWorker hooks (e.g. register workflows,
+      // activities, etc.)
       for (Object plugin : plugins) {
         if (plugin instanceof WorkerPlugin) {
           ((WorkerPlugin) plugin).initializeWorker(taskQueue, worker);
@@ -339,20 +340,33 @@ public synchronized void shutdownNow() {
   private void shutdownInternal(boolean interruptUserTasks) {
     state = State.Shutdown;
 
-    // Notify plugins of shutdown (forward order)
-    for (Object plugin : plugins) {
+    // Build plugin shutdown chain (reverse order for proper nesting)
+    Runnable shutdownChain = () -> doShutdown(interruptUserTasks);
+    List<Object> reversed = new ArrayList<>(plugins);
+    Collections.reverse(reversed);
+    for (Object plugin : reversed) {
       if (plugin instanceof WorkerPlugin) {
-        try {
-          ((WorkerPlugin) plugin).onWorkerFactoryShutdown(this);
-        } catch (Exception e) {
-          log.warn(
-              "Plugin {} failed during shutdown notification",
-              ((WorkerPlugin) plugin).getName(),
-              e);
-        }
+        final Runnable next = shutdownChain;
+        final WorkerPlugin workerPlugin = (WorkerPlugin) plugin;
+        shutdownChain =
+            () -> {
+              try {
+                workerPlugin.shutdownWorkerFactory(this, next);
+              } catch (Exception e) {
+                log.warn("Plugin {} failed during shutdown", workerPlugin.getName(), e);
+                // Still try to continue shutdown
+                next.run();
+              }
+            };
       }
     }
 
+    // Execute the chain
+    shutdownChain.run();
+  }
+
+  /** Internal method that actually shuts down workers. Called from the plugin chain. */
+  private void doShutdown(boolean interruptUserTasks) {
     ((WorkflowClientInternal) workflowClient.getInternal()).deregisterWorkerFactory(this);
     ShutdownManager shutdownManager = new ShutdownManager();
     CompletableFuture.allOf(