Expand Cluster.Hosting options

src/Akka.Cluster.Hosting.Tests/Akka.Cluster.Hosting.Tests.csproj

@@ -6,6 +6,7 @@
     <ItemGroup>
         <PackageReference Include="Akka.TestKit.Xunit2" Version="$(AkkaVersion)" />
         <PackageReference Include="FluentAssertions" Version="6.8.0" />
+        <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(TestSdkVersion)" />
         <PackageReference Include="xunit" Version="$(XunitVersion)" />
         <PackageReference Include="xunit.runner.visualstudio" Version="$(XunitRunneVisualstudio)">

src/Akka.Cluster.Hosting.Tests/ClusterOptionsSpec.cs

@@ -0,0 +1,152 @@
+// -----------------------------------------------------------------------
+//  <copyright file="ClusterOptionsSpec.cs" company="Akka.NET Project">
+//      Copyright (C) 2009-2022 Lightbend Inc. <http://www.lightbend.com>
+//      Copyright (C) 2013-2022 .NET Foundation <https://github.com/akkadotnet/akka.net>
+//  </copyright>
+// -----------------------------------------------------------------------
+
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Akka.Actor;
+using Akka.Cluster.Hosting.SBR;
+using Akka.Cluster.SBR;
+using Akka.Configuration;
+using Akka.Hosting;
+using FluentAssertions;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.Json;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Akka.Cluster.Hosting.Tests;
+
+public class ClusterOptionsSpec
+{
+    [Fact(DisplayName = "Empty ClusterOptions should contain default HOCON values")]
+    public void EmptyClusterOptionsTest()
+    {
+        var builder = new AkkaConfigurationBuilder(new ServiceCollection(), "")
+            .AddHocon(ConfigurationFactory.FromResource("Akka.Cluster.Configuration.Cluster.conf", typeof(Cluster).Assembly), HoconAddMode.Append)
+            .WithActorRefProvider(ProviderSelection.Cluster.Instance)
+            .BuildClusterHocon(new ClusterOptions());
+
+        builder.Configuration.HasValue.Should().BeTrue();
+        var settings = new ClusterSettings(builder.Configuration.Value, "");
+
+        settings.Roles.Count.Should().Be(0);
+        settings.AppVersion.CompareTo(Util.AppVersion.Create("assembly-version")).Should().Be(0);
+        settings.MinNrOfMembersOfRole.Count.Should().Be(0);
+        settings.SeedNodes.Count.Should().Be(0);
+        settings.MinNrOfMembers.Should().Be(1);
+        settings.LogInfo.Should().BeTrue();
+        settings.LogInfoVerbose.Should().BeFalse();
+        settings.DowningProviderType.Should().Be(typeof(NoDowning));
+    }
+
+    [Fact(DisplayName = "ClusterOptions should generate proper HOCON values")]
+    public void ClusterOptionsTest()
+    {
+        var builder = new AkkaConfigurationBuilder(new ServiceCollection(), "")
+            .AddHocon(ConfigurationFactory.FromResource("Akka.Cluster.Configuration.Cluster.conf", typeof(Cluster).Assembly), HoconAddMode.Append)
+            .BuildClusterHocon(new ClusterOptions
+            {
+                Roles = new []{ "front-end", "back-end"},
+                MinimumNumberOfMembersPerRole = new Dictionary<string, int>
+                {
+                    ["back-end"] = 5
+                },
+                AppVersion = "1.0.0",
+                MinimumNumberOfMembers = 99,
+                SeedNodes = new [] { "akka.tcp://system@somewhere.com:9999" },
+                LogInfo = false,
+                LogInfoVerbose = true,
+                SplitBrainResolver = new KeepMajorityOption
+                {
+                    Role = "back-end"
+                }
+            });
+
+        builder.Configuration.HasValue.Should().BeTrue();
+        var settings = new ClusterSettings(builder.Configuration.Value, "");
+
+        settings.Roles.Should().BeEquivalentTo("front-end", "back-end");
+
+        settings.MinNrOfMembersOfRole.Count.Should().Be(1);
+        settings.MinNrOfMembersOfRole.ContainsKey("back-end").Should().BeTrue();
+        settings.MinNrOfMembersOfRole["back-end"].Should().Be(5);
+
+        settings.AppVersion.CompareTo(Util.AppVersion.Create("1.0.0")).Should().Be(0);
+        settings.SeedNodes.Should().BeEquivalentTo(new [] { Address.Parse("akka.tcp://system@somewhere.com:9999" )});
+        settings.MinNrOfMembers.Should().Be(99);
+        settings.LogInfo.Should().BeTrue(); // This is not intuitive, but LogInfo is defined as LogInfoVerbose || LogInfo in ClusterSettings
+        settings.LogInfoVerbose.Should().BeTrue();
+        settings.DowningProviderType.Should().Be(typeof(SplitBrainResolverProvider));
+
+        var sbrConfig = builder.Configuration.Value.GetConfig("akka.cluster.split-brain-resolver");
+        sbrConfig.GetString("active-strategy").Should().Be(SplitBrainResolverSettings.KeepMajorityName);
+        sbrConfig.GetString($"{SplitBrainResolverSettings.KeepMajorityName}.role").Should().Be("back-end");
+    }
+
+    [Fact(DisplayName = "ClusterOptions should be bindable using Microsoft.Extensions.Configuration")]
+    public void ClusterOptionsConfigurationTest()
+    {
+        const string json = @"
+{
+  ""Logging"": {
+    ""LogLevel"": {
+      ""Default"": ""Information"",
+      ""Microsoft.AspNetCore"": ""Warning""
+    }
+  },
+  ""ConnectionStrings"": {
+    ""sqlServerLocal"": ""Server=localhost,1533;Database=Akka;User Id=sa;Password=l0lTh1sIsOpenSource;"",
+  },
+  ""Akka"": {
+    ""ClusterOptions"": {
+      ""Roles"": [ ""front-end"", ""back-end"" ],
+      ""MinimumNumberOfMembersPerRole"" : {
+        ""back-end"" : 5
+      },
+      ""AppVersion"": ""1.0.0"",
+      ""MinimumNumberOfMembers"": 99,
+      ""SeedNodes"": [ ""akka.tcp://system@somewhere.com:9999"" ],
+      ""LogInfo"": false,
+      ""LogInfoVerbose"": true
+    },
+    ""KeepMajorityOption"": {
+      ""Role"" : ""back-end""
+    }
+  }
+}";
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(json));
+        var jsonConfig = new ConfigurationBuilder().AddJsonStream(stream).Build();
+
+        var clusterOptions = jsonConfig.GetSection("Akka:ClusterOptions").Get<ClusterOptions>();
+        clusterOptions.SplitBrainResolver = jsonConfig.GetSection("Akka:KeepMajorityOption").Get<KeepMajorityOption>();
+
+        var builder = new AkkaConfigurationBuilder(new ServiceCollection(), "")
+            .AddHocon(ConfigurationFactory.FromResource("Akka.Cluster.Configuration.Cluster.conf", typeof(Cluster).Assembly), HoconAddMode.Append)
+            .BuildClusterHocon(clusterOptions);
+
+        builder.Configuration.HasValue.Should().BeTrue();
+        var settings = new ClusterSettings(builder.Configuration.Value, "");
+
+        settings.Roles.Should().BeEquivalentTo("front-end", "back-end");
+
+        settings.MinNrOfMembersOfRole.Count.Should().Be(1);
+        settings.MinNrOfMembersOfRole.ContainsKey("back-end").Should().BeTrue();
+        settings.MinNrOfMembersOfRole["back-end"].Should().Be(5);
+
+        settings.AppVersion.CompareTo(Util.AppVersion.Create("1.0.0")).Should().Be(0);
+        settings.SeedNodes.Should().BeEquivalentTo(new [] { Address.Parse("akka.tcp://system@somewhere.com:9999" )});
+        settings.MinNrOfMembers.Should().Be(99);
+        settings.LogInfo.Should().BeTrue(); // This is not intuitive, but LogInfo is defined as LogInfoVerbose || LogInfo in ClusterSettings
+        settings.LogInfoVerbose.Should().BeTrue();
+        settings.DowningProviderType.Should().Be(typeof(SplitBrainResolverProvider));
+
+        var sbrConfig = builder.Configuration.Value.GetConfig("akka.cluster.split-brain-resolver");
+        sbrConfig.GetString("active-strategy").Should().Be(SplitBrainResolverSettings.KeepMajorityName);
+        sbrConfig.GetString($"{SplitBrainResolverSettings.KeepMajorityName}.role").Should().Be("back-end");
+    }
+}

