HTTP APIs for .NET Isolated Parity

src/WebJobs.Extensions.DurableTask/OutOfProcMiddleware.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Net.Http;
 using System.Threading.Tasks;
 using DurableTask.Core;
 using DurableTask.Core.Entities;
@@ -14,6 +15,7 @@
 using DurableTask.Core.History;
 using DurableTask.Core.Middleware;
 using Microsoft.Azure.WebJobs.Host.Executors;
+using Microsoft.Extensions.Primitives;
 using Newtonsoft.Json;
 
 namespace Microsoft.Azure.WebJobs.Extensions.DurableTask
@@ -416,6 +418,45 @@ public async Task CallActivityAsync(DispatchMiddlewareContext dispatchContext, F
                 throw new InvalidOperationException($"An activity was scheduled but no {nameof(TaskScheduledEvent)} was found!");
             }
 
+            if (!string.IsNullOrEmpty(scheduledEvent.Name) && scheduledEvent.Name.StartsWith("BuiltIn::HttpActivity"))
+            {
+                try
+                {
+                    if (dispatchContext.GetProperty<TaskActivity>() is TaskHttpActivityShim shim)
+                    {
+                        OrchestrationInstance orchestrationInstance = dispatchContext.GetProperty<OrchestrationInstance>();
+                        TaskContext context = new TaskContext(orchestrationInstance);
+
+                        // convert the DurableHttpRequest
+                        DurableHttpRequest? req = ConvertDurableHttpRequest(scheduledEvent.Input);
+                        IList<DurableHttpRequest> list = new List<DurableHttpRequest>() { req };
+                        string serializedRequest = JsonConvert.SerializeObject(list);
+
+                        string? output = await shim.RunAsync(context, serializedRequest);
+                        dispatchContext.SetProperty(new ActivityExecutionResult
+                        {
+                            ResponseEvent = new TaskCompletedEvent(
+                            eventId: -1,
+                            taskScheduledId: scheduledEvent.EventId,
+                            result: JsonConvert.SerializeObject(output)),
+                        });
+                        return;
+                    }
+                }
+                catch (Exception e)
+                {
+                    dispatchContext.SetProperty(new ActivityExecutionResult
+                    {
+                        ResponseEvent = new TaskFailedEvent(
+                        eventId: -1,
+                        taskScheduledId: scheduledEvent.EventId,
+                        reason: $"Function failed",
+                        details: e.Message),
+                    });
+                    return;
+                }
+            }
+
             FunctionName functionName = new FunctionName(scheduledEvent.Name);
 
             OrchestrationInstance? instance = dispatchContext.GetProperty<OrchestrationInstance>();
@@ -540,6 +581,23 @@ public async Task CallActivityAsync(DispatchMiddlewareContext dispatchContext, F
             dispatchContext.SetProperty(activityResult);
         }
 
