[Enhanced Http] Private preview support for http proxying scenarios (#9193)

satvu · web-flow · commit 5c6c3794901f · 2023-04-04T13:08:14.000-07:00
diff --git a/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannel.cs b/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannel.cs
@@ -31,6 +31,7 @@
 using Microsoft.Azure.WebJobs.Script.Workers.SharedMemoryDataTransfer;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Yarp.ReverseProxy.Forwarder;
 
 using static Microsoft.Azure.WebJobs.Script.Grpc.Messages.RpcLog.Types;
 using FunctionMetadata = Microsoft.Azure.WebJobs.Script.Description.FunctionMetadata;
@@ -81,7 +82,8 @@ internal class GrpcWorkerChannel : IRpcWorkerChannel, IDisposable
         private bool _isSharedMemoryDataTransferEnabled;
         private bool? _cancelCapabilityEnabled;
         private bool _isWorkerApplicationInsightsLoggingEnabled;
-
+        private IHttpProxyService _httpProxyService;
+        private Uri _httpProxyEndpoint;
         private System.Timers.Timer _timer;
 
         internal GrpcWorkerChannel(
@@ -96,7 +98,8 @@ internal GrpcWorkerChannel(
             IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions,
             ISharedMemoryManager sharedMemoryManager,
             IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions,
-            IOptions<FunctionsHostingConfigOptions> hostingConfigOptions)
+            IOptions<FunctionsHostingConfigOptions> hostingConfigOptions,
+            IHttpProxyService httpProxyService)
         {
             _workerId = workerId;
             _eventManager = eventManager;
@@ -112,6 +115,7 @@ internal GrpcWorkerChannel(
             _processInbound = state => ProcessItem((InboundGrpcEvent)state);
             _hostingConfigOptions = hostingConfigOptions;
 
+            _httpProxyService = httpProxyService;
             _workerCapabilities = new GrpcCapabilities(_workerChannelLogger);
 
             if (!_eventManager.TryGetGrpcChannels(workerId, out var inbound, out var outbound))
@@ -133,6 +137,8 @@ internal GrpcWorkerChannel(
             _state = RpcWorkerChannelState.Default;
         }
 
+        private bool IsHttpProxyingWorker => _httpProxyEndpoint is not null;
+
         public string Id => _workerId;
 
         public IDictionary<string, BufferBlock<ScriptInvocationContext>> FunctionInputBuffers => _functionInputBuffers;
@@ -420,6 +426,20 @@ internal void WorkerInitResponse(GrpcEvent initEvent)
                 _isWorkerApplicationInsightsLoggingEnabled = true;
             }
 
+            // If http proxying is enabled, we need to get the proxying endpoint of this worker
+            var httpUri = _workerCapabilities.GetCapabilityState(RpcWorkerConstants.HttpUri);
+            if (!string.IsNullOrEmpty(httpUri) && FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableHttpProxying))
+            {
+                try
+                {
+                    _httpProxyEndpoint = new Uri(httpUri);
+                }
+                catch (Exception ex)
+                {
+                    HandleWorkerInitError(ex);
+                }
+            }
+
             _workerInitTask.TrySetResult(true);
         }
 
