Shutdown placeholder language worker channels if not needed (#3867)

pragnagopa · web-flow · commit e265feb9d810 · 2018-12-08T08:39:38.000-08:00
diff --git a/src/WebJobs.Script/Host/ScriptHost.cs b/src/WebJobs.Script/Host/ScriptHost.cs
@@ -273,11 +273,10 @@ public async Task InitializeAsync()
 
                 // Generate Functions
                 IEnumerable<FunctionMetadata> functions = GetFunctionsMetadata();
-                _workerRuntime = _workerRuntime ?? Utility.GetWorkerRuntime(functions);
-                if (Utility.ShouldInitializeFunctionDispatcher(_environment, functions, _workerRuntime))
-                {
-                    _functionDispatcher.CreateWorkerState(_workerRuntime);
-                }
+
+                // Initialize language worker function dispatcher
+                _functionDispatcher.Initialize(_workerRuntime, functions);
+
                 var directTypes = GetDirectTypes(functions);
                 await InitializeFunctionDescriptorsAsync(functions);
                 GenerateFunctions(directTypes);
diff --git a/src/WebJobs.Script/Rpc/FunctionRegistration/FunctionDispatcher.cs b/src/WebJobs.Script/Rpc/FunctionRegistration/FunctionDispatcher.cs
@@ -12,6 +12,7 @@
 using Microsoft.Azure.WebJobs.Script.Eventing;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+
 using FunctionMetadata = Microsoft.Azure.WebJobs.Script.Description.FunctionMetadata;
 
 namespace Microsoft.Azure.WebJobs.Script.Rpc
@@ -90,27 +91,38 @@ public LanguageWorkerState CreateWorkerStateWithExistingChannel(string language,
             return state;
         }
 
-        public LanguageWorkerState CreateWorkerState(string language)
+        public void Initialize(string workerRuntime, IEnumerable<FunctionMetadata> functions)
         {
-            ILanguageWorkerChannel initializedChannel = _languageWorkerChannelManager.GetChannel(language);
-            if (initializedChannel != null)
-            {
-                return CreateWorkerStateWithExistingChannel(language, initializedChannel);
-            }
-            else
+            _languageWorkerChannelManager.ShutdownStandbyChannels(functions);
+
+            workerRuntime = workerRuntime ?? Utility.GetWorkerRuntime(functions);
+
+            if (Utility.IsSupportedRuntime(workerRuntime, _workerConfigs))
             {
-                var state = new LanguageWorkerState();
-                WorkerConfig config = _workerConfigs.Where(c => c.Language.Equals(language, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-                state.Channel = ChannelFactory(language, state.Functions, 0);
-                _workerStates[language] = state;
-                return state;
+                ILanguageWorkerChannel initializedChannel = _languageWorkerChannelManager.GetChannel(workerRuntime);
+                if (initializedChannel != null)
+                {
+                    CreateWorkerStateWithExistingChannel(workerRuntime, initializedChannel);
+                }
+                else
+                {
+                    CreateWorkerState(workerRuntime);
+                }
             }
         }
 
+        private LanguageWorkerState CreateWorkerState(string runtime)
+        {
+            var state = new LanguageWorkerState();
+            WorkerConfig config = _workerConfigs.Where(c => c.Language.Equals(runtime, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+            state.Channel = ChannelFactory(runtime, state.Functions, 0);
+            _workerStates[runtime] = state;
+            return state;
+        }
+
         public void Register(FunctionRegistrationContext context)
         {
-            var state = _workerStates.GetOrAdd(context.Metadata.Language, CreateWorkerState);
-            state.Functions.OnNext(context);
+            _workerStates[context.Metadata.Language].Functions.OnNext(context);
         }
 
         public void WorkerError(WorkerErrorEvent workerError)
diff --git a/src/WebJobs.Script/Rpc/FunctionRegistration/IFunctionDispatcher.cs b/src/WebJobs.Script/Rpc/FunctionRegistration/IFunctionDispatcher.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Description;
 
 namespace Microsoft.Azure.WebJobs.Script.Rpc
@@ -17,6 +18,6 @@ public interface IFunctionDispatcher : IDisposable
         // Registers a supported function with the dispatcher
         void Register(FunctionRegistrationContext context);
 
-        LanguageWorkerState CreateWorkerState(string language);
+        void Initialize(string runtime, IEnumerable<FunctionMetadata> functions);
     }
 }
diff --git a/src/WebJobs.Script/Rpc/ILanguageWorkerChannelManager.cs b/src/WebJobs.Script/Rpc/ILanguageWorkerChannelManager.cs
@@ -4,8 +4,11 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Host;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
 
+using FunctionMetadata = Microsoft.Azure.WebJobs.Script.Description.FunctionMetadata;
+
 namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
     public interface ILanguageWorkerChannelManager
@@ -18,7 +21,9 @@ public interface ILanguageWorkerChannelManager
 
         bool ShutdownChannelIfExists(string language);
 
-        Task ShutdownChannelsAsync();
+        void ShutdownStandbyChannels(IEnumerable<FunctionMetadata> functions);
+
+        void ShutdownChannels();
 
         ILanguageWorkerChannel CreateLanguageWorkerChannel(string workerId, string scriptRootPath, string language, IObservable<FunctionRegistrationContext> functionRegistrations, IMetricsLogger metricsLogger, int attemptCount);
     }
diff --git a/src/WebJobs.Script/Rpc/LanguageWorkerChannelManager.cs b/src/WebJobs.Script/Rpc/LanguageWorkerChannelManager.cs
@@ -12,6 +12,8 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
+using FunctionMetadata = Microsoft.Azure.WebJobs.Script.Description.FunctionMetadata;
+
 namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
     public class LanguageWorkerChannelManager : ILanguageWorkerChannelManager
@@ -150,8 +152,7 @@ public bool ShutdownChannelIfExists(string language)
 
         internal void ScheduleShutdownStandbyChannels()
         {
-            _workerRuntime = _environment.GetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeSettingName);
-            _logger.LogInformation("{FunctionWorkerRuntimeSettingName} is set to: {workerRuntime}. Will shutdown other standby channels", LanguageWorkerConstants.FunctionWorkerRuntimeSettingName, _workerRuntime);
+            _workerRuntime = _workerRuntime ?? _environment.GetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeSettingName);
             if (!string.IsNullOrEmpty(_workerRuntime))
             {
                 var standbyChannels = _workerChannels.Where(ch => ch.Key.ToLower() != _workerRuntime.ToLower()).ToList();
@@ -164,15 +165,33 @@ internal void ScheduleShutdownStandbyChannels()
             }
         }
 
