Make RedisInsight work with WithLifetime(...).

src/Aspire.Hosting.Redis/RedisBuilderExtensions.cs

@@ -2,8 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Globalization;
+using System.Net.Http.Json;
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using Aspire.Hosting.ApplicationModel;
 using Aspire.Hosting.Redis;
 using Aspire.Hosting.Utils;
@@ -192,20 +194,50 @@ public static IResourceBuilder<RedisResource> WithRedisInsight(this IResourceBui
             return builder;
         }
 
-        static async Task ImportRedisDatabases(ILogger resourceLogger, IEnumerable<RedisResource> redisInstances, HttpClient client, CancellationToken ct)
+        static async Task ImportRedisDatabases(ILogger resourceLogger, IEnumerable<RedisResource> redisInstances, HttpClient client, CancellationToken cancellationToken)
         {
+            var databasesPath = "/api/databases";
+
+            var pipeline = new ResiliencePipelineBuilder().AddRetry(new Polly.Retry.RetryStrategyOptions
+            {
+                Delay = TimeSpan.FromSeconds(2),
+                MaxRetryAttempts = 5,
+            }).Build();
+
             using (var stream = new MemoryStream())
             {
+                // As part of configuring RedisInsight we need to factor in the possibility that the
+                // container resource is being run with persistence turned on. In this case we need
+                // to get the list of existing databases because we might need to delete some.
+                var lookup = await pipeline.ExecuteAsync(async (ctx) =>
+                {
+                    var getDatabasesResponse = await client.GetFromJsonAsync<RedisDatabaseDto[]>(databasesPath, cancellationToken).ConfigureAwait(false);
+                    return getDatabasesResponse?.ToLookup(
+                        i => i.Name ?? throw new InvalidDataException("Database name is missing."),
+                        i => i.Id ?? throw new InvalidDataException("Database ID is missing."));
+                }, cancellationToken).ConfigureAwait(false);
+
+                var databasesToDelete = new List<Guid>();
+
                 using var writer = new Utf8JsonWriter(stream);
 
                 writer.WriteStartArray();
 
                 foreach (var redisResource in redisInstances)
                 {
+                    if (lookup is { } && lookup.Contains(redisResource.Name))
+                    {
+                        // It is possible that there are multiple databases with
+                        // a conflicting name so we delete them all. This just keeps
+                        // track of the specific ID that we need to delete.
+                        databasesToDelete.AddRange(lookup[redisResource.Name]);
+                    }
+
                     if (redisResource.PrimaryEndpoint.IsAllocated)
                     {
                         var endpoint = redisResource.PrimaryEndpoint;
                         writer.WriteStartObject();
+
                         writer.WriteString("host", redisResource.Name);
                         writer.WriteNumber("port", endpoint.TargetPort!.Value);
                         writer.WriteString("name", redisResource.Name);
@@ -218,7 +250,7 @@ static async Task ImportRedisDatabases(ILogger resourceLogger, IEnumerable<Redis
                     }
                 }
                 writer.WriteEndArray();
-                await writer.FlushAsync(ct).ConfigureAwait(false);
+                await writer.FlushAsync(cancellationToken).ConfigureAwait(false);
                 stream.Seek(0, SeekOrigin.Begin);
 
                 var content = new MultipartFormDataContent();
@@ -227,23 +259,36 @@ static async Task ImportRedisDatabases(ILogger resourceLogger, IEnumerable<Redis
 
                 content.Add(fileContent, "file", "RedisInsight_connections.json");
 
-                var apiUrl = $"/api/databases/import";
-
-                var pipeline = new ResiliencePipelineBuilder().AddRetry(new Polly.Retry.RetryStrategyOptions
-                {
-                    Delay = TimeSpan.FromSeconds(2),
-                    MaxRetryAttempts = 5,
-                }).Build();
+                var apiUrl = $"{databasesPath}/import";
 
                 try
                 {
+                    await pipeline.ExecuteAsync(async (ctx) =>
+                    {
+                        // Create a DELETE request to send to the existing instance of
+                        // RedisInsight with the IDs of the database to delete.
+                        var deleteContent = JsonContent.Create(new
+                        {
+                            ids = databasesToDelete
+                        });
+
+                        var deleteRequest = new HttpRequestMessage(HttpMethod.Delete, databasesPath)
+                        {
+                            Content = deleteContent
+                        };
+
+                        var deleteResponse = await client.SendAsync(deleteRequest, cancellationToken).ConfigureAwait(false);
+                        deleteResponse.EnsureSuccessStatusCode();
+
+                    }, cancellationToken).ConfigureAwait(false);
+
                     await pipeline.ExecuteAsync(async (ctx) =>
                     {
                         var response = await client.PostAsync(apiUrl, content, ctx)
                         .ConfigureAwait(false);
 
                         response.EnsureSuccessStatusCode();
-                    }, ct).ConfigureAwait(false);
+                    }, cancellationToken).ConfigureAwait(false);
 
                 }
                 catch (Exception ex)
@@ -254,6 +299,15 @@ await pipeline.ExecuteAsync(async (ctx) =>
         }
     }
 
+    private class RedisDatabaseDto
+    {
+        [JsonPropertyName("id")]
+        public Guid? Id { get; set; }
+
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+    }
+
     /// <summary>
     /// Configures the host port that the Redis Commander resource is exposed on instead of using randomly assigned port.
     /// </summary>