src/Akka.Cluster.Hosting.Tests/ClusterSingletonSpecs.cs

@@ -34,7 +34,7 @@ public async Task Should_launch_ClusterSingletonAndProxy()
         // arrange
         using var host = await TestHelper.CreateHost(
             builder => { builder.WithSingleton<ClusterSingletonSpecs.MySingletonActor>("my-singleton", MySingletonActor.MyProps); },
-            new ClusterOptions(){ Roles = new[] { "my-host"}}, Output);
+            new ClusterOptions(){ Roles = new[] { "my-host" }}, Output);
 
         var registry = host.Services.GetRequiredService<ActorRegistry>();
         var singletonProxy = registry.Get<ClusterSingletonSpecs.MySingletonActor>();
@@ -58,14 +58,14 @@ public async Task Should_launch_ClusterSingleton_and_Proxy_separately()
         var singletonOptions = new ClusterSingletonOptions() { Role = "my-host" };
         using var singletonHost = await TestHelper.CreateHost(
             builder => { builder.WithSingleton<ClusterSingletonSpecs.MySingletonActor>("my-singleton", MySingletonActor.MyProps, singletonOptions, createProxyToo:false); },
-            new ClusterOptions(){ Roles = new[] { "my-host"}}, Output);
+            new ClusterOptions(){ Roles = new[] { "my-host" }}, Output);
 
         var singletonSystem = singletonHost.Services.GetRequiredService<ActorSystem>();
         var address = Cluster.Get(singletonSystem).SelfAddress;
 
         using var singletonProxyHost =  await TestHelper.CreateHost(
             builder => { builder.WithSingletonProxy<ClusterSingletonSpecs.MySingletonActor>("my-singleton", singletonOptions); },
-            new ClusterOptions(){ Roles = new[] { "proxy" }, SeedNodes = new Address[]{ address } }, Output);
+            new ClusterOptions(){ Roles = new[] { "proxy" }, SeedNodes = new []{ address.ToString() } }, Output);
 
         var registry = singletonProxyHost.Services.GetRequiredService<ActorRegistry>();
         var singletonProxy = registry.Get<ClusterSingletonSpecs.MySingletonActor>();