-        public Task ShutdownChannelsAsync()
+        public void ShutdownStandbyChannels(IEnumerable<FunctionMetadata> functions)
+        {
+            if (_environment.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsitePlaceholderMode) == "1")
+            {
+                return;
+            }
+            _workerRuntime = _environment.GetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeSettingName) ?? Utility.GetWorkerRuntime(functions);
+            _logger.LogInformation("WorkerRuntime: {workerRuntime}. Will shutdown other standby channels", _workerRuntime);
+            if (string.IsNullOrEmpty(_workerRuntime))
+            {
+                ShutdownChannels();
+                return;
+            }
+            else
+            {
+                ScheduleShutdownStandbyChannels();
+            }
+        }
+
+        public void ShutdownChannels()
         {
-            foreach (string lang in _workerChannels.Keys)
+            foreach (string runtime in _workerChannels.Keys)
             {
-                _logger.LogDebug("Language worker channel for runtime:{language} disposed", lang);
-                _workerChannels[lang]?.Dispose();
+                _logger.LogInformation("Shutting down language worker channel for runtime:{runtime}", runtime);
+                _workerChannels[runtime]?.Dispose();
             }
             _workerChannels.Clear();
-            return Task.CompletedTask;
         }
 
         private void AddOrUpdateWorkerChannels(RpcChannelReadyEvent rpcChannelReadyEvent)
diff --git a/src/WebJobs.Script/Rpc/RpcInitializationService.cs b/src/WebJobs.Script/Rpc/RpcInitializationService.cs
@@ -49,7 +49,7 @@ public async Task StartAsync(CancellationToken cancellationToken)
         public async Task StopAsync(CancellationToken cancellationToken)
         {
             _logger.LogInformation("Shuttingdown Rpc Channels Manager");
-            await _languageWorkerChannelManager.ShutdownChannelsAsync();
+            _languageWorkerChannelManager.ShutdownChannels();
             await _rpcServer.KillAsync();
         }
 
