Join the original Aspire benchmark disposal task

Await the testing factory's original DisposeAsync task instead of its cancelable StopAsync wrapper. Capture the configured host shutdown budget before startup and retain the existing original-task settlement budget after it. Remove the manual container-stop path, which timed out InfluxDB after its workload had passed.

Verified: complete Debug solution build with -warnaserror (0 warnings/errors), full format verification and repository governance. Real ClickHouse 1M and InfluxDB controls passed on unchanged source/DLL/PDB inputs; their owned containers and anonymous volumes were removed. Full Linux session qualification follows this checkpoint.

Author: KSemenenko

benchmarks/KeyLoad.ComparisonHost/DatabaseAdapters/Resources/AdditionalDatabaseResources.cs

@@ -52,15 +52,12 @@ or BenchmarkAdditionalTargets.MySql or BenchmarkAdditionalTargets.ClickHouse or
             failures.Add(failure);
         }
         await SettleAsync(observations.CompleteAsync, failures);
-        using var stop = new CancellationTokenSource(ExecutionPolicyFixture.Harness().Value.OriginalTaskSettlementTimeout, TimeProvider.System);
-        await SettleAsync(() => IsolatedResourceShutdown.StopAsync(application, containers, stop.Token), failures);
         await SettleAsync(capture.StopAsync, failures);
         await SettleAsync(() => capture.WriteResourcesToAsync(root), failures);
         await SettleAsync(() => capture.DisposeAsync().AsTask(), failures);
-        var beforeStop = failures.Count;
-        await SettleAsync(() => application.StopAsync(CancellationToken.None), failures);
+        var beforeDisposal = failures.Count;
         await SettleAsync(() => application.DisposeAsync().AsTask(), failures);
-        if (failures.Count == beforeStop)
+        if (failures.Count == beforeDisposal)
         {
             await SettleAsync(() => IsolatedDataCleanup.DeleteAsync(IsolatedResourceContext.ExecutionDirectory(root), containers), failures);
         }

benchmarks/KeyLoad.ComparisonHost/Orchestration/Fixtures/BenchmarkSessionAspireFixture.cs

@@ -7,7 +7,9 @@
 using KeyLoad.LoadTests.AppHost.BenchmarkComparisons;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace KeyLoad.ComparisonHost.BenchmarkOrchestration;
 
