private void ResetEnvironment() { Environment.SetEnvironmentVariable(EnvironmentSettingNames.ContainerName, string.Empty); Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteZipDeployment, string.Empty); Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHomePath, null); WebScriptHostManager.ResetStandbyMode(); }
public async Task StandbyMode_EndToEnd() { var vars = new Dictionary <string, string> { { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1" }, { EnvironmentSettingNames.AzureWebsiteContainerReady, null }, { EnvironmentSettingNames.AzureWebsiteSku, "Dynamic" }, { EnvironmentSettingNames.AzureWebsiteHomePath, null }, { EnvironmentSettingNames.AzureWebsiteConfigurationReady, null }, { EnvironmentSettingNames.AzureWebsiteInstanceId, "87654639876900123453445678890144" }, { "AzureWebEncryptionKey", "0F75CA46E7EBDD39E4CA6B074D1F9A5972B849A55F91A248" } }; using (var env = new TestScopedEnvironmentVariable(vars)) { InitializeTestHost("Windows"); await VerifyWarmupSucceeds(); await VerifyWarmupSucceeds(restart : true); // now specialize the host ScriptSettingsManager.Instance.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "0"); ScriptSettingsManager.Instance.SetSetting(EnvironmentSettingNames.AzureWebsiteContainerReady, "1"); ScriptSettingsManager.Instance.SetSetting(EnvironmentSettingNames.AzureWebsiteConfigurationReady, "1"); Assert.False(WebScriptHostManager.InStandbyMode); Assert.True(ScriptSettingsManager.Instance.ContainerReady); _httpServer.Dispose(); _httpClient.Dispose(); // give time for the specialization to happen string[] logLines = null; await TestHelpers.Await(() => { // wait for the trace indicating that the host has been specialized logLines = _loggerProvider.GetAllLogMessages().Where(p => p.FormattedMessage != null).Select(p => p.FormattedMessage).ToArray(); return(logLines.Contains("Generating 0 job function(s)")); }, userMessageCallback : () => string.Join(Environment.NewLine, _loggerProvider.GetAllLogMessages().Select(p => $"[{p.Timestamp.ToString("HH:mm:ss.fff")}] {p.FormattedMessage}"))); // verify the rest of the expected logs Assert.True(logLines.Count(p => p.Contains("Stopping Host")) >= 1); Assert.Equal(1, logLines.Count(p => p.Contains("Creating StandbyMode placeholder function directory"))); Assert.Equal(1, logLines.Count(p => p.Contains("StandbyMode placeholder function directory created"))); Assert.Equal(2, logLines.Count(p => p.Contains("Starting Host (HostId=placeholder-host"))); Assert.Equal(2, logLines.Count(p => p.Contains("Host is in standby mode"))); Assert.Equal(2, logLines.Count(p => p.Contains("Executed 'Functions.WarmUp' (Succeeded"))); Assert.Equal(1, logLines.Count(p => p.Contains("Starting host specialization"))); Assert.Equal(1, logLines.Count(p => p.Contains($"Starting Host (HostId={_expectedHostId}"))); Assert.Contains("Generating 0 job function(s)", logLines); WebScriptHostManager.ResetStandbyMode(); } }
public void IsWarmUpRequest_ReturnsExpectedValue() { var request = HttpTestHelpers.CreateHttpRequest("POST", "http://azure.com/api/warmup"); Assert.False(StandbyManager.IsWarmUpRequest(request)); var vars = new Dictionary <string, string> { { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "0" }, { EnvironmentSettingNames.AzureWebsiteInstanceId, null } }; using (var env = new TestScopedEnvironmentVariable(vars)) { // in this test we're forcing a transition from non-placeholder mode to placeholder mode // which can't happen in the wild, so we force a reset here WebScriptHostManager.ResetStandbyMode(); _settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1"); Assert.False(StandbyManager.IsWarmUpRequest(request)); _settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsiteInstanceId, "12345"); Assert.True(StandbyManager.IsWarmUpRequest(request)); request = HttpTestHelpers.CreateHttpRequest("POST", "http://azure.com/api/csharphttpwarmup"); Assert.True(StandbyManager.IsWarmUpRequest(request)); request = HttpTestHelpers.CreateHttpRequest("POST", "http://azure.com/api/warmup"); request.Headers.Add(ScriptConstants.AntaresLogIdHeaderName, "xyz123"); Assert.False(StandbyManager.IsWarmUpRequest(request)); request = HttpTestHelpers.CreateHttpRequest("POST", "http://azure.com/api/foo"); Assert.False(StandbyManager.IsWarmUpRequest(request)); } vars = new Dictionary <string, string> { { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "0" }, { EnvironmentSettingNames.AzureWebsiteInstanceId, null } }; using (var env = new TestScopedEnvironmentVariable(vars)) { WebScriptHostManager.ResetStandbyMode(); _settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1"); Assert.False(StandbyManager.IsWarmUpRequest(request)); request = HttpTestHelpers.CreateHttpRequest("POST", "http://azure.com/api/warmup"); _settingsManager.SetSetting(EnvironmentSettingNames.ContainerName, "TestContainer"); Assert.True(_settingsManager.IsLinuxContainerEnvironment); Assert.True(StandbyManager.IsWarmUpRequest(request)); } }
public StandbyModeTests() { _settingsManager = ScriptSettingsManager.Instance; var eventManagerMock = new Mock <IScriptEventManager>(); var routerMock = new Mock <IWebJobsRouter>(); _webHostResolver = new WebHostResolver(_settingsManager, new TestSecretManagerFactory(false), eventManagerMock.Object, WebHostSettings.CreateDefault(_settingsManager), routerMock.Object, new DefaultLoggerFactoryBuilder()); _traceWriter = new TestTraceWriter(TraceLevel.Info); WebScriptHostManager.ResetStandbyMode(); }
public StandbyModeTests() { _settingsManager = ScriptSettingsManager.Instance; var eventManagerMock = new Mock <IScriptEventManager>(); var routerMock = new Mock <IWebJobsRouter>(); var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(_loggerProvider); _webHostResolver = new WebHostResolver(_settingsManager, new TestSecretManagerFactory(false), eventManagerMock.Object, new WebHostSettings(), routerMock.Object, new TestLoggerProviderFactory(_loggerProvider), loggerFactory); WebScriptHostManager.ResetStandbyMode(); }
public async Task StartAssignment_AppliesAssignmentContext() { var envValue = new { Name = Path.GetTempFileName().Replace(".", string.Empty), Value = Guid.NewGuid().ToString() }; _settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1"); WebScriptHostManager.ResetStandbyMode(); var context = new HostAssignmentContext { Environment = new Dictionary <string, string> { { envValue.Name, envValue.Value } } }; bool result = _instanceManager.StartAssignment(context); Assert.True(result); Assert.True(WebScriptHostManager.InStandbyMode); // specialization is done in the background await Task.Delay(500); var value = Environment.GetEnvironmentVariable(envValue.Name); Assert.Equal(value, envValue.Value); // verify logs var logs = _loggerProvider.GetAllLogMessages().Select(p => p.FormattedMessage).ToArray(); Assert.Collection(logs, p => Assert.StartsWith("Starting Assignment", p), p => Assert.StartsWith("Applying 1 app setting(s)", p), p => Assert.StartsWith("Triggering specialization", p)); // calling again should return false, since we're no longer // in placeholder mode _loggerProvider.ClearAllLogMessages(); result = _instanceManager.StartAssignment(context); Assert.False(result); logs = _loggerProvider.GetAllLogMessages().Select(p => p.FormattedMessage).ToArray(); Assert.Collection(logs, p => Assert.StartsWith("Assign called while host is not in placeholder mode", p)); }
public async Task StartAssignment_AppliesAssignmentContext() { var loggerFactory = MockNullLogerFactory.CreateLoggerFactory(); var settingsManager = new ScriptSettingsManager(); var instanceManager = new InstanceManager(settingsManager, null, loggerFactory, null); var envValue = new { Name = Path.GetTempFileName().Replace(".", string.Empty), Value = Guid.NewGuid().ToString() }; settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1"); WebScriptHostManager.ResetStandbyMode(); var context = new HostAssignmentContext { Environment = new Dictionary <string, string> { { envValue.Name, envValue.Value } } }; bool result = instanceManager.StartAssignment(context); Assert.True(result); // specialization is done in the background await Task.Delay(500); var value = Environment.GetEnvironmentVariable(envValue.Name); Assert.Equal(value, envValue.Value); // calling again should return false, since we're no longer // in placeholder mode result = instanceManager.StartAssignment(context); Assert.False(result); }
private void Reset() { WebScriptHostManager.ResetStandbyMode(); _settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, null); }
private void Reset() { WebScriptHostManager.ResetStandbyMode(); WebHostResolver.Reset(); Environment.SetEnvironmentVariable("WEBSITE_PLACEHOLDER_MODE", null); }
public async Task StandbyMode_EndToEnd() { var vars = new Dictionary <string, string> { { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1" }, { EnvironmentSettingNames.AzureWebsiteContainerReady, null }, { EnvironmentSettingNames.AzureWebsiteInstanceId, "87654639876900123453445678890144" }, { "AzureWebEncryptionKey", "0F75CA46E7EBDD39E4CA6B074D1F9A5972B849A55F91A248" } }; using (var env = new TestScopedEnvironmentVariable(vars)) { var httpConfig = new HttpConfiguration(); var testRootPath = Path.Combine(Path.GetTempPath(), "StandbyModeTest"); await FileUtility.DeleteDirectoryAsync(testRootPath, true); var loggerProvider = new TestLoggerProvider(); var loggerProviderFactory = new TestLoggerProviderFactory(loggerProvider); var webHostSettings = new WebHostSettings { IsSelfHost = true, LogPath = Path.Combine(testRootPath, "Logs"), SecretsPath = Path.Combine(testRootPath, "Secrets"), ScriptPath = Path.Combine(testRootPath, "WWWRoot") }; var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(loggerProvider); var webHostBuilder = Program.CreateWebHostBuilder() .ConfigureServices(c => { c.AddSingleton(webHostSettings) .AddSingleton <ILoggerProviderFactory>(loggerProviderFactory) .AddSingleton <ILoggerFactory>(loggerFactory); }); var httpServer = new TestServer(webHostBuilder); var httpClient = httpServer.CreateClient(); httpClient.BaseAddress = new Uri("https://localhost/"); TestHelpers.WaitForWebHost(httpClient); var traces = loggerProvider.GetAllLogMessages().ToArray(); Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Starting Host (HostId=placeholder-host"))); Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Host is in standby mode"))); // issue warmup request and verify var request = new HttpRequestMessage(HttpMethod.Get, "api/warmup"); var response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.OK, response.StatusCode); string responseBody = await response.Content.ReadAsStringAsync(); Assert.Equal("WarmUp complete.", responseBody); // issue warmup request with restart and verify request = new HttpRequestMessage(HttpMethod.Get, "api/warmup?restart=1"); response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.OK, response.StatusCode); responseBody = await response.Content.ReadAsStringAsync(); Assert.Equal("WarmUp complete.", responseBody); // Now specialize the host ScriptSettingsManager.Instance.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "0"); ScriptSettingsManager.Instance.SetSetting(EnvironmentSettingNames.AzureWebsiteContainerReady, "1"); Assert.False(WebScriptHostManager.InStandbyMode); Assert.True(ScriptSettingsManager.Instance.ContainerReady); // give time for the specialization to happen string[] logLines = null; await TestHelpers.Await(() => { // wait for the trace indicating that the host has been specialized logLines = loggerProvider.GetAllLogMessages().Where(p => p.FormattedMessage != null).Select(p => p.FormattedMessage).ToArray(); return(logLines.Contains("Generating 0 job function(s)")); }, userMessageCallback : () => string.Join(Environment.NewLine, loggerProvider.GetAllLogMessages().Select(p => $"[{p.Timestamp.ToString("HH:mm:ss.fff")}] {p.FormattedMessage}"))); httpServer.Dispose(); httpClient.Dispose(); await Task.Delay(2000); var hostConfig = WebHostResolver.CreateScriptHostConfiguration(webHostSettings, true); var expectedHostId = hostConfig.HostConfig.HostId; // verify the rest of the expected logs string text = string.Join(Environment.NewLine, logLines); Assert.True(logLines.Count(p => p.Contains("Stopping Host")) >= 1); Assert.Equal(1, logLines.Count(p => p.Contains("Creating StandbyMode placeholder function directory"))); Assert.Equal(1, logLines.Count(p => p.Contains("StandbyMode placeholder function directory created"))); Assert.Equal(2, logLines.Count(p => p.Contains("Starting Host (HostId=placeholder-host"))); Assert.Equal(2, logLines.Count(p => p.Contains("Host is in standby mode"))); Assert.Equal(2, logLines.Count(p => p.Contains("Executed 'Functions.WarmUp' (Succeeded"))); Assert.Equal(1, logLines.Count(p => p.Contains("Starting host specialization"))); Assert.Equal(1, logLines.Count(p => p.Contains($"Starting Host (HostId={expectedHostId}"))); Assert.Contains("Generating 0 job function(s)", logLines); WebScriptHostManager.ResetStandbyMode(); } }
public StandbyManagerTests() { _settingsManager = ScriptSettingsManager.Instance; WebScriptHostManager.ResetStandbyMode(); }
public async Task StandbyMode_EndToEnd_LinuxContainer() { byte[] bytes = TestHelpers.GenerateKeyBytes(); var encryptionKey = Convert.ToBase64String(bytes); var vars = new Dictionary <string, string> { { EnvironmentSettingNames.ContainerName, "TestContainer" }, { EnvironmentSettingNames.ContainerEncryptionKey, encryptionKey }, { EnvironmentSettingNames.AzureWebsiteContainerReady, null }, { "AzureWebEncryptionKey", "0F75CA46E7EBDD39E4CA6B074D1F9A5972B849A55F91A248" } }; using (var env = new TestScopedEnvironmentVariable(vars)) { var httpConfig = new HttpConfiguration(); var testRootPath = Path.Combine(Path.GetTempPath(), "StandbyModeTest_Linux"); await FileUtility.DeleteDirectoryAsync(testRootPath, true); var loggerProvider = new TestLoggerProvider(); var loggerProviderFactory = new TestLoggerProviderFactory(loggerProvider); var webHostSettings = new WebHostSettings { IsSelfHost = true, LogPath = Path.Combine(testRootPath, "Logs"), SecretsPath = Path.Combine(testRootPath, "Secrets"), ScriptPath = Path.Combine(testRootPath, "WWWRoot") }; var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(loggerProvider); var webHostBuilder = Program.CreateWebHostBuilder() .ConfigureServices(c => { c.AddSingleton(webHostSettings) .AddSingleton <ILoggerProviderFactory>(loggerProviderFactory) .AddSingleton <ILoggerFactory>(loggerFactory); }); var httpServer = new TestServer(webHostBuilder); var httpClient = httpServer.CreateClient(); httpClient.BaseAddress = new Uri("https://localhost/"); TestHelpers.WaitForWebHost(httpClient); var traces = loggerProvider.GetAllLogMessages().ToArray(); Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Starting Host (HostId=placeholder-host"))); Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Host is in standby mode"))); // issue warmup request and verify var request = new HttpRequestMessage(HttpMethod.Get, "api/warmup"); var response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.OK, response.StatusCode); string responseBody = await response.Content.ReadAsStringAsync(); Assert.Equal("WarmUp complete.", responseBody); // issue warmup request with restart and verify request = new HttpRequestMessage(HttpMethod.Get, "api/warmup?restart=1"); response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.OK, response.StatusCode); responseBody = await response.Content.ReadAsStringAsync(); Assert.Equal("WarmUp complete.", responseBody); // Now specialize the host by invoking assign var secretManager = httpServer.Host.Services.GetService <ISecretManager>(); var masterKey = (await secretManager.GetHostSecretsAsync()).MasterKey; string uri = "admin/instance/assign"; request = new HttpRequestMessage(HttpMethod.Post, uri); var environment = new Dictionary <string, string>(); var assignmentContext = new HostAssignmentContext { SiteId = 1234, SiteName = "TestSite", Environment = environment }; var encryptedAssignmentContext = EncryptedHostAssignmentContext.Create(assignmentContext, encryptionKey); string json = JsonConvert.SerializeObject(encryptedAssignmentContext); request.Content = new StringContent(json, Encoding.UTF8, "application/json"); request.Headers.Add(AuthenticationLevelHandler.FunctionsKeyHeaderName, masterKey); response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.Accepted, response.StatusCode); // give time for the specialization to happen string[] logLines = null; await TestHelpers.Await(() => { // wait for the trace indicating that the host has been specialized logLines = loggerProvider.GetAllLogMessages().Where(p => p.FormattedMessage != null).Select(p => p.FormattedMessage).ToArray(); return(logLines.Contains("Generating 0 job function(s)")); }, userMessageCallback : () => string.Join(Environment.NewLine, loggerProvider.GetAllLogMessages().Select(p => $"[{p.Timestamp.ToString("HH:mm:ss.fff")}] {p.FormattedMessage}"))); httpServer.Dispose(); httpClient.Dispose(); await Task.Delay(2000); var hostConfig = WebHostResolver.CreateScriptHostConfiguration(webHostSettings, true); var expectedHostId = hostConfig.HostConfig.HostId; // verify the rest of the expected logs string text = string.Join(Environment.NewLine, logLines); Assert.True(logLines.Count(p => p.Contains("Stopping Host")) >= 1); Assert.Equal(1, logLines.Count(p => p.Contains("Creating StandbyMode placeholder function directory"))); Assert.Equal(1, logLines.Count(p => p.Contains("StandbyMode placeholder function directory created"))); Assert.Equal(2, logLines.Count(p => p.Contains("Starting Host (HostId=placeholder-host"))); Assert.Equal(2, logLines.Count(p => p.Contains("Host is in standby mode"))); Assert.Equal(2, logLines.Count(p => p.Contains("Executed 'Functions.WarmUp' (Succeeded"))); Assert.Equal(1, logLines.Count(p => p.Contains("Starting host specialization"))); Assert.Equal(1, logLines.Count(p => p.Contains($"Starting Host (HostId={expectedHostId}"))); Assert.Contains("Generating 0 job function(s)", logLines); WebScriptHostManager.ResetStandbyMode(); } }
public async Task StandbyMode_EndToEnd_LinuxContainer() { byte[] bytes = TestHelpers.GenerateKeyBytes(); var encryptionKey = Convert.ToBase64String(bytes); var vars = new Dictionary <string, string> { { EnvironmentSettingNames.ContainerName, "TestApp" }, { EnvironmentSettingNames.AzureWebsiteName, "TestApp" }, { EnvironmentSettingNames.ContainerEncryptionKey, encryptionKey }, { EnvironmentSettingNames.AzureWebsiteContainerReady, null }, { EnvironmentSettingNames.AzureWebsiteConfigurationReady, null }, { EnvironmentSettingNames.AzureWebsiteSku, "Dynamic" }, { EnvironmentSettingNames.AzureWebsiteZipDeployment, null }, { "AzureWebEncryptionKey", "0F75CA46E7EBDD39E4CA6B074D1F9A5972B849A55F91A248" } }; using (var env = new TestScopedEnvironmentVariable(vars)) { InitializeTestHost("Linux"); await VerifyWarmupSucceeds(); await VerifyWarmupSucceeds(restart : true); // now specialize the site await Assign(encryptionKey); // immediately call a function - expect the call to block until // the host is fully specialized // the Unauthorized is expected since we havne't specified the key // it's enough here to ensure we don't get a 404 var request = new HttpRequestMessage(HttpMethod.Get, $"api/httptrigger"); request.Headers.Add(ScriptConstants.AntaresColdStartHeaderName, "1"); var response = await _httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); // now that the host is initialized, send a valid key // and expect success var secretManager = _httpServer.Host.Services.GetService <ISecretManager>(); var keys = await secretManager.GetFunctionSecretsAsync("HttpTrigger"); string key = keys.First().Value; request = new HttpRequestMessage(HttpMethod.Get, $"api/httptrigger?code={key}"); request.Headers.Add(ScriptConstants.AntaresColdStartHeaderName, "1"); response = await _httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.False(WebScriptHostManager.InStandbyMode); Assert.True(ScriptSettingsManager.Instance.ContainerReady); // verify warmup function no longer there request = new HttpRequestMessage(HttpMethod.Get, "api/warmup"); response = await _httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); _httpServer.Dispose(); _httpClient.Dispose(); // verify the expected logs var logLines = _loggerProvider.GetAllLogMessages().Where(p => p.FormattedMessage != null).Select(p => p.FormattedMessage).ToArray(); Assert.True(logLines.Count(p => p.Contains("Stopping Host")) >= 1); Assert.Equal(1, logLines.Count(p => p.Contains("Creating StandbyMode placeholder function directory"))); Assert.Equal(1, logLines.Count(p => p.Contains("StandbyMode placeholder function directory created"))); Assert.Equal(2, logLines.Count(p => p.Contains("Starting Host (HostId=placeholder-host"))); Assert.Equal(2, logLines.Count(p => p.Contains("Host is in standby mode"))); Assert.Equal(2, logLines.Count(p => p.Contains("Executed 'Functions.WarmUp' (Succeeded"))); Assert.Equal(1, logLines.Count(p => p.Contains("Validating host assignment context"))); Assert.Equal(1, logLines.Count(p => p.Contains("Starting Assignment"))); Assert.Equal(1, logLines.Count(p => p.Contains("Applying 1 app setting(s)"))); Assert.Equal(1, logLines.Count(p => p.Contains($"Extracting files to '{_webHostSettings.ScriptPath}'"))); Assert.Equal(1, logLines.Count(p => p.Contains("Zip extraction complete"))); Assert.Equal(1, logLines.Count(p => p.Contains("Triggering specialization"))); Assert.Equal(1, logLines.Count(p => p.Contains("Starting host specialization"))); Assert.Equal(1, logLines.Count(p => p.Contains($"Starting Host (HostId={_expectedHostId}"))); Assert.Contains("Node.js HttpTrigger function invoked.", logLines); // verify cold start log entry var coldStartLog = _loggerProvider.GetAllLogMessages().FirstOrDefault(p => p.Category == ScriptConstants.LogCategoryHostMetrics); JObject coldStartData = JObject.Parse(coldStartLog.FormattedMessage); Assert.Equal("Dynamic", coldStartData["sku"]); Assert.True((int)coldStartData["dispatchDuration"] > 0); Assert.True((int)coldStartData["functionDuration"] > 0); WebScriptHostManager.ResetStandbyMode(); } }
public async Task StandbyMode_EndToEnd() { var vars = new Dictionary <string, string> { { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1" }, { EnvironmentSettingNames.AzureWebsiteInstanceId, "87654639876900123453445678890144" } }; using (var env = new TestScopedEnvironmentVariable(vars)) { var httpConfig = new HttpConfiguration(); var settingsManager = ScriptSettingsManager.Instance; var testRootPath = Path.Combine(Path.GetTempPath(), "StandbyModeTest"); if (Directory.Exists(testRootPath)) { Directory.Delete(testRootPath, true); } var traceWriter = new TestTraceWriter(TraceLevel.Info); var webHostSettings = new WebHostSettings { IsSelfHost = true, LogPath = testRootPath, SecretsPath = Path.Combine(testRootPath, "Secrets"), ScriptPath = testRootPath, TraceWriter = traceWriter }; var httpServer = new HttpServer(httpConfig); var httpClient = new HttpClient(httpServer); httpClient.BaseAddress = new Uri("https://localhost/"); TestHelpers.WaitForWebHost(httpClient); var traces = traceWriter.Traces.ToArray(); Assert.Equal($"Creating StandbyMode placeholder function directory ({Path.GetTempPath()}Functions\\Standby\\WWWRoot)", traces[0].Message); Assert.Equal("StandbyMode placeholder function directory created", traces[1].Message); // issue warmup request and verify var request = new HttpRequestMessage(HttpMethod.Get, "api/warmup"); var response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.OK, response.StatusCode); string responseBody = await response.Content.ReadAsStringAsync(); Assert.Equal("WarmUp complete.", responseBody); // issue warmup request with restart and verify request = new HttpRequestMessage(HttpMethod.Get, "api/warmup?restart=1"); response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.OK, response.StatusCode); responseBody = await response.Content.ReadAsStringAsync(); Assert.Equal("WarmUp complete.", responseBody); // Now specialize the host ScriptSettingsManager.Instance.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "0"); request = new HttpRequestMessage(HttpMethod.Get, "api/dne"); response = await httpClient.SendAsync(request); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); httpServer.Dispose(); httpClient.Dispose(); await Task.Delay(2000); // verify logs string[] logLines = traceWriter.Traces.Select(p => p.Message).ToArray(); Assert.Equal(2, logLines.Count(p => p.Contains("Host is in standby mode"))); Assert.Equal(2, logLines.Count(p => p.Contains("Stopping Host"))); Assert.Equal(2, logLines.Count(p => p.Contains("Executed 'Functions.WarmUp' (Succeeded"))); Assert.Equal(1, logLines.Count(p => p.Contains("Starting host specialization"))); WebScriptHostManager.ResetStandbyMode(); } }
public StandbyManagerTests() { _settingsManager = ScriptSettingsManager.Instance; _traceWriter = new TestTraceWriter(TraceLevel.Info); WebScriptHostManager.ResetStandbyMode(); }