diff --git a/src/WebJobs.Script/Utility.cs b/src/WebJobs.Script/Utility.cs
@@ -439,22 +439,22 @@ internal static bool TryReadFunctionConfig(string scriptDir, out string json, IF
             return true;
         }
 
-        internal static void VerifyFunctionsMatchSpecifiedLanguage(IEnumerable<FunctionMetadata> functions, string currentRuntimeLanguage)
+        internal static void VerifyFunctionsMatchSpecifiedLanguage(IEnumerable<FunctionMetadata> functions, string workerRuntime)
         {
-            if (!IsSingleLanguage(functions, currentRuntimeLanguage))
+            if (!IsSingleLanguage(functions, workerRuntime))
             {
-                if (string.IsNullOrEmpty(currentRuntimeLanguage))
+                if (string.IsNullOrEmpty(workerRuntime))
                 {
                     throw new HostInitializationException($"Found functions with more than one language. Select a language for your function app by specifying {LanguageWorkerConstants.FunctionWorkerRuntimeSettingName} AppSetting");
                 }
                 else
                 {
-                    throw new HostInitializationException($"Did not find functions with language [{currentRuntimeLanguage}].");
+                    throw new HostInitializationException($"Did not find functions with language [{workerRuntime}].");
                 }
             }
         }
 
-        internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, string currentRuntimeLanguage)
+        internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, string workerRuntime)
         {
             if (functions == null)
             {
@@ -465,54 +465,36 @@ internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, s
             {
                 return true;
             }
-            if (string.IsNullOrEmpty(currentRuntimeLanguage))
+            if (string.IsNullOrEmpty(workerRuntime))
             {
                 return functionsListWithoutProxies.Select(f => f.Language).Distinct().Count() <= 1;
             }
-            return ContainsFunctionWithWorkerRuntime(functionsListWithoutProxies, currentRuntimeLanguage);
-        }
-
-        internal static bool ShouldInitializeFunctionDispatcher(IEnvironment environment, IEnumerable<FunctionMetadata> functions, string workerRuntime)
-        {
-            if (environment.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsitePlaceholderMode) == "1")
-            {
-                return false;
-            }
-            if (!string.IsNullOrEmpty(workerRuntime) && workerRuntime.Equals(LanguageWorkerConstants.DotNetLanguageWorkerName, StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-            var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);
-            if (!string.IsNullOrEmpty(workerRuntime) && ContainsFunctionWithWorkerRuntime(functionsListWithoutProxies, workerRuntime))
-            {
-                return true;
-            }
-            return ContainsNonDotNetFunctions(functionsListWithoutProxies);
+            return ContainsFunctionWithWorkerRuntime(functionsListWithoutProxies, workerRuntime);
         }
 
         internal static string GetWorkerRuntime(IEnumerable<FunctionMetadata> functions)
         {
-            var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);
-            string functionLanguage = functionsListWithoutProxies.FirstOrDefault()?.Language;
-            if (IsDotNetLanguageFunction(functionLanguage))
+            if (IsSingleLanguage(functions, null))
             {
-                return LanguageWorkerConstants.DotNetLanguageWorkerName;
+                var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);
+                string functionLanguage = functionsListWithoutProxies.FirstOrDefault()?.Language;
+                if (IsDotNetLanguageFunction(functionLanguage))
+                {
+                    return LanguageWorkerConstants.DotNetLanguageWorkerName;
+                }
+                return functionLanguage;
             }
-            return functionLanguage;
+            return null;
         }
 
-        private static bool ContainsNonDotNetFunctions(IEnumerable<FunctionMetadata> functions)
+        public static bool IsDotNetLanguageFunction(string functionLanguage)
         {
-            if (functions != null && functions.Any())
-            {
-                return functions.Any(f => !dotNetLanguages.Contains(f.Language, StringComparer.OrdinalIgnoreCase));
-            }
-            return false;
+            return dotNetLanguages.Any(lang => string.Equals(lang, functionLanguage, StringComparison.OrdinalIgnoreCase));
         }
 
