Implement changes needed in the Host to decouple workers from the Host release

release_notes.md

@@ -10,3 +10,4 @@
 - Handles loading extensions.json with empty extensions(#11174)
 - Update HttpWorkerOptions to implement IOptionsFormatter (#11175)
 - Improved metadata binding validation (#11101)
+- Implement changes needed in the Host to decouple workers from the Host release (#11111)

src/WebJobs.Script/Config/FunctionsHostingConfigOptions.cs

@@ -91,6 +91,17 @@ internal string WorkerIndexingDisabledApps
             }
         }
 
+        /// <summary>
+        /// Gets a string delimited by '|' that contains the names of the language workers available through probing paths outside of the Host.
+        /// </summary>
+        internal string WorkersAvailableForDynamicResolution
+        {
+            get
+            {
+                return GetFeature(RpcWorkerConstants.WorkersAvailableForDynamicResolution) ?? string.Empty;
+            }
+        }
+
         /// <summary>
         /// Gets a value indicating whether Linux Log Backoff is disabled in the hosting config.
         /// </summary>

src/WebJobs.Script/Environment/EnvironmentExtensions.cs

@@ -278,6 +278,16 @@ public static bool IsWindowsElasticPremium(this IEnvironment environment)
             return string.Equals(value, ScriptConstants.ElasticPremiumSku, StringComparison.OrdinalIgnoreCase);
         }
 
+        /// <summary>
+        /// Gets a value indicating whether the application is running in a Windows App Service environment.
+        /// </summary>
+        /// <param name="environment">The environment to verify.</param>
+        /// <returns><see cref="true"/> if running in a Windows App Service app; otherwise, false.</returns>
+        public static bool IsWindowsEnvironment(this IEnvironment environment)
+        {
+            return environment.IsWindowsAzureManagedHosting() || environment.IsWindowsConsumption() || environment.IsWindowsElasticPremium();
+        }
+
         public static bool IsDynamicSku(this IEnvironment environment)
         {
             return environment.IsConsumptionSku() || environment.IsWindowsElasticPremium();
@@ -687,6 +697,42 @@ public static bool IsInProc(this IEnvironment environment, string workerRuntime
             return string.IsNullOrEmpty(workerRuntime) || string.Equals(workerRuntime, RpcWorkerConstants.DotNetLanguageWorkerName, StringComparison.OrdinalIgnoreCase);
         }
 
+        public static string GetPlatformReleaseChannel(this IEnvironment environment)
+        {
+            return environment.GetEnvironmentVariable(AntaresPlatformReleaseChannel) ?? ScriptConstants.LatestPlatformChannelNameUpper;
+        }
+
+        /// <summary>
+        /// Checks if the Dynamic Worker Resolution feature is disabled via feature flag.
+        /// Returns true if the feature is disabled, false otherwise.
+        /// </summary>
+        public static bool IsWorkerResolutionFeatureDisabled(this IEnvironment environment)
+        {
+            return FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagDisableDynamicWorkerResolution, environment);
+        }
+
+        // Users can disable dynamic worker resolution via setting the appropriate feature flag.
+        // Worker resolution can be enabled for specific workers at the stamp level via hosting config options.
+        // Feature flag takes precedence over hosting config options.
+        public static bool IsDynamicWorkerResolutionEnabled(this IEnvironment environment, HashSet<string> workersAvailableForResolutionViaHostingConfig)
+        {
+            if (environment.IsWorkerResolutionFeatureDisabled() || workersAvailableForResolutionViaHostingConfig is null)
+            {
+                return false;
+            }
+
+            string workerRuntime = environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);
+
+            if (!environment.IsMultiLanguageRuntimeEnvironment() &&
+                !string.IsNullOrWhiteSpace(workerRuntime) &&
+                !environment.IsPlaceholderModeEnabled())
+            {
+                return workersAvailableForResolutionViaHostingConfig.Contains(workerRuntime);
+            }
+
+            return workersAvailableForResolutionViaHostingConfig.Any();
+        }
+
         public static bool IsApplicationInsightsAgentEnabled(this IEnvironment environment)
         {
             // cache the value of the environment variable

src/WebJobs.Script/Environment/EnvironmentSettingNames.cs

@@ -35,6 +35,7 @@ public static class EnvironmentSettingNames
         public const string AppInsightsAgent = "APPLICATIONINSIGHTS_ENABLE_AGENT";
         public const string FunctionsExtensionVersion = "FUNCTIONS_EXTENSION_VERSION";
         public const string FunctionWorkerRuntime = "FUNCTIONS_WORKER_RUNTIME";
+        public const string WorkerProbingPaths = "WORKER_PROBING_PATHS";
         public const string ContainerName = "CONTAINER_NAME";
         public const string WebsitePodName = "WEBSITE_POD_NAME";
         public const string LegionServiceHost = "LEGION_SERVICE_HOST";

src/WebJobs.Script/ScriptConstants.cs

@@ -2,6 +2,7 @@
 // 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 NuGet.Versioning;
 
@@ -132,6 +133,7 @@ public static class ScriptConstants
         public const string FeatureFlagDisableWebHostLogForwarding = "DisableWebHostLogForwarding";
         public const string FeatureFlagDisableMergedWebHostScriptHostConfiguration = "DisableMergedConfiguration";
         public const string FeatureFlagEnableWorkerIndexing = "EnableWorkerIndexing";
+        public const string FeatureFlagDisableDynamicWorkerResolution = "DisableDynamicWorkerResolution";
         public const string FeatureFlagEnableDebugTracing = "EnableDebugTracing";
         public const string FeatureFlagEnableProxies = "EnableProxies";
         public const string FeatureFlagStrictHISModeEnabled = "StrictHISModeEnabled";
@@ -247,6 +249,7 @@ public static class ScriptConstants
         public static readonly long DefaultMaxRequestBodySize = 104857600;
 
         public static readonly ImmutableArray<string> SystemLogCategoryPrefixes = ImmutableArray.Create("Microsoft.Azure.WebJobs.", "Function.", "Worker.", "Host.");
+        public static readonly HashSet<string> HostCapabilities = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 
         public static readonly string FunctionMetadataDirectTypeKey = "DirectType";
         public static readonly string LiveLogsSessionAIKey = "#AzFuncLiveLogsSessionId";

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

@@ -0,0 +1,44 @@
+// 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.IO;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Azure.WebJobs.Script.Workers.Rpc.Configuration
+{
+    // This class resolves worker configurations by scanning the "workers" directory within the Host for worker config files.
+    internal sealed class DefaultWorkerConfigurationResolver : IWorkerConfigurationResolver
+    {
+        private readonly ILogger _logger;
+        private readonly IConfiguration _configuration;
+
+        public DefaultWorkerConfigurationResolver(IConfiguration configuration, ILogger logger)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
+        }
+
+        public List<string> GetWorkerConfigPaths()
+        {
+            var workersDirPath = WorkerConfigurationHelper.GetWorkersDirPath(_configuration);
+            _logger.LogDebug("Workers Directory set to: {workersDirPath}", workersDirPath);
+
+            List<string> workerConfigs = new();
+
+            foreach (var workerDir in Directory.EnumerateDirectories(workersDirPath))
+            {
+                string workerConfigPath = Path.Combine(workerDir, RpcWorkerConstants.WorkerConfigFileName);
+
+                if (File.Exists(workerConfigPath))
+                {
+                    workerConfigs.Add(workerDir);
+                }
+            }
+
+            return workerConfigs;
+        }
+    }
+}