+        private static DurableHttpRequest? ConvertDurableHttpRequest(string? inputString)
+        {
+            IList<dynamic>? input = JsonConvert.DeserializeObject<IList<dynamic>>(inputString);
+            dynamic? dynamicRequest = input[0];
+
+            HttpMethod httpMethod = dynamicRequest.method.ToObject<HttpMethod>();
+            Uri uri = dynamicRequest.uri.ToObject<Uri>();
+            string content = dynamicRequest.content.ToString();
+
+            JsonSerializerSettings settings = new JsonSerializerSettings { Converters = new List<JsonConverter> { new HttpHeadersConverter() } };
+            Dictionary<string, StringValues> headers = JsonConvert.DeserializeObject<Dictionary<string, StringValues>>(dynamicRequest.headers.ToString(), settings);
+
+            DurableHttpRequest request = new DurableHttpRequest(httpMethod, uri, headers, content);
+
+            return request;
+        }
+
         private static FailureDetails GetFailureDetails(Exception e)
         {
             if (e.InnerException != null && e.InnerException.Message.StartsWith("Result:"))

src/Worker.Extensions.DurableTask/DurableHttpRequest.cs

@@ -0,0 +1,70 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Azure.Functions.Worker;
+
+/// <summary>
+/// Request used to make an HTTP call through Durable Functions.
+/// </summary>
+public class DurableHttpRequest
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DurableHttpRequest"/> class.
+    /// </summary>
+    public DurableHttpRequest(
+        HttpMethod method,
+        Uri uri,
+        IDictionary<string, StringValues>? headers = null,
+        string? content = null)
+    {
+        this.Method = method;
+        this.Uri = uri;
+        this.Headers = HttpHeadersConverter.CreateCopy(headers);
+        this.Content = content;
+    }
+
+    /// <summary>
+    /// HttpMethod used in the HTTP request made by the Durable Function.
+    /// </summary>
+    [JsonPropertyName("method")]
+    public HttpMethod Method { get; }
+
+    /// <summary>
+    /// Uri used in the HTTP request made by the Durable Function.
+    /// </summary>
+    [JsonPropertyName("uri")]
+    public Uri Uri { get; }
+
+    /// <summary>
+    /// Headers passed with the HTTP request made by the Durable Function.
+    /// </summary>
+    [JsonPropertyName("headers")]
+    [JsonConverter(typeof(HttpHeadersConverter))]
+    public IDictionary<string, StringValues>? Headers { get; }
+
+    /// <summary>
+    /// Content passed with the HTTP request made by the Durable Function.
+    /// </summary>
+    [JsonPropertyName("content")]
+    public string? Content { get; }
+
+    internal static IDictionary<string, StringValues> CreateCopy(IDictionary<string, StringValues> input)
+    {
+        var copy = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);
+        if (input != null)
+        {
+            foreach (var pair in input)
+            {
+                copy[pair.Key] = pair.Value;
+            }
+        }
+
+        return copy;
+    }
+}

src/Worker.Extensions.DurableTask/DurableHttpResponse.cs

@@ -0,0 +1,83 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Azure.Functions.Worker;
+
+/// <summary>
+/// Response received from the HTTP request made by the Durable Function.
+/// </summary>
+public class DurableHttpResponse
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DurableHttpResponse"/> class.
+    /// </summary>
+    /// <param name="statusCode">HTTP Status code returned from the HTTP call.</param>
+    /// <param name="headers">Headers returned from the HTTP call.</param>
+    /// <param name="content">Content returned from the HTTP call.</param>
+    public DurableHttpResponse(
+        HttpStatusCode statusCode,
+        IDictionary<string, StringValues> headers = null,
+        string content = null)
+    {
+        this.StatusCode = statusCode;
+        this.Headers = HttpHeadersConverter.CreateCopy(headers);
+        this.Content = content;
+    }
+
+    /// <summary>
+    /// Status code returned from an HTTP request.
+    /// </summary>
+    [JsonPropertyName("statusCode")]
+    public HttpStatusCode StatusCode { get; }
+
+    /// <summary>
+    /// Headers in the response from an HTTP request.
+    /// </summary>
+    [JsonPropertyName("headers")]
+    [JsonConverter(typeof(HttpHeadersConverter))]
+    public IDictionary<string, StringValues> Headers { get; }
+
+    /// <summary>
+    /// Content returned from an HTTP request.
+    /// </summary>
+    [JsonPropertyName("content")]
+    public string Content { get; }
+
+    /// <summary>
+    /// Creates a DurableHttpResponse from an HttpResponseMessage.
+    /// </summary>
+    /// <param name="httpResponseMessage">HttpResponseMessage returned from the HTTP call.</param>
+    /// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns>
+    public static async Task<DurableHttpResponse> CreateDurableHttpResponseWithHttpResponseMessage(HttpResponseMessage httpResponseMessage)
+    {
+        DurableHttpResponse durableHttpResponse = new DurableHttpResponse(
+            statusCode: httpResponseMessage.StatusCode,
+            headers: CreateStringValuesHeaderDictionary(httpResponseMessage.Headers),
+            content: await httpResponseMessage.Content.ReadAsStringAsync());
+
+        return durableHttpResponse;
+    }
+
+    private static IDictionary<string, StringValues> CreateStringValuesHeaderDictionary(IEnumerable<KeyValuePair<string, IEnumerable<string>>> headers)
+    {
+        IDictionary<string, StringValues> newHeaders = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);
+        if (headers != null)
+        {
+            foreach (var header in headers)
+            {
+                newHeaders[header.Key] = new StringValues(header.Value.ToArray());
+            }
+        }
+
+        return newHeaders;
+    }
+}