-        public static bool IsDotNetLanguageFunction(string functionLanguage)
+        public static bool IsSupportedRuntime(string workerRuntime, IEnumerable<WorkerConfig> workerConfigs)
         {
-            return dotNetLanguages.Any(lang => string.Equals(lang, functionLanguage, StringComparison.OrdinalIgnoreCase));
+            return workerConfigs.Any(config => string.Equals(config.Language, workerRuntime, StringComparison.OrdinalIgnoreCase));
         }
 
         private static bool ContainsFunctionWithWorkerRuntime(IEnumerable<FunctionMetadata> functions, string workerRuntime)
diff --git a/test/WebJobs.Script.Tests.Integration/Rpc/LanguageWorkerChannelManagerEndToEndTests.cs b/test/WebJobs.Script.Tests.Integration/Rpc/LanguageWorkerChannelManagerEndToEndTests.cs
@@ -1,11 +1,8 @@
 ﻿// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Rpc;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Microsoft.Azure.WebJobs.Script.Tests
@@ -23,17 +20,23 @@ public LanguageWorkerChannelManagerEndToEndTests(TestFixture fixture)
         public TestFixture Fixture { get; set; }
 
         [Fact]
-        public void InitializeAsync_DoNotInitialize_JavaWorker()
+        public void InitializeAsync_DoNotInitialize_JavaWorker_ProxiesOnly()
         {
             var javaChannel = _languageWorkerChannelManager.GetChannel(LanguageWorkerConstants.JavaLanguageWorkerName);
             Assert.Null(javaChannel);
         }
 
         public class TestFixture : ScriptHostEndToEndTestFixture
         {
-            public TestFixture() : base(@"TestScripts\Node", "node", LanguageWorkerConstants.NodeLanguageWorkerName,
-                startHost: true, functions: new[] { "HttpTrigger" })
+            public TestFixture() : base(@"TestScripts\ProxiesOnly", "proxiesOnly", string.Empty,
+                startHost: true)
+            {
+            }
+
+            protected override Task CreateTestStorageEntities()
             {
+                // No need for this.
+                return Task.CompletedTask;
             }
         }
     }
