Support codeless non-dotnet functions (#6878)

Author: pragnagopa

src/WebJobs.Script/Host/ScriptHost.cs

@@ -282,7 +282,7 @@ public async Task InitializeAsync(CancellationToken cancellationToken = default)
                 {
                     string runtimeStack = _workerRuntime;
 
-                    if (!string.IsNullOrEmpty(_environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName)))
+                    if (!string.IsNullOrEmpty(runtimeStack))
                     {
                         // Appending the runtime version is currently only enabled for linux consumption. This will be eventually enabled for
                         // Windows Consumption as well.
@@ -304,7 +304,8 @@ public async Task InitializeAsync(CancellationToken cancellationToken = default)
 
                 // Initialize worker function invocation dispatcher only for valid functions after creating function descriptors
                 // Dispatcher not needed for non-proxy codeless function.
-                var filteredFunctionMetadata = functionMetadataList.Where(m => m.IsProxy() || !m.IsCodeless());
+                // Disptacher needed for non-dotnet codeless functions
+                var filteredFunctionMetadata = functionMetadataList.Where(m => m.IsProxy() || !Utility.IsCodelessDotNetLanguageFunction(m));
                 await _functionDispatcher.InitializeAsync(Utility.GetValidFunctions(filteredFunctionMetadata, Functions), cancellationToken);
 
                 GenerateFunctions(directTypes);

src/WebJobs.Script/Utility.cs

@@ -634,6 +634,20 @@ public static bool IsSupportedRuntime(string workerRuntime, IEnumerable<RpcWorke
             return workerConfigs.Any(config => string.Equals(config.Description.Language, workerRuntime, StringComparison.OrdinalIgnoreCase));
         }
 
+        public static bool IsCodelessDotNetLanguageFunction(FunctionMetadata functionMetadata)
+        {
+            if (functionMetadata == null)
+            {
+                throw new ArgumentNullException(nameof(functionMetadata));
+            }
+
+            if (functionMetadata.IsCodeless() && !string.IsNullOrEmpty(functionMetadata.Language))
+            {
+                return IsDotNetLanguageFunction(functionMetadata.Language);
+            }
+            return false;
+        }
+
         private static bool ContainsFunctionWithWorkerRuntime(IEnumerable<FunctionMetadata> functions, string workerRuntime)
         {
             if (string.Equals(workerRuntime, RpcWorkerConstants.DotNetLanguageWorkerName, StringComparison.OrdinalIgnoreCase))

test/WebJobs.Script.Tests/UtilityTests.cs

@@ -676,6 +676,45 @@ public async Task Test_LogAutorestGeneratedJson_With_AutorestGeneratedJson(strin
             }
         }
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void IsCodelessDotNetLanguageFunction_Returns_Expected(bool setIsCodeless)
+        {
+            FunctionMetadata func1 = new FunctionMetadata()
+            {
+                Name = "func1",
+                Language = DotNetScriptTypes.CSharp
+            };
+
+            FunctionMetadata func2 = new FunctionMetadata()
+            {
+                Name = "func2",
+                Language = DotNetScriptTypes.DotNetAssembly
+            };
+
+            FunctionMetadata nodeFunc = new FunctionMetadata()
+            {
+                Name = "func3",
+                Language = "node"
+            };
+
+            if (setIsCodeless)
+            {
+                func1.Properties.Add("IsCodeless", true);
+                func2.Properties.Add("IsCodeless", true);
+                nodeFunc.Properties.Add("IsCodeless", true);
+                Assert.True(Utility.IsCodelessDotNetLanguageFunction(func1));
+                Assert.True(Utility.IsCodelessDotNetLanguageFunction(func2));
+            }
+            else
+            {
+                Assert.False(Utility.IsCodelessDotNetLanguageFunction(func1));
+                Assert.False(Utility.IsCodelessDotNetLanguageFunction(func2));
+                Assert.False(Utility.IsCodelessDotNetLanguageFunction(nodeFunc));
+            }
+        }
+
         private static void VerifyLogLevel(IList<LogMessage> allLogs, string msg, LogLevel expectedLevel)
         {
             var message = allLogs.Where(l => l.FormattedMessage.Contains(msg)).FirstOrDefault();