Load all workerConfigs in Placeholder Mode (#5454)

Author: pragnagopa

src/WebJobs.Script/Host/FunctionMetadataManager.cs

@@ -18,19 +18,17 @@ namespace Microsoft.Azure.WebJobs.Script
     public class FunctionMetadataManager : IFunctionMetadataManager
     {
         private const string _functionConfigurationErrorMessage = "Unable to determine the primary function script.Make sure atleast one script file is present.Try renaming your entry point script to 'run' or alternatively you can specify the name of the entry point script explicitly by adding a 'scriptFile' property to your function metadata.";
-        private readonly IEnumerable<RpcWorkerConfig> _workerConfigs;
         private readonly bool _isHttpWorker;
         private readonly Lazy<ImmutableArray<FunctionMetadata>> _functionMetadataArray;
         private readonly IOptions<ScriptJobHostOptions> _scriptOptions;
         private readonly IFunctionMetadataProvider _functionMetadataProvider;
         private readonly ILogger _logger;
         private Dictionary<string, ICollection<string>> _functionErrors = new Dictionary<string, ICollection<string>>();
 
-        public FunctionMetadataManager(IOptions<ScriptJobHostOptions> scriptOptions, IFunctionMetadataProvider functionMetadataProvider, IOptions<LanguageWorkerOptions> languageWorkerOptions, IOptions<HttpWorkerOptions> httpWorkerOptions, ILoggerFactory loggerFactory)
+        public FunctionMetadataManager(IOptions<ScriptJobHostOptions> scriptOptions, IFunctionMetadataProvider functionMetadataProvider, IOptions<HttpWorkerOptions> httpWorkerOptions, ILoggerFactory loggerFactory)
         {
             _scriptOptions = scriptOptions;
             _functionMetadataProvider = functionMetadataProvider;
-            _workerConfigs = languageWorkerOptions.Value.WorkerConfigs;
             _logger = loggerFactory.CreateLogger(LogCategories.Startup);
             _functionMetadataArray = new Lazy<ImmutableArray<FunctionMetadata>>(LoadFunctionMetadata);
             _isHttpWorker = httpWorkerOptions.Value.Description != null;

src/WebJobs.Script/Utility.cs

@@ -585,6 +585,11 @@ internal static string GetWorkerRuntime(IEnumerable<FunctionMetadata> functions)
             {
                 var functionsListWithoutProxies = functions?.Where(f => f.IsProxy == false);
                 string functionLanguage = functionsListWithoutProxies.FirstOrDefault()?.Language;
+                if (string.IsNullOrEmpty(functionLanguage))
+                {
+                    return null;
+                }
+
                 if (IsDotNetLanguageFunction(functionLanguage))
                 {
                     return RpcWorkerConstants.DotNetLanguageWorkerName;
@@ -604,7 +609,7 @@ internal static bool IsFunctionMetadataLanguageSupportedByWorkerRuntime(Function
             {
                 return true;
             }
-            return functionMetadata.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase);
+            return !string.IsNullOrEmpty(functionMetadata.Language) && functionMetadata.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase);
         }
 
         public static bool IsDotNetLanguageFunction(string functionLanguage)
@@ -625,7 +630,7 @@ private static bool ContainsFunctionWithWorkerRuntime(IEnumerable<FunctionMetada
             }
             if (functions != null && functions.Any())
             {
-                return functions.Any(f => f.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase));
+                return functions.Any(f => !string.IsNullOrEmpty(f.Language) && f.Language.Equals(workerRuntime, StringComparison.OrdinalIgnoreCase));
             }
             return false;
         }

src/WebJobs.Script/Workers/Rpc/Configuration/RpcWorkerConfigFactory.cs

@@ -143,6 +143,7 @@ internal void AddProvider(string workerDir)
                         workerDescription.FormatWorkerPathIfNeeded(_systemRuntimeInformation, _environment, _logger);
                         workerDescription.ThrowIfDefaultWorkerPathNotExists();
                         _workerDescripionDictionary[workerDescription.Language] = workerDescription;
+                        _logger.LogDebug($"Added WorkerConfig for language: {workerDescription.Language}");
                     }
                 }
                 catch (Exception ex)
@@ -226,6 +227,11 @@ internal string GetExecutablePathForJava(string defaultExecutablePath)
         internal bool ShouldAddWorkerConfig(string workerDescriptionLanguage)
         {
             string workerRuntime = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);
+            if (_environment.IsPlaceholderModeEnabled())
+            {
+                return true;
+            }
+
             if (!string.IsNullOrEmpty(workerRuntime))
             {
                 _logger.LogDebug($"EnvironmentVariable {RpcWorkerConstants.FunctionWorkerRuntimeSettingName}: {workerRuntime}");

test/WebJobs.Script.Tests/FunctionMetadataManagerTests.cs

@@ -29,7 +29,7 @@ public FunctionMetadataManagerTests()
             string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\node");
             _defaultHttpWorkerOptions = new HttpWorkerOptions();
             _scriptJobHostOptions.RootScriptPath = functionsPath;
-            _testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
+            _testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
         }
 
         [Theory]
