Remove unneeded constructors, make options public

Signed-off-by: Hal Spang <[email protected]>

Author: halspang

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## (Unreleased)
 
+- Expose gRPC retry options in Azure Managed extensions ([#447](https://github.com/microsoft/durabletask-dotnet/pull/447))
+
 ## v1.12.0
 
 - Activity tag support ([#426](https://github.com/microsoft/durabletask-dotnet/pull/426))

src/Client/AzureManaged/DurableTaskSchedulerClientExtensions.cs

@@ -40,70 +40,15 @@ public static void UseDurableTaskScheduler(
             configure);
     }
 
-    /// <summary>
-    /// Configures Durable Task client to use the Azure Durable Task Scheduler service.
-    /// </summary>
-    /// <param name="builder">The Durable Task client builder to configure.</param>
-    /// <param name="endpointAddress">The endpoint address of the Durable Task Scheduler resource. Expected to be in the format "https://{scheduler-name}.{region}.durabletask.io".</param>
-    /// <param name="taskHubName">The name of the task hub resource associated with the Durable Task Scheduler resource.</param>
-    /// <param name="credential">The credential used to authenticate with the Durable Task Scheduler task hub resource.</param>
-    /// <param name="retryOptions">The options that determine how and when a request will be retried.</param>
-    /// <param name="configure">Optional callback to dynamically configure DurableTaskSchedulerClientOptions.</param>
-    public static void UseDurableTaskScheduler(
-        this IDurableTaskClientBuilder builder,
-        string endpointAddress,
-        string taskHubName,
-        TokenCredential credential,
-        DurableTaskSchedulerClientOptions.ClientRetryOptions retryOptions,
-        Action<DurableTaskSchedulerClientOptions>? configure = null)
-    {
-        ConfigureSchedulerOptions(
-            builder,
-            options =>
-            {
-                options.EndpointAddress = endpointAddress;
-                options.TaskHubName = taskHubName;
-                options.Credential = credential;
-                options.RetryOptions = retryOptions;
-            },
-            configure);
-    }
-
-    /// <summary>
-    /// Configures Durable Task client to use the Azure Durable Task Scheduler service using a connection string.
-    /// </summary>
-    /// <param name="builder">The Durable Task client builder to configure.</param>
-    /// <param name="connectionString">The connection string used to connect to the Durable Task Scheduler service.</param>
-    /// <param name="configure">Optional callback to dynamically configure DurableTaskSchedulerClientOptions.</param>
-    public static void UseDurableTaskScheduler(
-        this IDurableTaskClientBuilder builder,
-        string connectionString,
-        Action<DurableTaskSchedulerClientOptions>? configure = null)
-    {
-        var connectionOptions = DurableTaskSchedulerClientOptions.FromConnectionString(connectionString);
-        ConfigureSchedulerOptions(
-            builder,
-            options =>
-            {
-                options.EndpointAddress = connectionOptions.EndpointAddress;
-                options.TaskHubName = connectionOptions.TaskHubName;
-                options.Credential = connectionOptions.Credential;
-                options.AllowInsecureCredentials = connectionOptions.AllowInsecureCredentials;
-            },
-            configure);
-    }
-
     /// <summary>
     /// Configures Durable Task client to use the Azure Durable Task Scheduler service using a connection string.
     /// </summary>
     /// <param name="builder">The Durable Task client builder to configure.</param>
     /// <param name="connectionString">The connection string used to connect to the Durable Task Scheduler service.</param>
-    /// /// <param name="retryOptions">The options that determine how and when a request will be retried.</param>
     /// <param name="configure">Optional callback to dynamically configure DurableTaskSchedulerClientOptions.</param>
     public static void UseDurableTaskScheduler(
         this IDurableTaskClientBuilder builder,
         string connectionString,
-        DurableTaskSchedulerClientOptions.ClientRetryOptions retryOptions,
         Action<DurableTaskSchedulerClientOptions>? configure = null)
     {
         var connectionOptions = DurableTaskSchedulerClientOptions.FromConnectionString(connectionString);
@@ -115,7 +60,6 @@ public static void UseDurableTaskScheduler(
                 options.TaskHubName = connectionOptions.TaskHubName;
                 options.Credential = connectionOptions.Credential;
                 options.AllowInsecureCredentials = connectionOptions.AllowInsecureCredentials;
-                options.RetryOptions = retryOptions;
             },
             configure);
     }

src/Client/AzureManaged/DurableTaskSchedulerClientOptions.cs

@@ -7,7 +7,7 @@
 using Grpc.Core;
 using Grpc.Net.Client;
 using Microsoft.DurableTask.Client;
-using grpcConfig = Grpc.Net.Client.Configuration;
+using GrpcConfig = Grpc.Net.Client.Configuration;
 
 namespace Microsoft.DurableTask;
 
@@ -49,7 +49,7 @@ public class DurableTaskSchedulerClientOptions
     /// <summary>
     /// Gets or sets the options that determine how and when calls made to the scheduler will be retried.
     /// </summary>
-    internal ClientRetryOptions? RetryOptions { get; set; }
+    public ClientRetryOptions? RetryOptions { get; set; }
 
     /// <summary>
     /// Creates a new instance of <see cref="DurableTaskSchedulerClientOptions"/> from a connection string.
@@ -114,10 +114,10 @@ this.Credential is not null
                 metadata.Add("Authorization", $"Bearer {token.Token}");
             });
 