@@ -738,6 +758,13 @@ await SendStreamingMessageAsync(new StreamingMessage
                 {
                     context.CancellationToken.Register(() => SendInvocationCancel(invocationRequest.InvocationId));
                 }
+
+                if (IsHttpProxyingWorker && FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableHttpProxying) && context.FunctionMetadata.IsHttpTriggerFunction())
+                {
+                    var aspNetTask = _httpProxyService.ForwardAsync(context, _httpProxyEndpoint).AsTask();
+
+                    context.Properties.Add(ScriptConstants.HttpProxyTask, aspNetTask);
+                }
             }
             catch (Exception invokeEx)
             {
@@ -902,6 +929,20 @@ internal async Task InvokeResponse(InvocationResponse invokeResponse)
             {
                 if (invokeResponse.Result.IsInvocationSuccess(context.ResultSource, capabilityEnabled))
                 {
+                    if (FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableHttpProxying) && IsHttpProxyingWorker)
+                    {
+                        if (context.Properties.TryGetValue(ScriptConstants.HttpProxyTask, out Task<ForwarderError> httpProxyTask))
+                        {
+                            ForwarderError httpProxyTaskResult = await httpProxyTask;
+
+                            if (httpProxyTaskResult is not ForwarderError.None)
+                            {
+                                // TODO: Understand scenarios where function invocation succeeds but there is an error proxying
+                                // need to investigate different ForwarderErrors and consider how they will be relayed through other services and to users
+                            }
+                        }
+                    }
+
                     _metricsLogger.LogEvent(string.Format(MetricEventNames.WorkerInvokeSucceeded, Id));
 
                     try
diff --git a/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannelFactory.cs b/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannelFactory.cs
@@ -26,10 +26,11 @@ public class GrpcWorkerChannelFactory : IRpcWorkerChannelFactory
         private readonly ISharedMemoryManager _sharedMemoryManager = null;
         private readonly IOptions<WorkerConcurrencyOptions> _workerConcurrencyOptions;
         private readonly IOptions<FunctionsHostingConfigOptions> _hostingConfigOptions;
+        private readonly IHttpProxyService _httpProxyService;
 
         public GrpcWorkerChannelFactory(IScriptEventManager eventManager, IEnvironment environment, ILoggerFactory loggerFactory,
             IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, IRpcWorkerProcessFactory rpcWorkerProcessManager, ISharedMemoryManager sharedMemoryManager,
-            IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions)
+            IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions, IHttpProxyService httpProxyService)
         {
             _eventManager = eventManager;
             _loggerFactory = loggerFactory;
@@ -39,6 +40,7 @@ public GrpcWorkerChannelFactory(IScriptEventManager eventManager, IEnvironment e
             _sharedMemoryManager = sharedMemoryManager;
             _workerConcurrencyOptions = workerConcurrencyOptions;
             _hostingConfigOptions = hostingConfigOptions;
+            _httpProxyService = httpProxyService;
         }
 
         public IRpcWorkerChannel Create(string scriptRootPath, string runtime, IMetricsLogger metricsLogger, int attemptCount, IEnumerable<RpcWorkerConfig> workerConfigs)
@@ -54,12 +56,12 @@ public IRpcWorkerChannel Create(string scriptRootPath, string runtime, IMetricsL
             IWorkerProcess rpcWorkerProcess = _rpcWorkerProcessFactory.Create(workerId, runtime, scriptRootPath, languageWorkerConfig);
 
             return CreateInternal(workerId, _eventManager, languageWorkerConfig, rpcWorkerProcess, workerLogger, metricsLogger, attemptCount,
-                _environment, _applicationHostOptions, _sharedMemoryManager, _workerConcurrencyOptions, _hostingConfigOptions);
+                _environment, _applicationHostOptions, _sharedMemoryManager, _workerConcurrencyOptions, _hostingConfigOptions, _httpProxyService);
         }
 
         internal virtual IRpcWorkerChannel CreateInternal(string workerId, IScriptEventManager eventManager, RpcWorkerConfig languageWorkerConfig, IWorkerProcess rpcWorkerProcess,
             ILogger workerLogger, IMetricsLogger metricsLogger, int attemptCount, IEnvironment environment, IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions,
-            ISharedMemoryManager sharedMemoryManager, IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions)
+            ISharedMemoryManager sharedMemoryManager, IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions, IHttpProxyService httpProxyService)
         {
             return new GrpcWorkerChannel(
                          workerId,
@@ -73,7 +75,8 @@ internal virtual IRpcWorkerChannel CreateInternal(string workerId, IScriptEventM
                          applicationHostOptions,
                          sharedMemoryManager,
                          workerConcurrencyOptions,
-                         hostingConfigOptions);
+                         hostingConfigOptions,
+                         httpProxyService);
         }
     }
 }
diff --git a/src/WebJobs.Script.Grpc/GrpcServiceCollectionsExtensions.cs b/src/WebJobs.Script.Grpc/GrpcServiceCollectionsExtensions.cs
@@ -16,6 +16,9 @@ public static IServiceCollection AddScriptGrpc(this IServiceCollection services)
 
             services.AddSingleton<IRpcServer, AspNetCoreGrpcServer>();
 
