Microsoft.Extensions.Configuration support for Cosmos Clustering Provider

src/Azure/Orleans.Clustering.Cosmos/CosmosClusteringProviderBuilder.cs

@@ -0,0 +1,115 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Orleans;
+using Orleans.Clustering.Cosmos;
+using Orleans.Hosting;
+using Orleans.Providers;
+
+[assembly: RegisterProvider("Cosmos", "Clustering", "Silo", typeof(CosmosClusteringProviderBuilder))]
+[assembly: RegisterProvider("Cosmos", "Clustering", "Client", typeof(CosmosClusteringProviderBuilder))]
+
+namespace Orleans.Hosting;
+
+internal sealed class CosmosClusteringProviderBuilder : IProviderBuilder<ISiloBuilder>, IProviderBuilder<IClientBuilder>
+{
+    public void Configure(ISiloBuilder builder, string name, IConfigurationSection configurationSection) =>
+        builder.UseCosmosClustering(optionsBuilder =>
+            optionsBuilder.Configure<IServiceProvider>((options, services) =>
+            {
+                var databaseName = configurationSection[nameof(options.DatabaseName)];
+                if (!string.IsNullOrEmpty(databaseName))
+                {
+                    options.DatabaseName = databaseName;
+                }
+                var containerName = configurationSection[nameof(options.ContainerName)];
+                if (!string.IsNullOrEmpty(containerName))
+                {
+                    options.ContainerName = containerName;
+                }
+                if (bool.TryParse(configurationSection[nameof(options.IsResourceCreationEnabled)], out var irce))
+                {
+                    options.IsResourceCreationEnabled = irce;
+                }
+                if(int.TryParse(configurationSection[nameof(options.DatabaseThroughput)], out var dt))
+                {
+                    options.DatabaseThroughput = dt;
+                }
+                if(bool.TryParse(configurationSection[nameof(options.CleanResourcesOnInitialization)], out var croi))
+                {
+                    options.CleanResourcesOnInitialization = croi;
+                }
+
+                var serviceKey = configurationSection["ServiceKey"];
+                if(!string.IsNullOrEmpty(serviceKey))
+                {
+                    options.ConfigureCosmosClient(sp=>
+                        new ValueTask<CosmosClient>(sp.GetRequiredKeyedService<CosmosClient>(serviceKey)));
+                }
+                else
+                {
+                    var connectionName = configurationSection["ConnectionName"];
+                    var connectionString = configurationSection["ConnectionString"];
+                    if (!string.IsNullOrEmpty(connectionName) && string.IsNullOrEmpty(connectionString))
+                    {
+                        var rootConfiguration = services.GetRequiredService<IConfiguration>();
+                        connectionString = rootConfiguration.GetConnectionString(connectionName);
+                    }
+
+                    if (!string.IsNullOrEmpty(connectionString))
+                    {
+                        options.ConfigureCosmosClient(connectionString);
+                    }
+                }
+            }));
+
+    public void Configure(IClientBuilder builder, string name, IConfigurationSection configurationSection) =>
+        builder.UseCosmosGatewayListProvider(optionsBuilder =>
+            optionsBuilder.Configure<IServiceProvider>((options, services) =>
+            {
+                var databaseName = configurationSection[nameof(options.DatabaseName)];
+                if (!string.IsNullOrEmpty(databaseName))
+                {
+                    options.DatabaseName = databaseName;
+                }
+                var containerName = configurationSection[nameof(options.ContainerName)];
+                if (!string.IsNullOrEmpty(containerName))
+                {
+                    options.ContainerName = containerName;
+                }
+                if (bool.TryParse(configurationSection[nameof(options.IsResourceCreationEnabled)], out var irce))
+                {
+                    options.IsResourceCreationEnabled = irce;
+                }
+                if (int.TryParse(configurationSection[nameof(options.DatabaseThroughput)], out var dt))
+                {
+                    options.DatabaseThroughput = dt;
+                }
+                if (bool.TryParse(configurationSection[nameof(options.CleanResourcesOnInitialization)], out var croi))
+                {
+                    options.CleanResourcesOnInitialization = croi;
+                }
+
+                var serviceKey = configurationSection["ServiceKey"];
+                if (!string.IsNullOrEmpty(serviceKey))
+                {
+                    options.ConfigureCosmosClient(sp =>
+                        new ValueTask<CosmosClient>(sp.GetRequiredKeyedService<CosmosClient>(serviceKey)));
+                }
+                else
+                {
+                    // Construct a connection multiplexer from a connection string.
+                    var connectionName = configurationSection["ConnectionName"];
+                    var connectionString = configurationSection["ConnectionString"];
+                    if (!string.IsNullOrEmpty(connectionName) && string.IsNullOrEmpty(connectionString))
+                    {
+                        var rootConfiguration = services.GetRequiredService<IConfiguration>();
+                        connectionString = rootConfiguration.GetConnectionString(connectionName);
+                    }
+
+                    if (!string.IsNullOrEmpty(connectionString))
+                    {
+                        options.ConfigureCosmosClient(connectionString);
+                    }
+                }
+            }));
+}

src/Azure/Orleans.Clustering.Cosmos/Options/CosmosClusteringOptions.cs

@@ -0,0 +1,32 @@
+namespace Orleans.Clustering.Cosmos;
+
+/// <summary>
+/// Options for configuring Azure Cosmos DB clustering.
+/// </summary>
+public class CosmosClusteringOptions : CosmosOptions
+{
+    private const string ORLEANS_CLUSTER_CONTAINER = "OrleansCluster";
+
+    /// <summary>
+    /// Initializes a new <see cref="CosmosClusteringOptions"/> instance.
+    /// </summary>
+    public CosmosClusteringOptions()
+    {
+        ContainerName = ORLEANS_CLUSTER_CONTAINER;
+    }
+}
+
+/// <summary>
+/// Configuration validator for <see cref="CosmosClusteringOptions"/>.
+/// </summary>
+public class CosmosClusteringOptionsValidator : CosmosOptionsValidator<CosmosClusteringOptions>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CosmosClusteringOptionsValidator"/> class.
+    /// </summary>
+    /// <param name="options">The option to be validated.</param>
+    /// <param name="name">The option name to be validated.</param>
+    public CosmosClusteringOptionsValidator(CosmosClusteringOptions options, string name) : base(options, name)
+    {
+    }
+}

src/Azure/Orleans.Clustering.Cosmos/Properties/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Tester.AzureUtils")]