diff --git a/test/WebJobs.Script.Tests.Integration/ScriptHostEndToEnd/NodeContentTests.cs b/test/WebJobs.Script.Tests.Integration/ScriptHostEndToEnd/NodeContentTests.cs
@@ -17,9 +17,12 @@ namespace Microsoft.Azure.WebJobs.Script.Tests
 {
     public class NodeContentTests : IClassFixture<NodeContentTests.TestFixture>
     {
+        private ILanguageWorkerChannelManager _languageWorkerChannelManager;
+
         public NodeContentTests(TestFixture fixture)
         {
             Fixture = fixture;
+            _languageWorkerChannelManager = (ILanguageWorkerChannelManager)fixture.Host.Services.GetService(typeof(ILanguageWorkerChannelManager));
         }
 
         public TestFixture Fixture { get; set; }
@@ -129,6 +132,13 @@ public async Task ObjectXml()
             Assert.Equal(str, content);
         }
 
+        [Fact]
+        public void InitializeAsync_WorkerRuntime_Node_DoNotInitialize_JavaWorker()
+        {
+            var javaChannel = _languageWorkerChannelManager.GetChannel(LanguageWorkerConstants.JavaLanguageWorkerName);
+            Assert.Null(javaChannel);
+        }
+
         // Get response with default ObjectResult content negotiation enabled 
         protected Task<string> ResponseWithConneg<Req>(Req content, string contentType, string expectedContentType = null)
         {
diff --git a/test/WebJobs.Script.Tests.Integration/TestScripts/ProxiesOnly/host.json b/test/WebJobs.Script.Tests.Integration/TestScripts/ProxiesOnly/host.json
@@ -0,0 +1,3 @@
+﻿{
+    "version": "2.0"
+}
diff --git a/test/WebJobs.Script.Tests.Integration/TestScripts/ProxiesOnly/proxies.json b/test/WebJobs.Script.Tests.Integration/TestScripts/ProxiesOnly/proxies.json
@@ -0,0 +1,11 @@
+﻿{
+  "$schema": "http://json.schemastore.org/proxies",
+  "proxies": {
+    "testproxy2": {
+      "matchCondition": {
+        "route": "/mthttp2"
+      },
+      "backendUri": "https://testapp.azurewebsites.net/api/HttpTriggerCSharp1?name=test"
+    }
+  }
+}
diff --git a/test/WebJobs.Script.Tests/Rpc/LanguageWorkerChannelManagerTests.cs b/test/WebJobs.Script.Tests/Rpc/LanguageWorkerChannelManagerTests.cs
diff --git a/test/WebJobs.Script.Tests/Rpc/RpcInitializationServiceTests.cs b/test/WebJobs.Script.Tests/Rpc/RpcInitializationServiceTests.cs
diff --git a/test/WebJobs.Script.Tests/ScriptHostTests.cs b/test/WebJobs.Script.Tests/ScriptHostTests.cs

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections.Generic;`
	`6`	`+using System.Threading.Tasks;`
`6`	`7`	`using Microsoft.Azure.WebJobs.Script.Description;`
`7`	`8`
`8`	`9`	`namespace Microsoft.Azure.WebJobs.Script.Rpc`
`@@ -17,6 +18,6 @@ public interface IFunctionDispatcher : IDisposable`
`17`	`18`	`// Registers a supported function with the dispatcher`
`18`	`19`	`void Register(FunctionRegistrationContext context);`
`19`	`20`
`20`		`- LanguageWorkerState CreateWorkerState(string language);`
	`21`	`+ void Initialize(string runtime, IEnumerable<FunctionMetadata> functions);`
`21`	`22`	`}`
`22`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public async Task StartAsync(CancellationToken cancellationToken)`
`49`	`49`	`public async Task StopAsync(CancellationToken cancellationToken)`
`50`	`50`	`{`
`51`	`51`	`_logger.LogInformation("Shuttingdown Rpc Channels Manager");`
`52`		`- await _languageWorkerChannelManager.ShutdownChannelsAsync();`
	`52`	`+ _languageWorkerChannelManager.ShutdownChannels();`
`53`	`53`	`await _rpcServer.KillAsync();`
`54`	`54`	`}`
`55`	`55`
Original file line number	Diff line number	Diff line change
`@@ -439,22 +439,22 @@ internal static bool TryReadFunctionConfig(string scriptDir, out string json, IF`
`439`	`439`	`return true;`
`440`	`440`	`}`
`441`	`441`
`442`		`- internal static void VerifyFunctionsMatchSpecifiedLanguage(IEnumerable<FunctionMetadata> functions, string currentRuntimeLanguage)`
	`442`	`+ internal static void VerifyFunctionsMatchSpecifiedLanguage(IEnumerable<FunctionMetadata> functions, string workerRuntime)`
`443`	`443`	`{`
`444`		`- if (!IsSingleLanguage(functions, currentRuntimeLanguage))`
	`444`	`+ if (!IsSingleLanguage(functions, workerRuntime))`
`445`	`445`	`{`
`446`		`- if (string.IsNullOrEmpty(currentRuntimeLanguage))`
	`446`	`+ if (string.IsNullOrEmpty(workerRuntime))`
`447`	`447`	`{`
`448`	`448`	`throw new HostInitializationException($"Found functions with more than one language. Select a language for your function app by specifying {LanguageWorkerConstants.FunctionWorkerRuntimeSettingName} AppSetting");`
`449`	`449`	`}`
`450`	`450`	`else`
`451`	`451`	`{`
`452`		`- throw new HostInitializationException($"Did not find functions with language [{currentRuntimeLanguage}].");`
	`452`	`+ throw new HostInitializationException($"Did not find functions with language [{workerRuntime}].");`
`453`	`453`	`}`
`454`	`454`	`}`
`455`	`455`	`}`
`456`	`456`
`457`		`- internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, string currentRuntimeLanguage)`
	`457`	`+ internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, string workerRuntime)`
`458`	`458`	`{`
`459`	`459`	`if (functions == null)`
`460`	`460`	`{`
`@@ -465,54 +465,36 @@ internal static bool IsSingleLanguage(IEnumerable<FunctionMetadata> functions, s`
`465`	`465`	`{`
`466`	`466`	`return true;`
`467`	`467`	`}`
`468`		`- if (string.IsNullOrEmpty(currentRuntimeLanguage))`
	`468`	`+ if (string.IsNullOrEmpty(workerRuntime))`
`469`	`469`	`{`
`470`	`470`	`return functionsListWithoutProxies.Select(f => f.Language).Distinct().Count() <= 1;`
`471`	`471`	`}`
`472`		`- return ContainsFunctionWithWorkerRuntime(functionsListWithoutProxies, currentRuntimeLanguage);`
`473`		`- }`
`474`		`-`
`475`		`- internal static bool ShouldInitializeFunctionDispatcher(IEnvironment environment, IEnumerable<FunctionMetadata> functions, string workerRuntime)`
`476`		`- {`
`477`		`- if (environment.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsitePlaceholderMode) == "1")`
`478`		`- {`
`479`		`- return false;`
`480`		`- }`
`481`		`- if (!string.IsNullOrEmpty(workerRuntime) && workerRuntime.Equals(LanguageWorkerConstants.DotNetLanguageWorkerName, StringComparison.OrdinalIgnoreCase))`
`482`		`- {`
`483`		`- return false;`
`484`		`- }`
`485`		`- var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);`
`486`		`- if (!string.IsNullOrEmpty(workerRuntime) && ContainsFunctionWithWorkerRuntime(functionsListWithoutProxies, workerRuntime))`
`487`		`- {`
`488`		`- return true;`
`489`		`- }`
`490`		`- return ContainsNonDotNetFunctions(functionsListWithoutProxies);`
	`472`	`+ return ContainsFunctionWithWorkerRuntime(functionsListWithoutProxies, workerRuntime);`
`491`	`473`	`}`
`492`	`474`
`493`	`475`	`internal static string GetWorkerRuntime(IEnumerable<FunctionMetadata> functions)`
`494`	`476`	`{`
`495`		`- var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);`
`496`		`- string functionLanguage = functionsListWithoutProxies.FirstOrDefault()?.Language;`
`497`		`- if (IsDotNetLanguageFunction(functionLanguage))`
	`477`	`+ if (IsSingleLanguage(functions, null))`
`498`	`478`	`{`
`499`		`- return LanguageWorkerConstants.DotNetLanguageWorkerName;`
	`479`	`+ var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);`
	`480`	`+ string functionLanguage = functionsListWithoutProxies.FirstOrDefault()?.Language;`
	`481`	`+ if (IsDotNetLanguageFunction(functionLanguage))`
	`482`	`+ {`
	`483`	`+ return LanguageWorkerConstants.DotNetLanguageWorkerName;`
	`484`	`+ }`
	`485`	`+ return functionLanguage;`
`500`	`486`	`}`
`501`		`- return functionLanguage;`
	`487`	`+ return null;`
`502`	`488`	`}`
`503`	`489`
`504`		`- private static bool ContainsNonDotNetFunctions(IEnumerable<FunctionMetadata> functions)`
	`490`	`+ public static bool IsDotNetLanguageFunction(string functionLanguage)`
`505`	`491`	`{`
`506`		`- if (functions != null && functions.Any())`
`507`		`- {`
`508`		`- return functions.Any(f => !dotNetLanguages.Contains(f.Language, StringComparer.OrdinalIgnoreCase));`
`509`		`- }`
`510`		`- return false;`
	`492`	`+ return dotNetLanguages.Any(lang => string.Equals(lang, functionLanguage, StringComparison.OrdinalIgnoreCase));`
`511`	`493`	`}`
`512`	`494`
`513`		`- public static bool IsDotNetLanguageFunction(string functionLanguage)`
	`495`	`+ public static bool IsSupportedRuntime(string workerRuntime, IEnumerable<WorkerConfig> workerConfigs)`
`514`	`496`	`{`
`515`		`- return dotNetLanguages.Any(lang => string.Equals(lang, functionLanguage, StringComparison.OrdinalIgnoreCase));`
	`497`	`+ return workerConfigs.Any(config => string.Equals(config.Language, workerRuntime, StringComparison.OrdinalIgnoreCase));`
`516`	`498`	`}`
`517`	`499`
`518`	`500`	`private static bool ContainsFunctionWithWorkerRuntime(IEnumerable<FunctionMetadata> functions, string workerRuntime)`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,8 @@`
`1`	`1`	`// Copyright (c) .NET Foundation. All rights reserved.`
`2`	`2`	`// Licensed under the MIT License. See License.txt in the project root for license information.`
`3`	`3`
`4`		`-using System.Collections.Generic;`
`5`		`-using System.Diagnostics;`
`6`		`-using System.Linq;`
`7`		`-using System.Threading.Tasks;`
`8`	`4`	`using Microsoft.Azure.WebJobs.Script.Rpc;`
	`5`	`+using System.Threading.Tasks;`
