Implement CreateHttpManagementPayload API in Durable Worker Extension

src/WebJobs.Extensions.DurableTask/Bindings/BindingHelper.cs

@@ -43,6 +43,7 @@ public string DurableOrchestrationClientToString(IDurableOrchestrationClient cli
                     ConnectionName = attr.ConnectionName,
                     RpcBaseUrl = localRpcAddress,
                     RequiredQueryStringParameters = this.config.HttpApiHandler.GetUniversalQueryStrings(),
+                    BaseUrl = this.config.HttpApiHandler.GetBaseUrl(),
                 });
             }
 

src/Worker.Extensions.DurableTask/DurableTaskClientConverter.cs

@@ -49,7 +49,7 @@ public ValueTask<ConversionResult> ConvertAsync(ConverterContext context)
             }
 
             DurableTaskClient client = this.clientProvider.GetClient(endpoint, inputData?.taskHubName, inputData?.connectionName);
-            client = new FunctionsDurableTaskClient(client, inputData!.requiredQueryStringParameters);
+            client = new FunctionsDurableTaskClient(client, inputData!.requiredQueryStringParameters, inputData!.baseUrl);
             return new ValueTask<ConversionResult>(ConversionResult.Success(client));
         }
         catch (Exception innerException)
@@ -62,5 +62,5 @@ public ValueTask<ConversionResult> ConvertAsync(ConverterContext context)
     }
 
     // Serializer is case-sensitive and incoming JSON properties are camel-cased.
-    private record DurableClientInputData(string rpcBaseUrl, string taskHubName, string connectionName, string requiredQueryStringParameters);
+    private record DurableClientInputData(string rpcBaseUrl, string taskHubName, string connectionName, string requiredQueryStringParameters, string baseUrl);
 }

src/Worker.Extensions.DurableTask/DurableTaskClientExtensions.cs

@@ -120,8 +120,37 @@ public static HttpResponseData CreateCheckStatusResponse(
         return response;
     }
 
