Support handling function return value from worker process (#46158)

Fix Azure/azure-functions-dotnet-worker#1496

The reason to add .NET 6 and .NET 8 as TFM:
The worker function return value is a Newtonsoft JObject if it's an object in the worker. Since .NET Core Frameworks, the default SignalR JSON protocol uses System.Text.Json library and can't serialize Newtonsoft JObject. Therefore, we need to wrap the JObject to a System.Text.Json serializable object with a customized JSON converter. The customized JSON converter first converts the Newtonsoft JObject to JSON with Newtonsoft library, then writes the raw JSON object with System.Text.Json writer. For .NET Standard 2.0, it's not possible to write a raw JSON with System.Text.Json writer, therefore, we need to add .NET 6 and .NET 8 as TFM to write the raw JSON.

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/CHANGELOG.md

@@ -1,14 +1,9 @@
 # Release History
 
-## 1.15.0-beta.1 (Unreleased)
-
-### Features Added
-
-### Breaking Changes
+## 1.15.0 (2024-10-14)
 
 ### Bugs Fixed
-
-### Other Changes
+* Fixed the issue that the function return value from isolated-worker process is not handled correctly.
 
 ## 1.14.0 (2024-05-24)
 

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/api/Microsoft.Azure.WebJobs.Extensions.SignalRService.netstandard2.0.cs

@@ -254,8 +254,8 @@ public partial class SignalRParameterAttribute : System.Attribute
     {
         public SignalRParameterAttribute() { }
     }
-    [Microsoft.Azure.WebJobs.Description.BindingAttribute]
-    [System.AttributeUsageAttribute(System.AttributeTargets.Parameter | System.AttributeTargets.ReturnValue)]
+    [Microsoft.Azure.WebJobs.Description.BindingAttribute(TriggerHandlesReturnValue=true)]
+    [System.AttributeUsageAttribute(System.AttributeTargets.Parameter)]
     public partial class SignalRTriggerAttribute : System.Attribute
     {
         public SignalRTriggerAttribute() { }

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/src/Config/SignalRConfigProvider.cs

@@ -71,7 +71,7 @@ public void Initialize(ExtensionConfigContext context)
             // Trigger binding rule
             var triggerBindingRule = context.AddBindingRule<SignalRTriggerAttribute>();
             triggerBindingRule.AddConverter<InvocationContext, JObject>(JObject.FromObject);
-            triggerBindingRule.BindToTrigger<InvocationContext>(new SignalRTriggerBindingProvider(_dispatcher, _nameResolver, _serviceManagerStore, webhookException));
+            triggerBindingRule.BindToTrigger(new SignalRTriggerBindingProvider(_dispatcher, _nameResolver, _serviceManagerStore, webhookException));
 
             // Non-trigger binding rule
             var signalRConnectionInfoAttributeRule = context.AddBindingRule<SignalRConnectionInfoAttribute>();

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/src/Microsoft.Azure.WebJobs.Extensions.SignalRService.csproj

@@ -1,11 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>$(RequiredTargetFrameworks)</TargetFrameworks>
+    <TargetFrameworks>$(RequiredTargetFrameworks);net6.0;net8.0</TargetFrameworks>
     <PackageId>Microsoft.Azure.WebJobs.Extensions.SignalRService</PackageId>
-    <Version>1.15.0-beta.1</Version>
+    <Version>1.15.0</Version>
     <!--The ApiCompatVersion is managed automatically and should not generally be modified manually.-->
-    <ApiCompatVersion>1.14.0</ApiCompatVersion>
     <SignAssembly>true</SignAssembly>
     <IsExtensionClientLibrary>true</IsExtensionClientLibrary>
     <NoWarn>$(NoWarn);CS1591;AZC0107;</NoWarn>

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/src/TriggerBindings/Executor/SignalRInvocationMethodExecutor.cs

@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 
 using Microsoft.AspNetCore.SignalR.Protocol;
+using Newtonsoft.Json.Linq;
 using InvocationMessage = Microsoft.Azure.SignalR.Serverless.Protocols.InvocationMessage;
 
 namespace Microsoft.Azure.WebJobs.Extensions.SignalRService
@@ -52,7 +53,7 @@ public override async Task<HttpResponseMessage> ExecuteAsync(HttpRequestMessage
                 else
                 {
                     var result = await tcs.Task.ConfigureAwait(false);
-                    completionMessage = CompletionMessage.WithResult(message.InvocationId, result);
+                    completionMessage = CompletionMessage.WithResult(message.InvocationId, ToSafeSerializationType(result));
                     response = new HttpResponseMessage(HttpStatusCode.OK);
                 }
             }
@@ -68,6 +69,18 @@ public override async Task<HttpResponseMessage> ExecuteAsync(HttpRequestMessage
             return response;
         }
 
+        private static object ToSafeSerializationType(object result)
+        {
+            if (result is JToken jtoken)
+            {
+                return new JTokenWrapper(jtoken);
+            }
+            else
+            {
+                return result;
+            }
+        }
+
         private static void AssertConsistency(InvocationContext context, InvocationMessage message)
         {
             if (!string.Equals(context.Event, message.Target, StringComparison.OrdinalIgnoreCase))

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/src/TriggerBindings/SignalRTriggerAttribute.cs

@@ -10,8 +10,10 @@ namespace Microsoft.Azure.WebJobs.Extensions.SignalRService
     /// <summary>
     /// Attribute used to mark a function that should be triggered by messages sent from SignalR clients.
     /// </summary>
-    [AttributeUsage(AttributeTargets.ReturnValue | AttributeTargets.Parameter)]
-    [Binding]
+    [AttributeUsage(AttributeTargets.Parameter)]
+#pragma warning disable CS0618 // Type or member is obsolete
+    [Binding(TriggerHandlesReturnValue = true)]
+#pragma warning restore CS0618 // Type or member is obsolete
     public class SignalRTriggerAttribute : Attribute
     {
         /// <summary>

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/src/TriggerBindings/SignalRTriggerBinding.cs

@@ -17,6 +17,7 @@
 using Microsoft.Azure.WebJobs.Host.Protocols;
 using Microsoft.Azure.WebJobs.Host.Triggers;
 using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.WebJobs.Extensions.SignalRService
@@ -201,6 +202,11 @@ public Task<object> GetValueAsync()
                 {
                     return Task.FromResult<object>(JObject.FromObject(_value));
                 }
+                // Isolated worker model
+                else if (_parameter.ParameterType == typeof(string))
+                {
+                    return Task.FromResult(JsonConvert.SerializeObject(_value) as object);
+                }
 
                 return Task.FromResult<object>(null);
             }
@@ -210,7 +216,7 @@ public string ToInvokeString()
                 return _value.ToString();
             }
 
-            public Type Type => _parameter.GetType();
+            public Type Type => _parameter.ParameterType;
 
             // No use here
             public Task SetValueAsync(object value, CancellationToken cancellationToken)

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/src/TriggerBindings/Utils/JTokenWrapper.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Text.Json;
+using Microsoft.AspNetCore.SignalR.Protocol;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Microsoft.Azure.WebJobs.Extensions.SignalRService;
+
+/// <summary>
+/// Helps to make the <see cref="JToken"/> object correctly seralized in <see cref="JsonHubProtocol"/> that using System.Text.Json internally.
+/// <para>Since .Net Core 3.0, the <see cref="JsonHubProtocol"/> uses System.Text.Json library for JSON (de)serialization, which cannot handle <see cref="JToken"/> correctly. However, in isolated worker model, if a SignalR trigger function returns an object, then the SignalR extensions in host process gets a <see cref="JToken"/> object. We need to make sure the <see cref="JToken"/> object serialized correctly in the <see cref="CompletionMessage"/>.</para>
+/// </summary>
+
+[System.Text.Json.Serialization.JsonConverter(typeof(JTokenWrapperJsonConverter))]
+internal class JTokenWrapper
+{
+    public JTokenWrapper(JToken value)
+    {
+        Value = value;
+    }
+
+    public JToken Value { get; }
+}
+
+internal class JTokenWrapperJsonConverter : System.Text.Json.Serialization.JsonConverter<JTokenWrapper>
+{
+    public override JTokenWrapper Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override void Write(Utf8JsonWriter writer, JTokenWrapper value, JsonSerializerOptions options)
+    {
+#if NET6_0_OR_GREATER
+        var jsonString = JsonConvert.SerializeObject(value.Value);
+        writer.WriteRawValue(jsonString);
+#elif NETSTANDARD2_0
+        // No need to implement.
+        // First of all, the SignalR extensions for host process always run on .NET 6 or greater runtime when this class is first written.
+        // Even if somehow the extensions run on .NET Framework, the JsonHubProtocol would use Newtonsoft.Json for serialization and this class would not be used.
+        throw new NotImplementedException("Serializing Newtonsoft.Json.JsonToken with System.Text.Json is not implemented. ");
+#endif
+    }
+}

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/tests/DefaultSecurityTokenValidatorTests.cs

@@ -41,7 +41,7 @@ public void ValidateSecurityTokenFacts(string tokenString, SecurityTokenStatus e
         {
             var ctx = new DefaultHttpContext();
             var req = ctx.Request;
-            req.Headers.Add("Authorization", new StringValues(tokenString));
+            req.Headers.Append("Authorization", new StringValues(tokenString));
 
             Action<TokenValidationParameters> configureTokenValidationParameters = parameters =>
             {

sdk/signalr/Microsoft.Azure.WebJobs.Extensions.SignalRService/tests/Utils/TestHelpers.cs

@@ -68,13 +68,13 @@ public static HttpRequestMessage CreateHttpRequestMessage(string hub, string cat
             var context = new DefaultHttpContext();
             context.Request.ContentType = contentType;
             context.Request.Method = "Post";
-            context.Request.Headers.Add(Constants.AsrsHubNameHeader, hub);
-            context.Request.Headers.Add(Constants.AsrsCategory, category);
-            context.Request.Headers.Add(Constants.AsrsEvent, @event);
-            context.Request.Headers.Add(Constants.AsrsConnectionIdHeader, connectionId);
+            context.Request.Headers.Append(Constants.AsrsHubNameHeader, hub);
+            context.Request.Headers.Append(Constants.AsrsCategory, category);
+            context.Request.Headers.Append(Constants.AsrsEvent, @event);
+            context.Request.Headers.Append(Constants.AsrsConnectionIdHeader, connectionId);
             if (signatures != null)
             {
-                context.Request.Headers.Add(Constants.AsrsSignature, string.Join(",", signatures));
+                context.Request.Headers.Append(Constants.AsrsSignature, string.Join(",", signatures));
             }
             context.Request.Body = content == null ? Stream.Null : new MemoryStream(content);