+            services.AddHttpForwarder();
+            services.AddSingleton<IHttpProxyService, DefaultHttpProxyService>();
+
             return services;
         }
     }
diff --git a/src/WebJobs.Script.Grpc/Server/DefaultHttpProxyService.cs b/src/WebJobs.Script.Grpc/Server/DefaultHttpProxyService.cs
@@ -0,0 +1,66 @@
+﻿// 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.Http;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Azure.WebJobs.Script.Description;
+using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
+using Yarp.ReverseProxy.Forwarder;
+
+namespace Microsoft.Azure.WebJobs.Script.Grpc
+{
+    internal class DefaultHttpProxyService : IHttpProxyService, IDisposable
+    {
+        private readonly SocketsHttpHandler _handler;
+        private readonly IHttpForwarder _httpForwarder;
+        private readonly HttpMessageInvoker _messageInvoker;
+        private readonly ForwarderRequestConfig _forwarderRequestConfig;
+
+        public DefaultHttpProxyService(IHttpForwarder httpForwarder)
+        {
+            _httpForwarder = httpForwarder ?? throw new ArgumentNullException(nameof(httpForwarder));
+
+            _handler = new SocketsHttpHandler();
+            _messageInvoker = new HttpMessageInvoker(_handler);
+            _forwarderRequestConfig = new ForwarderRequestConfig();
+        }
+
+        public void Dispose()
+        {
+            _handler?.Dispose();
+            _messageInvoker?.Dispose();
+        }
+
+        public ValueTask<ForwarderError> ForwardAsync(ScriptInvocationContext context, Uri httpUri)
+        {
+            ArgumentNullException.ThrowIfNull(context);
+
+            if (context.Inputs is null || context.Inputs?.Count() == 0)
+            {
+                throw new InvalidOperationException($"The function {context.FunctionMetadata.Name} can not be evaluated since it has no inputs.");
+            }
+
+            HttpRequest httpRequest = context.Inputs.FirstOrDefault(i => i.Val is HttpRequest).Val as HttpRequest;
+
+            if (httpRequest is null)
+            {
+                throw new InvalidOperationException($"Cannot proxy the HttpTrigger function {context.FunctionMetadata.Name} without an input of type {nameof(HttpRequest)}.");
+            }
+
+            HttpContext httpContext = httpRequest.HttpContext;
+
+            httpContext.Items.Add(ScriptConstants.HttpProxyingEnabled, bool.TrueString);
+
+            // add invocation id as correlation id
+            httpRequest.Headers.TryAdd(ScriptConstants.HttpProxyCorrelationHeader, context.ExecutionContext.InvocationId.ToString());
+
+            var aspNetTask = _httpForwarder.SendAsync(httpContext, httpUri.ToString(), _messageInvoker, _forwarderRequestConfig);
+
+            return aspNetTask;
+        }
+    }
+}
diff --git a/src/WebJobs.Script.Grpc/Server/IHttpProxyService.cs b/src/WebJobs.Script.Grpc/Server/IHttpProxyService.cs
@@ -0,0 +1,15 @@
+﻿// 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.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Script.Description;
+using Yarp.ReverseProxy.Forwarder;
+
+namespace Microsoft.Azure.WebJobs.Script.Grpc
+{
+    public interface IHttpProxyService
+    {
+        ValueTask<ForwarderError> ForwardAsync(ScriptInvocationContext context, Uri httpUri);
+    }
+}
diff --git a/src/WebJobs.Script.Grpc/WebJobs.Script.Grpc.csproj b/src/WebJobs.Script.Grpc/WebJobs.Script.Grpc.csproj
@@ -31,6 +31,7 @@
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="System.Threading.Channels" Version="6.0.0" />
+    <PackageReference Include="Yarp.ReverseProxy" Version="2.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/WebJobs.Script.WebHost/Middleware/FunctionInvocationMiddleware.cs b/src/WebJobs.Script.WebHost/Middleware/FunctionInvocationMiddleware.cs
@@ -33,6 +33,7 @@ public FunctionInvocationMiddleware(RequestDelegate next)
             _next = next;
         }
 
