refactor

Author: YunchuWang

src/Client/Grpc/GrpcDurableTaskClient.cs

@@ -143,17 +143,11 @@ public override async Task<string> ScheduleNewOrchestrationInstanceAsync(
                     return status;
                 }).ToImmutableHashSet();
 
-            P.OrchestrationIdReusePolicy policy = new();
+            // Convert dedupe statuses to protobuf statuses and create reuse policy
+            IEnumerable<P.OrchestrationStatus> dedupeStatusesProto = dedupeStatuses.Select(s => s.ToGrpcStatus());
+            P.OrchestrationIdReusePolicy? policy = ProtoUtils.ConvertDedupeStatusesToReusePolicy(dedupeStatusesProto);
 
-            // The policy uses "replaceableStatus" - these are statuses that CAN be replaced
-            // dedupeStatuses are statuses that should NOT be replaced
-            foreach (OrchestrationRuntimeStatus terminalStatus in StartOrchestrationOptionsExtensions.ValidDedupeStatuses.Where(ts => !dedupeStatuses.Contains(ts)))
-            {
-                policy.ReplaceableStatus.Add(terminalStatus.ToGrpcStatus());
-            }
-
-            // Only set if we have replaceable statuses
-            if (policy.ReplaceableStatus.Count > 0)
+            if (policy != null)
             {
                 request.OrchestrationIdReusePolicy = policy;
             }

src/Client/Grpc/ProtoUtils.cs

@@ -1,15 +1,100 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Collections.Immutable;
 using P = Microsoft.DurableTask.Protobuf;
 
 namespace Microsoft.DurableTask.Client.Grpc;
 
 /// <summary>
 /// Protobuf helpers and utilities.
 /// </summary>
