Handling env reload response from native placeholder for failure case. (#9602)

kshyju · web-flow · commit d6a572bcdcde · 2023-10-12T11:46:26.000-07:00
* Handling env reload response from native placeholder for failure case.

* Almost working except one test needs cleanup

* Cleanup

* Cleanup

* Fixing Worker.Extensions.Http package version to align with Http.AspNetCore package.

* Logging error as it is received from the worker.

* DotNetIsolatedNativeHost package to 1.0.2

* Inlining a variable (Reverting to previous version)
diff --git a/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannel.cs b/src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannel.cs
@@ -374,12 +374,18 @@ internal void FunctionEnvironmentReloadResponse(FunctionEnvironmentReloadRespons
 
             ApplyCapabilities(res.Capabilities, res.CapabilitiesUpdateStrategy.ToGrpcCapabilitiesUpdateStrategy());
 
-            if (res.Result.IsFailure(out Exception reloadEnvironmentVariablesException))
+            if (res.Result.IsFailure(IsUserCodeExceptionCapabilityEnabled(), out var reloadEnvironmentVariablesException))
             {
-                _workerChannelLogger.LogError(reloadEnvironmentVariablesException, "Failed to reload environment variables");
-                _reloadTask.SetException(reloadEnvironmentVariablesException);
+                if (res.Result.Exception is not null && reloadEnvironmentVariablesException is not null)
+                {
+                    _workerChannelLogger.LogWarning(reloadEnvironmentVariablesException, reloadEnvironmentVariablesException.Message);
+                }
+                _reloadTask.SetResult(false);
+            }
+            else
+            {
+                _reloadTask.SetResult(true);
             }
-            _reloadTask.SetResult(true);
             latencyEvent.Dispose();
         }
 
@@ -414,6 +420,15 @@ internal void WorkerInitResponse(GrpcEvent initEvent)
             _workerInitTask.TrySetResult(true);
         }
 
+        private bool IsUserCodeExceptionCapabilityEnabled()
+        {
+            var enableUserCodeExceptionCapability = string.Equals(
+                _workerCapabilities.GetCapabilityState(RpcWorkerConstants.EnableUserCodeException), bool.TrueString,
+                StringComparison.OrdinalIgnoreCase);
+
+            return enableUserCodeExceptionCapability;
+        }
+
         private void LogWorkerMetadata(WorkerMetadata workerMetadata)
         {
             if (workerMetadata == null)
@@ -546,7 +561,7 @@ internal FunctionLoadRequestCollection GetFunctionLoadRequestCollection(IEnumera
             return functionLoadRequestCollection;
         }
 
-        public Task SendFunctionEnvironmentReloadRequest()
+        public Task<bool> SendFunctionEnvironmentReloadRequest()
         {
             _functionsIndexingTask = new TaskCompletionSource<List<RawFunctionMetadata>>(TaskCreationOptions.RunContinuationsAsynchronously);
             _functionMetadataRequestSent = false;
@@ -1584,4 +1599,4 @@ private void OnTimeout()
             }
         }
     }
-}
+}
diff --git a/src/WebJobs.Script.Grpc/MessageExtensions/StatusResultExtensions.cs b/src/WebJobs.Script.Grpc/MessageExtensions/StatusResultExtensions.cs
@@ -3,20 +3,18 @@
 
 using System;
 using System.Threading.Tasks;
-using Grpc.Core;
-using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
 
 namespace Microsoft.Azure.WebJobs.Script.Grpc
 {
     internal static class StatusResultExtensions
     {
-        public static bool IsFailure(this StatusResult statusResult, out Exception exception)
+        public static bool IsFailure(this StatusResult statusResult, bool enableUserCodeExceptionCapability, out Exception exception)
         {
             switch (statusResult.Status)
             {
                 case StatusResult.Types.Status.Failure:
-                    exception = GetRpcException(statusResult);
+                    exception = GetRpcException(statusResult, enableUserCodeExceptionCapability);
                     return true;
 
                 case StatusResult.Types.Status.Cancelled:
@@ -29,6 +27,11 @@ public static bool IsFailure(this StatusResult statusResult, out Exception excep
             }
         }
 
+        public static bool IsFailure(this StatusResult statusResult, out Exception exception)
+        {
+            return IsFailure(statusResult, false, out exception);
+        }
+
         /// <summary>
         /// This method is only hit on the invocation code path.
         /// enableUserCodeExceptionCapability = feature flag exposed as a capability that is set by the worker.
@@ -68,4 +71,4 @@ public static Workers.Rpc.RpcException GetRpcException(StatusResult statusResult
             return new Workers.Rpc.RpcException(status, string.Empty, string.Empty);
         }
     }
-}
+}
diff --git a/src/WebJobs.Script/WebJobs.Script.csproj b/src/WebJobs.Script/WebJobs.Script.csproj
@@ -47,7 +47,7 @@
     <PackageReference Include="Microsoft.ApplicationInsights.DependencyCollector" Version="2.21.0" />
     <PackageReference Include="Microsoft.ApplicationInsights.WindowsServer" Version="2.21.0" />
     <PackageReference Include="Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel" Version="2.21.0" />