src/Akka.Cluster.Hosting.Tests/SplitBrainResolverSpecs.cs

@@ -79,7 +79,7 @@ public async Task HostingSbrTest()
     {
         var host = await StartHost(builder =>
         {
-            builder.WithClustering(sbrOptions: SplitBrainResolverOption.Default);
+            builder.WithClustering( new ClusterOptions{ SplitBrainResolver = SplitBrainResolverOption.Default });
         });
 
         var system = host.Services.GetRequiredService<ActorSystem>();
@@ -95,10 +95,13 @@ public async Task StaticQuorumTest()
     {
         var host = await StartHost(builder =>
         {
-            builder.WithClustering(sbrOptions: new StaticQuorumOption
+            builder.WithClustering( new ClusterOptions
             {
-                QuorumSize = 1,
-                Role = "myRole"
+                SplitBrainResolver = new StaticQuorumOption
+                {
+                    QuorumSize = 1,
+                    Role = "myRole"
+                }
             });
         });
 
@@ -116,9 +119,12 @@ public async Task KeepMajorityTest()
     {
         var host = await StartHost(builder =>
         {
-            builder.WithClustering(sbrOptions: new KeepMajorityOption
+            builder.WithClustering(new ClusterOptions
             {
-                Role = "myRole"
+                SplitBrainResolver = new KeepMajorityOption
+                {
+                    Role = "myRole"
+                }
             });
         });
 
@@ -135,10 +141,13 @@ public async Task KeepOldestTest()
     {
         var host = await StartHost(builder =>
         {
-            builder.WithClustering(sbrOptions: new KeepOldestOption
+            builder.WithClustering(new ClusterOptions
             {
-                DownIfAlone = false,
-                Role = "myRole"
+                SplitBrainResolver = new KeepOldestOption
+                {
+                    DownIfAlone = false,
+                    Role = "myRole"
+                }
             });
         });
 
@@ -157,11 +166,14 @@ public async Task LeaseMajorityTest()
         var host = await StartHost(builder =>
         {
             builder.AddHocon(TestLease.Configuration, HoconAddMode.Prepend);
-            builder.WithClustering(sbrOptions: new LeaseMajorityOption
+            builder.WithClustering(new ClusterOptions
             {
-                LeaseImplementation = new TestLeaseOption(),
-                LeaseName = "myService-akka-sbr",
-                Role = "myRole"
+                SplitBrainResolver = new LeaseMajorityOption
+                {
+                    LeaseImplementation = new TestLeaseOption(),
+                    LeaseName = "myService-akka-sbr",
+                    Role = "myRole"
+                }
             });
         });