@@ -56,7 +58,8 @@ private static async Task RunOwnedAsync(DistributedApplication application, Benc
         var containers = application.Services.GetRequiredService<DistributedApplicationModel>()
             .Resources.OfType<ContainerResource>().ToArray();
         var execution = ExecutionPolicyFixture.Harness();
-        var work = new IsolatedOwnedWork(execution);
+        var shutdown = application.Services.GetRequiredService<IOptions<HostOptions>>().Value.ShutdownTimeout;
+        var work = new IsolatedOwnedWork(execution, shutdown);
         Exception? primary = null;
         try
         {

benchmarks/KeyLoad.ComparisonHost/Orchestration/Fixtures/IsolatedOwnedWork.cs

@@ -39,13 +39,17 @@ internal ComparisonTestLogCapture? Capture
     private Task? runnerStop;
     private Task? disposing;
 
-    internal IsolatedOwnedWork(IOptions<ComparisonHarnessOptions> executionOptions)
+    internal IsolatedOwnedWork(IOptions<ComparisonHarnessOptions> executionOptions, TimeSpan hostShutdownTimeout)
     {
         ArgumentNullException.ThrowIfNull(executionOptions);
+        ArgumentOutOfRangeException.ThrowIfLessThan(hostShutdownTimeout, TimeSpan.Zero);
         executionOptions.Value.Validate();
         ExecutionOptions = executionOptions;
+        HostShutdownTimeout = hostShutdownTimeout;
     }
 
+    internal TimeSpan HostShutdownTimeout { get; }
+
     internal IOptions<ComparisonHarnessOptions> ExecutionOptions
     {
         get;

benchmarks/KeyLoad.ComparisonHost/Orchestration/Lifecycle/IsolatedOriginalTaskSettlement.cs

@@ -5,8 +5,11 @@ namespace KeyLoad.ComparisonHost.BenchmarkOrchestration;
 internal static class IsolatedOriginalTaskSettlement
 {
     internal static async Task<bool> RunAsync(Func<Task> start, string stage,
-        IsolatedTeardownFailures failures, IOptions<ComparisonHarnessOptions> options, Func<Task>? escalate = null)
+        IsolatedTeardownFailures failures, IOptions<ComparisonHarnessOptions> options, Func<Task>? escalate = null,
+        TimeSpan shutdownAllowance = default)
     {
+        ArgumentOutOfRangeException.ThrowIfLessThan(shutdownAllowance, TimeSpan.Zero);
+        var settlementTimeout = shutdownAllowance + options.Value.OriginalTaskSettlementTimeout;
         var initiation = StartAsync(start);
         Task original;
         try
@@ -18,7 +21,7 @@ internal static async Task<bool> RunAsync(Func<Task> start, string stage,
             Record(initiation, failure, stage, failures);
             return false;
         }
-        return await JoinAsync(original, stage, failures, options, escalate);
+        return await JoinAsync(original, stage, failures, options, escalate, settlementTimeout);
     }
 
     private static async Task<Task> StartAsync(Func<Task> start)
@@ -28,9 +31,10 @@ private static async Task<Task> StartAsync(Func<Task> start)
     }
 
     private static async Task<bool> JoinAsync(Task original, string stage,
-        IsolatedTeardownFailures failures, IOptions<ComparisonHarnessOptions> options, Func<Task>? escalate)
+        IsolatedTeardownFailures failures, IOptions<ComparisonHarnessOptions> options, Func<Task>? escalate,
+        TimeSpan settlementTimeout)
     {
-        var wait = original.WaitAsync(options.Value.OriginalTaskSettlementTimeout, TimeProvider.System);
+        var wait = original.WaitAsync(settlementTimeout, TimeProvider.System);
         try
         {
             await wait;

benchmarks/KeyLoad.ComparisonHost/Orchestration/Lifecycle/IsolatedResourceShutdown.cs

@@ -21,8 +21,6 @@ internal static class IsolatedTeardown
     private const int EmptyCount = 0;
     private const string ServerResourceValue = "server-resource";
     private const string ServerResourceTaskOwnershipWasIncompleteMessage = "Server resource task ownership was incomplete.";
-    private const string StopStage = "stop";
-    private const string ResourcesStopStage = "resources-stop";
     private const string SessionStateJsonFileName = "session-state.json";
     private const string SessionJsonFileName = "session.json";
     private const string SessionResourceEvidenceJsonFileName = "session-resource-evidence.json";
@@ -55,7 +53,6 @@ private static async Task CompleteCoreAsync(DistributedApplication app, Comparis
         var runnerSettled = await IsolatedOriginalTaskSettlement.RunAsync(
             work.StopRunnerAsync, ExecutionRunnerValue, failures, options);
         var collectorSettled = await SettleCollectorAsync(work, failures, options);
-        var resourcesStopped = await StopResourcesAsync(app, containers, failures, options);
         var captureSettled = capture is null || await IsolatedOriginalTaskSettlement.RunAsync(
             capture.StopAsync, LogsCloseValue, failures, options);
         if (capture is not null)
@@ -66,15 +63,17 @@ await IsolatedOriginalTaskSettlement.RunAsync(
                 () => capture.WriteResourcesToAsync(evidence), NodeLogsRetainValue, failures, options);
         }
         await IsolatedOriginalTaskSettlement.RunAsync(() => CopyRawAsync(output, evidence), RawReportStage, failures, options);
-        var stopped = await StopAsync(app, failures, options);
         var captureDisposed = disposeCapture is null || await IsolatedOriginalTaskSettlement.RunAsync(
             disposeCapture, CaptureDisposeValue, failures, options);
+        // Own the testing factory's original disposal task, including its configured host shutdown budget.
+        // The testing application's cancelable StopAsync wait does not own that task's completion.
         var applicationDisposed = await IsolatedOriginalTaskSettlement.RunAsync(
-            () => app.DisposeAsync().AsTask(), AppDisposeValue, failures, options);
-        var reportsRetained = stopped && applicationDisposed
+            () => app.DisposeAsync().AsTask(), AppDisposeValue, failures, options,
+            shutdownAllowance: work.HostShutdownTimeout);
+        var reportsRetained = applicationDisposed
             && await IsolatedOriginalTaskSettlement.RunAsync(() => RetainReportsAsync(output, evidence),
                 ExecutionTrxRetainValue, failures, options);
-        if (runnerSettled && collectorSettled && resourcesStopped && captureSettled && captureDisposed && stopped && applicationDisposed && reportsRetained)
+        if (runnerSettled && collectorSettled && captureSettled && captureDisposed && applicationDisposed && reportsRetained)
         {
             await IsolatedOriginalTaskSettlement.RunAsync(
                 () => IsolatedDataCleanup.DeleteAsync(root, containers), DataStage, failures, options);
@@ -124,23 +123,6 @@ private static async Task<bool> SettleCollectorAsync(IsolatedOwnedWork work,
         return await IsolatedOriginalTaskSettlement.RunAsync(() => original, ServerResourceValue, failures, options);
     }
 
-    private static async Task<bool> StopAsync(DistributedApplication app,
-        IsolatedTeardownFailures failures, IOptions<ComparisonHarnessOptions> options)
-    {
-        using var cancellation = new CancellationTokenSource();
-        return await IsolatedOriginalTaskSettlement.RunAsync(
-            () => app.StopAsync(cancellation.Token), StopStage, failures, options, cancellation.CancelAsync);
-    }
-
-    private static async Task<bool> StopResourcesAsync(DistributedApplication app, ContainerResource[] containers,
-        IsolatedTeardownFailures failures, IOptions<ComparisonHarnessOptions> options)
-    {
-        using var cancellation = new CancellationTokenSource();
-        return await IsolatedOriginalTaskSettlement.RunAsync(
-            () => IsolatedResourceShutdown.StopAsync(app, containers, cancellation.Token), ResourcesStopStage,
-            failures, options, cancellation.CancelAsync);
-    }
-
     private static Task RetainReportsAsync(string output, string evidence)
     {
         WorkloadTestReports.Retain(output, evidence);

benchmarks/KeyLoad.ComparisonHost/Orchestration/Scenarios/IsolatedTeardown.cs

@@ -196,11 +196,13 @@ the same joined lifecycle and validate anonymous-volume ownership before removin
 their host data directory. Original resource identities and logs remain available.
 Measured document deletes still use the real native mutation path.
 
-After the workload and resource observers settle, the client requests each created
-container's registered Aspire stop command and awaits its actual exit notification.
-Resource logs remain open until these exits are observed. Application disposal
-then removes the stopped session containers and anonymous volumes. Each shutdown
-stage retains its 30-second deadline; a rejected command, missing exit, timeout or
+After the workload, resource observers and captured logs settle, the fixture owns
+and awaits the original Aspire testing application's `DisposeAsync` task. The
+testing factory owns host shutdown, session containers and anonymous volumes.
+Its configured `HostOptions.ShutdownTimeout` remains unchanged. The outer disposal
+join allows that host-shutdown budget plus the existing 30-second original-task
+settlement budget; other teardown stages retain their 30-second deadlines. The
+original disposal task remains joined after a threshold, and any timeout or
 disposal failure still fails the original session.
 
 ClickHouse uses native patch-part `UPDATE` and `DELETE FROM` operations over the