`9`	`6`	`using Xunit;`
`10`	`7`
`11`	`8`	`namespace Microsoft.Azure.WebJobs.Script.Tests`
`@@ -23,17 +20,23 @@ public LanguageWorkerChannelManagerEndToEndTests(TestFixture fixture)`
`23`	`20`	`public TestFixture Fixture { get; set; }`
`24`	`21`
`25`	`22`	`[Fact]`
`26`		`- public void InitializeAsync_DoNotInitialize_JavaWorker()`
	`23`	`+ public void InitializeAsync_DoNotInitialize_JavaWorker_ProxiesOnly()`
`27`	`24`	`{`
`28`	`25`	`var javaChannel = _languageWorkerChannelManager.GetChannel(LanguageWorkerConstants.JavaLanguageWorkerName);`
`29`	`26`	`Assert.Null(javaChannel);`
`30`	`27`	`}`
`31`	`28`
`32`	`29`	`public class TestFixture : ScriptHostEndToEndTestFixture`
`33`	`30`	`{`
`34`		`- public TestFixture() : base(@"TestScripts\Node", "node", LanguageWorkerConstants.NodeLanguageWorkerName,`
`35`		`- startHost: true, functions: new[] { "HttpTrigger" })`
	`31`	`+ public TestFixture() : base(@"TestScripts\ProxiesOnly", "proxiesOnly", string.Empty,`
	`32`	`+ startHost: true)`
	`33`	`+ {`
	`34`	`+ }`
	`35`	`+`
	`36`	`+ protected override Task CreateTestStorageEntities()`
