Create a single node cluster by default with no add'l config required

Author: brantburnett

src/Couchbase.Aspire.Client/README.md

@@ -128,14 +128,13 @@ Then, in the _AppHost.cs_ file of your project, register a Couchbase cluster and
 
 ```csharp
 var couchbase = builder.AddCouchbase("couchbase");
-var servers = couchbase.AddServerGroup("couchbase_servers");
-var bucket = servers.AddBucket("mybucket");
+var bucket = couchbase.AddBucket("mybucket");
 
 var myService = builder.AddProject<Projects.MyService>()
     .WithReference(bucket)
     .WaitFor(bucket);
 
-// Altertively, reference the cluster rather than a specific bucket, INamedBucketProvider will not be registered in DI
+// Alternatively, reference the cluster rather than a specific bucket, INamedBucketProvider will not be registered in DI
 var myService2 = builder.AddProject<Projects.MyService>()
     .WithReference(couchbase)
     .WaitFor(couchbase);

src/Couchbase.Aspire.Hosting/CouchbaseClusterBuilderExtensions.cs

@@ -113,7 +113,7 @@ public static IResourceBuilder<CouchbaseClusterResource> AddCouchbase(this IDist
                 serviceRequirementsFactory: _ => cluster.GetHealthCheckServiceRequirements(),
                 name: healthCheckKey);
 
-        return builder.AddResource(cluster)
+        var clusterBuilder = builder.AddResource(cluster)
             .WithInitialState(new()
             {
                 ResourceType = "CouchbaseCluster",
@@ -148,6 +148,49 @@ public static IResourceBuilder<CouchbaseClusterResource> AddCouchbase(this IDist
                     });
                 }
             })
+            .OnInitializeResource(async (resource, @event, ct) =>
+            {
+                // Ensure we display the Docker image as the Source for the cluster
+
+                var server = resource.GetPrimaryServer();
+                if (server is not null)
+                {
+                    _ = Task.Run(async () =>
+                    {
+                        var rns = @event.Services.GetRequiredService<ResourceNotificationService>();
+
+                        await foreach (var @event in rns.WatchAsync(ct).ConfigureAwait(false))
+                        {
+                            if (@event.Resource == server)
+                            {
+                                var serverSource = @event.Snapshot.Properties
+                                   .FirstOrDefault(p => p.Name == "container.image")?
+                                   .Value;
+
+                                if (serverSource is not null)
+                                {
+                                    await rns.PublishUpdateAsync(resource, s =>
+                                    {
+                                        var currentSource = s.Properties.FirstOrDefault(p => p.Name == CustomResourceKnownProperties.Source);
+
+                                        if (serverSource != currentSource?.Value)
+                                        {
+                                            return s with
+                                            {
+                                                Properties =
+                                                    (currentSource is not null ? s.Properties.Remove(currentSource) : s.Properties)
+                                                    .Add(new(CustomResourceKnownProperties.Source, serverSource))
+                                            };
+                                        }
+
+                                        return s;
+                                    });
+                                }
+                            }
+                        }
+                    }, ct);
+                }
+            })
             .WithCommand(KnownResourceCommands.StartCommand, "Start", async (context) =>
             {
                 var orchestrator = context.ServiceProvider.GetRequiredService<CouchbaseClusterOrchestrator>();
@@ -207,6 +250,33 @@ public static IResourceBuilder<CouchbaseClusterResource> AddCouchbase(this IDist
                 IconVariant = IconVariant.Filled,
                 IsHighlighted = true,
             });
+
+        // Add the default single node server group
+        clusterBuilder.AddServerGroup($"{name}-server", isDefaultServerGroup: true);
+
+        return clusterBuilder;
+    }
+
+    /// <summary>
+    /// Specify the Couchbase services to be enabled on this cluster. Only applies if no server groups are added.
+    /// </summary>
+    /// <param name="builder">Builder for the Couchbase cluster.</param>
+    /// <param name="services">The services to be enabled.</param>
+    /// <returns>The <paramref name="builder"/>.</returns>
+    public static IResourceBuilder<CouchbaseClusterResource> WithServices(this IResourceBuilder<CouchbaseClusterResource> builder,
+        CouchbaseServices services)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        var serverGroup = builder.Resource.ServerGroups.Values.FirstOrDefault(p => p.IsDefaultServerGroup);
+        if (serverGroup is null)
+        {
+            throw new InvalidOperationException("Services may only be set on the Couchbase cluster when no service groups are added. Use WithServices on the server group instead.");
+        }
+
+        builder.ApplicationBuilder.CreateResourceBuilder(serverGroup).WithServices(services);
+
+        return builder;
     }
 
     public static IResourceBuilder<CouchbaseClusterResource> WithSettings(this IResourceBuilder<CouchbaseClusterResource> builder, Action<CouchbaseClusterSettingsCallbackContext> configureSettings)

src/Couchbase.Aspire.Hosting/CouchbaseClusterResource.cs

@@ -128,6 +128,11 @@ internal void AddServerGroup(string name, CouchbaseServerGroupResource serverGro
         _serverGroups.TryAdd(name, serverGroup);
     }
 
+    internal bool RemoveServerGroup(string name)
+    {
+        return _serverGroups.Remove(name);
+    }
+
     public IEnumerable<CouchbaseServerResource> Servers => _serverGroups.Values.SelectMany(g => g.Servers);
 
     private readonly Dictionary<string, CouchbaseBucketBaseResource> _buckets = new(StringComparer.OrdinalIgnoreCase);

src/Couchbase.Aspire.Hosting/CouchbaseServerBuilderExtensions.cs

@@ -19,7 +19,7 @@ public static IResourceBuilder<CouchbaseServerResource> AddServer(this IResource
         var server = new CouchbaseServerResource(name, builder.Resource);
         builder.Resource.AddServer(server);
 
-        return builder.ApplicationBuilder.AddResource(server)
+        var serverBuilder = builder.ApplicationBuilder.AddResource(server)
             .WithParentRelationship(builder)
             .WithImage(CouchbaseContainerImageTags.Image, CouchbaseContainerImageTags.Tag)
             .WithImageRegistry(CouchbaseContainerImageTags.Registry)
@@ -62,9 +62,25 @@ CouchbaseEndpointNames.FtsSecure or CouchbaseEndpointNames.AnalyticsSecure or Co
                     }
                 }
             })
+
             .WithNodeCertificate()
             .ExcludeFromManifest()
             .ApplyDynamicConfiguration();
+
+        // Hide the server if the server group is the default server group, which is also hidden
+        if (builder.Resource.IsDefaultServerGroup)
+        {
+            serverBuilder.OnInitializeResource(async (resource, @event, ct) =>
+             {
+                 var rns = @event.Services.GetRequiredService<ResourceNotificationService>();
+                 await rns.PublishUpdateAsync(resource, s => s with
+                 {
+                     IsHidden = true
+                 }).ConfigureAwait(false);
+             });
+        }
+
+        return serverBuilder;
     }
 
     private static IResourceBuilder<CouchbaseServerResource> ApplyInsecureEndpoints(this IResourceBuilder<CouchbaseServerResource> builder)

src/Couchbase.Aspire.Hosting/CouchbaseServerGroupBuilderExtensions.cs

@@ -6,12 +6,30 @@ namespace Couchbase.Aspire.Hosting;
 public static class CouchbaseServerGroupBuilderExtensions
 {
     public static IResourceBuilder<CouchbaseServerGroupResource> AddServerGroup(this IResourceBuilder<CouchbaseClusterResource> builder,
-        [ResourceName] string name)
+        [ResourceName] string name) =>
+        builder.AddServerGroup(name, isDefaultServerGroup: false);
+
+    internal static IResourceBuilder<CouchbaseServerGroupResource> AddServerGroup(this IResourceBuilder<CouchbaseClusterResource> builder,
+        [ResourceName] string name,
+        bool isDefaultServerGroup)
     {
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentException.ThrowIfNullOrEmpty(name);
 
-        var serverGroup = new CouchbaseServerGroupResource(name, builder.Resource);
+        var defaultServerGroup = builder.Resource.ServerGroups.FirstOrDefault(p => p.Value.IsDefaultServerGroup);
+        if (defaultServerGroup.Key is not null)
+        {
+            // We're adding manual server groups, remove the default one
+            builder.Resource.RemoveServerGroup(defaultServerGroup.Key);
+
+            builder.ApplicationBuilder.Resources.Remove(defaultServerGroup.Value);
+            foreach (var server in defaultServerGroup.Value.Servers)
+            {
+                builder.ApplicationBuilder.Resources.Remove(server);
+            }
+        }
+
+        var serverGroup = new CouchbaseServerGroupResource(name, builder.Resource, isDefaultServerGroup);
         builder.Resource.AddServerGroup(name, serverGroup);
 
         var serverGroupBuilder = builder.ApplicationBuilder.AddResource(serverGroup)
@@ -20,6 +38,7 @@ public static IResourceBuilder<CouchbaseServerGroupResource> AddServerGroup(this
                 ResourceType = "CouchbaseServerGroup",
                 CreationTimeStamp = DateTime.UtcNow,
                 State = KnownResourceStates.NotStarted,
+                IsHidden = isDefaultServerGroup,
                 Properties =
                 [
                     new(CustomResourceKnownProperties.Source, "Couchbase")

src/Couchbase.Aspire.Hosting/CouchbaseServerGroupResource.cs

@@ -11,11 +11,18 @@ public CouchbaseServerGroupResource(string name, CouchbaseClusterResource parent
         Parent = parent;
     }
 
+    internal CouchbaseServerGroupResource(string name, CouchbaseClusterResource parent, bool isDefaultServerGroup) : this(name, parent)
+    {
+        IsDefaultServerGroup = isDefaultServerGroup;
+    }
+
     /// <summary>
     /// Gets the parent Couchbase Server container resource.
     /// </summary>
     public CouchbaseClusterResource Parent { get; }
 
+    internal bool IsDefaultServerGroup { get; }
+
     private readonly List<CouchbaseServerResource> _servers = [];
 
     /// <summary>

src/Couchbase.Aspire.Hosting/README.md

@@ -12,12 +12,33 @@ dotnet add package Couchbase.Aspire.Hosting
 
 ## Usage example
 
-In the _AppHost.cs_ file of your `AppHost`, add a Couchbase cluster resource and consume the connection using the following methods:
+In the _AppHost.cs_ file of your `AppHost`, add a Couchbase cluster resource with the data, query, and index services
+and consume the connection using the following methods:
 
 ```csharp
 var couchbase = builder.AddCouchbase("couchbase");
