Ensuring warmup file operations only happen if configuration is for standby state

Author: fabiocav

src/WebJobs.Script.WebHost/Configuration/ScriptApplicationHostOptionsSetup.cs

@@ -59,6 +59,7 @@ public void Configure(string name, ScriptApplicationHostOptions options)
                 options.ScriptPath = Path.Combine(tempRoot, @"functions\standby\wwwroot");
                 options.SecretsPath = Path.Combine(tempRoot, @"functions\standby\secrets");
                 options.IsSelfHost = options.IsSelfHost;
+                options.IsStandbyConfiguration = true;
             }
         }
 

src/WebJobs.Script.WebHost/Standby/StandbyInitializationService.cs

@@ -17,9 +17,9 @@ public StandbyInitializationService(IStandbyManager standbyManager)
             _standbyManager = standbyManager ?? throw new ArgumentNullException(nameof(standbyManager));
         }
 
-        public async Task StartAsync(CancellationToken cancellationToken)
+        public Task StartAsync(CancellationToken cancellationToken)
         {
-            await _standbyManager.InitializeAsync();
+            return _standbyManager.InitializeAsync();
         }
 
         public Task StopAsync(CancellationToken cancellationToken)

src/WebJobs.Script.WebHost/Standby/StandbyManager.cs

@@ -6,6 +6,7 @@
 using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Google.Protobuf.WellKnownTypes;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Diagnostics;
@@ -182,7 +183,17 @@ public async Task InitializeAsync()
 
         private async Task CreateStandbyWarmupFunctions()
         {
-            string scriptPath = _options.CurrentValue.ScriptPath;
+            ScriptApplicationHostOptions options = _options.CurrentValue;
+
+            if (!options.IsStandbyConfiguration)
+            {
+                _logger.LogDebug(new EventId(600, "StandByWarmupFunctionsCreationOnSpecializedSite"),
+                    $"{nameof(CreateStandbyWarmupFunctions)} called with a specialized site configuration. Skipping warmup function creation.");
+
+                return;
+            }
+
+            string scriptPath = options.ScriptPath;
             _logger.LogInformation($"Creating StandbyMode placeholder function directory ({scriptPath})");
 
             await FileUtility.DeleteDirectoryAsync(scriptPath, true);

src/WebJobs.Script/Config/ScriptApplicationHostOptions.cs

@@ -29,5 +29,7 @@ public class ScriptApplicationHostOptions
         public bool HasParentScope { get; set; }
 
         public IServiceProvider RootServiceProvider { get; set; }
+
+        public bool IsStandbyConfiguration { get; internal set; }
     }
 }

test/WebJobs.Script.Tests.Integration/Host/StandbyManager/StandbyManagerE2ETestBase.cs

@@ -43,7 +43,7 @@ public StandbyManagerE2ETestBase()
             StandbyManager.ResetChangeToken();
         }
 
-        protected async Task InitializeTestHostAsync(string testDirName, IEnvironment environment)
+        protected async Task<IWebHostBuilder> CreateWebHostBuilderAsync(string testDirName, IEnvironment environment)
         {
             var httpConfig = new HttpConfiguration();
             var uniqueTestRootPath = Path.Combine(_testRootPath, testDirName, Guid.NewGuid().ToString());
@@ -80,6 +80,7 @@ protected async Task InitializeTestHostAsync(string testDirName, IEnvironment en
                 .ConfigureLogging(c =>
                 {
                     c.AddProvider(_loggerProvider);
+                    c.AddFilter((cat, lev) => true);
                 })
                 .ConfigureServices(c =>
                 {
@@ -99,6 +100,12 @@ protected async Task InitializeTestHostAsync(string testDirName, IEnvironment en
                     b.AddProvider(_loggerProvider);
                 });
 
+            return webHostBuilder;
+        }
+
+        protected async Task InitializeTestHostAsync(string testDirName, IEnvironment environment)
+        {
+            var webHostBuilder = await CreateWebHostBuilderAsync(testDirName, environment);
             _httpServer = new TestServer(webHostBuilder);
             _httpClient = _httpServer.CreateClient();
             _httpClient.BaseAddress = new Uri("https://localhost/");
@@ -165,9 +172,9 @@ protected static object GetCachedTimeZoneInfo()
 
         public virtual void Dispose()
         {
-            _loggerProvider.Dispose();
-            _httpServer.Dispose();
-            _httpClient.Dispose();
+            _loggerProvider?.Dispose();
+            _httpServer?.Dispose();
+            _httpClient?.Dispose();
             CleanupTestDirectory();
         }
     }

test/WebJobs.Script.Tests.Integration/Host/StandbyManager/StandbyManagerE2ETests_Windows.cs

@@ -8,8 +8,12 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.WebJobs.Script.Tests;
 using Xunit;
 
@@ -82,6 +86,51 @@ await TestHelpers.Await(() =>
             Assert.NotSame(GetCachedTimeZoneInfo(), _originalTimeZoneInfoCache);
         }
 
+        [Fact]
+        public async Task InitialisAsync_WithSpecializedSite_SkipsWarmupFunctionsAndLogs()
+        {
+            _settings.Add(EnvironmentSettingNames.AzureWebsiteInstanceId, Guid.NewGuid().ToString());
+            var environment = new TestEnvironment(_settings);
+
+            // We cannot create and run a full test host as there's no way to issue
+            // requests to the TestServer before initialization has occurred.
+            var webHostBuilder = await CreateWebHostBuilderAsync("Windows", environment);
+            IWebHost host = webHostBuilder.Build();
+
+            // Pull the service out of the built host. If it were easier to construct, we'd do that instead.
+            var standbyManager = host.Services.GetService<IStandbyManager>();
+            var scriptHostManager = host.Services.GetService<IScriptHostManager>() as WebJobsScriptHostService;
+
+            // Simulate the race condition by flipping the specialization env vars and calling
+            // Specialize before the call to Initialize was made.
+            environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "0");
+            environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteContainerReady, "1");
+
+            bool changeTokenFired = false;
+            using (StandbyManager.ChangeToken.RegisterChangeCallback(_ => changeTokenFired = true, null))
+            {
+                Task specializeTask = standbyManager.SpecializeHostAsync();
+
+                await TestHelpers.Await(() => changeTokenFired);
+
+                await standbyManager.InitializeAsync();
+
+                await TestHelpers.Await(() => _loggerProvider.GetLog().Contains(" called with a specialized site configuration. Skipping warmup function creation."));
+
+                // Note: we also need to start the ScriptHostManager or else specialization will never complete
+                await scriptHostManager.StartAsync(CancellationToken.None);
+
+                await specializeTask;
+
+                Assert.True(changeTokenFired);
+
+                bool warmupCreationLogPresent = _loggerProvider.GetAllLogMessages()
+                    .Any(p => p.FormattedMessage != null && p.FormattedMessage.StartsWith("Creating StandbyMode placeholder function directory"));
+
+                Assert.False(warmupCreationLogPresent);
+            }
+        }
+
         [Fact(Skip = "https://github.com/Azure/azure-functions-host/issues/4230")]
         public async Task StandbyModeE2E_Java()
         {