Set extension RPC max message length

extensions/Worker.Extensions.Rpc/release_notes.md

@@ -4,7 +4,6 @@
 - My change description (#PR/#issue)
 -->
 
-### Microsoft.Azure.Functions.Worker.Extensions.Rpc 1.0.0
+### Microsoft.Azure.Functions.Worker.Extensions.Rpc 1.0.1
 
-- Initial public release
-- Adds API for getting a `CallInvoker` pre-configured for communication with Functions host. 
+- Set max message send and receive length on gRPC `CallInvoker`.

extensions/Worker.Extensions.Rpc/src/ConfigurationExtensions.cs

@@ -38,5 +38,16 @@ public static Uri GetFunctionsHostGrpcUri(this IConfiguration configuration)
 
             return grpcUri;
         }
+
+        /// <summary>
+        /// Gets the maximum message length for the functions host gRPC channel.
+        /// </summary>
+        /// <param name="configuration">The configuration to retrieve values from.</param>
+        /// <returns>The maximum message length if available. </returns>
+        public static int? GetFunctionsHostMaxMessageLength(this IConfiguration configuration)
+        {
+            return configuration.GetValue<int?>("Functions:Worker:GrpcMaxMessageLength", null)
+                ?? configuration.GetValue<int?>("grpcMaxMessageLength", null);
+        }
     }
 }

extensions/Worker.Extensions.Rpc/src/GrpcHttpClientBuilderExtensions.cs

@@ -31,7 +31,18 @@ public static IHttpClientBuilder ConfigureForFunctionsHostGrpc(this IHttpClientB
 
             ValidateGrpcClient(builder);
             builder.Services.AddOptions<GrpcClientFactoryOptions>(builder.Name)
-                .Configure<IConfiguration>((options, config) => options.Address = config.GetFunctionsHostGrpcUri());
+                .Configure<IConfiguration>((options, config) =>
+                {
+                    options.Address = config.GetFunctionsHostGrpcUri();
+                    if (config.GetFunctionsHostMaxMessageLength() is int length)
+                    {
+                        options.ChannelOptionsActions.Add(o =>
+                        {
+                            o.MaxReceiveMessageSize = length;
+                            o.MaxSendMessageSize = length;
+                        });
+                    }
+                });
 
             return builder;
         }

extensions/Worker.Extensions.Rpc/src/RpcServiceCollectionExtensions.NetApp.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 #if !NETSTANDARD
@@ -19,8 +19,7 @@ private static void ConfigureCallInvoker(IServiceCollection services)
         {
             // Instead of building the GrpcChannel/CallInvoker ourselves, we use Grpc.Net.ClientFactory to
             // construct and configure the CallInvoker for us, then we attach that to our options.
-            services.AddGrpcClient<CallInvokerExtractor>(_ => { })
-                .ConfigureForFunctionsHostGrpc();
+            services.AddGrpcClient<CallInvokerExtractor>(_ => { }).ConfigureForFunctionsHostGrpc();
             services.TryAddEnumerable(
                 ServiceDescriptor.Transient<IConfigureOptions<FunctionsGrpcOptions>, ConfigureOptions>());
         }

extensions/Worker.Extensions.Rpc/src/RpcServiceCollectionExtensions.NetStandard.cs

@@ -1,8 +1,10 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 #if NETSTANDARD
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Grpc.Core;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -33,8 +35,18 @@ public ConfigureOptions(IConfiguration configuration)
 
             public void Configure(FunctionsGrpcOptions options)
             {
+                IEnumerable<ChannelOption> channelOptions = _configuration.GetFunctionsHostMaxMessageLength() switch
+                {
+                    int maxMessageLength => new[]
+                    {
+                        new ChannelOption(ChannelOptions.MaxReceiveMessageLength, maxMessageLength),
+                        new ChannelOption(ChannelOptions.MaxSendMessageLength, maxMessageLength),
+                    },
+                    _ => Enumerable.Empty<ChannelOption>(),
+                };
+
                 Uri address = _configuration.GetFunctionsHostGrpcUri();
-                Channel c = new Channel(address.Host, address.Port, ChannelCredentials.Insecure);
+                Channel c = new Channel(address.Host, address.Port, ChannelCredentials.Insecure, channelOptions);
                 options.CallInvoker = c.CreateCallInvoker();
             }
         }

extensions/Worker.Extensions.Rpc/src/Worker.Extensions.Rpc.csproj

@@ -5,7 +5,7 @@
     <AssemblyName>Microsoft.Azure.Functions.Worker.Extensions.Rpc</AssemblyName>
     <RootNamespace>Microsoft.Azure.Functions.Worker.Extensions.Rpc</RootNamespace>
     <Description>Contains types to facilitate RPC communication between a worker extension and the functions host.</Description>
-    <VersionPrefix>1.0.0</VersionPrefix>
+    <VersionPrefix>1.0.1</VersionPrefix>
     <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 

test/Worker.Extensions.Rpc.Tests/GrpcHttpClientBuilderExtensionsTests.cs

@@ -4,6 +4,7 @@
 #if NET6_0_OR_GREATER
 
 using Grpc.Core;
+using Grpc.Net.Client;
 using Grpc.Net.ClientFactory;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -23,14 +24,19 @@ public void ConfigureForFunctionsHostGrpc_Configure_SetsUri()
         public void ConfigureForFunctionsHostGrpc_SetsUri()
             => ConfigureForFunctionsHostGrpc(s => s.AddGrpcClient<CallInvokerExtractor>());
 
-        private void ConfigureForFunctionsHostGrpc(Func<IServiceCollection, IHttpClientBuilder> configure)
+        [Fact]
+        public void ConfigureForFunctionsHostGrpc_SetsMessageSize()
+            => ConfigureForFunctionsHostGrpc(s => s.AddGrpcClient<CallInvokerExtractor>(), Random.Shared.Next(4098, 10000));
+
+        private void ConfigureForFunctionsHostGrpc(Func<IServiceCollection, IHttpClientBuilder> configure, int? maxMessageLength = null)
         {
             int port = 21584; // random enough.
             ConfigurationBuilder configBuilder = new();
             configBuilder.AddInMemoryCollection(new Dictionary<string, string>()
             {
                 ["HOST"] = "localhost",
                 ["PORT"] = port.ToString(),
+                ["grpcMaxMessageLength"] = maxMessageLength?.ToString(),
             });
 
             ServiceCollection services = new();
@@ -55,10 +61,22 @@ private void ConfigureForFunctionsHostGrpc(Func<IServiceCollection, IHttpClientB
             Assert.NotNull(extractor.CallInvoker);
 
             IOptionsMonitor<GrpcClientFactoryOptions> monitor = sp.GetService<IOptionsMonitor<GrpcClientFactoryOptions>>();
-            GrpcClientFactoryOptions options = monitor.Get(builder.Name);
+            GrpcClientFactoryOptions factoryOptions = monitor.Get(builder.Name);
 
-            Assert.Equal(new Uri($"http://localhost:{port}"), options.Address);
+            Assert.Equal(new Uri($"http://localhost:{port}"), factoryOptions.Address);
             Assert.Null(handler);
+
+            if (maxMessageLength is int expectedLength)
+            {
+                GrpcChannelOptions channelOptions = new();
+                foreach (Action<GrpcChannelOptions> action in factoryOptions.ChannelOptionsActions)
+                {
+                    action(channelOptions);
+                }
+
+                Assert.Equal(expectedLength, channelOptions.MaxReceiveMessageSize);
+                Assert.Equal(expectedLength, channelOptions.MaxSendMessageSize);
+            }
         }
 
         private class CallInvokerExtractor