-static class ProtoUtils
+public static class ProtoUtils
 {
+    /// <summary>
+    /// Gets the terminal orchestration statuses that are commonly used for deduplication.
+    /// These are the statuses that can be used in OrchestrationIdReusePolicy.
+    /// </summary>
+    /// <returns>An immutable array of terminal orchestration statuses.</returns>
+    public static ImmutableArray<P.OrchestrationStatus> GetTerminalStatuses()
+    {
+#pragma warning disable CS0618 // Type or member is obsolete - Canceled is intentionally included for compatibility
+        return ImmutableArray.Create(
+            P.OrchestrationStatus.Completed,
+            P.OrchestrationStatus.Failed,
+            P.OrchestrationStatus.Terminated,
+            P.OrchestrationStatus.Canceled);
+#pragma warning restore CS0618
+    }
+
+    /// <summary>
+    /// Converts dedupe statuses (statuses that should NOT be replaced) to an OrchestrationIdReusePolicy
+    /// with replaceable statuses (statuses that CAN be replaced).
+    /// </summary>
+    /// <param name="dedupeStatuses">The orchestration statuses that should NOT be replaced. These are statuses for which an exception should be thrown if an orchestration already exists.</param>
+    /// <returns>An OrchestrationIdReusePolicy with replaceable statuses set, or null if all terminal statuses are dedupe statuses.</returns>
+    /// <remarks>
+    /// The policy uses "replaceableStatus" - these are statuses that CAN be replaced.
+    /// dedupeStatuses are statuses that should NOT be replaced.
+    /// So replaceableStatus = all terminal statuses MINUS dedupeStatuses.
+    /// </remarks>
+    public static P.OrchestrationIdReusePolicy? ConvertDedupeStatusesToReusePolicy(
+        IEnumerable<P.OrchestrationStatus> dedupeStatuses)
+    {
+        ImmutableArray<P.OrchestrationStatus> terminalStatuses = GetTerminalStatuses();
+        ImmutableHashSet<P.OrchestrationStatus> dedupeStatusSet = dedupeStatuses.ToImmutableHashSet();
+
+        P.OrchestrationIdReusePolicy policy = new();
+
+        // Add terminal statuses that are NOT in dedupeStatuses as replaceable
+        foreach (P.OrchestrationStatus terminalStatus in terminalStatuses)
+        {
+            if (!dedupeStatusSet.Contains(terminalStatus))
+            {
+                policy.ReplaceableStatus.Add(terminalStatus);
+            }
+        }
+
+        // Only return policy if we have replaceable statuses
+        return policy.ReplaceableStatus.Count > 0 ? policy : null;
+    }
+
+    /// <summary>
+    /// Converts an OrchestrationIdReusePolicy with replaceable statuses to dedupe statuses
+    /// (statuses that should NOT be replaced).
+    /// </summary>
+    /// <param name="policy">The OrchestrationIdReusePolicy containing replaceable statuses.</param>
+    /// <returns>An array of orchestration statuses that should NOT be replaced, or null if all terminal statuses are replaceable.</returns>
+    /// <remarks>
+    /// The policy uses "replaceableStatus" - these are statuses that CAN be replaced.
+    /// dedupeStatuses are statuses that should NOT be replaced (should throw exception).
+    /// So dedupeStatuses = all terminal statuses MINUS replaceableStatus.
+    /// </remarks>
+    public static P.OrchestrationStatus[]? ConvertReusePolicyToDedupeStatuses(
+        P.OrchestrationIdReusePolicy? policy)
+    {
+        if (policy == null || policy.ReplaceableStatus.Count == 0)
+        {
+            return null;
+        }
+
+        ImmutableArray<P.OrchestrationStatus> terminalStatuses = GetTerminalStatuses();
+        ImmutableHashSet<P.OrchestrationStatus> replaceableStatusSet = policy.ReplaceableStatus.ToImmutableHashSet();
+
+        // Calculate dedupe statuses = terminal statuses - replaceable statuses
+        List<P.OrchestrationStatus> dedupeStatuses = new();
+        foreach (P.OrchestrationStatus terminalStatus in terminalStatuses)
+        {
+            if (!replaceableStatusSet.Contains(terminalStatus))
+            {
+                dedupeStatuses.Add(terminalStatus);
+            }
+        }
+
+        // Only return if there are dedupe statuses
+        return dedupeStatuses.Count > 0 ? dedupeStatuses.ToArray() : null;
+    }
+
 #pragma warning disable 0618 // Referencing Obsolete member. This is intention as we are only converting it.
     /// <summary>
     /// Converts <see cref="OrchestrationRuntimeStatus" /> to <see cref="P.OrchestrationStatus" />.

src/InProcessTestHost/Sidecar/Grpc/TaskHubGrpcServer.cs

@@ -4,12 +4,14 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Globalization;
+using System.Linq;
 using DurableTask.Core;
 using DurableTask.Core.Exceptions;
 using DurableTask.Core.History;
 using DurableTask.Core.Query;
 using Google.Protobuf.WellKnownTypes;
 using Grpc.Core;
+using Microsoft.DurableTask.Client.Grpc;
 using Microsoft.DurableTask.Testing.Sidecar.Dispatcher;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -208,27 +210,11 @@ async Task WaitForWorkItemClientConnection()
             // dedupeStatuses are statuses that should NOT be replaced (should throw exception)
             // So dedupeStatuses = all terminal statuses MINUS replaceableStatus
             OrchestrationStatus[]? dedupeStatuses = null;
-            if (request.OrchestrationIdReusePolicy != null && request.OrchestrationIdReusePolicy.ReplaceableStatus.Count > 0)
+            P.OrchestrationStatus[]? dedupeStatusesProto = ProtoUtils.ConvertReusePolicyToDedupeStatuses(request.OrchestrationIdReusePolicy);
+            if (dedupeStatusesProto != null)
             {
-                var terminalStatuses = new HashSet<OrchestrationStatus>
-                {
-                    OrchestrationStatus.Completed,
-                    OrchestrationStatus.Failed,
-                    OrchestrationStatus.Terminated,
-                    OrchestrationStatus.Canceled,
-                };
-
-                // Remove replaceable statuses from terminal statuses to get dedupe statuses
-                foreach (P.OrchestrationStatus replaceableStatus in request.OrchestrationIdReusePolicy.ReplaceableStatus)
-                {
-                    terminalStatuses.Remove((OrchestrationStatus)replaceableStatus);
-                }
-
-                // Only set dedupeStatuses if there are any statuses that should not be replaced
-                if (terminalStatuses.Count > 0)
-                {
-                    dedupeStatuses = terminalStatuses.ToArray();
-                }
+                // Convert protobuf statuses to Core.OrchestrationStatus
+                dedupeStatuses = dedupeStatusesProto.Select(s => (OrchestrationStatus)s).ToArray();
             }
 
             await this.client.CreateTaskOrchestrationAsync(