src/Worker.Extensions.DurableTask/HttpHeadersConverter.cs

@@ -0,0 +1,103 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Azure.Functions.Worker;
+
+// StringValues does not deserialize as you would expect, so we need a custom mechanism
+// for serializing HTTP header collections
+internal class HttpHeadersConverter : JsonConverter<object>
+{
+    public override bool CanConvert(Type objectType)
+    {
+        return typeof(IDictionary<string, StringValues>).IsAssignableFrom(objectType);
+    }
+
+    public override object Read(
+        ref Utf8JsonReader reader,
+        Type objectType,
+        JsonSerializerOptions options)
+    {
+        var headers = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);
+
+        if (reader.TokenType != JsonTokenType.StartObject)
+        {
+            return headers;
+        }
+
+        var valueList = new List<string>();
+        while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
+        {
+            string? propertyName = reader.GetString();
+
+            reader.Read();
+
+            // Header values can be either individual strings or string arrays
+            StringValues values = default(StringValues);
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                values = new StringValues(reader.GetString());
+            }
+            else if (reader.TokenType == JsonTokenType.StartArray)
+            {
+                while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
+                {
+                    valueList.Add(reader.GetString());
+                }
+
+                values = new StringValues(valueList.ToArray());
+                valueList.Clear();
+            }
+
+            headers[propertyName] = values;
+        }
+
+        return headers;
+    }
+
+    public override void Write(
+        Utf8JsonWriter writer,
+        object value,
+        JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+
+        var headers = (IDictionary<string, StringValues>)value;
+        foreach (var pair in headers)
+        {
+            if (pair.Value.Count == 1)
+            {
+                // serialize as a single string value
+                writer.WriteString(pair.Key, pair.Value[0]);
+            }
+            else
+            {
+                // serializes as an array
+                writer.WriteStartArray(pair.Key);
+                writer.WriteStringValue(pair.Value);
+                writer.WriteEndArray();
+            }
+        }
+
+        writer.WriteEndObject();
+    }
+
+    internal static IDictionary<string, StringValues> CreateCopy(IDictionary<string, StringValues> input)
+    {
+        var copy = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);
+        if (input != null)
+        {
+            foreach (var pair in input)
+            {
+                copy[pair.Key] = pair.Value;
+            }
+        }
+
+        return copy;
+    }
+}

src/Worker.Extensions.DurableTask/TaskOrchestrationContextExtensionMethods.cs

@@ -0,0 +1,29 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.DurableTask;
+
+namespace Microsoft.Azure.Functions.Worker;
+
+/// <summary>
+/// Extensions for <see cref="TaskOrchestrationContext"/>.
+/// </summary>
+public static class TaskOrchestrationContextExtensionMethods
+{
+    /// <summary>
+    /// Makes an HTTP call using the information in the DurableHttpRequest.
+    /// </summary>
+    /// <param name="context">The task orchestration context.</param>
+    /// <param name="req">The DurableHttpRequest used to make the HTTP call.</param>
+    /// <returns></returns>
+    public static async Task<DurableHttpResponse> CallHttpAsync(this TaskOrchestrationContext context, DurableHttpRequest req)
+    {
+        string responseString = await context.CallActivityAsync<string>("BuiltIn::HttpActivity", req);
+
+        DurableHttpResponse? response = JsonSerializer.Deserialize<DurableHttpResponse>(responseString);
+
+        return response;
+    }
+}