Remove PostPluginConfiguration and add an internal plugin for versioning

and tuning enforcement

Author: eamsden

src/Temporalio.Extensions.Aws.Lambda/TemporalLambdaWorker.cs

@@ -198,14 +198,15 @@ private static LambdaWorkerHandlerState PrepareHandlerState(
                     "WorkerOptions.TaskQueue must be set or TEMPORAL_TASK_QUEUE must be present");
             }
 
-            var postPluginConfiguration = config.WorkerOptions.PostPluginConfiguration;
-            config.WorkerOptions.PostPluginConfiguration = options =>
-            {
-                postPluginConfiguration?.Invoke(options);
-                ApplyDeploymentVersion(options, version);
-                ClearConcurrencyLimitsIfTunerSet(options);
-            };
-            config.WorkerOptions.ApplyPostPluginConfiguration();
+            AppendWorkerPlugin(
+                config.WorkerOptions,
+                new InternalWorkerPlugin(
+                    "Temporalio.Extensions.Aws.Lambda",
+                    options =>
+                    {
+                        ApplyDeploymentVersion(options, version);
+                        ClearConcurrencyLimitsIfTunerSet(options);
+                    }));
 
             return new LambdaWorkerHandlerState(
                 (TemporalClientConnectOptions)config.ClientOptions.Clone(),
@@ -215,6 +216,19 @@ private static LambdaWorkerHandlerState PrepareHandlerState(
                 handlerOptions);
         }
 
+        private static void AppendWorkerPlugin(
+            TemporalWorkerOptions workerOptions,
+            ITemporalWorkerPlugin plugin)
+        {
+            var plugins = new List<ITemporalWorkerPlugin>();
+            if (workerOptions.Plugins != null)
+            {
+                plugins.AddRange(workerOptions.Plugins);
+            }
+            plugins.Add(plugin);
+            workerOptions.Plugins = plugins;
+        }
+
         private static void ApplyDeploymentVersion(
             TemporalWorkerOptions workerOptions,
             WorkerDeploymentVersion version)

src/Temporalio/Worker/InternalWorkerPlugin.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Temporalio.Worker
+{
+    /// <summary>
+    /// Internal pass-through plugin for extensions that need worker plugin ordering.
+    /// </summary>
+    internal sealed class InternalWorkerPlugin : ITemporalWorkerPlugin
+    {
+        private readonly Action<TemporalWorkerOptions> configureWorker;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InternalWorkerPlugin"/> class.
+        /// </summary>
+        /// <param name="name">Plugin name reported to the worker.</param>
+        /// <param name="configureWorker">Worker options configuration callback.</param>
+        public InternalWorkerPlugin(string name, Action<TemporalWorkerOptions> configureWorker)
+        {
+            Name = name ?? throw new ArgumentNullException(nameof(name));
+            this.configureWorker = configureWorker ??
+                throw new ArgumentNullException(nameof(configureWorker));
+        }
+
+        /// <inheritdoc />
+        public string Name { get; }
+
+        /// <inheritdoc />
+        public void ConfigureWorker(TemporalWorkerOptions options) => configureWorker(options);
+
+        /// <inheritdoc />
+        public Task<TResult> RunWorkerAsync<TResult>(
+            TemporalWorker worker,
+            Func<TemporalWorker, CancellationToken, Task<TResult>> continuation,
+            CancellationToken stoppingToken) =>
+            continuation(worker, stoppingToken);
+
+        /// <inheritdoc />
+        public void ConfigureReplayer(WorkflowReplayerOptions options)
+        {
+            _ = options;
+        }
+
+        /// <inheritdoc />
+        public Task<IEnumerable<WorkflowReplayResult>> ReplayWorkflowsAsync(
+            WorkflowReplayer replayer,
+            Func<WorkflowReplayer, CancellationToken, Task<IEnumerable<WorkflowReplayResult>>> continuation,
+            CancellationToken cancellationToken) =>
+            continuation(replayer, cancellationToken);
+
+#if NETCOREAPP3_0_OR_GREATER
+        /// <inheritdoc />
+        public IAsyncEnumerable<WorkflowReplayResult> ReplayWorkflowsAsync(
+            WorkflowReplayer replayer,
+            Func<WorkflowReplayer, IAsyncEnumerable<WorkflowReplayResult>> continuation,
+            CancellationToken cancellationToken)
+        {
+            _ = cancellationToken;
+            return continuation(replayer);
+        }
+#endif
+    }
+}

src/Temporalio/Worker/TemporalWorker.cs

@@ -57,7 +57,6 @@ public TemporalWorker(IWorkerClient client, TemporalWorkerOptions options)
                 {
                     plugin.ConfigureWorker(Options);
                 }
-                Options.ApplyPostPluginConfiguration();
 
                 // Ensure later accesses use the modified version of options.
                 options = Options;

