WIP

Show updates in UI from config

Remove calls from resource

Test changes

Show connection strings

WIP

Tweaks to make it work
- Return a snapshot on watch

Remove lifecycle hook

Fixed playground app

Fix tests

Remove connection strings until we get masking

Cleanup

Smaller diff

Cleanup

Small cleanup

Send updates to dashboard when resources fail to start

Post updates using NotificationService from the ApplicationExecutor

playground/CosmosEndToEnd/CosmosEndToEnd.AppHost/Program.cs

@@ -6,8 +6,8 @@
 builder.AddAzureProvisioning();
 
 var db = builder.AddAzureCosmosDB("cosmos")
-                .AddDatabase("db")
-                .RunAsEmulator();
+                .AddDatabase("db");
+                // .RunAsEmulator();
 
 builder.AddProject<Projects.CosmosEndToEnd_ApiService>("api")
        .WithReference(db);

playground/CustomResources/CustomResources.AppHost/TestResource.cs

@@ -12,8 +12,7 @@ public static IResourceBuilder<TestResource> AddTestResource(this IDistributedAp
         builder.Services.AddLifecycleHook<TestResourceLifecycleHook>();
 
         var rb = builder.AddResource(new TestResource(name))
-                      .WithResourceLogger()
-                      .WithResourceUpdates(() => new()
+                      .WithInitialState(new()
                       {
                           ResourceType = "Test Resource",
                           State = "Starting",
@@ -28,53 +27,44 @@ public static IResourceBuilder<TestResource> AddTestResource(this IDistributedAp
     }
 }
 
-internal sealed class TestResourceLifecycleHook : IDistributedApplicationLifecycleHook, IAsyncDisposable
+internal sealed class TestResourceLifecycleHook(ResourceNotificationService notificationService, ResourceLoggerService loggerService) : IDistributedApplicationLifecycleHook, IAsyncDisposable
 {
     private readonly CancellationTokenSource _tokenSource = new();
 
     public Task BeforeStartAsync(DistributedApplicationModel appModel, CancellationToken cancellationToken = default)
     {
-        foreach (var item in appModel.Resources.OfType<TestResource>())
+        foreach (var resource in appModel.Resources.OfType<TestResource>())
         {
-            if (item.TryGetLastAnnotation<ResourceUpdatesAnnotation>(out var resourceUpdates) &&
-                item.TryGetLastAnnotation<ResourceLoggerAnnotation>(out var loggerAnnotation))
-            {
-                var states = new[] { "Starting", "Running", "Finished" };
+            var states = new[] { "Starting", "Running", "Finished" };
 
-                Task.Run(async () =>
-                {
-                    // Simulate custom resource state changes
-                    var state = await resourceUpdates.GetInitialSnapshotAsync(_tokenSource.Token);
-                    var seconds = Random.Shared.Next(2, 12);
+            var logger = loggerService.GetLogger(resource);
 
-                    state = state with
-                    {
-                        Properties = [.. state.Properties, ("Interval", seconds.ToString(CultureInfo.InvariantCulture))]
-                    };
-
-                    loggerAnnotation.Logger.LogInformation("Starting test resource {ResourceName} with update interval {Interval} seconds", item.Name, seconds);
+            Task.Run(async () =>
+            {
+                var seconds = Random.Shared.Next(2, 12);
 
-                    // This might run before the dashboard is ready to receive updates, but it will be queued.
-                    await resourceUpdates.UpdateStateAsync(state);
+                logger.LogInformation("Starting test resource {ResourceName} with update interval {Interval} seconds", resource.Name, seconds);
 
-                    using var timer = new PeriodicTimer(TimeSpan.FromSeconds(seconds));
+                await notificationService.PublishUpdateAsync(resource, state => state with
+                {
+                    Properties = [.. state.Properties, ("Interval", seconds.ToString(CultureInfo.InvariantCulture))]
+                });
 
-                    while (await timer.WaitForNextTickAsync(_tokenSource.Token))
-                    {
-                        var randomState = states[Random.Shared.Next(0, states.Length)];
+                using var timer = new PeriodicTimer(TimeSpan.FromSeconds(seconds));
 
-                        state = state with
-                        {
-                            State = randomState
-                        };
+                while (await timer.WaitForNextTickAsync(_tokenSource.Token))
+                {
+                    var randomState = states[Random.Shared.Next(0, states.Length)];
 
-                        loggerAnnotation.Logger.LogInformation("Test resource {ResourceName} is now in state {State}", item.Name, randomState);
+                    await notificationService.PublishUpdateAsync(resource, state => state with
+                    {
+                        State = randomState
+                    });
 
-                        await resourceUpdates.UpdateStateAsync(state);
-                    }
-                },
-                cancellationToken);
-            }
+                    logger.LogInformation("Test resource {ResourceName} is now in state {State}", resource.Name, randomState);
+                }
+            },
+            cancellationToken);
         }
 
         return Task.CompletedTask;

src/Aspire.Dashboard/Components/Controls/ResourceDetails.razor.cs

@@ -64,7 +64,8 @@ protected override void OnInitialized()
             new KnownProperty(KnownProperties.Resource.DisplayName, Loc[Resources.Resources.ResourcesDetailsDisplayNameProperty]),
             new KnownProperty(KnownProperties.Resource.State, Loc[Resources.Resources.ResourcesDetailsStateProperty]),
             new KnownProperty(KnownProperties.Resource.CreateTime, Loc[Resources.Resources.ResourcesDetailsStartTimeProperty]),
-            new KnownProperty(KnownProperties.Resource.ExitCode, Loc[Resources.Resources.ResourcesDetailsExitCodeProperty])
+            new KnownProperty(KnownProperties.Resource.ExitCode, Loc[Resources.Resources.ResourcesDetailsExitCodeProperty]),
+            new KnownProperty(KnownProperties.Resource.ConnectionString, Loc[Resources.Resources.ResourcesDetailsConnectionStringProperty]),
         ];
         _projectProperties =
         [

src/Aspire.Dashboard/Components/ResourcesGridColumns/EndpointsColumnDisplay.razor

@@ -39,7 +39,7 @@
         <li>
             @if (displayedEndpoint.Url != null)
             {
-                <a href="@displayedEndpoint.Url" target="_blank">@displayedEndpoint.Url</a>
+                <a href="@displayedEndpoint.Url" target="_blank">@displayedEndpoint.Text</a>
             }
             else
             {

src/Aspire.Dashboard/Model/ResourceEndpointHelpers.cs

@@ -12,28 +12,63 @@ internal static class ResourceEndpointHelpers
     /// </summary>
     public static List<DisplayedEndpoint> GetEndpoints(ILogger logger, ResourceViewModel resource, bool excludeServices = false, bool includeEndpointUrl = false)
     {
+        var isKnownResourceType = resource.IsContainer() || resource.IsExecutable(allowSubtypes: false) || resource.IsProject();
+
         var displayedEndpoints = new List<DisplayedEndpoint>();
 
-        if (!excludeServices)
+        if (isKnownResourceType)
         {
-            foreach (var service in resource.Services)
+            if (!excludeServices)
             {
-                displayedEndpoints.Add(new DisplayedEndpoint
+                foreach (var service in resource.Services)
                 {
-                    Name = service.Name,
-                    Text = service.AddressAndPort,
-                    Address = service.AllocatedAddress,
-                    Port = service.AllocatedPort
-                });
+                    displayedEndpoints.Add(new DisplayedEndpoint
+                    {
+                        Name = service.Name,
+                        Text = service.AddressAndPort,
+                        Address = service.AllocatedAddress,
+                        Port = service.AllocatedPort
+                    });
+                }
             }
-        }
 
-        foreach (var endpoint in resource.Endpoints)
+            foreach (var endpoint in resource.Endpoints)
+            {
+                ProcessUrl(logger, resource, displayedEndpoints, endpoint.ProxyUrl, "ProxyUrl");
+                if (includeEndpointUrl)
+                {
+                    ProcessUrl(logger, resource, displayedEndpoints, endpoint.EndpointUrl, "EndpointUrl");
+                }
+            }
+        }
+        else
         {
-            ProcessUrl(logger, resource, displayedEndpoints, endpoint.ProxyUrl, "ProxyUrl");
-            if (includeEndpointUrl)
+            // Look for services with an address (which might be a URL) and use that to match up with endpoints.
+            // otherwise, just display the endpoints.
+            var addressLookup = resource.Services.Where(s => s.AllocatedAddress is not null)
+                                                 .ToDictionary(s => s.AllocatedAddress!);
+
+            foreach (var endpoint in resource.Endpoints)
             {
-                ProcessUrl(logger, resource, displayedEndpoints, endpoint.EndpointUrl, "EndpointUrl");
+                if (addressLookup.TryGetValue(endpoint.EndpointUrl, out var service))
+                {
+                    displayedEndpoints.Add(new DisplayedEndpoint
+                    {
+                        Name = service.Name,
+                        Url = endpoint.EndpointUrl,
+                        Text = service.Name,
+                        Address = service.AllocatedAddress,
+                        Port = service.AllocatedPort
+                    });
+                }
+                else
+                {
+                    displayedEndpoints.Add(new DisplayedEndpoint
+                    {
+                        Name = endpoint.EndpointUrl,
+                        Text = endpoint.EndpointUrl
+                    });
+                }
             }
         }
 

src/Aspire.Dashboard/Resources/Resources.resx

@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
-  <!--
-    Microsoft ResX Schema
-
+  <!-- 
+    Microsoft ResX Schema 
+    
     Version 2.0
-
-    The primary goals of this format is to allow a simple XML format
-    that is mostly human readable. The generation and parsing of the
-    various data types are done through the TypeConverter classes
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
     associated with the data types.
-
+    
     Example:
-
+    
     ... ado.net/XML headers & schema ...
     <resheader name="resmimetype">text/microsoft-resx</resheader>
     <resheader name="version">2.0</resheader>
@@ -26,36 +26,36 @@
         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
         <comment>This is a comment</comment>
     </data>
-
-    There are any number of "resheader" rows that contain simple
+                
+    There are any number of "resheader" rows that contain simple 
     name/value pairs.
-
-    Each data row contains a name, and value. The row also contains a
-    type or mimetype. Type corresponds to a .NET class that support
-    text/value conversion through the TypeConverter architecture.
-    Classes that don't support this are serialized and stored with the
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
     mimetype set.
-
-    The mimetype is used for serialized objects, and tells the
-    ResXResourceReader how to depersist the object. This is currently not
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
     extensible. For a given mimetype the value must be set accordingly:
-
-    Note - application/x-microsoft.net.object.binary.base64 is the format
-    that the ResXResourceWriter will generate, however the reader can
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
     read any of the formats listed below.
-
+    
     mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
             : and then encoded with base64 encoding.
-
+    
     mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
             : and then encoded with base64 encoding.
 
     mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array
+    value   : The object must be serialized into a byte array 
             : using a System.ComponentModel.TypeConverter
             : and then encoded with base64 encoding.
     -->
@@ -215,4 +215,7 @@
   <data name="ResourcesDetailsStateProperty" xml:space="preserve">
     <value>State</value>
   </data>
-</root>
+  <data name="ResourcesDetailsConnectionStringProperty" xml:space="preserve">
+    <value>Connection string</value>
+  </data>
+</root>