-var servers = couchbase.AddServerGroup("couchbase_servers");
-var bucket = servers.AddBucket("mybucket");
+var bucket = couchbase.AddBucket("mybucket");
+
+var myService = builder.AddProject<Projects.MyService>()
+    .WithReference(bucket)
+    .WaitFor(bucket);
+```
+
+### Multi-dimensional scaling example
+
+It is also possible to run a multiple server cluster with various services assigned to different server groups:
+
+```csharp
+var couchbase = builder.AddCouchbase("couchbase");
+var bucket1 = couchbase.AddBucket("bucket1");
+
+var group1 = couchbase.AddServerGroup("couchbase-group1")
+    .WithServices(CouchbaseServices.Data)
+    .WithReplicas(2);
+
+var group2 = couchbase.AddServerGroup("couchbase-group2")
+    .WithServices(CouchbaseServices.Index | CouchbaseServices.Query)
+    .WithReplicas(2);
 
 var myService = builder.AddProject<Projects.MyService>()
     .WithReference(bucket)
@@ -40,7 +61,6 @@ The Couchbase cluster resource exposes the following connection properties:
 
 The `ConnectionString` property is also available, which exposes all properties as a single string in the format `couchbase://{Username}:{Password}@{Host}:{Port},{Host2}:{Port}`.
 
-
 ### Couchbase bucket
 
 The Couchbase bucket resource exposes the following connection properties:

tests/Aspire.Test.AppHost/AppHost.cs

@@ -4,7 +4,7 @@
 
 var builder = DistributedApplication.CreateBuilder(args);
 
-var couchbasePassword = builder.AddParameter("couchbase-password", "password");
+var couchbasePassword = builder.AddParameter("couchbase-password", "password", secret: true);
 
 var couchbase = builder.AddCouchbase("couchbase", password: couchbasePassword)
     .WithManagementPort(8091) // Optional fixed port number for the primary node