src/Temporalio/Worker/TemporalWorkerOptions.cs

@@ -376,14 +376,6 @@ public TemporalWorkerOptions()
         internal Func<WorkflowInstanceDetails, IWorkflowInstance> WorkflowInstanceFactory { get; set; } =
             DefaultWorkflowInstanceFactory;
 
-        /// <summary>
-        /// Gets or sets a function to run after worker plugins configure options.
-        /// </summary>
-        /// <remarks>
-        /// Don't expose this until there's a use case.
-        /// </remarks>
-        internal Action<TemporalWorkerOptions>? PostPluginConfiguration { get; set; }
-
         /// <summary>
         /// Add the given delegate with <see cref="ActivityAttribute" /> as an activity. This is
         /// usually a method reference.
@@ -525,10 +517,5 @@ internal void OnTaskCompleted(WorkflowInstance instance, Exception? failureExcep
                 handler(instance, new(instance, failureException));
             }
         }
-
-        /// <summary>
-        /// Run post-plugin configuration.
-        /// </summary>
-        internal void ApplyPostPluginConfiguration() => PostPluginConfiguration?.Invoke(this);
     }
 }

tests/Temporalio.Tests/Extensions/Aws/Lambda/TemporalLambdaWorkerTests.cs

@@ -80,7 +80,7 @@ public async Task CreateHandler_DefaultsAreAppliedAndUserOverridesWin()
                 },
                 CreateWorker = (_, options) =>
                 {
-                    capturedWorkerOptions = options;
+                    capturedWorkerOptions = SimulateWorkerPluginConfiguration(options);
                     return new FakeLambdaWorker(_ => Task.CompletedTask);
                 },
             });
@@ -143,7 +143,7 @@ public async Task CreateHandler_DefaultsVersioningBehaviorToAutoUpgrade()
                 ConnectClientAsync = _ => Task.FromResult<object>(new object()),
                 CreateWorker = (_, options) =>
                 {
-                    capturedWorkerOptions = options;
+                    capturedWorkerOptions = SimulateWorkerPluginConfiguration(options);
                     return new FakeLambdaWorker(_ => Task.CompletedTask);
                 },
             });
@@ -253,7 +253,7 @@ public async Task CreateHandler_ClearsConcurrencyDefaultsWhenTunerSet()
                 ConnectClientAsync = _ => Task.FromResult<object>(new object()),
                 CreateWorker = (_, options) =>
                 {
-                    capturedWorkerOptions = options;
+                    capturedWorkerOptions = SimulateWorkerPluginConfiguration(options);
                     return new FakeLambdaWorker(_ => Task.CompletedTask);
                 },
             });
@@ -290,12 +290,7 @@ public async Task CreateHandler_ClearsConcurrencyDefaultsWhenPluginSetsTuner()
                 ConnectClientAsync = _ => Task.FromResult<object>(new object()),
                 CreateWorker = (_, options) =>
                 {
-                    foreach (var plugin in options.Plugins ?? Array.Empty<ITemporalWorkerPlugin>())
-                    {
-                        plugin.ConfigureWorker(options);
-                    }
-                    options.ApplyPostPluginConfiguration();
-                    capturedWorkerOptions = options;
+                    capturedWorkerOptions = SimulateWorkerPluginConfiguration(options);
                     return new FakeLambdaWorker(_ => Task.CompletedTask);
                 },
             });
@@ -327,12 +322,7 @@ public async Task CreateHandler_ReappliesDeploymentVersionAfterPlugins()
                 ConnectClientAsync = _ => Task.FromResult<object>(new object()),
                 CreateWorker = (_, options) =>
                 {
-                    foreach (var plugin in options.Plugins ?? Array.Empty<ITemporalWorkerPlugin>())
-                    {
-                        plugin.ConfigureWorker(options);
-                    }
-                    options.ApplyPostPluginConfiguration();
-                    capturedWorkerOptions = options;
+                    capturedWorkerOptions = SimulateWorkerPluginConfiguration(options);
                     return new FakeLambdaWorker(_ => Task.CompletedTask);
                 },
             });
@@ -991,6 +981,18 @@ private static ActivityDefinition DummyActivity() =>
             0,
             _ => Task.CompletedTask);
 
+    private static TemporalWorkerOptions SimulateWorkerPluginConfiguration(
+        TemporalWorkerOptions options)
+    {
+        var plugins = new List<ITemporalWorkerPlugin>(
+            options.Plugins ?? Array.Empty<ITemporalWorkerPlugin>());
+        foreach (var plugin in plugins)
+        {
+            plugin.ConfigureWorker(options);
+        }
+        return options;
+    }
+
     [Workflow]
     public sealed class WorkflowWithoutVersioningBehavior
     {