+    /// <summary>
+    /// Creates an HTTP management payload for the specified orchestration instance.
+    /// </summary>
+    /// <param name="client">The <see cref="DurableTaskClient"/>.</param>
+    /// <param name="instanceId">The ID of the orchestration instance.</param>
+    /// <param name="request">Optional HTTP request data to use for creating the base URL.</param>
+    /// <returns>An object containing instance control URLs.</returns>
+    /// <exception cref="ArgumentException">Thrown when instanceId is null or empty.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when a valid base URL cannot be determined.</exception>
+    public static object CreateHttpManagementPayload(
+        this DurableTaskClient client,
+        string instanceId,
+        HttpRequestData? request = null)
+    {
+        if (string.IsNullOrEmpty(instanceId))
+        {
+            throw new ArgumentException("InstanceId cannot be null or empty.", nameof(instanceId));
+        }
+
+        try
+        {
+            return SetHeadersAndGetPayload(client, request, null, instanceId);
+        }
+        catch (InvalidOperationException ex)
+        {
+            throw new InvalidOperationException("Failed to create HTTP management payload. " + ex.Message, ex);
+        }
+    }
+
     private static object SetHeadersAndGetPayload(
-        DurableTaskClient client, HttpRequestData request, HttpResponseData response, string instanceId)
+        DurableTaskClient client, HttpRequestData? request, HttpResponseData? response, string instanceId)
     {
         static string BuildUrl(string url, params string?[] queryValues)
         {
@@ -143,12 +172,31 @@ static string BuildUrl(string url, params string?[] queryValues)
         //       request headers into consideration and generate the base URL accordingly.
         //       More info: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Forwarded.
         //       One potential workaround is to set ASPNETCORE_FORWARDEDHEADERS_ENABLED to true.
-        string baseUrl = request.Url.GetLeftPart(UriPartial.Authority);
+
+        // If HttpRequestData is provided, use its URL; otherwise, get the baseUrl from the DurableTaskClient.
+        // The base URL could be null if:
+        // 1. The DurableTaskClient isn't a FunctionsDurableTaskClient (which would have the baseUrl from bindings)
+        // 2. There's no valid HttpRequestData provided
+        string? baseUrl = ((request != null) ? request.Url.GetLeftPart(UriPartial.Authority) : GetBaseUrl(client))
+            ?? throw new InvalidOperationException("Base URL is null. Either use Functions bindings or provide an HTTP request to create the HttpPayload.");
+        bool isFromRequest = request != null;
+
         string formattedInstanceId = Uri.EscapeDataString(instanceId);
-        string instanceUrl = $"{baseUrl}/runtime/webhooks/durabletask/instances/{formattedInstanceId}";
+
+        // The baseUrl differs depending on the source. Eg:
+        // - From request: http://localhost:7071/
+        // - From durable client: http://localhost:7071/runtime/webhooks/durabletask
+        // We adjust the instanceUrl construction accordingly.
+        string instanceUrl = isFromRequest
+            ? $"{baseUrl}/runtime/webhooks/durabletask/instances/{formattedInstanceId}"
+            : $"{baseUrl}/instances/{formattedInstanceId}";
         string? commonQueryParameters = GetQueryParams(client);
-        response.Headers.Add("Location", BuildUrl(instanceUrl, commonQueryParameters));
-        response.Headers.Add("Content-Type", "application/json");
+
+        if (response != null)
+        {
+            response.Headers.Add("Location", BuildUrl(instanceUrl, commonQueryParameters));
+            response.Headers.Add("Content-Type", "application/json");
+        }
 
         return new
         {
@@ -172,4 +220,9 @@ private static ObjectSerializer GetObjectSerializer(HttpResponseData response)
     {
         return client is FunctionsDurableTaskClient functions ? functions.QueryString : null;
     }
+
+    private static string? GetBaseUrl(DurableTaskClient client)
+    {
+        return client is FunctionsDurableTaskClient functions ? functions.BaseUrl : null;
+    }
 }

src/Worker.Extensions.DurableTask/FunctionsDurableTaskClient.cs

@@ -17,15 +17,16 @@ internal sealed class FunctionsDurableTaskClient : DurableTaskClient
 {
     private readonly DurableTaskClient inner;
 
-    public FunctionsDurableTaskClient(DurableTaskClient inner, string? queryString)
+    public FunctionsDurableTaskClient(DurableTaskClient inner, string? queryString, string? baseUrl)
         : base(inner.Name)
     {
         this.inner = inner;
         this.QueryString = queryString;
+        this.BaseUrl = baseUrl;
     }
 
     public string? QueryString { get; }
-
+    public string? BaseUrl { get; }
     public override DurableEntityClient Entities => this.inner.Entities;
 
     public override ValueTask DisposeAsync()

test/Worker.Extensions.DurableTask.Tests/FunctionsDurableTaskClientTests.cs

@@ -1,3 +1,5 @@
+using System.Security.Claims;
+using Microsoft.Azure.Functions.Worker.Http;
 using Microsoft.DurableTask.Client;
 using Microsoft.DurableTask.Client.Grpc;
 using Moq;
@@ -9,7 +11,7 @@
     /// </summary>
     public class FunctionsDurableTaskClientTests
     {
-        private FunctionsDurableTaskClient GetTestFunctionsDurableTaskClient()
+        private FunctionsDurableTaskClient GetTestFunctionsDurableTaskClient(string? baseUrl = null)
         {
             // construct mock client
 
@@ -22,7 +24,7 @@
                 It.IsAny<string>(), It.IsAny<TerminateInstanceOptions>(), It.IsAny<CancellationToken>())).Returns(completedTask);
 
             DurableTaskClient durableClient = durableClientMock.Object;
-            FunctionsDurableTaskClient client = new FunctionsDurableTaskClient(durableClient, queryString: null);
+            FunctionsDurableTaskClient client = new FunctionsDurableTaskClient(durableClient, queryString: null, baseUrl: baseUrl);
             return client;
         }
 
@@ -53,5 +55,93 @@
             await client.TerminateInstanceAsync(instanceId, options);
             await client.TerminateInstanceAsync(instanceId, options, token);
         }
+
+        /// <summary>
+        /// Test that the `CreateHttpManagementPayload` method returns the expected payload structure without HttpRequestData.
+        /// </summary>
+        [Fact]
+        public void CreateHttpManagementPayload_WithBaseUrl()
+        {
+            string BaseUrl = "http://localhost:7071/runtime/webhooks/durabletask";
+            FunctionsDurableTaskClient client = this.GetTestFunctionsDurableTaskClient(BaseUrl);
+            string instanceId = "testInstanceIdWithHostBaseUrl";
+
+            dynamic payload = client.CreateHttpManagementPayload(instanceId);
+
+            AssertHttpManagementPayload(payload, BaseUrl, instanceId);
+        }
+
+        /// <summary>
+        /// Test that the `CreateHttpManagementPayload` method returns the expected payload structure with HttpRequestData.
+        /// </summary>
+        [Fact]
+        public void CreateHttpManagementPayload_WithHttpRequestData()
+        {
+            string requestUrl = "http://localhost:7075/orchestrators/E1_HelloSequence";
+            FunctionsDurableTaskClient client = this.GetTestFunctionsDurableTaskClient();
+            string instanceId = "testInstanceIdWithRequest";
+            var context = new TestFunctionContext();
+            var request = new TestHttpRequestData(context, new Uri(requestUrl));
+
+            dynamic payload = client.CreateHttpManagementPayload(instanceId, request);
+
+            AssertHttpManagementPayload(payload, "http://localhost:7075/runtime/webhooks/durabletask", instanceId);
+        }
+
+        private static void AssertHttpManagementPayload(dynamic payload, string BaseUrl, string instanceId)
+        {
+            Assert.Equal(instanceId, payload.id);
+            Assert.Equal($"{BaseUrl}/instances/{instanceId}", payload.purgeHistoryDeleteUri);
+            Assert.Equal($"{BaseUrl}/instances/{instanceId}/raiseEvent/{{eventName}}", payload.sendEventPostUri);
+            Assert.Equal($"{BaseUrl}/instances/{instanceId}", payload.statusQueryGetUri);
+            Assert.Equal($"{BaseUrl}/instances/{instanceId}/terminate?reason={{{{text}}}}", payload.terminatePostUri);
+            Assert.Equal($"{BaseUrl}/instances/{instanceId}/suspend?reason={{{{text}}}}", payload.suspendPostUri);
+            Assert.Equal($"{BaseUrl}/instances/{instanceId}/resume?reason={{{{text}}}}", payload.resumePostUri);
+        }
+    }
+
+    /// <summary>
+    /// A minimal implementation of FunctionContext for testing purposes.
+    /// It's used to create a TestHttpRequestData instance, which requires a FunctionContext.
+    /// </summary>
+    public class TestFunctionContext : FunctionContext
+    {
+        public override string InvocationId => throw new NotImplementedException();
+        public override string FunctionId => throw new NotImplementedException();
+        public override TraceContext TraceContext => throw new NotImplementedException();
+        public override BindingContext BindingContext => throw new NotImplementedException();
+        public override RetryContext RetryContext => throw new NotImplementedException();
+        public override IServiceProvider InstanceServices { get; set; } = new EmptyServiceProvider();
+        public override FunctionDefinition FunctionDefinition => throw new NotImplementedException();
+        public override IDictionary<object, object> Items { get; set; } = new Dictionary<object, object>();
+        public override IInvocationFeatures Features => throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// A minimal implementation of IServiceProvider for testing purposes.
+    /// </summary>
+    public class EmptyServiceProvider : IServiceProvider
+    {
+        public object GetService(Type serviceType) => null;
+    }
+
+    // <summary>
+    /// A test implementation of HttpRequestData used for unit testing.
+    /// This class allows us to create instances of HttpRequestData, which is normally abstract.
+    /// </summary>
+    public class TestHttpRequestData : HttpRequestData
+    {
+        public TestHttpRequestData(FunctionContext functionContext, Uri url) : base(functionContext)
+        {
+            Url = url;
+        }
+
+        public override Stream Body => throw new NotImplementedException();
+        public override HttpHeadersCollection Headers => throw new NotImplementedException();
+        public override IReadOnlyCollection<IHttpCookie> Cookies => throw new NotImplementedException();
+        public override Uri Url { get; }
+        public override IEnumerable<ClaimsIdentity> Identities => throw new NotImplementedException();
+        public override string Method => throw new NotImplementedException();
+        public override HttpResponseData CreateResponse() => throw new NotImplementedException();
     }
 }