Do not throw when dotnet-isolated app deployed without payload (#8589)

* Skipping the code to throw exception for dotnet isolated app without payload

* Added tests

* Updated release notes

* Fixed typo in comments

* Update release_notes.md

Author: kshyju

release_notes.md

@@ -6,3 +6,4 @@
 **Release sprint:** Sprint 125
 [ [bugs](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+125%22+label%3Abug+is%3Aclosed) | [features](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+125%22+label%3Afeature+is%3Aclosed) ]
 - Fix the bug where debugging of dotnet isolated function apps hangs in visual studio (#8596)
+- Host does not throw anymore for dotnet-isolated app without deployed payload (#8311)

src/WebJobs.Script/Workers/Rpc/FunctionRegistration/RpcFunctionInvocationDispatcher.cs

@@ -277,8 +277,17 @@ public async Task InitializeAsync(IEnumerable<FunctionMetadata> functions, Cance
 
             var workerConfig = _workerConfigs.Where(c => c.Description.Language.Equals(_workerRuntime, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
 
+            // For other OOP workers, workerconfigs are present inside "workers" folder of host bin directory and is used to populate "_workerConfigs".
+            // For dotnet-isolated _workerConfigs is populated by reading workerconfig.json from the deployed payload(customer function app code).
+            // So if workerConfig is null and worker runtime is dotnet-isolated, that means isolated function code was not deployed yet.
+            var isDotNetIsolatedAppWithoutPayload = string.Equals(_workerRuntime, RpcWorkerConstants.DotNetIsolatedLanguageWorkerName, StringComparison.InvariantCultureIgnoreCase)
+                                                    && workerConfig == null;
+
             // We are skipping this check for multi-language environments because they use multiple workers and thus doesn't honor 'FUNCTIONS_WORKER_RUNTIME'
-            if ((workerConfig == null && (functions == null || functions.Count() == 0)) && !_environment.IsMultiLanguageRuntimeEnvironment())
+            // Also, skip if dotnet-isolated app without payload as it is a valid case to exist.
+            if ((workerConfig == null && (functions == null || functions.Count() == 0))
+                && !_environment.IsMultiLanguageRuntimeEnvironment()
+                && !isDotNetIsolatedAppWithoutPayload)
             {
                 // Only throw if workerConfig is null AND some functions have been found.
                 // With .NET out-of-proc, worker config comes from functions.

src/WebJobs.Script/Workers/Rpc/RpcWorkerConstants.cs

@@ -18,6 +18,7 @@ public static class RpcWorkerConstants
         // This will override the default directories.
         public const string FunctionsUnixSharedMemoryDirectories = "FUNCTIONS_UNIX_SHARED_MEMORY_DIRECTORIES";
         public const string DotNetLanguageWorkerName = "dotnet";
+        public const string DotNetIsolatedLanguageWorkerName = "dotnet-isolated";
         public const string NodeLanguageWorkerName = "node";
         public const string JavaLanguageWorkerName = "java";
         public const string PowerShellLanguageWorkerName = "powershell";

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

@@ -330,6 +330,27 @@ public async Task FunctionDispatcherState_Default_DotNetFunctions()
             Assert.Equal(FunctionInvocationDispatcherState.Default, functionDispatcher.State);
         }
 
+        [Fact]
+        public async Task InitializeAsync_Throws_When_Worker_Config_not_found()
+        {
+            // Our GetTestFunctionDispatcher return a dispatcher with 2 worker configs loaded(java, node)
+            RpcFunctionInvocationDispatcher functionDispatcher = GetTestFunctionDispatcher(runtime: "python");
+
+            Func<Task> task = () => functionDispatcher.InitializeAsync(new List<FunctionMetadata>());
+
+            InvalidOperationException exception = await Assert.ThrowsAsync<InvalidOperationException>(task);
+            Assert.Equal("WorkerConfig for runtime: python not found", exception.Message);
+        }
+
+        [Fact]
+        public async Task InitializeAsync_DoesNotThrow_ForDotNetIsolatedWithoutDeployedPayload()
+        {
+            RpcFunctionInvocationDispatcher functionDispatcher = GetTestFunctionDispatcher(runtime: RpcWorkerConstants.DotNetIsolatedLanguageWorkerName);
+
+            // Should not throw for dotnet-isolated runtime.
+            await functionDispatcher.InitializeAsync(new List<FunctionMetadata>());
+        }
+
         [Fact]
         public async Task FunctionDispatcherState_Default_NoFunctions()
         {