Remove IResourceWithoutLifetime on everything

src/Aspire.Hosting/ApplicationModel/ParameterResource.cs

@@ -9,7 +9,7 @@ namespace Aspire.Hosting.ApplicationModel;
 /// <summary>
 /// Represents a parameter resource.
 /// </summary>
-public class ParameterResource : Resource, IResourceWithoutLifetime, IManifestExpressionProvider, IValueProvider
+public class ParameterResource : Resource, IManifestExpressionProvider, IValueProvider
 {
     private readonly Lazy<string> _lazyValue;
     private readonly Func<ParameterDefault?, string> _valueGetter;

src/Aspire.Hosting/ConnectionStringBuilderExtensions.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 using Aspire.Dashboard.Model;
 using Aspire.Hosting.ApplicationModel;
+using Microsoft.Extensions.Logging;
 
 namespace Aspire.Hosting;
 
@@ -46,6 +47,44 @@ public static IResourceBuilder<ConnectionStringResource> AddConnectionString(thi
                           ResourceType = KnownResourceTypes.ConnectionString,
                           State = KnownResourceStates.Waiting,
                           Properties = []
+                      })
+                      .OnInitializeResource(async (r, @evt, ct) =>
+                      {
+                          // Wait for any referenced resources in the connection string.
+                          // We only look at top level resources with the assumption that they are transitive themselves.
+                          var tasks = new List<Task>();
+                          foreach (var referencedResource in r.ConnectionStringExpression.ValueProviders.OfType<IResource>())
+                          {
+                              tasks.Add(evt.Notifications.WaitForResourceHealthyAsync(referencedResource.Name, ct));
+                          }
+
+                          try
+                          {
+                              // Connection string resolution is dependent on parameters being resolved
+                              // We use this to wait for the parameters to be resolved before we can compute the connection string.
+                              await Task.WhenAll(tasks).ConfigureAwait(false);
+
+                              // Publish the update with the connection string value and the state as running.
+                              // This will allow health checks to start running.
+                              await evt.Notifications.PublishUpdateAsync(r, s => s with
+                              {
+                                  State = KnownResourceStates.Running
+                              }).ConfigureAwait(false);
+
+                              // Publish the connection string available event for other resources that may depend on this resource.
+                              await evt.Eventing.PublishAsync(new ConnectionStringAvailableEvent(r, evt.Services), ct)
+                                                .ConfigureAwait(false);
+                          }
+                          catch (Exception ex)
+                          {
+                              evt.Logger.LogError(ex, "Failed to resolve connection string for resource '{ResourceName}'", r.Name);
+
+                              // If we fail to resolve the connection string, we set the state to failed.
+                              await evt.Notifications.PublishUpdateAsync(r, s => s with
+                              {
+                                  State = KnownResourceStates.FailedToStart
+                              }).ConfigureAwait(false);
+                          }
                       });
     }
 

src/Aspire.Hosting/ConnectionStringResource.cs

@@ -10,7 +10,7 @@ namespace Aspire.Hosting;
 /// </summary>
 /// <param name="name">The name of the resource.</param>
 /// <param name="connectionStringExpression">The connection string expression.</param>