-        grpcConfig.ServiceConfig? serviceConfig = null;
+        GrpcConfig.ServiceConfig? serviceConfig = GrpcRetryPolicyDefaults.DefaultServiceConfig;
         if (this.RetryOptions != null)
         {
-            grpcConfig.RetryPolicy retryPolicy = new grpcConfig.RetryPolicy
+            GrpcConfig.RetryPolicy retryPolicy = new GrpcConfig.RetryPolicy
             {
                 MaxAttempts = this.RetryOptions.MaxRetries ?? GrpcRetryPolicyDefaults.DefaultMaxAttempts,
                 InitialBackoff = TimeSpan.FromMilliseconds(this.RetryOptions.InitialBackoffMs ?? GrpcRetryPolicyDefaults.DefaultInitialBackoffMs),
@@ -140,21 +140,18 @@ this.Credential is not null
                 }
             }
 
-            grpcConfig.MethodConfig methodConfig = new grpcConfig.MethodConfig
+            GrpcConfig.MethodConfig methodConfig = new GrpcConfig.MethodConfig
             {
-                Names = { grpcConfig.MethodName.Default },
+                // MethodName.Default applies this retry policy configuration to all gRPC methods on the channel.
+                Names = { GrpcConfig.MethodName.Default },
                 RetryPolicy = retryPolicy,
             };
 
-            serviceConfig = new grpcConfig.ServiceConfig
+            serviceConfig = new GrpcConfig.ServiceConfig
             {
                 MethodConfigs = { methodConfig },
             };
         }
-        else
-        {
-            serviceConfig = GrpcRetryPolicyDefaults.DefaultServiceConfig;
-        }
 
         // Production will use HTTPS, but local testing will use HTTP
         ChannelCredentials channelCreds = endpoint.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ?

test/Client/AzureManaged.Tests/DurableTaskSchedulerClientExtensionsTests.cs

@@ -205,15 +205,16 @@ public void UseDurableTaskScheduler_WithEndpointAndCredentialAndRetryOptions_Sho
         DefaultAzureCredential credential = new DefaultAzureCredential();
 
         // Act
-        mockBuilder.Object.UseDurableTaskScheduler(ValidEndpoint, ValidTaskHub, credential,
-            new DurableTaskSchedulerClientOptions.ClientRetryOptions
-            {
-                MaxRetries = 5,
-                InitialBackoffMs = 100,
-                MaxBackoffMs = 1000,
-                BackoffMultiplier = 2.0,
-                RetryableStatusCodes = new List<StatusCode> { StatusCode.Unknown }
-            });
+        mockBuilder.Object.UseDurableTaskScheduler(ValidEndpoint, ValidTaskHub, credential, options =>
+                options.RetryOptions = new DurableTaskSchedulerClientOptions.ClientRetryOptions
+                {
+                    MaxRetries = 5,
+                    InitialBackoffMs = 100,
+                    MaxBackoffMs = 1000,
+                    BackoffMultiplier = 2.0,
+                    RetryableStatusCodes = new List<StatusCode> { StatusCode.Unknown }
+                }
+            );
 
         // Assert
         ServiceProvider provider = services.BuildServiceProvider();
@@ -247,15 +248,16 @@ public void UseDurableTaskScheduler_WithConnectionStringAndRetryOptions_ShouldCo
         string connectionString = $"Endpoint={ValidEndpoint};Authentication=DefaultAzure;TaskHub={ValidTaskHub}";
 
         // Act
-        mockBuilder.Object.UseDurableTaskScheduler(connectionString,
-            new DurableTaskSchedulerClientOptions.ClientRetryOptions
-            {
-                MaxRetries = 5,
-                InitialBackoffMs = 100,
-                MaxBackoffMs = 1000,
-                BackoffMultiplier = 2.0,
-                RetryableStatusCodes = new List<StatusCode> { StatusCode.Unknown }
-            });
+        mockBuilder.Object.UseDurableTaskScheduler(connectionString, options =>
+                options.RetryOptions = new DurableTaskSchedulerClientOptions.ClientRetryOptions
+                {
+                    MaxRetries = 5,
+                    InitialBackoffMs = 100,
+                    MaxBackoffMs = 1000,
+                    BackoffMultiplier = 2.0,
+                    RetryableStatusCodes = new List<StatusCode> { StatusCode.Unknown }
+                }
+            );
 
         // Assert
         ServiceProvider provider = services.BuildServiceProvider();