Refine explicit-start DCP lifecycle

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 2 people

src/Aspire.Hosting/Dcp/DcpExecutor.cs

@@ -376,7 +376,7 @@ internal static string GetResourceType<T>(T resource, IResource appModelResource
     Task IDcpObjectFactory.UpdateWithEffectiveAddressInfo(IEnumerable<Service> services, CancellationToken cancellationToken, TimeSpan? timeout)
         => UpdateWithEffectiveAddressInfo(services, cancellationToken, timeout);
 
-    // Watches DCP object updates via a Kubernetes watch wrapped in the supplied retry pipeline, 
+    // Watches DCP object updates via a Kubernetes watch wrapped in the supplied retry pipeline,
     // till all objects reach desired state or a timeout occurs.
     // Returns names of objects that did not reach the desired state.
     private async Task<HashSet<string>> WatchUntilDesiredStateAsync<TDcpResource>(
@@ -591,8 +591,8 @@ private Task CreateAllDcpObjectsAsync<RT>(CancellationToken cancellationToken) w
     Task IDcpObjectFactory.CreateDcpObjectsAsync<T>(IEnumerable<T> objects, CancellationToken cancellationToken)
         => CreateDcpObjectsAsync(objects, cancellationToken);
 
-    async Task<T> IDcpObjectFactory.PatchDcpObjectAsync<T>(T obj, Action<T> change, CancellationToken cancellationToken)
-        => await PatchDcpObjectAsync(obj, change, cancellationToken).ConfigureAwait(false);
+    Task<T> IDcpObjectFactory.PatchDcpObjectAsync<T>(T obj, Action<T> change, CancellationToken cancellationToken)
+        => PatchDcpObjectAsync(obj, change, cancellationToken);
 
     private async Task<T> PatchDcpObjectAsync<T>(T obj, Action<T> change, CancellationToken cancellationToken)
         where T : CustomResource, IKubernetesStaticMetadata
@@ -1071,20 +1071,25 @@ public async Task StartResourceAsync(IResourceReference resourceReference, Cance
             await appResource.Initialized.WaitAsync(cancellationToken).ConfigureAwait(false);
             using var _ = await ConcurrencyUtils.AcquireAllAsync([appResource.SerializedOpSemaphore], cancellationToken).ConfigureAwait(false);
 
-            if (await TryStartCreatedDelayedStartResourceAsync(resourceReference, resourceType, cancellationToken).ConfigureAwait(false))
+            // For resources that need delete/recreate startup, raise the starting event after deletion. This is required because
+            // deleting the existing DCP object temporarily overrides the status with a terminal state, such as "Exited".
+            switch (resourceReference)
             {
-                return;
-            }
+                // We need to handle explicit start persistent resources specially on first launch as they may already be running, so we need to register them with DCP to discover their status.
+                case RenderedModelResource<Container> { DcpResource.Spec.Start: false } cr when !DcpModelUtilities.ShouldDeferCreateForExplicitStart(cr.ModelResource, cr.DcpResource.Spec.Start):
+                    await PublishConnectionStringAvailableEventAsync(cr.ModelResource, cancellationToken).ConfigureAwait(false);
+                    await _executorEvents.PublishAsync(new OnResourceStartingContext(cancellationToken, resourceType, cr.ModelResource, cr.DcpResourceName)).ConfigureAwait(false);
+                    await PatchDcpObjectAsync(cr.DcpResource, static c => c.Spec.Start = true, cancellationToken).ConfigureAwait(false);
+                    break;
 
-            // Reset cached callback results so they are re-evaluated on restart.
-            ForgetCachedCallbackResults(resourceReference.ModelResource);
+                case RenderedModelResource<Executable> { DcpResource.Spec.Start: false } er when !DcpModelUtilities.ShouldDeferCreateForExplicitStart(er.ModelResource, er.DcpResource.Spec.Start):
+                    await PublishConnectionStringAvailableEventAsync(er.ModelResource, cancellationToken).ConfigureAwait(false);
+                    await _executorEvents.PublishAsync(new OnResourceStartingContext(cancellationToken, resourceType, er.ModelResource, er.DcpResourceName)).ConfigureAwait(false);
+                    await PatchDcpObjectAsync(er.DcpResource, static e => e.Spec.Start = true, cancellationToken).ConfigureAwait(false);
+                    break;
 
-            // Raise event after resource has been deleted. This is required because the event sets the status to "Starting" and resources being
-            // deleted will temporarily override the status to a terminal state, such as "Exited".
-            switch (resourceReference)
-            {
                 case RenderedModelResource<Container> cr:
-                    await EnsureResourceDeletedAsync<Container>(resourceReference.DcpResourceName, cancellationToken).ConfigureAwait(false);
+                    await EnsureResourceDeletedAsync<Container>(resourceReference, cancellationToken).ConfigureAwait(false);
 
                     // Ensure we explicitly start the container even if original container was created in "delay-start" mode.
                     cr.DcpResource.Spec.Start = true;
@@ -1095,7 +1100,7 @@ public async Task StartResourceAsync(IResourceReference resourceReference, Cance
                     await _containerCreator.CreateObjectAsync(cr, cctx, resourceLogger, this, cancellationToken).ConfigureAwait(false);
                     break;
                 case RenderedModelResource<Executable> er:
-                    await EnsureResourceDeletedAsync<Executable>(resourceReference.DcpResourceName, cancellationToken).ConfigureAwait(false);
+                    await EnsureResourceDeletedAsync<Executable>(resourceReference, cancellationToken).ConfigureAwait(false);
 
                     // Ensure we explicitly start the executable even if original executable was created in "delay-start" mode.
                     er.DcpResource.Spec.Start = true;
@@ -1125,32 +1130,12 @@ public async Task StartResourceAsync(IResourceReference resourceReference, Cance
         }
     }
 
-    private async Task<bool> TryStartCreatedDelayedStartResourceAsync(IResourceReference resourceReference, string resourceType, CancellationToken cancellationToken)
+    private async Task EnsureResourceDeletedAsync<T>(IResourceReference resource, CancellationToken cancellationToken) where T : CustomResource, IKubernetesStaticMetadata
     {
-        switch (resourceReference)
-        {
-            case RenderedModelResource<Container> { DcpResource.Spec.Start: false } cr
-                when !DcpModelUtilities.ShouldDeferCreateForExplicitStart(cr.ModelResource, cr.DcpResource.Spec.Start):
-                await PublishConnectionStringAvailableEventAsync(cr.ModelResource, cancellationToken).ConfigureAwait(false);
-                await _executorEvents.PublishAsync(new OnResourceStartingContext(cancellationToken, resourceType, cr.ModelResource, cr.DcpResourceName)).ConfigureAwait(false);
-                await PatchDcpObjectAsync(cr.DcpResource, static c => c.Spec.Start = true, cancellationToken).ConfigureAwait(false);
-                return true;
-
-            case RenderedModelResource<Executable> { DcpResource.Spec.Start: false } er
-                when !DcpModelUtilities.ShouldDeferCreateForExplicitStart(er.ModelResource, er.DcpResource.Spec.Start):
-                await PublishConnectionStringAvailableEventAsync(er.ModelResource, cancellationToken).ConfigureAwait(false);
-                await _executorEvents.PublishAsync(new OnResourceStartingContext(cancellationToken, resourceType, er.ModelResource, er.DcpResourceName)).ConfigureAwait(false);
-                await PatchDcpObjectAsync(er.DcpResource, static e => e.Spec.Start = true, cancellationToken).ConfigureAwait(false);
-                return true;
-
-            default:
-                return false;
-        }
-    }
+        _logger.LogDebug("Ensuring '{ResourceName}' is deleted.", resource.DcpResourceName);
 
-    private async Task EnsureResourceDeletedAsync<T>(string resourceName, CancellationToken cancellationToken) where T : CustomResource, IKubernetesStaticMetadata
-    {
-        _logger.LogDebug("Ensuring '{ResourceName}' is deleted.", resourceName);
+        // Reset cached callback results so they are re-evaluated on restart.
+        ForgetCachedCallbackResults(resource.ModelResource);
 
         var result = await DeleteResourceRetryPipeline.ExecuteAsync(async (resourceName, attemptCancellationToken) =>
         {
@@ -1194,11 +1179,11 @@ private async Task EnsureResourceDeletedAsync<T>(string resourceName, Cancellati
                 // Success.
                 return true;
             }
-        }, resourceName, cancellationToken).ConfigureAwait(false);
+        }, resource.DcpResourceName, cancellationToken).ConfigureAwait(false);
 
         if (!result)
         {
-            throw new DistributedApplicationException($"Failed to delete '{resourceName}' successfully before restart.");
+            throw new DistributedApplicationException($"Failed to delete '{resource.DcpResourceName}' successfully before restart.");
         }
     }
 

src/Aspire.Hosting/Dcp/DcpModelUtilities.cs

@@ -16,12 +16,12 @@ namespace Aspire.Hosting.Dcp;
 internal static class DcpModelUtilities
 {
     /// <summary>
-    /// Determines whether DCP registration should be deferred until an explicit manual start.
+    /// Determines whether DCP object creation should be deferred until an explicit manual start.
     /// </summary>
     internal static bool ShouldDeferCreateForExplicitStart(IResource modelResource, bool? start)
     {
         // Explicit-start, non-persistent resources use manual snapshots for dashboard visibility.
-        // Do not register them with DCP until the manual start path flips Spec.Start=true; creation
+        // Do not create corresponding DCP objects until the manual start path flips Spec.Start=true; creation
         // evaluates callbacks that can prompt for input or depend on start-time state.
         return start == false &&
             modelResource.TryGetLastAnnotation<ExplicitStartupAnnotation>(out _) &&

tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs

@@ -2586,7 +2586,7 @@ public async Task PersistentPlainExecutable_UsesStableCertificateOutputPath()
     }
 
     [Fact]
-    public async Task ExplicitStartPlainExecutable_IsNotCreatedUntilManualStart()
+    public async Task SessionScopedExplicitStartPlainExecutable_DefersDcpObjectCreationUntilManualStart()
     {
         var builder = DistributedApplication.CreateBuilder();