4.16.5 Hotfix (#9165)

* Revert "Switching worker indexing feature flag from opt-in to opt-out (#8864)" (#9163)

* Bumping minor version

---------

Co-authored-by: Naren Soni <[email protected]>
Co-authored-by: azfuncgh <[email protected]>

Author: 3 people

build/common.props

@@ -5,7 +5,7 @@
     <LangVersion>latest</LangVersion>
     <MajorVersion>4</MajorVersion>
     <MinorVersion>16</MinorVersion>
-    <PatchVersion>4</PatchVersion>
+    <PatchVersion>5</PatchVersion>
     <BuildNumber Condition="'$(BuildNumber)' == '' ">0</BuildNumber>
     <PreviewVersion></PreviewVersion>
 

src/WebJobs.Script/Host/WorkerFunctionMetadataProvider.cs

@@ -20,20 +20,20 @@ namespace Microsoft.Azure.WebJobs.Script
     internal class WorkerFunctionMetadataProvider : IWorkerFunctionMetadataProvider
     {
         private readonly Dictionary<string, ICollection<string>> _functionErrors = new Dictionary<string, ICollection<string>>();
-        private readonly IOptions<ScriptApplicationHostOptions> _scriptApplicationHostOptions;
+        private readonly IOptions<ScriptJobHostOptions> _scriptOptions;
         private readonly ILogger _logger;
         private readonly IEnvironment _environment;
         private readonly IWebHostRpcWorkerChannelManager _channelManager;
         private string _workerRuntime;
         private ImmutableArray<FunctionMetadata> _functions;
 
         public WorkerFunctionMetadataProvider(
-            IOptions<ScriptApplicationHostOptions> scriptOptions,
+            IOptions<ScriptJobHostOptions> scriptOptions,
             ILogger<WorkerFunctionMetadataProvider> logger,
             IEnvironment environment,
             IWebHostRpcWorkerChannelManager webHostRpcWorkerChannelManager)
         {
-            _scriptApplicationHostOptions = scriptOptions;
+            _scriptOptions = scriptOptions;
             _logger = logger;
             _environment = environment;
             _channelManager = webHostRpcWorkerChannelManager;
@@ -95,7 +95,7 @@ public async Task<FunctionMetadataResult> GetFunctionMetadataAsync(IEnumerable<R
                             _logger.FunctionMetadataProviderFunctionFound(_functions.IsDefault ? 0 : _functions.Count());
 
                             // Validate if the app has functions in legacy format and add in logs to inform about the mixed app
-                            _ = Task.Delay(TimeSpan.FromMinutes(1)).ContinueWith(t => ValidateFunctionAppFormat(_scriptApplicationHostOptions.Value.ScriptPath, _logger, _environment));
+                            _ = Task.Delay(TimeSpan.FromMinutes(1)).ContinueWith(t => ValidateFunctionAppFormat(_scriptOptions.Value.RootScriptPath, _logger, _environment));
 
                             break;
                         }

src/WebJobs.Script/ScriptConstants.cs

@@ -121,7 +121,7 @@ public static class ScriptConstants
         public const string FeatureFlagEnableDiagnosticEventLogging = "EnableDiagnosticEventLogging";
         public const string FeatureFlagDisableDiagnosticEventLogging = "DisableDiagnosticEventLogging";
         public const string FeatureFlagDisableMergedWebHostScriptHostConfiguration = "DisableMergedConfiguration";
-        public const string FeatureFlagDisableWorkerIndexing = "DisableWorkerIndexing";
+        public const string FeatureFlagEnableWorkerIndexing = "EnableWorkerIndexing";
         public const string FeatureFlagEnableDebugTracing = "EnableDebugTracing";
         public const string FeatureFlagEnableMultiLanguageWorker = "EnableMultiLanguageWorker";
         public const string FeatureFlagEnableProxies = "EnableProxies";

src/WebJobs.Script/Utility.cs

@@ -911,9 +911,12 @@ public static void ValidateRetryOptions(RetryOptions
 
         public static bool CanWorkerIndex(IEnumerable<RpcWorkerConfig> workerConfigs, IEnvironment environment)
         {
-            if (!FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagDisableWorkerIndexing, environment)
-                && workerConfigs != null
-                && !environment.IsMultiLanguageRuntimeEnvironment())
+            if (!FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableWorkerIndexing, environment))
+            {
+                return false;
+            }
+
+            if (workerConfigs != null && !environment.IsMultiLanguageRuntimeEnvironment())
             {
                 var workerRuntime = environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);
                 var workerConfig = workerConfigs.Where(c => c.Description != null && c.Description.Language != null && c.Description.Language.Equals(workerRuntime, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/EndToEndTestFixture.cs

@@ -122,9 +122,6 @@ string GetDestPath(int counter)
             string logPath = Path.Combine(Path.GetTempPath(), @"Functions");
             if (!string.IsNullOrEmpty(_functionsWorkerRuntime))
             {
-                string currentFeatureFlags = Environment.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags);
-                var featureFlags = string.IsNullOrEmpty(currentFeatureFlags) ? ScriptConstants.FeatureFlagDisableWorkerIndexing : $"{currentFeatureFlags}, {ScriptConstants.FeatureFlagDisableWorkerIndexing}";
-                Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, featureFlags);
                 Environment.SetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName, _functionsWorkerRuntime);
                 Environment.SetEnvironmentVariable(RpcWorkerConstants.FunctionsWorkerProcessCountSettingName, _workerProcessCount.ToString());
             }

test/WebJobs.Script.Tests.Shared/TestHostBuilderExtensions.cs

@@ -3,8 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs;
 using Microsoft.Azure.WebJobs.Host.Storage;
 using Microsoft.Azure.WebJobs.Script;
@@ -102,13 +100,11 @@ private static IServiceCollection AddFunctionMetadataManager(this IServiceCollec
             var optionsMonitor = new OptionsMonitor<ScriptApplicationHostOptions>(factory, changeTokens, factory);
 
             var metadataProvider = new HostFunctionMetadataProvider(optionsMonitor, NullLogger<HostFunctionMetadataProvider>.Instance, metricsLogger);
-
-            var workerProvider = new Mock<IWorkerFunctionMetadataProvider>();
-            workerProvider.Setup(m => m.GetFunctionMetadataAsync(It.IsAny<IEnumerable<RpcWorkerConfig>>(), false)).Returns(Task.FromResult(new FunctionMetadataResult(true, ImmutableArray<FunctionMetadata>.Empty)));
-            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, workerProvider.Object, metadataProvider);
+            var defaultProvider = new FunctionMetadataProvider(NullLogger<FunctionMetadataProvider>.Instance, null, metadataProvider);
             var metadataManager = TestFunctionMetadataManager.GetFunctionMetadataManager(new OptionsWrapper<ScriptJobHostOptions>(new ScriptJobHostOptions()), defaultProvider, new List<IFunctionProvider>(), new OptionsWrapper<HttpWorkerOptions>(new HttpWorkerOptions()), new NullLoggerFactory(), new TestOptionsMonitor<LanguageWorkerOptions>(TestHelpers.GetTestLanguageWorkerOptions()));
             services.AddSingleton<IFunctionMetadataManager>(metadataManager);
             services.AddSingleton<IFunctionMetadataProvider>(defaultProvider);
+
             return services;
         }
     }

test/WebJobs.Script.Tests/FunctionMetadataProviderTests.cs

@@ -84,7 +84,7 @@ public void GetFunctionMetadataAsync_HostIndexing()
             functionMetadataCollection.Add(GetTestFunctionMetadata());
 
             var workerConfigs = TestHelpers.GetTestWorkerConfigs().ToImmutableArray();
-            workerConfigs.ToList().ForEach(config => config.Description.WorkerIndexing = "false");
+            workerConfigs.ToList().ForEach(config => config.Description.WorkerIndexing = "true");
             var scriptjobhostoptions = new ScriptJobHostOptions();
             scriptjobhostoptions.RootScriptPath = Path.Combine(Environment.CurrentDirectory, @"..", "..", "..", "..", "..", "sample", "node");
 

test/WebJobs.Script.Tests/ScriptStartupTypeDiscovererTests.cs

@@ -601,6 +601,7 @@ void CopyToBin(string path)
                 tempOptions.WorkerConfigs.Add(workerConfig);
 
                 var languageWorkerOptions = new TestOptionsMonitor<LanguageWorkerOptions>(tempOptions);
+                Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
                 Environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, "python");
                 var discoverer = new ScriptStartupTypeLocator(directory.Path, testLogger, mockExtensionBundleManager.Object, mockFunctionMetadataManager, testMetricsLogger, languageWorkerOptions);
 