+        // TODO: Confirm that only HttpTrigger requests would flow through here
         public async Task Invoke(HttpContext context)
         {
             if (_next != null)
@@ -52,6 +53,15 @@ public async Task Invoke(HttpContext context)
 
                 int nestedProxiesCount = GetNestedProxiesCount(context, functionExecution);
                 IActionResult result = await GetResultAsync(context, functionExecution);
+
+                if (context.Items.TryGetValue(ScriptConstants.HttpProxyingEnabled, out var value))
+                {
+                    if (value?.ToString() == bool.TrueString)
+                    {
+                        return;
+                    }
+                }
+
                 if (nestedProxiesCount > 0)
                 {
                     // if Proxy, the rest of the pipeline will be processed by Proxies in
diff --git a/src/WebJobs.Script/Description/Workers/ScriptInvocationContext.cs b/src/WebJobs.Script/Description/Workers/ScriptInvocationContext.cs
@@ -31,5 +31,7 @@ public class ScriptInvocationContext
         public ILogger Logger { get; set; }
 
         public System.Threading.ExecutionContext AsyncExecutionContext { get; set; }
+
+        public Dictionary<string, object> Properties { get; set; } = new Dictionary<string, object>();
     }
 }
diff --git a/src/WebJobs.Script/Extensions/FunctionMetadataExtensions.cs b/src/WebJobs.Script/Extensions/FunctionMetadataExtensions.cs
@@ -14,6 +14,8 @@ public static class FunctionMetadataExtensions
         private const string IsDisabledKey = "IsDisabled";
         private const string IsCodelessKey = "IsCodeless";
         private const string FunctionIdKey = "FunctionId";
+        private const string HttpTriggerKey = "HttpTrigger";
+        private const string HttpOutputKey = "Http";
 
         public static bool IsHttpInAndOutFunction(this FunctionMetadata metadata)
         {
@@ -24,15 +26,20 @@ public static bool IsHttpInAndOutFunction(this FunctionMetadata metadata)
 
             BindingMetadata inputBindingMetadata = metadata.InputBindings.ElementAt(0);
             BindingMetadata outputBindingMetadata = metadata.OutputBindings.ElementAt(0);
-            if (string.Equals("httptrigger", inputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase) &&
-                string.Equals("http", outputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase))
+            if (string.Equals(HttpTriggerKey, inputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase) &&
+                string.Equals(HttpOutputKey, outputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase))
             {
                 return true;
             }
 
             return false;
         }
 
+        public static bool IsHttpTriggerFunction(this FunctionMetadata metadata)
+        {
+            return metadata.InputBindings.Any(b => string.Equals(HttpTriggerKey, b.Type, StringComparison.OrdinalIgnoreCase));
+        }
+
         public static string GetFunctionId(this FunctionMetadata metadata)
         {
             if (!metadata.Properties.TryGetValue(FunctionIdKey, out object idObj)
diff --git a/src/WebJobs.Script/ScriptConstants.cs b/src/WebJobs.Script/ScriptConstants.cs
@@ -125,6 +125,7 @@ public static class ScriptConstants
         public const string FeatureFlagEnableWorkerIndexing = "EnableWorkerIndexing";
         public const string FeatureFlagEnableDebugTracing = "EnableDebugTracing";
         public const string FeatureFlagEnableProxies = "EnableProxies";
+        public const string FeatureFlagEnableHttpProxying = "EnableHttpProxying";
         public const string HostingConfigDisableLinuxAppServiceDetailedExecutionEvents = "DisableLinuxExecutionDetails";
         public const string HostingConfigDisableLinuxAppServiceExecutionEventLogBackoff = "DisableLinuxLogBackoff";
 
@@ -225,5 +226,10 @@ public static class ScriptConstants
         public static readonly string LiveLogsSessionAIKey = "#AzFuncLiveLogsSessionId";
 
         public static readonly string FunctionsHostingConfigSectionName = "FunctionsHostingConfig";
+
+        // HTTP Proxying constants
+        public static readonly string HttpProxyingEnabled = "HttpProxyingEnabled";
+        public static readonly string HttpProxyCorrelationHeader = "x-ms-invocation-id";
+        public static readonly string HttpProxyTask = "HttpProxyTask";
     }
 }