`36`	`37`	`{`
	`38`	`+ // No need for this.`
	`39`	`+ return Task.CompletedTask;`
`37`	`40`	`}`
`38`	`41`	`}`
`39`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,12 @@ namespace Microsoft.Azure.WebJobs.Script.Tests`
`17`	`17`	`{`
`18`	`18`	`public class NodeContentTests : IClassFixture<NodeContentTests.TestFixture>`
`19`	`19`	`{`
	`20`	`+ private ILanguageWorkerChannelManager _languageWorkerChannelManager;`
	`21`	`+`
`20`	`22`	`public NodeContentTests(TestFixture fixture)`
`21`	`23`	`{`
`22`	`24`	`Fixture = fixture;`
	`25`	`+ _languageWorkerChannelManager = (ILanguageWorkerChannelManager)fixture.Host.Services.GetService(typeof(ILanguageWorkerChannelManager));`
`23`	`26`	`}`
`24`	`27`
`25`	`28`	`public TestFixture Fixture { get; set; }`
`@@ -129,6 +132,13 @@ public async Task ObjectXml()`
`129`	`132`	`Assert.Equal(str, content);`
`130`	`133`	`}`
`131`	`134`
	`135`	`+ [Fact]`
	`136`	`+ public void InitializeAsync_WorkerRuntime_Node_DoNotInitialize_JavaWorker()`
	`137`	`+ {`
	`138`	`+ var javaChannel = _languageWorkerChannelManager.GetChannel(LanguageWorkerConstants.JavaLanguageWorkerName);`
	`139`	`+ Assert.Null(javaChannel);`
	`140`	`+ }`
	`141`	`+`
`132`	`142`	`// Get response with default ObjectResult content negotiation enabled`
`133`	`143`	`protected Task<string> ResponseWithConneg<Req>(Req content, string contentType, string expectedContentType = null)`
`134`	`144`	`{`