fixing issue with worker indexing, dotnet-isolated, and placeholders (#9253)

Author: brettsam

NuGet.config

@@ -9,6 +9,7 @@
     <add key="AzureFunctions@staging" value="https://azfunc.pkgs.visualstudio.com/e6a70c92-4128-439f-8012-382fe78d6396/_packaging/AzureFunctions%40staging/nuget/v3/index.json" />
     <add key="AzureFunctionsRelease" value="https://azfunc.pkgs.visualstudio.com/e6a70c92-4128-439f-8012-382fe78d6396/_packaging/AzureFunctionsRelease/nuget/v3/index.json" />
     <add key="AzureFunctionsPreRelease" value="https://azfunc.pkgs.visualstudio.com/e6a70c92-4128-439f-8012-382fe78d6396/_packaging/AzureFunctionsPreRelease/nuget/v3/index.json" />
+    <add key="AzureFunctionsTempStaging" value="https://azfunc.pkgs.visualstudio.com/e6a70c92-4128-439f-8012-382fe78d6396/_packaging/AzureFunctionsTempStaging/nuget/v3/index.json" />
     <!-- dotnet-tools is required for Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit -->
     <add key="dotnet-tools" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json"/>
   </packageSources>

release_notes.md

@@ -11,3 +11,4 @@
 [ [bugs](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+143%22+label%3Abug+is%3Aclosed) | [features](https://github.com/Azure/azure-functions-host/issues?q=is%3Aissue+milestone%3A%22Functions+Sprint+143%22+label%3Afeature+is%3Aclosed) ]
 - Update PowerShell Worker 7.2 to 4.0.2803 [Release Note](https://github.com/Azure/azure-functions-powershell-worker/releases/tag/v4.0.2803)
 - Update PowerShell Worker 7.4 to 4.0.2802 [Release Note](https://github.com/Azure/azure-functions-powershell-worker/releases/tag/v4.0.2802)
+- Fixing bug with placeholder misses in dotnet-isolated #9253

src/WebJobs.Script.Grpc/Channel/GrpcWorkerChannel.cs

@@ -845,7 +845,8 @@ internal void ProcessFunctionMetadataResponses(FunctionMetadataResponse function
                         FunctionDirectory = metadata.Directory,
                         ScriptFile = metadata.ScriptFile,
                         EntryPoint = metadata.EntryPoint,
-                        Name = metadata.Name
+                        Name = metadata.Name,
+                        Language = metadata.Language
                     };
 
                     functionMetadata.SetFunctionId(metadata.FunctionId);

src/WebJobs.Script/Host/FunctionMetadataManager.cs

@@ -135,7 +135,7 @@ internal ImmutableArray<FunctionMetadata> LoadFunctionMetadata(bool forceRefresh
             ImmutableArray<FunctionMetadata> immutableFunctionMetadata;
             var workerConfigs = _languageWorkerOptions.CurrentValue.WorkerConfigs;
 
-            immutableFunctionMetadata = _functionMetadataProvider.GetFunctionMetadataAsync(workerConfigs, SystemEnvironment.Instance, forceRefresh).GetAwaiter().GetResult();
+            immutableFunctionMetadata = _functionMetadataProvider.GetFunctionMetadataAsync(workerConfigs, _environment, forceRefresh).GetAwaiter().GetResult();
 
             var functionMetadataList = new List<FunctionMetadata>();
             _functionErrors = new Dictionary<string, ICollection<string>>();

src/WebJobs.Script/Host/FunctionMetadataProvider.cs

@@ -1,7 +1,6 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
-using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading.Tasks;
@@ -21,13 +20,14 @@ internal class FunctionMetadataProvider : IFunctionMetadataProvider
         private IWorkerFunctionMetadataProvider _workerFunctionMetadataProvider;
         private IHostFunctionMetadataProvider _hostFunctionMetadataProvider;
 
-        public FunctionMetadataProvider(ILogger<FunctionMetadataProvider> logger, IWorkerFunctionMetadataProvider workerFunctionMetadataProvider, IHostFunctionMetadataProvider hostFunctionMetadataProvider, IOptions<FunctionsHostingConfigOptions> functionsHostingConfigOptions)
+        public FunctionMetadataProvider(ILogger<FunctionMetadataProvider> logger, IWorkerFunctionMetadataProvider workerFunctionMetadataProvider, IHostFunctionMetadataProvider hostFunctionMetadataProvider,
+            IOptions<FunctionsHostingConfigOptions> functionsHostingConfigOptions, IEnvironment environment)
         {
             _logger = logger;
             _workerFunctionMetadataProvider = workerFunctionMetadataProvider;
             _hostFunctionMetadataProvider = hostFunctionMetadataProvider;
             _functionsHostingConfigOptions = functionsHostingConfigOptions.Value;
-            _environment = SystemEnvironment.Instance;
+            _environment = environment;
         }
 
         public ImmutableDictionary<string, ImmutableArray<string>> FunctionErrors { get; private set; }

src/WebJobs.Script/Host/WorkerFunctionMetadataProvider.cs

@@ -65,7 +65,7 @@ public async Task<FunctionMetadataResult> GetFunctionMetadataAsync(IEnumerable<R
 
                 if (channels?.Any() != true)
                 {
-                    await _channelManager.InitializeChannelAsync(_workerRuntime);
+                    await _channelManager.InitializeChannelAsync(workerConfigs, _workerRuntime);
                     channels = _channelManager.GetChannels(_workerRuntime);
                 }
                 // start up GRPC channels
@@ -162,7 +162,7 @@ internal IEnumerable<FunctionMetadata> ValidateMetadata(IEnumerable<RawFunctionM
                 {
                     Utility.ValidateName(function.Name);
 
-                    function.Language = SystemEnvironment.Instance.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);
+                    function.Language = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);
 
                     // skip function directory validation because this involves reading function.json
 

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

@@ -172,7 +172,7 @@ internal async Task InitializeWebhostLanguageWorkerChannel(IEnumerable<string> l
             foreach (string language in languages)
             {
                 _logger.LogDebug("Creating new webhost language worker channel for runtime:{workerRuntime}.", language);
-                IRpcWorkerChannel workerChannel = await _webHostLanguageWorkerChannelManager.InitializeChannelAsync(language);
+                IRpcWorkerChannel workerChannel = await _webHostLanguageWorkerChannelManager.InitializeChannelAsync(_workerConfigs, language);
 
                 // if the worker is indexing, we will not have function metadata yet. So, we cannot set up invocation buffers or send load requests
                 workerChannel.SetupFunctionInvocationBuffers(_functions);

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

@@ -9,7 +9,7 @@ namespace Microsoft.Azure.WebJobs.Script.Workers.Rpc
 {
     public interface IWebHostRpcWorkerChannelManager
     {
-        Task<IRpcWorkerChannel> InitializeChannelAsync(string language);
+        Task<IRpcWorkerChannel> InitializeChannelAsync(IEnumerable<RpcWorkerConfig> workerConfigs, string language);
 
         Dictionary<string, TaskCompletionSource<IRpcWorkerChannel>> GetChannels(string language);
 

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

@@ -18,12 +18,14 @@ public class RpcInitializationService : IManagedHostedService
         private readonly IWebHostRpcWorkerChannelManager _webHostRpcWorkerChannelManager;
         private readonly IRpcServer _rpcServer;
         private readonly ILogger _logger;
+        private readonly IOptionsMonitor<LanguageWorkerOptions> _languageWorkerOptions;
 
         private readonly string _workerRuntime;
         private readonly int _rpcServerShutdownTimeoutInMilliseconds;
         private HashSet<string> _placeholderLanguageWorkersList = new HashSet<string>();
 
-        public RpcInitializationService(IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, IEnvironment environment, IRpcServer rpcServer, IWebHostRpcWorkerChannelManager rpcWorkerChannelManager, ILogger<RpcInitializationService> logger)
+        public RpcInitializationService(IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, IEnvironment environment, IRpcServer rpcServer,
+            IWebHostRpcWorkerChannelManager rpcWorkerChannelManager, ILogger<RpcInitializationService> logger, IOptionsMonitor<LanguageWorkerOptions> languageWorkerOptions)
         {
             _applicationHostOptions = applicationHostOptions ?? throw new ArgumentNullException(nameof(applicationHostOptions));
             _logger = logger;
@@ -33,6 +35,7 @@ public RpcInitializationService(IOptionsMonitor<ScriptApplicationHostOptions> ap
             _webHostRpcWorkerChannelManager = rpcWorkerChannelManager ?? throw new ArgumentNullException(nameof(rpcWorkerChannelManager));
             _workerRuntime = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);
             _placeholderLanguageWorkersList = _environment.GetLanguageWorkerListToStartInPlaceholder();
+            _languageWorkerOptions = languageWorkerOptions;
         }
 
         public async Task StartAsync(CancellationToken cancellationToken)
@@ -116,7 +119,7 @@ internal Task InitializeChannelsAsync()
                 if (_placeholderLanguageWorkersList.Count() != 0)
                 {
                     return Task.WhenAll(_placeholderLanguageWorkersList.Select(runtime =>
-                    _webHostRpcWorkerChannelManager.InitializeChannelAsync(runtime)));
+                    _webHostRpcWorkerChannelManager.InitializeChannelAsync(_languageWorkerOptions.CurrentValue.WorkerConfigs, runtime)));
                 }
             }
             return Task.CompletedTask;

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

@@ -23,6 +23,7 @@ internal class RpcWorkerProcess : WorkerProcess
         private readonly WorkerProcessArguments _workerProcessArguments;
         private readonly string _workerDirectory;
         private readonly IOptions<FunctionsHostingConfigOptions> _hostingConfigOptions;
+        private readonly IEnvironment _environment;
 
         internal RpcWorkerProcess(string runtime,
                                        string workerId,
@@ -36,7 +37,8 @@ internal RpcWorkerProcess(string runtime,
                                        IWorkerConsoleLogSource consoleLogSource,
                                        IMetricsLogger metricsLogger,
                                        IServiceProvider serviceProvider,
-                                       IOptions<FunctionsHostingConfigOptions> hostingConfigOptions)
+                                       IOptions<FunctionsHostingConfigOptions> hostingConfigOptions,
+                                       IEnvironment environment)
             : base(eventManager, processRegistry, workerProcessLogger, consoleLogSource, metricsLogger, serviceProvider, rpcWorkerConfig.Description.UseStdErrorStreamForErrorsOnly)
         {
             _runtime = runtime;
@@ -49,13 +51,15 @@ internal RpcWorkerProcess(string runtime,
             _workerProcessArguments = rpcWorkerConfig.Arguments;
             _workerDirectory = rpcWorkerConfig.Description.WorkerDirectory;
             _hostingConfigOptions = hostingConfigOptions;
+            _environment = environment;
         }
 
         internal override Process CreateWorkerProcess()
         {
             var workerContext = new RpcWorkerContext(Guid.NewGuid().ToString(), RpcWorkerConstants.DefaultMaxMessageLengthBytes, _workerId, _workerProcessArguments, _scriptRootPath, _serverUri);
             workerContext.EnvironmentVariables.Add(WorkerConstants.FunctionsWorkerDirectorySettingName, _workerDirectory);
             workerContext.EnvironmentVariables.Add(WorkerConstants.FunctionsApplicationDirectorySettingName, _scriptRootPath);
+            workerContext.EnvironmentVariables.Add(RpcWorkerConstants.FunctionWorkerRuntimeVersionSettingName, _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeVersionSettingName));
             foreach (var pair in _hostingConfigOptions.Value.Features)
             {
                 workerContext.EnvironmentVariables[pair.Key] = pair.Value;