diff --git a/src/WebJobs.Script/Workers/Rpc/RpcWorkerConstants.cs b/src/WebJobs.Script/Workers/Rpc/RpcWorkerConstants.cs
@@ -54,6 +54,7 @@ public static class RpcWorkerConstants
         public const string HandlesInvocationCancelMessage = "HandlesInvocationCancelMessage";
         public const string HandlesWorkerWarmupMessage = "HandlesWorkerWarmupMessage";
         public const string WorkerApplicationInsightsLoggingEnabled = nameof(WorkerApplicationInsightsLoggingEnabled);
+        public const string HttpUri = "HttpUri";
 
         /// <summary>
         /// Indicates whether empty entries in the trigger message should be included when sending RpcInvocation data to OOP workers.
diff --git a/test/WebJobs.Script.Tests.Integration/ApplicationInsights/ApplicationInsightsTestFixture.cs b/test/WebJobs.Script.Tests.Integration/ApplicationInsights/ApplicationInsightsTestFixture.cs
diff --git a/test/WebJobs.Script.Tests/Microsoft.Azure.WebJobs.Script.WebHost.deps.json b/test/WebJobs.Script.Tests/Microsoft.Azure.WebJobs.Script.WebHost.deps.json
diff --git a/test/WebJobs.Script.Tests/Workers/Rpc/GrpcWorkerChannelTests.cs b/test/WebJobs.Script.Tests/Workers/Rpc/GrpcWorkerChannelTests.cs

Original file line number	Diff line number	Diff line change
`@@ -26,10 +26,11 @@ public class GrpcWorkerChannelFactory : IRpcWorkerChannelFactory`
`26`	`26`	`private readonly ISharedMemoryManager _sharedMemoryManager = null;`
`27`	`27`	`private readonly IOptions<WorkerConcurrencyOptions> _workerConcurrencyOptions;`
`28`	`28`	`private readonly IOptions<FunctionsHostingConfigOptions> _hostingConfigOptions;`
	`29`	`+ private readonly IHttpProxyService _httpProxyService;`
`29`	`30`
`30`	`31`	`public GrpcWorkerChannelFactory(IScriptEventManager eventManager, IEnvironment environment, ILoggerFactory loggerFactory,`
`31`	`32`	`IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, IRpcWorkerProcessFactory rpcWorkerProcessManager, ISharedMemoryManager sharedMemoryManager,`
`32`		`- IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions)`
	`33`	`+ IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions, IHttpProxyService httpProxyService)`
`33`	`34`	`{`
`34`	`35`	`_eventManager = eventManager;`
`35`	`36`	`_loggerFactory = loggerFactory;`
`@@ -39,6 +40,7 @@ public GrpcWorkerChannelFactory(IScriptEventManager eventManager, IEnvironment e`
`39`	`40`	`_sharedMemoryManager = sharedMemoryManager;`
`40`	`41`	`_workerConcurrencyOptions = workerConcurrencyOptions;`
`41`	`42`	`_hostingConfigOptions = hostingConfigOptions;`
	`43`	`+ _httpProxyService = httpProxyService;`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`public IRpcWorkerChannel Create(string scriptRootPath, string runtime, IMetricsLogger metricsLogger, int attemptCount, IEnumerable<RpcWorkerConfig> workerConfigs)`
`@@ -54,12 +56,12 @@ public IRpcWorkerChannel Create(string scriptRootPath, string runtime, IMetricsL`
`54`	`56`	`IWorkerProcess rpcWorkerProcess = _rpcWorkerProcessFactory.Create(workerId, runtime, scriptRootPath, languageWorkerConfig);`
`55`	`57`
`56`	`58`	`return CreateInternal(workerId, _eventManager, languageWorkerConfig, rpcWorkerProcess, workerLogger, metricsLogger, attemptCount,`
`57`		`- _environment, _applicationHostOptions, _sharedMemoryManager, _workerConcurrencyOptions, _hostingConfigOptions);`
	`59`	`+ _environment, _applicationHostOptions, _sharedMemoryManager, _workerConcurrencyOptions, _hostingConfigOptions, _httpProxyService);`