test/WebJobs.Script.Tests/UtilityTests.cs

@@ -857,17 +857,17 @@ public void GetFunctionAppContentEditingState_Returns_Expected(bool isFileSystem
         }
 
         [Theory]
-        [InlineData(true, true, false)]
-        [InlineData(true, false, false)]
+        [InlineData(false, true, false)]
         [InlineData(false, false, false)]
-        [InlineData(false, true, true)]
-        public void VerifyWorkerIndexingDecisionLogic(bool disableWorkerIndexingFeatureFlag, bool workerIndexingConfigProperty, bool expected)
+        [InlineData(true, false, false)]
+        [InlineData(true, true, true)]
+        public void VerifyWorkerIndexingDecisionLogic(bool workerIndexingFeatureFlag, bool workerIndexingConfigProperty, bool expected)
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (disableWorkerIndexingFeatureFlag)
+            if (workerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
             }
             RpcWorkerConfig workerConfig = new RpcWorkerConfig() { Description = TestHelpers.GetTestWorkerDescription("python", "none", workerIndexingConfigProperty) };
             bool workerShouldIndex = Utility.CanWorkerIndex(new List<RpcWorkerConfig>() { workerConfig }, testEnv);
@@ -881,9 +881,9 @@ public void WorkerIndexingDecisionLogic_NullConfig(bool workerIndexingFeatureFla
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (!workerIndexingFeatureFlag)
+            if (workerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
             }
             bool workerShouldIndex = Utility.CanWorkerIndex(null, testEnv);
             Assert.Equal(expected, workerShouldIndex);
@@ -896,9 +896,9 @@ public void WorkerIndexingDecisionLogic_NullConfigDescription(bool workerIndexin
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (!workerIndexingFeatureFlag)
+            if (workerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
             }
             RpcWorkerConfig workerConfig = new RpcWorkerConfig();
             bool workerShouldIndex = Utility.CanWorkerIndex(new List<RpcWorkerConfig>() { workerConfig }, testEnv);
@@ -912,9 +912,9 @@ public void WorkerIndexingDecisionLogic_NullWorkerIndexingProperty(bool workerIn
         {
             var testEnv = new TestEnvironment();
             testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, RpcWorkerConstants.PythonLanguageWorkerName);
-            if (!workerIndexingFeatureFlag)
+            if (workerIndexingFeatureFlag)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
             }
             RpcWorkerConfig workerConfig = new RpcWorkerConfig()
             {

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

@@ -646,9 +646,9 @@ private static RpcFunctionInvocationDispatcher GetTestFunctionDispatcher(int max
             {
                 testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, runtime);
             }
-            if (!workerIndexing)
+            if (workerIndexing)
             {
-                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagDisableWorkerIndexing);
+                testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
             }
             if (placeholder)
             {