-public sealed class ConnectionStringResource(string name, ReferenceExpression connectionStringExpression) : Resource(name), IResourceWithConnectionString, IResourceWithoutLifetime
+public sealed class ConnectionStringResource(string name, ReferenceExpression connectionStringExpression) : Resource(name), IResourceWithConnectionString
 {
     /// <summary>
     /// Describes the connection string format string used for this resource.

src/Aspire.Hosting/ExternalServiceResource.cs

@@ -9,7 +9,7 @@ namespace Aspire.Hosting;
 /// <summary>
 /// Represents an external service resource with service discovery capabilities.
 /// </summary>
-public sealed class ExternalServiceResource : Resource, IResourceWithoutLifetime
+public sealed class ExternalServiceResource : Resource
 {
     private readonly Uri? _uri;
     private readonly ParameterResource? _urlParameter;

src/Aspire.Hosting/Orchestrator/ApplicationOrchestrator.cs

@@ -9,7 +9,6 @@
 using Aspire.Hosting.Dcp;
 using Aspire.Hosting.Eventing;
 using Aspire.Hosting.Lifecycle;
-using Microsoft.Extensions.Logging;
 
 namespace Aspire.Hosting.Orchestrator;
 
@@ -59,7 +58,6 @@ public ApplicationOrchestrator(DistributedApplicationModel model,
         _eventing.Subscribe<ConnectionStringAvailableEvent>(PublishConnectionStringValue);
         // Implement WaitFor functionality using BeforeResourceStartedEvent.
         _eventing.Subscribe<BeforeResourceStartedEvent>(WaitForInBeforeResourceStartedEvent);
-        _eventing.Subscribe<InitializeResourceEvent>(OnResourceInitialized);
     }
 
     private async Task PublishConnectionStringValue(ConnectionStringAvailableEvent @event, CancellationToken token)
@@ -306,69 +304,6 @@ private async Task OnResourceEndpointsAllocated(ResourceEndpointsAllocatedEvent
         await PublishResourceEndpointUrls(@event.Resource, cancellationToken).ConfigureAwait(false);
     }
 
-    private Task OnResourceInitialized(InitializeResourceEvent @event, CancellationToken cancellationToken)
-    {
-        var resource = @event.Resource;
-
-        if (resource is ConnectionStringResource connectionStringResource)
-        {
-            InitializeConnectionString(connectionStringResource);
-        }
-
-        void InitializeConnectionString(ConnectionStringResource connectionStringResource)
-        {
-            var logger = _loggerService.GetLogger(resource);
-            var waitFor = new List<Task>();
-
-            var references = connectionStringResource.Annotations.OfType<ResourceRelationshipAnnotation>()
-                .Where(x => x.Type == KnownRelationshipTypes.Reference)
-                .Select(x => x.Resource);
-
-            foreach (var reference in references)
-            {
-                if (reference is IResourceWithEndpoints)
-                {
-                    var tcs = new TaskCompletionSource();
-                    logger.LogInformation("Waiting for endpoints to be allocated for resource {ResourceName}", reference.Name);
-                    _eventing.Subscribe<ResourceEndpointsAllocatedEvent>(reference, (_, _) =>
-                    {
-                        logger.LogInformation("Endpoints allocated for resource {ResourceName}", reference.Name);
-                        tcs.SetResult();
-                        return Task.CompletedTask;
-                    });
-
-                    waitFor.Add(tcs.Task.WaitAsync(cancellationToken));
-                }
-
-                if (reference is IResourceWithConnectionString)
-                {
-                    var tcs = new TaskCompletionSource();
-                    logger.LogInformation("Waiting for connection string to be available for resource {ResourceName}", reference.Name);
-                    _eventing.Subscribe<ConnectionStringAvailableEvent>(reference, (_, _) =>
-                    {
-                        logger.LogInformation("Connection string is available for resource {ResourceName}", reference.Name);
-                        tcs.SetResult();
-                        return Task.CompletedTask;
-                    });
-
-                    waitFor.Add(tcs.Task.WaitAsync(cancellationToken));
-                }
-            }
-
-            _ = Task.Run(async () =>
-            {
-                await Task.WhenAll(waitFor).ConfigureAwait(false);
-                await PublishConnectionStringAvailableEvent(connectionStringResource, cancellationToken).ConfigureAwait(false);
-                await _notificationService.PublishUpdateAsync(connectionStringResource, s => s with
-                {
-                    State = new(KnownResourceStates.Active, KnownResourceStateStyles.Success),
-                }).ConfigureAwait(false);
-            }, cancellationToken);
-        }
-
-        return Task.CompletedTask;
-    }
-
     private async Task OnResourceChanged(OnResourceChangedContext context)
     {
         await _notificationService.PublishUpdateAsync(context.Resource, context.DcpResourceName, context.UpdateSnapshot).ConfigureAwait(false);

src/Aspire.Hosting/Orchestrator/ParameterProcessor.cs

@@ -70,7 +70,7 @@ await notificationService.PublishUpdateAsync(parameterResource, s =>
                 return s with
                 {
                     Properties = s.Properties.SetResourceProperty(KnownProperties.Parameter.Value, value, parameterResource.Secret),
-                    State = new(KnownResourceStates.Active, KnownResourceStateStyles.Success)
+                    State = KnownResourceStates.Running
                 };
             })
             .ConfigureAwait(false);
@@ -189,7 +189,7 @@ await notificationService.PublishUpdateAsync(parameter, s =>
                             return s with
                             {
                                 Properties = s.Properties.SetResourceProperty(KnownProperties.Parameter.Value, inputValue, parameter.Secret),
-                                State = new(KnownResourceStates.Active, KnownResourceStateStyles.Success)
+                                State = KnownResourceStates.Running
                             };
                         })
                         .ConfigureAwait(false);

src/Aspire.Hosting/ParameterResourceBuilderExtensions.cs

@@ -216,7 +216,6 @@ internal static IResourceBuilder<T> AddParameter<T>(this IDistributedApplication
         {
             ResourceType = KnownResourceTypes.Parameter,
             Properties = [
-                new("parameter.secret", resource.Secret.ToString()),
                 new(CustomResourceKnownProperties.Source, resource.ConfigurationKey)
             ],
             State = KnownResourceStates.Waiting

src/Aspire.Hosting/ResourceBuilderExtensions.cs

@@ -1202,16 +1202,6 @@ private static IResourceBuilder<T> WaitForCore<T>(this IResourceBuilder<T> build
             builder.WaitForCore(parentBuilder, waitBehavior, addRelationship: false);
         }
 
-        // Wait for any referenced resources in the connection string.
-        if (dependency.Resource is ConnectionStringResource cs)
-        {
-            // We only look at top level resources with the assumption that they are transitive themselves.
-            foreach (var referencedResource in cs.ConnectionStringExpression.ValueProviders.OfType<IResource>())
-            {
-                builder.WaitForCore(builder.ApplicationBuilder.CreateResourceBuilder(referencedResource), waitBehavior, addRelationship: false);
-            }
-        }
-
         if (addRelationship)
         {
             builder.WithRelationship(dependency.Resource, KnownRelationshipTypes.WaitFor);

tests/Aspire.Hosting.Tests/AddParameterTests.cs

@@ -33,11 +33,6 @@ public void ParametersAreVisibleByDefault()
 
         Assert.False(state.IsHidden);
         Assert.Collection(state.Properties,
-            prop =>
-            {
-                Assert.Equal("parameter.secret", prop.Name);
-                Assert.Equal("True", prop.Value);
-            },
             prop =>
             {
                 Assert.Equal(CustomResourceKnownProperties.Source, prop.Name);

tests/Aspire.Hosting.Tests/ExternalServiceTests.cs

@@ -246,17 +246,6 @@ public void ExternalServiceResourceHasExpectedInitialState()
         Assert.Equal("ExternalService", snapshot.InitialSnapshot.ResourceType);
     }
 
-    [Fact]
-    public void ExternalServiceResourceImplementsExpectedInterfaces()
-    {
-        using var builder = TestDistributedApplicationBuilder.Create();
-
-        var externalService = builder.AddExternalService("nuget", "https://nuget.org/");
-
-        // Verify the resource implements the expected interfaces
-        Assert.IsAssignableFrom<IResourceWithoutLifetime>(externalService.Resource);
-    }
-
     [Fact]
     public void ExternalServiceResourceIsExcludedFromPublishingManifest()
     {

tests/Aspire.Hosting.Tests/Orchestrator/ParameterProcessorTests.cs

@@ -16,7 +16,7 @@ namespace Aspire.Hosting.Tests.Orchestrator;
 public class ParameterProcessorTests
 {
     [Fact]
-    public async Task InitializeParametersAsync_WithValidParameters_SetsActiveState()
+    public async Task InitializeParametersAsync_WithValidParameters_SetsRunningState()
     {
         // Arrange
         var parameterProcessor = CreateParameterProcessor();
@@ -41,7 +41,7 @@ public async Task InitializeParametersAsync_WithValidParameters_SetsActiveState(
     }
 
     [Fact]
-    public async Task InitializeParametersAsync_WithValidParametersAndDashboardEnabled_SetsActiveState()
+    public async Task InitializeParametersAsync_WithValidParametersAndDashboardEnabled_SetsRunningState()
     {
         // Arrange
         var interactionService = CreateInteractionService(disableDashboard: false);
@@ -93,8 +93,7 @@ public async Task InitializeParametersAsync_WithSecretParameter_MarksAsSecret()
         // Assert
         var (resource, snapshot) = Assert.Single(updates);
         Assert.Same(secretParam, resource);
-        Assert.Equal(KnownResourceStates.Active, snapshot.State?.Text);
-        Assert.Equal(KnownResourceStateStyles.Success, snapshot.State?.Style);
+        Assert.Equal(KnownResourceStates.Running, snapshot.State?.Text);
     }
 
     [Fact]
@@ -246,17 +245,17 @@ public async Task HandleUnresolvedParametersAsync_WithMultipleUnresolvedParamete
         Assert.Equal("secretValue", await secretParam.WaitForValueTcs.Task);
 
         // Notification service should have received updates for each parameter
-        // Marking them as Active with the provided values
+        // Marking them as Running with the provided values
         await updates.MoveNextAsync();
-        Assert.Equal(KnownResourceStates.Active, updates.Current.Snapshot.State?.Text);
+        Assert.Equal(KnownResourceStates.Running, updates.Current.Snapshot.State?.Text);
         Assert.Equal("value1", updates.Current.Snapshot.Properties.FirstOrDefault(p => p.Name == KnownProperties.Parameter.Value)?.Value);
 
         await updates.MoveNextAsync();
-        Assert.Equal(KnownResourceStates.Active, updates.Current.Snapshot.State?.Text);
+        Assert.Equal(KnownResourceStates.Running, updates.Current.Snapshot.State?.Text);
         Assert.Equal("value2", updates.Current.Snapshot.Properties.FirstOrDefault(p => p.Name == KnownProperties.Parameter.Value)?.Value);
 
         await updates.MoveNextAsync();
-        Assert.Equal(KnownResourceStates.Active, updates.Current.Snapshot.State?.Text);
+        Assert.Equal(KnownResourceStates.Running, updates.Current.Snapshot.State?.Text);
         Assert.Equal("secretValue", updates.Current.Snapshot.Properties.FirstOrDefault(p => p.Name == KnownProperties.Parameter.Value)?.Value);
         Assert.True(updates.Current.Snapshot.Properties.FirstOrDefault(p => p.Name == KnownProperties.Parameter.Value)?.IsSensitive ?? false);
     }