@@ -54,7 +54,7 @@ public void FunctionMetadataManager_Verify_FunctionErrors(string scriptFile)
             mockFunctionMetadataProvider.Setup(m => m.GetFunctionMetadata(false)).Returns(functionMetadataCollection.ToImmutableArray());
             mockFunctionMetadataProvider.Setup(m => m.FunctionErrors).Returns(mockFunctionErrors);
 
-            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), mockFunctionMetadataProvider.Object, new OptionsWrapper<LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
+            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), mockFunctionMetadataProvider.Object, new OptionsWrapper<HttpWorkerOptions>(_defaultHttpWorkerOptions), MockNullLoggerFactory.CreateLoggerFactory());
 
             var validatedFunctionMetadataArray = testFunctionMetadataManager.LoadFunctionMetadata();
             Assert.Empty(validatedFunctionMetadataArray);
@@ -71,7 +71,7 @@ public void FunctionMetadataManager_Verify_FunctionErrors(string scriptFile)
         public void IsScriptFileDetermined_ScriptFile_Emtpy_HttpWorker_Returns_True(string scriptFile)
         {
             FunctionMetadata functionMetadata = GetTestFunctionMetadata(scriptFile);
-            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<LanguageWorkerOptions>(GetTestLanguageWorkerOptions()), new OptionsWrapper<HttpWorkerOptions>(GetTestHttpWorkerOptions()), MockNullLoggerFactory.CreateLoggerFactory());
+            FunctionMetadataManager testFunctionMetadataManager = new FunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(_scriptJobHostOptions), _mockFunctionMetadataProvider.Object, new OptionsWrapper<HttpWorkerOptions>(GetTestHttpWorkerOptions()), MockNullLoggerFactory.CreateLoggerFactory());
 
             Assert.True(testFunctionMetadataManager.IsScriptFileDetermined(functionMetadata));
         }

test/WebJobs.Script.Tests/ScriptHostTests.cs

@@ -914,6 +914,37 @@ public void IsSupportedRuntime_Returns_True()
             Assert.True(Utility.IsSupportedRuntime(RpcWorkerConstants.NodeLanguageWorkerName, TestHelpers.GetTestWorkerConfigs()));
         }
 
+        [Fact]
+        public void GetWorkerRuntime_Returns_null()
+        {
+            FunctionMetadata funcJs1 = new FunctionMetadata()
+            {
+                Name = "funcJs1",
+                Language = "node"
+            };
+            FunctionMetadata funcPython1 = new FunctionMetadata()
+            {
+                Name = "funcPython1",
+                Language = null,
+            };
+            IEnumerable<FunctionMetadata> functionsList = new Collection<FunctionMetadata>()
+            {
+                funcJs1, funcPython1
+            };
+            string actualRuntime = Utility.GetWorkerRuntime(functionsList);
+            Assert.Equal(null, actualRuntime);
+
+            FunctionMetadata funcLanguageNull = new FunctionMetadata()
+            {
+                Name = "func"
+            };
+            functionsList = new Collection<FunctionMetadata>()
+            {
+                funcJs1, funcPython1, funcLanguageNull
+            };
+            Assert.Equal(null, actualRuntime);
+        }
+
         [Theory]
         [InlineData("CSharp")]
         [InlineData("DotNetAssembly")]

test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigFactoryTests.cs

@@ -223,12 +223,18 @@ public void AddArgumentsFromAppSettings_JavaOpts(string expectedArgument, string
         }
 
         [Theory]
-        [InlineData("python", "Python", true)]
-        [InlineData("python", "NOde", false)]
-        [InlineData("python", "", true)]
-        [InlineData("python", null, true)]
-        public void ShouldAddProvider_Returns_Expected(string workerLanguage, string workerRuntime, bool expectedResult)
+        [InlineData("python", "Python", false, true)]
+        [InlineData("python", "NOde", false, false)]
+        [InlineData("python", "", false, true)]
+        [InlineData("python", null, false, true)]
+        [InlineData("python", "NOde", true, true)]
+        [InlineData("python", null, true, true)]
+        public void ShouldAddProvider_Returns_Expected(string workerLanguage, string workerRuntime, bool placeholderMode, bool expectedResult)
         {
+            if (placeholderMode)
+            {
+                _testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1");
+            }
             var expectedWorkersDir = Path.Combine(Path.GetDirectoryName(new Uri(typeof(RpcWorkerConfigFactory).Assembly.CodeBase).LocalPath), RpcWorkerConstants.DefaultWorkersDirectoryName);
             var config = new ConfigurationBuilder().Build();
             var testLogger = new TestLogger("test");