`58`	`60`	`}`
`59`	`61`
`60`	`62`	`internal virtual IRpcWorkerChannel CreateInternal(string workerId, IScriptEventManager eventManager, RpcWorkerConfig languageWorkerConfig, IWorkerProcess rpcWorkerProcess,`
`61`	`63`	`ILogger workerLogger, IMetricsLogger metricsLogger, int attemptCount, IEnvironment environment, IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions,`
`62`		`- ISharedMemoryManager sharedMemoryManager, IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions)`
	`64`	`+ ISharedMemoryManager sharedMemoryManager, IOptions<WorkerConcurrencyOptions> workerConcurrencyOptions, IOptions<FunctionsHostingConfigOptions> hostingConfigOptions, IHttpProxyService httpProxyService)`
`63`	`65`	`{`
`64`	`66`	`return new GrpcWorkerChannel(`
`65`	`67`	`workerId,`
`@@ -73,7 +75,8 @@ internal virtual IRpcWorkerChannel CreateInternal(string workerId, IScriptEventM`
`73`	`75`	`applicationHostOptions,`
`74`	`76`	`sharedMemoryManager,`
`75`	`77`	`workerConcurrencyOptions,`
`76`		`- hostingConfigOptions);`
	`78`	`+ hostingConfigOptions,`
	`79`	`+ httpProxyService);`
`77`	`80`	`}`
`78`	`81`	`}`
`79`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,9 @@ public static IServiceCollection AddScriptGrpc(this IServiceCollection services)`
`16`	`16`
`17`	`17`	`services.AddSingleton<IRpcServer, AspNetCoreGrpcServer>();`
`18`	`18`
	`19`	`+ services.AddHttpForwarder();`
	`20`	`+ services.AddSingleton<IHttpProxyService, DefaultHttpProxyService>();`
	`21`	`+`
`19`	`22`	`return services;`
`20`	`23`	`}`
`21`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,5 +31,7 @@ public class ScriptInvocationContext`
`31`	`31`	`public ILogger Logger { get; set; }`
`32`	`32`
`33`	`33`	`public System.Threading.ExecutionContext AsyncExecutionContext { get; set; }`
	`34`	`+`
	`35`	`+ public Dictionary<string, object> Properties { get; set; } = new Dictionary<string, object>();`
`34`	`36`	`}`
`35`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@ public static class FunctionMetadataExtensions`
`14`	`14`	`private const string IsDisabledKey = "IsDisabled";`
`15`	`15`	`private const string IsCodelessKey = "IsCodeless";`
`16`	`16`	`private const string FunctionIdKey = "FunctionId";`
	`17`	`+ private const string HttpTriggerKey = "HttpTrigger";`
	`18`	`+ private const string HttpOutputKey = "Http";`
`17`	`19`
`18`	`20`	`public static bool IsHttpInAndOutFunction(this FunctionMetadata metadata)`
`19`	`21`	`{`
`@@ -24,15 +26,20 @@ public static bool IsHttpInAndOutFunction(this FunctionMetadata metadata)`
`24`	`26`
`25`	`27`	`BindingMetadata inputBindingMetadata = metadata.InputBindings.ElementAt(0);`
`26`	`28`	`BindingMetadata outputBindingMetadata = metadata.OutputBindings.ElementAt(0);`
`27`		`- if (string.Equals("httptrigger", inputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase) &&`
`28`		`- string.Equals("http", outputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase))`
	`29`	`+ if (string.Equals(HttpTriggerKey, inputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase) &&`
	`30`	`+ string.Equals(HttpOutputKey, outputBindingMetadata.Type, StringComparison.OrdinalIgnoreCase))`
`29`	`31`	`{`
`30`	`32`	`return true;`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`return false;`
`34`	`36`	`}`
`35`	`37`
	`38`	`+ public static bool IsHttpTriggerFunction(this FunctionMetadata metadata)`
	`39`	`+ {`
	`40`	`+ return metadata.InputBindings.Any(b => string.Equals(HttpTriggerKey, b.Type, StringComparison.OrdinalIgnoreCase));`
	`41`	`+ }`
	`42`	`+`
`36`	`43`	`public static string GetFunctionId(this FunctionMetadata metadata)`
`37`	`44`	`{`
`38`	`45`	`if (!metadata.Properties.TryGetValue(FunctionIdKey, out object idObj)`