-    <PackageReference Include="Microsoft.Azure.Functions.DotNetIsolatedNativeHost" Version="1.0.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.DotNetIsolatedNativeHost" Version="1.0.2" />
     <PackageReference Include="Microsoft.Azure.WebJobs" Version="3.0.39" />
     <PackageReference Include="Microsoft.Azure.WebJobs.Host.Storage" Version="5.0.0-beta.2-11957" />
     <PackageReference Include="Microsoft.Extensions.Azure" Version="1.7.0" />
diff --git a/src/WebJobs.Script/Workers/Rpc/IRpcWorkerChannel.cs b/src/WebJobs.Script/Workers/Rpc/IRpcWorkerChannel.cs
@@ -22,7 +22,7 @@ public interface IRpcWorkerChannel : IWorkerChannel
 
         void SendFunctionLoadRequests(ManagedDependencyOptions managedDependencyOptions, TimeSpan? functionTimeout);
 
-        Task SendFunctionEnvironmentReloadRequest();
+        Task<bool> SendFunctionEnvironmentReloadRequest();
 
         void SendWorkerWarmupRequest();
 
diff --git a/src/WebJobs.Script/Workers/Rpc/WebHostRpcWorkerChannelManager.cs b/src/WebJobs.Script/Workers/Rpc/WebHostRpcWorkerChannelManager.cs
@@ -123,12 +123,14 @@ public async Task SpecializeAsync()
 
             if (_workerRuntime != null && rpcWorkerChannel != null)
             {
+                bool envReloadRequestResultSuccessful = false;
                 if (UsePlaceholderChannel(rpcWorkerChannel))
                 {
                     _logger.LogDebug("Loading environment variables for runtime: {runtime}", _workerRuntime);
-                    await rpcWorkerChannel.SendFunctionEnvironmentReloadRequest();
+                    envReloadRequestResultSuccessful = await rpcWorkerChannel.SendFunctionEnvironmentReloadRequest();
                 }
-                else
+
+                if (envReloadRequestResultSuccessful == false)
                 {
                     _logger.LogDebug("Shutting down placeholder worker. Worker is not compatible for runtime: {runtime}", _workerRuntime);
                     // If we need to allow file edits, we should shutdown the webhost channel on specialization.
diff --git a/test/DotNetIsolated60/DotNetIsolated60.csproj b/test/DotNetIsolated60/DotNetIsolated60.csproj
@@ -6,13 +6,15 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <FunctionsEnableWorkerIndexing>True</FunctionsEnableWorkerIndexing>
+    <FunctionsAutoRegisterGeneratedMetadataProvider>True</FunctionsAutoRegisterGeneratedMetadataProvider>
+    <FunctionsEnableExecutorSourceGen>True</FunctionsEnableExecutorSourceGen>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.18.0" />
-    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.0.13" />
-    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" Version="1.0.0-preview2" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.19.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.1.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" Version="1.0.0" />
     <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Storage" Version="6.0.0" />
-    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.12.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.15.1" />
   </ItemGroup>
   <ItemGroup>
     <None Update="host.json">
diff --git a/test/DotNetIsolated60/DotNetIsolated60.sln b/test/DotNetIsolated60/DotNetIsolated60.sln
@@ -5,6 +5,8 @@ VisualStudioVersion = 17.5.33627.172
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DotNetIsolated60", "DotNetIsolated60.csproj", "{1DA92227-F28E-408D-96B1-20C72571E4AE}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotNetIsolatedUnsupportedWorker", "..\DotNetIsolatedUnsupportedWorker\DotNetIsolatedUnsupportedWorker.csproj", "{3F15B936-6365-447E-9EC6-4E996B30C55F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +17,10 @@ Global
 		{1DA92227-F28E-408D-96B1-20C72571E4AE}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1DA92227-F28E-408D-96B1-20C72571E4AE}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1DA92227-F28E-408D-96B1-20C72571E4AE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3F15B936-6365-447E-9EC6-4E996B30C55F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3F15B936-6365-447E-9EC6-4E996B30C55F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3F15B936-6365-447E-9EC6-4E996B30C55F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3F15B936-6365-447E-9EC6-4E996B30C55F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/test/DotNetIsolated60/Program.cs b/test/DotNetIsolated60/Program.cs
@@ -11,14 +11,12 @@
 if (useProxy)
 {
     hostBuilder
-        .ConfigureFunctionsWebApplication()
-        .ConfigureGeneratedFunctionMetadataProvider();
+        .ConfigureFunctionsWebApplication();
 }
 else
 {
     hostBuilder
-        .ConfigureFunctionsWorkerDefaults()
-        .ConfigureGeneratedFunctionMetadataProvider();
+        .ConfigureFunctionsWorkerDefaults();
 }
 
 var host = hostBuilder.Build();
diff --git a/test/DotNetIsolatedUnsupportedWorker/DotNetIsolatedUnsupportedWorker.csproj b/test/DotNetIsolatedUnsupportedWorker/DotNetIsolatedUnsupportedWorker.csproj
@@ -0,0 +1,29 @@
+﻿<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AzureFunctionsVersion>v4</AzureFunctionsVersion>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <FunctionsEnableWorkerIndexing>True</FunctionsEnableWorkerIndexing>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.19.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.1.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore" Version="1.0.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Storage" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.14.0" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Update="host.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="local.settings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <CopyToPublishDirectory>Never</CopyToPublishDirectory>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Using Include="System.Threading.ExecutionContext" Alias="ExecutionContext" />
+  </ItemGroup>
+</Project>
diff --git a/test/DotNetIsolatedUnsupportedWorker/HttpRequestDataFunction.cs b/test/DotNetIsolatedUnsupportedWorker/HttpRequestDataFunction.cs
@@ -0,0 +1,30 @@
+using System.Net;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.Extensions.Logging;
+
+namespace DotNetIsolatedUnsupportedWorker
+{
+    public class HttpRequestDataFunction
+    {
+        private readonly ILogger _logger;
+
+        public HttpRequestDataFunction(ILoggerFactory loggerFactory)
+        {
+            _logger = loggerFactory.CreateLogger<HttpRequestDataFunction>();
+        }
+
+        [Function("HttpRequestDataFunction")]
+        public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
+
+            response.WriteString("Welcome to Azure Functions!");
+
+            return response;
+        }
+    }
+}
diff --git a/test/DotNetIsolatedUnsupportedWorker/HttpRequestFunction.cs b/test/DotNetIsolatedUnsupportedWorker/HttpRequestFunction.cs
@@ -0,0 +1,23 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+
+namespace DotNetIsolatedUnsupportedWorker
+{
+    public class HttpRequestFunction
+    {
+        private readonly ILogger<HttpRequestFunction> _logger;
+
+        public HttpRequestFunction(ILogger<HttpRequestFunction> logger)
+        {
+            _logger = logger;
+        }
+
+        [Function(nameof(HttpRequestFunction))]
+        public Task Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+            return req.HttpContext.Response.WriteAsync("Welcome to Azure Functions!");
+        }
+    }
+}
diff --git a/test/DotNetIsolatedUnsupportedWorker/Program.cs b/test/DotNetIsolatedUnsupportedWorker/Program.cs
@@ -0,0 +1,23 @@
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Hosting;
+
+//Debugger.Launch();
+
+// Tests can set an env var that will swap this to use the proxy
+bool useProxy = Environment.GetEnvironmentVariable("UseProxyInTest")?.Contains("1") ?? false;
+
+var hostBuilder = new HostBuilder();
+
+if (useProxy)
+{
+    hostBuilder
+        .ConfigureFunctionsWebApplication();
+}
+else
+{
+    hostBuilder
+        .ConfigureFunctionsWorkerDefaults();
+}
+
+var host = hostBuilder.Build();
+host.Run();
diff --git a/test/DotNetIsolatedUnsupportedWorker/QueueFunction.cs b/test/DotNetIsolatedUnsupportedWorker/QueueFunction.cs
@@ -0,0 +1,21 @@
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+
+namespace DotNetIsolatedUnsupportedWorker
+{
+    public class QueueFunction
+    {
+        private readonly ILogger _logger;
+
+        public QueueFunction(ILoggerFactory loggerFactory)
+        {
+            _logger = loggerFactory.CreateLogger<QueueFunction>();
+        }
+
+        [Function("QueueFunction")]
+        public void Run([QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")] string myQueueItem)
+        {
+            _logger.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
+        }
+    }
+}
diff --git a/test/DotNetIsolatedUnsupportedWorker/host.json b/test/DotNetIsolatedUnsupportedWorker/host.json
@@ -0,0 +1,12 @@
+{
+    "version": "2.0",
+    "logging": {
+        "applicationInsights": {
+            "samplingSettings": {
+                "isEnabled": true,
+                "excludedTypes": "Request"
+            },
+            "enableLiveMetricsFilters": true
+        }
+    }
+}
diff --git a/test/EmptyScriptRoot/host.json b/test/EmptyScriptRoot/host.json
@@ -0,0 +1,7 @@
+{
+  "version": "2.0",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  }
+}
diff --git a/test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/SpecializationE2ETests.cs b/test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/SpecializationE2ETests.cs
diff --git a/test/WebJobs.Script.Tests/Workers/Rpc/TestRpcWorkerChannel.cs b/test/WebJobs.Script.Tests/Workers/Rpc/TestRpcWorkerChannel.cs

Original file line number	Diff line number	Diff line change
`@@ -374,12 +374,18 @@ internal void FunctionEnvironmentReloadResponse(FunctionEnvironmentReloadRespons`
`374`	`374`
`375`	`375`	`ApplyCapabilities(res.Capabilities, res.CapabilitiesUpdateStrategy.ToGrpcCapabilitiesUpdateStrategy());`
`376`	`376`
`377`		`- if (res.Result.IsFailure(out Exception reloadEnvironmentVariablesException))`
	`377`	`+ if (res.Result.IsFailure(IsUserCodeExceptionCapabilityEnabled(), out var reloadEnvironmentVariablesException))`
`378`	`378`	`{`
`379`		`- _workerChannelLogger.LogError(reloadEnvironmentVariablesException, "Failed to reload environment variables");`
`380`		`- _reloadTask.SetException(reloadEnvironmentVariablesException);`
	`379`	`+ if (res.Result.Exception is not null && reloadEnvironmentVariablesException is not null)`
	`380`	`+ {`
	`381`	`+ _workerChannelLogger.LogWarning(reloadEnvironmentVariablesException, reloadEnvironmentVariablesException.Message);`
	`382`	`+ }`
	`383`	`+ _reloadTask.SetResult(false);`
	`384`	`+ }`
	`385`	`+ else`
	`386`	`+ {`
	`387`	`+ _reloadTask.SetResult(true);`
`381`	`388`	`}`
`382`		`- _reloadTask.SetResult(true);`
`383`	`389`	`latencyEvent.Dispose();`
`384`	`390`	`}`
`385`	`391`
`@@ -414,6 +420,15 @@ internal void WorkerInitResponse(GrpcEvent initEvent)`
`414`	`420`	`_workerInitTask.TrySetResult(true);`
`415`	`421`	`}`
`416`	`422`
	`423`	`+ private bool IsUserCodeExceptionCapabilityEnabled()`
	`424`	`+ {`
	`425`	`+ var enableUserCodeExceptionCapability = string.Equals(`
	`426`	`+ _workerCapabilities.GetCapabilityState(RpcWorkerConstants.EnableUserCodeException), bool.TrueString,`
	`427`	`+ StringComparison.OrdinalIgnoreCase);`
	`428`	`+`
	`429`	`+ return enableUserCodeExceptionCapability;`
	`430`	`+ }`
	`431`	`+`
`417`	`432`	`private void LogWorkerMetadata(WorkerMetadata workerMetadata)`
`418`	`433`	`{`
`419`	`434`	`if (workerMetadata == null)`
`@@ -546,7 +561,7 @@ internal FunctionLoadRequestCollection GetFunctionLoadRequestCollection(IEnumera`
`546`	`561`	`return functionLoadRequestCollection;`
`547`	`562`	`}`
`548`	`563`
`549`		`- public Task SendFunctionEnvironmentReloadRequest()`
	`564`	`+ public Task<bool> SendFunctionEnvironmentReloadRequest()`
`550`	`565`	`{`
`551`	`566`	`_functionsIndexingTask = new TaskCompletionSource<List<RawFunctionMetadata>>(TaskCreationOptions.RunContinuationsAsynchronously);`
`552`	`567`	`_functionMetadataRequestSent = false;`
`@@ -1584,4 +1599,4 @@ private void OnTimeout()`
`1584`	`1599`	`}`
`1585`	`1600`	`}`
`1586`	`1601`	`}`
`1587`		`-}`
	`1602`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -3,20 +3,18 @@`
`3`	`3`
`4`	`4`	`using System;`
`5`	`5`	`using System.Threading.Tasks;`
`6`		`-using Grpc.Core;`
`7`		`-using Microsoft.Azure.WebJobs.Script.Config;`
`8`	`6`	`using Microsoft.Azure.WebJobs.Script.Grpc.Messages;`
`9`	`7`
`10`	`8`	`namespace Microsoft.Azure.WebJobs.Script.Grpc`
`11`	`9`	`{`
`12`	`10`	`internal static class StatusResultExtensions`
`13`	`11`	`{`
`14`		`- public static bool IsFailure(this StatusResult statusResult, out Exception exception)`
	`12`	`+ public static bool IsFailure(this StatusResult statusResult, bool enableUserCodeExceptionCapability, out Exception exception)`
`15`	`13`	`{`
`16`	`14`	`switch (statusResult.Status)`
`17`	`15`	`{`
`18`	`16`	`case StatusResult.Types.Status.Failure:`
`19`		`- exception = GetRpcException(statusResult);`
	`17`	`+ exception = GetRpcException(statusResult, enableUserCodeExceptionCapability);`
`20`	`18`	`return true;`
`21`	`19`
`22`	`20`	`case StatusResult.Types.Status.Cancelled:`
`@@ -29,6 +27,11 @@ public static bool IsFailure(this StatusResult statusResult, out Exception excep`
`29`	`27`	`}`
`30`	`28`	`}`
`31`	`29`
	`30`	`+ public static bool IsFailure(this StatusResult statusResult, out Exception exception)`
	`31`	`+ {`
	`32`	`+ return IsFailure(statusResult, false, out exception);`
	`33`	`+ }`
	`34`	`+`
`32`	`35`	`/// <summary>`
`33`	`36`	`/// This method is only hit on the invocation code path.`
`34`	`37`	`/// enableUserCodeExceptionCapability = feature flag exposed as a capability that is set by the worker.`
`@@ -68,4 +71,4 @@ public static Workers.Rpc.RpcException GetRpcException(StatusResult statusResult`
`68`	`71`	`return new Workers.Rpc.RpcException(status, string.Empty, string.Empty);`
`69`	`72`	`}`
`70`	`73`	`}`
`71`		`-}`
	`74`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -123,12 +123,14 @@ public async Task SpecializeAsync()`
`123`	`123`
`124`	`124`	`if (_workerRuntime != null && rpcWorkerChannel != null)`
`125`	`125`	`{`
	`126`	`+ bool envReloadRequestResultSuccessful = false;`
`126`	`127`	`if (UsePlaceholderChannel(rpcWorkerChannel))`
`127`	`128`	`{`
`128`	`129`	`_logger.LogDebug("Loading environment variables for runtime: {runtime}", _workerRuntime);`
`129`		`- await rpcWorkerChannel.SendFunctionEnvironmentReloadRequest();`
	`130`	`+ envReloadRequestResultSuccessful = await rpcWorkerChannel.SendFunctionEnvironmentReloadRequest();`
`130`	`131`	`}`
`131`		`- else`
	`132`	`+`
	`133`	`+ if (envReloadRequestResultSuccessful == false)`
`132`	`134`	`{`
`133`	`135`	`_logger.LogDebug("Shutting down placeholder worker. Worker is not compatible for runtime: {runtime}", _workerRuntime);`
`134`	`136`	`// If we need to allow file edits, we should shutdown the webhost channel on specialization.`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,12 @@`
`11`	`11`	`if (useProxy)`
`12`	`12`	`{`
`13`	`13`	`hostBuilder`
`14`		`- .ConfigureFunctionsWebApplication()`
`15`		`- .ConfigureGeneratedFunctionMetadataProvider();`
	`14`	`+ .ConfigureFunctionsWebApplication();`
`16`	`15`	`}`
`17`	`16`	`else`
`18`	`17`	`{`
`19`	`18`	`hostBuilder`
`20`		`- .ConfigureFunctionsWorkerDefaults()`
`21`		`- .ConfigureGeneratedFunctionMetadataProvider();`
	`19`	`+ .ConfigureFunctionsWorkerDefaults();`
`22`	`20`	`}`
`23`	`21`
`24`	`22`	`var host = hostBuilder.Build();`