[release/9.4] Made changes to how parameter.Value works (#10357)

github-actions[bot] · davidfowl · web-flow · commit 462c20d9b74a · 2025-07-12T15:27:10.000-06:00
* Made changes to how parameter.Value works - Value now blocks (sync over async) waiting for value resolution if WaitForValueTcs is set. - Made GetValueAsync on ParameterResource public. - Changed most code outside of tests to use GetValueAsync instead of Value

* Fix typo in comment regarding parameter access in WithHttpHealthCheck method

* Add error handling for URL parameter resolution in external service

---------

Co-authored-by: David Fowler &lt;davidfowl@gmail.com&gt;
diff --git a/src/Aspire.Hosting.Azure/Provisioning/Provisioners/BicepProvisioner.cs b/src/Aspire.Hosting.Azure/Provisioning/Provisioners/BicepProvisioner.cs
@@ -106,7 +106,7 @@ public async Task GetOrCreateResourceAsync(AzureBicepResource resource, Provisio
         if (BicepUtilities.GetExistingResourceGroup(resource) is { } existingResourceGroup)
         {
             var existingResourceGroupName = existingResourceGroup is ParameterResource parameterResource
-                ? parameterResource.Value
+                ? (await parameterResource.GetValueAsync(cancellationToken).ConfigureAwait(false))!
                 : (string)existingResourceGroup;
             var response = await context.Subscription.GetResourceGroups().GetAsync(existingResourceGroupName, cancellationToken).ConfigureAwait(false);
             resourceGroup = response.Value;
diff --git a/src/Aspire.Hosting.MySql/MySqlBuilderExtensions.cs b/src/Aspire.Hosting.MySql/MySqlBuilderExtensions.cs
@@ -205,14 +205,14 @@ public static IResourceBuilder<T> WithPhpMyAdmin<T>(this IResourceBuilder<T> bui
                                                 .WithHttpEndpoint(targetPort: 80, name: "http")
                                                 .ExcludeFromManifest();
 
-        builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(phpMyAdminContainer, (e, ct) =>
+        builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(phpMyAdminContainer, async (e, ct) =>
         {
             var mySqlInstances = builder.ApplicationBuilder.Resources.OfType<MySqlServerResource>();
 
             if (!mySqlInstances.Any())
             {
                 // No-op if there are no MySql resources present.
-                return Task.CompletedTask;
+                return;
             }
 
             if (mySqlInstances.Count() == 1)
@@ -225,12 +225,12 @@ public static IResourceBuilder<T> WithPhpMyAdmin<T>(this IResourceBuilder<T> bui
                     // This will need to be refactored once updated service discovery APIs are available
                     context.EnvironmentVariables.Add("PMA_HOST", $"{endpoint.Resource.Name}:{endpoint.TargetPort}");
                     context.EnvironmentVariables.Add("PMA_USER", "root");
-                    context.EnvironmentVariables.Add("PMA_PASSWORD", singleInstance.PasswordParameter.Value);
+                    context.EnvironmentVariables.Add("PMA_PASSWORD", singleInstance.PasswordParameter);
                 });
             }
             else
             {
-                var tempConfigFile = WritePhpMyAdminConfiguration(mySqlInstances);
+                var tempConfigFile = await WritePhpMyAdminConfiguration(mySqlInstances, ct).ConfigureAwait(false);
 
                 try
                 {
@@ -258,8 +258,6 @@ public static IResourceBuilder<T> WithPhpMyAdmin<T>(this IResourceBuilder<T> bui
                     }
                 }
             }
-
-            return Task.CompletedTask;
         });
 
         configureContainer?.Invoke(phpMyAdminContainerBuilder);
@@ -346,7 +344,7 @@ public static IResourceBuilder<MySqlServerResource> WithInitFiles(this IResource
         return builder.WithContainerFiles(initPath, importFullPath);
     }
 
-    private static string WritePhpMyAdminConfiguration(IEnumerable<MySqlServerResource> mySqlInstances)
+    private static async Task<string> WritePhpMyAdminConfiguration(IEnumerable<MySqlServerResource> mySqlInstances, CancellationToken cancellationToken)
     {
         // This temporary file is not used by the container, it will be copied and then deleted
         var filePath = Path.GetTempFileName();
@@ -360,14 +358,16 @@ private static string WritePhpMyAdminConfiguration(IEnumerable<MySqlServerResour
         foreach (var mySqlInstance in mySqlInstances)
         {
             var endpoint = mySqlInstance.PrimaryEndpoint;
+            var pwd = await mySqlInstance.PasswordParameter.GetValueAsync(cancellationToken).ConfigureAwait(false);
+
             writer.WriteLine("$i++;");
             // PhpMyAdmin assumes MySql is being accessed over a default Aspire container network and hardcodes the resource address
             // This will need to be refactored once updated service discovery APIs are available
             writer.WriteLine($"$cfg['Servers'][$i]['host'] = '{endpoint.Resource.Name}:{endpoint.TargetPort}';");
             writer.WriteLine($"$cfg['Servers'][$i]['verbose'] = '{mySqlInstance.Name}';");
             writer.WriteLine($"$cfg['Servers'][$i]['auth_type'] = 'cookie';");
             writer.WriteLine($"$cfg['Servers'][$i]['user'] = 'root';");
-            writer.WriteLine($"$cfg['Servers'][$i]['password'] = '{mySqlInstance.PasswordParameter.Value}';");
+            writer.WriteLine($"$cfg['Servers'][$i]['password'] = '{pwd}';");
             writer.WriteLine($"$cfg['Servers'][$i]['AllowNoPassword'] = true;");
             writer.WriteLine();
         }
diff --git a/src/Aspire.Hosting.Nats/NatsBuilderExtensions.cs b/src/Aspire.Hosting.Nats/NatsBuilderExtensions.cs
@@ -73,7 +73,7 @@ public static IResourceBuilder<NatsServerResource> AddNats(this IDistributedAppl
                 AuthOpts = new()
                 {
                     Username = await nats.UserNameReference.GetValueAsync(ct).ConfigureAwait(false),
-                    Password = nats.PasswordParameter!.Value,
+                    Password = await nats.PasswordParameter!.GetValueAsync(ct).ConfigureAwait(false),
                 }
             };
 
diff --git a/src/Aspire.Hosting.PostgreSQL/PostgresBuilderExtensions.cs b/src/Aspire.Hosting.PostgreSQL/PostgresBuilderExtensions.cs
@@ -203,18 +203,18 @@ public static IResourceBuilder<T> WithPgAdmin<T>(this IResourceBuilder<T> builde
 
             pgAdminContainerBuilder.WithContainerFiles(
                 destinationPath: "/pgadmin4",
-                callback: (context, _) =>
+                callback: async (context, cancellationToken) =>
                 {
                     var appModel = context.ServiceProvider.GetRequiredService<DistributedApplicationModel>();
                     var postgresInstances = builder.ApplicationBuilder.Resources.OfType<PostgresServerResource>();
 
-                    return Task.FromResult<IEnumerable<ContainerFileSystemItem>>([
+                    return [
                         new ContainerFile
                         {
                             Name = "servers.json",
-                            Contents = WritePgAdminServerJson(postgresInstances),
+                            Contents = await WritePgAdminServerJson(postgresInstances, cancellationToken).ConfigureAwait(false),
                         },
-                    ]);
+                    ];
                 });
 
             configureContainer?.Invoke(pgAdminContainerBuilder);
@@ -313,25 +313,25 @@ public static IResourceBuilder<PostgresServerResource> WithPgWeb(this IResourceB
 
             pgwebContainerBuilder.WithContainerFiles(
                 destinationPath: "/",
-                callback: (context, _) =>
+                callback: async (context, ct) =>
                 {
                     var appModel = context.ServiceProvider.GetRequiredService<DistributedApplicationModel>();
                     var postgresInstances = builder.ApplicationBuilder.Resources.OfType<PostgresDatabaseResource>();
 
                     // Add the bookmarks to the pgweb container
-                    return Task.FromResult<IEnumerable<ContainerFileSystemItem>>([
+                    return [
                         new ContainerDirectory
                         {
                             Name = ".pgweb",
                             Entries = [
                                 new ContainerDirectory
                                 {
                                     Name = "bookmarks",
-                                    Entries = WritePgWebBookmarks(postgresInstances),
+                                    Entries = await WritePgWebBookmarks(postgresInstances, ct).ConfigureAwait(false)
                                 },
                             ],
                         },
-                    ]);
+                    ];
                 });
 
             return builder;
@@ -489,21 +489,25 @@ public static IResourceBuilder<PostgresServerResource> WithHostPort(this IResour
         });
     }
 
-    private static IEnumerable<ContainerFileSystemItem> WritePgWebBookmarks(IEnumerable<PostgresDatabaseResource> postgresInstances)
+    private static async Task<IEnumerable<ContainerFileSystemItem>> WritePgWebBookmarks(IEnumerable<PostgresDatabaseResource> postgresInstances, CancellationToken cancellationToken)
     {
         var bookmarkFiles = new List<ContainerFileSystemItem>();
 
         foreach (var postgresDatabase in postgresInstances)
         {
-            var user = postgresDatabase.Parent.UserNameParameter?.Value ?? "postgres";
+            var user = postgresDatabase.Parent.UserNameParameter is null
+            ? "postgres"
+            : await postgresDatabase.Parent.UserNameParameter.GetValueAsync(cancellationToken).ConfigureAwait(false);
+
+            var password = await postgresDatabase.Parent.PasswordParameter.GetValueAsync(cancellationToken).ConfigureAwait(false) ?? "password";
 
             // PgAdmin assumes Postgres is being accessed over a default Aspire container network and hardcodes the resource address
             // This will need to be refactored once updated service discovery APIs are available
             var fileContent = $"""
                     host = "{postgresDatabase.Parent.Name}"
                     port = {postgresDatabase.Parent.PrimaryEndpoint.TargetPort}
                     user = "{user}"
-                    password = "{postgresDatabase.Parent.PasswordParameter.Value}"
+                    password = "{password}"
                     database = "{postgresDatabase.DatabaseName}"
                     sslmode = "disable"
                     """;
@@ -518,7 +522,7 @@ private static IEnumerable<ContainerFileSystemItem> WritePgWebBookmarks(IEnumera
         return bookmarkFiles;
     }
 
-    private static string WritePgAdminServerJson(IEnumerable<PostgresServerResource> postgresInstances)
+    private static async Task<string> WritePgAdminServerJson(IEnumerable<PostgresServerResource> postgresInstances, CancellationToken cancellationToken)
     {
         using var stream = new MemoryStream();
         using var writer = new Utf8JsonWriter(stream, new JsonWriterOptions { Indented = true });
@@ -531,6 +535,10 @@ private static string WritePgAdminServerJson(IEnumerable<PostgresServerResource>
         foreach (var postgresInstance in postgresInstances)
         {
             var endpoint = postgresInstance.PrimaryEndpoint;
+            var userName = postgresInstance.UserNameParameter is null
+                ? "postgres"
+                : await postgresInstance.UserNameParameter.GetValueAsync(cancellationToken).ConfigureAwait(false);
+            var password = await postgresInstance.PasswordParameter.GetValueAsync(cancellationToken).ConfigureAwait(false);
 
             writer.WriteStartObject($"{serverIndex}");
             writer.WriteString("Name", postgresInstance.Name);
@@ -539,10 +547,10 @@ private static string WritePgAdminServerJson(IEnumerable<PostgresServerResource>
             // This will need to be refactored once updated service discovery APIs are available
             writer.WriteString("Host", endpoint.Resource.Name);
             writer.WriteNumber("Port", (int)endpoint.TargetPort!);
-            writer.WriteString("Username", postgresInstance.UserNameParameter?.Value ?? "postgres");
+            writer.WriteString("Username", userName);
             writer.WriteString("SSLMode", "prefer");
             writer.WriteString("MaintenanceDB", "postgres");
-            writer.WriteString("PasswordExecCommand", $"echo '{postgresInstance.PasswordParameter.Value}'"); // HACK: Generating a pass file and playing around with chmod is too painful.
+            writer.WriteString("PasswordExecCommand", $"echo '{password}'"); // HACK: Generating a pass file and playing around with chmod is too painful.
             writer.WriteEndObject();
 
             serverIndex++;
diff --git a/src/Aspire.Hosting.Redis/RedisBuilderExtensions.cs b/src/Aspire.Hosting.Redis/RedisBuilderExtensions.cs
@@ -158,14 +158,14 @@ public static IResourceBuilder<RedisResource> WithRedisCommander(this IResourceB
                                       .WithHttpEndpoint(targetPort: 8081, name: "http")
                                       .ExcludeFromManifest();
 
-            builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(resource, (e, ct) =>
+            builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(resource, async (e, ct) =>
             {
                 var redisInstances = builder.ApplicationBuilder.Resources.OfType<RedisResource>();
 
                 if (!redisInstances.Any())
                 {
                     // No-op if there are no Redis resources present.
-                    return Task.CompletedTask;
+                    return;
                 }
 
                 var hostsVariableBuilder = new StringBuilder();
@@ -177,14 +177,13 @@ public static IResourceBuilder<RedisResource> WithRedisCommander(this IResourceB
                     var hostString = $"{(hostsVariableBuilder.Length > 0 ? "," : string.Empty)}{redisInstance.Name}:{redisInstance.Name}:{redisInstance.PrimaryEndpoint.TargetPort}:0";
                     if (redisInstance.PasswordParameter is not null)
                     {
-                        hostString += $":{redisInstance.PasswordParameter.Value}";
+                        var password = await redisInstance.PasswordParameter.GetValueAsync(ct).ConfigureAwait(false);
+                        hostString += $":{password}";
                     }
                     hostsVariableBuilder.Append(hostString);
                 }
 
                 resourceBuilder.WithEnvironment("REDIS_HOSTS", hostsVariableBuilder.ToString());
-
-                return Task.CompletedTask;
             });
 
             configureContainer?.Invoke(resourceBuilder);
@@ -244,7 +243,7 @@ public static IResourceBuilder<RedisResource> WithRedisInsight(this IResourceBui
                         context.EnvironmentVariables.Add($"RI_REDIS_ALIAS{counter}", redisInstance.Name);
                         if (redisInstance.PasswordParameter is not null)
                         {
-                            context.EnvironmentVariables.Add($"RI_REDIS_PASSWORD{counter}", redisInstance.PasswordParameter.Value);
+                            context.EnvironmentVariables.Add($"RI_REDIS_PASSWORD{counter}", redisInstance.PasswordParameter);
                         }
 
                         counter++;
diff --git a/src/Aspire.Hosting/ApplicationModel/ParameterResource.cs b/src/Aspire.Hosting/ApplicationModel/ParameterResource.cs
@@ -31,7 +31,9 @@ public ParameterResource(string name, Func<ParameterDefault?, string> callback,
     /// <summary>
     /// Gets the value of the parameter.
     /// </summary>
-    public string Value
+    public string Value => GetValueAsync(default).AsTask().GetAwaiter().GetResult()!;
+
+    internal string ValueInternal
     {
         get
         {
@@ -79,14 +81,20 @@ internal string ConfigurationKey
     /// </summary>
     internal TaskCompletionSource<string>? WaitForValueTcs { get; set; }
 
-    async ValueTask<string?> IValueProvider.GetValueAsync(CancellationToken cancellationToken)
+    /// <summary>
+    /// Gets the value of the parameter asynchronously, waiting if necessary for the value to be set.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token to observe while waiting for the value.</param>
+    /// <returns>A task that represents the asynchronous operation, containing the value of the parameter.</returns>
+    public async ValueTask<string?> GetValueAsync(CancellationToken cancellationToken)
     {
         if (WaitForValueTcs is not null)
         {
             // Wait for the value to be set if the task completion source is available.
             return await WaitForValueTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
         }
 
-        return Value;
+        // In publish mode, there's no WaitForValueTcs set.
+        return ValueInternal;
     }
 }
diff --git a/src/Aspire.Hosting/ExternalServiceBuilderExtensions.cs b/src/Aspire.Hosting/ExternalServiceBuilderExtensions.cs
@@ -80,6 +80,7 @@ private static IResourceBuilder<ExternalServiceResource> AddExternalServiceImpl(
             .WithInitialState(new CustomResourceSnapshot
             {
                 ResourceType = "ExternalService",
+                State = KnownResourceStates.Waiting,
                 Properties = []
             })
             .ExcludeFromManifest();
@@ -104,7 +105,24 @@ private static IResourceBuilder<ExternalServiceResource> AddExternalServiceImpl(
                 if (uri is null)
                 {
                     // If the URI is not set, it means we are using a parameterized URL
-                    var url = resource.UrlParameter?.Value;
+                    string? url;
+                    try
+                    {
+                        url = resource.UrlParameter is null
+                                ? null
+                                : await resource.UrlParameter.GetValueAsync(ct).ConfigureAwait(false);
+                    }
+                    catch (Exception ex)
+                    {
+                        e.Logger.LogError(ex, "Failed to get value for URL parameter '{ParameterName}'", resource.UrlParameter?.Name);
+
+                        await e.Notifications.PublishUpdateAsync(resource, snapshot => snapshot with
+                        {
+                            State = KnownResourceStates.FailedToStart
+                        }).ConfigureAwait(false);
+
+                        return;
+                    }
 
                     if (!ExternalServiceResource.UrlIsValidForExternalService(url, out uri, out var message))
                     {
@@ -182,6 +200,8 @@ public static IResourceBuilder<ExternalServiceResource> WithHttpHealthCheck(this
         {
             var uri = builder.Resource.Uri;
 
+            // OK accessing the parameter here synchronously as this should only activate once the resource is running
+
             if (uri is null && !Uri.TryCreate(builder.Resource.UrlParameter?.Value, UriKind.Absolute, out uri)
                 || (uri?.Scheme != "http" && uri?.Scheme != "https"))
             {
diff --git a/src/Aspire.Hosting/Orchestrator/ParameterProcessor.cs b/src/Aspire.Hosting/Orchestrator/ParameterProcessor.cs
@@ -62,7 +62,7 @@ private async Task ProcessParameterAsync(ParameterResource parameterResource)
     {
         try
         {
-            var value = parameterResource.Value ?? "";
+            var value = parameterResource.ValueInternal ?? "";
 
             await notificationService.PublishUpdateAsync(parameterResource, s =>
             {
diff --git a/src/Aspire.Hosting/ResourceBuilderExtensions.cs b/src/Aspire.Hosting/ResourceBuilderExtensions.cs
diff --git a/tests/Aspire.Hosting.Tests/ExternalServiceTests.cs b/tests/Aspire.Hosting.Tests/ExternalServiceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ public async Task GetOrCreateResourceAsync(AzureBicepResource resource, Provisio`
`106`	`106`	`if (BicepUtilities.GetExistingResourceGroup(resource) is { } existingResourceGroup)`
`107`	`107`	`{`
`108`	`108`	`var existingResourceGroupName = existingResourceGroup is ParameterResource parameterResource`
`109`		`- ? parameterResource.Value`
	`109`	`+ ? (await parameterResource.GetValueAsync(cancellationToken).ConfigureAwait(false))!`
`110`	`110`	`: (string)existingResourceGroup;`
`111`	`111`	`var response = await context.Subscription.GetResourceGroups().GetAsync(existingResourceGroupName, cancellationToken).ConfigureAwait(false);`
`112`	`112`	`resourceGroup = response.Value;`
Original file line number	Diff line number	Diff line change
`@@ -205,14 +205,14 @@ public static IResourceBuilder<T> WithPhpMyAdmin<T>(this IResourceBuilder<T> bui`
`205`	`205`	`.WithHttpEndpoint(targetPort: 80, name: "http")`
`206`	`206`	`.ExcludeFromManifest();`
`207`	`207`
`208`		`- builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(phpMyAdminContainer, (e, ct) =>`
	`208`	`+ builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(phpMyAdminContainer, async (e, ct) =>`
`209`	`209`	`{`
`210`	`210`	`var mySqlInstances = builder.ApplicationBuilder.Resources.OfType<MySqlServerResource>();`
`211`	`211`
`212`	`212`	`if (!mySqlInstances.Any())`
`213`	`213`	`{`
`214`	`214`	`// No-op if there are no MySql resources present.`
`215`		`- return Task.CompletedTask;`
	`215`	`+ return;`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`if (mySqlInstances.Count() == 1)`
`@@ -225,12 +225,12 @@ public static IResourceBuilder<T> WithPhpMyAdmin<T>(this IResourceBuilder<T> bui`
`225`	`225`	`// This will need to be refactored once updated service discovery APIs are available`
`226`	`226`	`context.EnvironmentVariables.Add("PMA_HOST", $"{endpoint.Resource.Name}:{endpoint.TargetPort}");`
`227`	`227`	`context.EnvironmentVariables.Add("PMA_USER", "root");`
`228`		`- context.EnvironmentVariables.Add("PMA_PASSWORD", singleInstance.PasswordParameter.Value);`
	`228`	`+ context.EnvironmentVariables.Add("PMA_PASSWORD", singleInstance.PasswordParameter);`
`229`	`229`	`});`
`230`	`230`	`}`
`231`	`231`	`else`
`232`	`232`	`{`
`233`		`- var tempConfigFile = WritePhpMyAdminConfiguration(mySqlInstances);`
	`233`	`+ var tempConfigFile = await WritePhpMyAdminConfiguration(mySqlInstances, ct).ConfigureAwait(false);`
`234`	`234`
`235`	`235`	`try`
`236`	`236`	`{`
`@@ -258,8 +258,6 @@ public static IResourceBuilder<T> WithPhpMyAdmin<T>(this IResourceBuilder<T> bui`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`	`}`
`261`		`-`
`262`		`- return Task.CompletedTask;`
`263`	`261`	`});`
`264`	`262`
`265`	`263`	`configureContainer?.Invoke(phpMyAdminContainerBuilder);`
`@@ -346,7 +344,7 @@ public static IResourceBuilder<MySqlServerResource> WithInitFiles(this IResource`
`346`	`344`	`return builder.WithContainerFiles(initPath, importFullPath);`
`347`	`345`	`}`
`348`	`346`
`349`		`- private static string WritePhpMyAdminConfiguration(IEnumerable<MySqlServerResource> mySqlInstances)`
	`347`	`+ private static async Task<string> WritePhpMyAdminConfiguration(IEnumerable<MySqlServerResource> mySqlInstances, CancellationToken cancellationToken)`
`350`	`348`	`{`
`351`	`349`	`// This temporary file is not used by the container, it will be copied and then deleted`
`352`	`350`	`var filePath = Path.GetTempFileName();`
`@@ -360,14 +358,16 @@ private static string WritePhpMyAdminConfiguration(IEnumerable<MySqlServerResour`
`360`	`358`	`foreach (var mySqlInstance in mySqlInstances)`
`361`	`359`	`{`
`362`	`360`	`var endpoint = mySqlInstance.PrimaryEndpoint;`
	`361`	`+ var pwd = await mySqlInstance.PasswordParameter.GetValueAsync(cancellationToken).ConfigureAwait(false);`
	`362`	`+`
`363`	`363`	`writer.WriteLine("$i++;");`
`364`	`364`	`// PhpMyAdmin assumes MySql is being accessed over a default Aspire container network and hardcodes the resource address`
`365`	`365`	`// This will need to be refactored once updated service discovery APIs are available`
`366`	`366`	`writer.WriteLine($"$cfg['Servers'][$i]['host'] = '{endpoint.Resource.Name}:{endpoint.TargetPort}';");`
`367`	`367`	`writer.WriteLine($"$cfg['Servers'][$i]['verbose'] = '{mySqlInstance.Name}';");`
`368`	`368`	`writer.WriteLine($"$cfg['Servers'][$i]['auth_type'] = 'cookie';");`
`369`	`369`	`writer.WriteLine($"$cfg['Servers'][$i]['user'] = 'root';");`
`370`		`- writer.WriteLine($"$cfg['Servers'][$i]['password'] = '{mySqlInstance.PasswordParameter.Value}';");`
	`370`	`+ writer.WriteLine($"$cfg['Servers'][$i]['password'] = '{pwd}';");`
`371`	`371`	`writer.WriteLine($"$cfg['Servers'][$i]['AllowNoPassword'] = true;");`
`372`	`372`	`writer.WriteLine();`
`373`	`373`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public static IResourceBuilder<NatsServerResource> AddNats(this IDistributedAppl`
`73`	`73`	`AuthOpts = new()`
`74`	`74`	`{`
`75`	`75`	`Username = await nats.UserNameReference.GetValueAsync(ct).ConfigureAwait(false),`
`76`		`- Password = nats.PasswordParameter!.Value,`
	`76`	`+ Password = await nats.PasswordParameter!.GetValueAsync(ct).ConfigureAwait(false),`
`77`	`77`	`}`
`78`	`78`	`};`
`79`	`79`
Original file line number	Diff line number	Diff line change
`@@ -158,14 +158,14 @@ public static IResourceBuilder<RedisResource> WithRedisCommander(this IResourceB`
`158`	`158`	`.WithHttpEndpoint(targetPort: 8081, name: "http")`
`159`	`159`	`.ExcludeFromManifest();`
`160`	`160`
`161`		`- builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(resource, (e, ct) =>`
	`161`	`+ builder.ApplicationBuilder.Eventing.Subscribe<BeforeResourceStartedEvent>(resource, async (e, ct) =>`
`162`	`162`	`{`
`163`	`163`	`var redisInstances = builder.ApplicationBuilder.Resources.OfType<RedisResource>();`
`164`	`164`
`165`	`165`	`if (!redisInstances.Any())`
`166`	`166`	`{`
`167`	`167`	`// No-op if there are no Redis resources present.`
`168`		`- return Task.CompletedTask;`
	`168`	`+ return;`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`var hostsVariableBuilder = new StringBuilder();`
`@@ -177,14 +177,13 @@ public static IResourceBuilder<RedisResource> WithRedisCommander(this IResourceB`
`177`	`177`	`var hostString = $"{(hostsVariableBuilder.Length > 0 ? "," : string.Empty)}{redisInstance.Name}:{redisInstance.Name}:{redisInstance.PrimaryEndpoint.TargetPort}:0";`
`178`	`178`	`if (redisInstance.PasswordParameter is not null)`
`179`	`179`	`{`
`180`		`- hostString += $":{redisInstance.PasswordParameter.Value}";`
	`180`	`+ var password = await redisInstance.PasswordParameter.GetValueAsync(ct).ConfigureAwait(false);`
	`181`	`+ hostString += $":{password}";`
`181`	`182`	`}`
`182`	`183`	`hostsVariableBuilder.Append(hostString);`
`183`	`184`	`}`
`184`	`185`
`185`	`186`	`resourceBuilder.WithEnvironment("REDIS_HOSTS", hostsVariableBuilder.ToString());`
`186`		`-`
`187`		`- return Task.CompletedTask;`
`188`	`187`	`});`
`189`	`188`
`190`	`189`	`configureContainer?.Invoke(resourceBuilder);`
`@@ -244,7 +243,7 @@ public static IResourceBuilder<RedisResource> WithRedisInsight(this IResourceBui`
`244`	`243`	`context.EnvironmentVariables.Add($"RI_REDIS_ALIAS{counter}", redisInstance.Name);`
`245`	`244`	`if (redisInstance.PasswordParameter is not null)`
`246`	`245`	`{`
`247`		`- context.EnvironmentVariables.Add($"RI_REDIS_PASSWORD{counter}", redisInstance.PasswordParameter.Value);`
	`246`	`+ context.EnvironmentVariables.Add($"RI_REDIS_PASSWORD{counter}", redisInstance.PasswordParameter);`
`248`	`247`	`}`
`249`	`248`
`250`	`249`	`counter++;`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,9 @@ public ParameterResource(string name, Func<ParameterDefault?, string> callback,`
`31`	`31`	`/// <summary>`
`32`	`32`	`/// Gets the value of the parameter.`
`33`	`33`	`/// </summary>`
`34`		`- public string Value`
	`34`	`+ public string Value => GetValueAsync(default).AsTask().GetAwaiter().GetResult()!;`
	`35`	`+`
	`36`	`+ internal string ValueInternal`
`35`	`37`	`{`
`36`	`38`	`get`
`37`	`39`	`{`
`@@ -79,14 +81,20 @@ internal string ConfigurationKey`
`79`	`81`	`/// </summary>`
`80`	`82`	`internal TaskCompletionSource<string>? WaitForValueTcs { get; set; }`
`81`	`83`
`82`		`- async ValueTask<string?> IValueProvider.GetValueAsync(CancellationToken cancellationToken)`
	`84`	`+ /// <summary>`
	`85`	`+ /// Gets the value of the parameter asynchronously, waiting if necessary for the value to be set.`
	`86`	`+ /// </summary>`
	`87`	`+ /// <param name="cancellationToken">The cancellation token to observe while waiting for the value.</param>`
	`88`	`+ /// <returns>A task that represents the asynchronous operation, containing the value of the parameter.</returns>`
	`89`	`+ public async ValueTask<string?> GetValueAsync(CancellationToken cancellationToken)`
`83`	`90`	`{`
`84`	`91`	`if (WaitForValueTcs is not null)`
`85`	`92`	`{`
`86`	`93`	`// Wait for the value to be set if the task completion source is available.`
`87`	`94`	`return await WaitForValueTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false);`
`88`	`95`	`}`
`89`	`96`
`90`		`- return Value;`
	`97`	`+ // In publish mode, there's no WaitForValueTcs set.`
	`98`	`+ return ValueInternal;`
`91`	`99`	`}`
`92`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ private async Task ProcessParameterAsync(ParameterResource parameterResource)`
`62`	`62`	`{`
`63`	`63`	`try`
`64`	`64`	`{`
`65`		`- var value = parameterResource.Value ?? "";`
	`65`	`+ var value = parameterResource.ValueInternal ?? "";`
`66`	`66`
`67`	`67`	`await notificationService.PublishUpdateAsync(parameterResource, s =>`
`68`	`68`	`{`