public EnsureHostRunningHandler(HttpConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } _scriptHostManager = (WebScriptHostManager)config.DependencyResolver.GetService(typeof(WebScriptHostManager)); }
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 void AddRouteDataToRequest_DoesNotAddRequestProperty_WhenRouteDataNull() { var mockRouteData = new Mock <IHttpRouteData>(MockBehavior.Strict); IDictionary <string, object> values = null; mockRouteData.Setup(p => p.Values).Returns(values); HttpRequestMessage request = new HttpRequestMessage(); WebScriptHostManager.AddRouteDataToRequest(mockRouteData.Object, request); Assert.False(request.Properties.ContainsKey(HttpExtensionConstants.AzureWebJobsHttpRouteDataKey)); }
public async Task EmptyHost_StartsSuccessfully() { await _fixture.InitializationTask; string functionTestDir = Path.Combine(_fixture.TestFunctionRoot, Guid.NewGuid().ToString()); Directory.CreateDirectory(functionTestDir); // important for the repro that these directories no not exist string logDir = Path.Combine(_fixture.TestLogsRoot, Guid.NewGuid().ToString()); string secretsDir = Path.Combine(_fixture.TestSecretsRoot, Guid.NewGuid().ToString()); JObject hostConfig = new JObject { { "id", "123456" } }; File.WriteAllText(Path.Combine(functionTestDir, ScriptConstants.HostMetadataFileName), hostConfig.ToString()); ScriptHostConfiguration config = new ScriptHostConfiguration { RootScriptPath = functionTestDir, RootLogPath = logDir, FileLoggingMode = FileLoggingMode.Always }; string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage); ISecretsRepository repository = new BlobStorageSecretsRepository(secretsDir, connectionString, "EmptyHost_StartsSuccessfully"); ISecretManager secretManager = new SecretManager(_settingsManager, repository, null); WebHostSettings webHostSettings = new WebHostSettings(); webHostSettings.SecretsPath = _secretsDirectory.Path; var mockEventManager = new Mock <IScriptEventManager>(); IWebJobsRouter router = _fixture.CreateRouter(); ScriptHostManager hostManager = new WebScriptHostManager(config, new TestSecretManagerFactory(secretManager), mockEventManager.Object, _settingsManager, webHostSettings, router, NullLoggerFactory.Instance); Task runTask = Task.Run(() => hostManager.RunAndBlock()); await TestHelpers.Await(() => hostManager.State == ScriptHostState.Running, timeout : 10000); hostManager.Stop(); Assert.Equal(ScriptHostState.Default, hostManager.State); // give some time for the logs to be flushed fullly await Task.Delay(FileWriter.LogFlushIntervalMs * 3); string hostLogFilePath = Directory.EnumerateFiles(Path.Combine(logDir, "Host")).Single(); string hostLogs = File.ReadAllText(hostLogFilePath); Assert.Contains("Generating 0 job function(s)", hostLogs); Assert.Contains("No job functions found.", hostLogs); Assert.Contains("Job host started", hostLogs); Assert.Contains("Job host stopped", hostLogs); }
public async Task StandbyMode_EndToEnd() { var vars = new Dictionary <string, string> { { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1" }, { EnvironmentSettingNames.AzureWebsiteContainerReady, null }, { EnvironmentSettingNames.AzureWebsiteSku, "Dynamic" }, { EnvironmentSettingNames.AzureWebsiteHomePath, 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"); 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(); } }
internal static void Initialize(ContainerBuilder builder, WebHostSettings settings) { ScriptHostConfiguration scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = settings.ScriptPath, RootLogPath = settings.LogPath, FileLoggingEnabled = true }; // If running on Azure Web App, derive the host ID from the site name string hostId = Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME"); if (!String.IsNullOrEmpty(hostId)) { // Truncate to the max host name length if needed const int MaximumHostIdLength = 32; if (hostId.Length > MaximumHostIdLength) { hostId = hostId.Substring(0, MaximumHostIdLength); } // Trim any trailing - as they can cause problems with queue names hostId = hostId.TrimEnd('-'); scriptHostConfig.HostConfig.HostId = hostId.ToLowerInvariant(); } WebScriptHostManager scriptHostManager = new WebScriptHostManager(scriptHostConfig); builder.RegisterInstance <WebScriptHostManager>(scriptHostManager); SecretManager secretManager = new SecretManager(settings.SecretsPath); // Make sure that host secrets get created on startup if they don't exist secretManager.GetHostSecrets(); builder.RegisterInstance <SecretManager>(secretManager); WebHookReceiverManager webHookReceiverManager = new WebHookReceiverManager(secretManager); builder.RegisterInstance <WebHookReceiverManager>(webHookReceiverManager); if (!settings.IsSelfHost) { HostingEnvironment.QueueBackgroundWorkItem((ct) => scriptHostManager.RunAndBlock(ct)); } else { Task.Run(() => scriptHostManager.RunAndBlock()); } }
private async Task RunTimeoutExceptionTest(TraceWriter trace, bool handleCancellation) { TimeSpan gracePeriod = TimeSpan.FromMilliseconds(5000); _manager = await CreateAndStartWebScriptHostManager(trace); string scenarioName = handleCancellation ? "useToken" : "ignoreToken"; var args = new Dictionary <string, object> { { "input", scenarioName } }; await Assert.ThrowsAsync <FunctionTimeoutException>(() => _manager.Instance.CallAsync("TimeoutToken", args)); }
public void Warmup_Succeeds() { using (new TestEnvironment()) { var settings = GetWebHostSettings(); WebScriptHostManager.WarmUp(settings); var hostLogPath = Path.Combine(settings.LogPath, @"host"); var hostLogFile = Directory.GetFiles(hostLogPath).First(); var content = File.ReadAllText(hostLogFile); Assert.Contains("Warm up started", content); Assert.Contains("Warm up succeeded", content); } }
public async Task MultipleHostRestarts() { string functionTestDir = Path.Combine(_fixture.TestFunctionRoot, Guid.NewGuid().ToString()); Directory.CreateDirectory(functionTestDir); string logDir = Path.Combine(_fixture.TestLogsRoot, Guid.NewGuid().ToString()); string secretsDir = Path.Combine(_fixture.TestSecretsRoot, Guid.NewGuid().ToString()); ScriptHostConfiguration config = new ScriptHostConfiguration { RootLogPath = logDir, RootScriptPath = functionTestDir, FileLoggingMode = FileLoggingMode.Always, }; ISecretsRepository repository = new FileSystemSecretsRepository(_secretsDirectory.Path); SecretManager secretManager = new SecretManager(_settingsManager, repository, NullTraceWriter.Instance, null); WebHostSettings webHostSettings = new WebHostSettings(); webHostSettings.SecretsPath = _secretsDirectory.Path; var mockEventManager = new Mock <IScriptEventManager>(); var factoryMock = new Mock <IScriptHostFactory>(); int count = 0; factoryMock.Setup(p => p.Create(It.IsAny <IScriptHostEnvironment>(), It.IsAny <IScriptEventManager>(), _settingsManager, config)).Callback(() => { count++; }).Throws(new Exception("Kaboom!")); ScriptHostManager hostManager = new WebScriptHostManager(config, new TestSecretManagerFactory(secretManager), mockEventManager.Object, _settingsManager, webHostSettings, factoryMock.Object); Task runTask = Task.Run(() => hostManager.RunAndBlock()); await TestHelpers.Await(() => { return(count > 3); }); hostManager.Stop(); Assert.Equal(ScriptHostState.Default, hostManager.State); // regression test: previously on multiple restarts we were recomposing // the writer on each restart, resulting in a nested chain of writers // increasing on each restart Assert.Equal(typeof(SystemTraceWriter), config.TraceWriter.GetType()); }
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)); }
internal static void Initialize(ContainerBuilder builder, WebHostSettings settings) { ScriptHostConfiguration scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = settings.ScriptPath, RootLogPath = settings.LogPath, FileLoggingEnabled = true }; // If running on Azure Web App, derive the host ID from the site name string hostId = Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME"); if (!String.IsNullOrEmpty(hostId)) { // Truncate to the max host name length if needed const int MaximumHostIdLength = 32; if (hostId.Length > MaximumHostIdLength) { hostId = hostId.Substring(0, MaximumHostIdLength); } // Trim any trailing - as they can cause problems with queue names hostId = hostId.TrimEnd('-'); scriptHostConfig.HostConfig.HostId = hostId.ToLowerInvariant(); } WebScriptHostManager scriptHostManager = new WebScriptHostManager(scriptHostConfig); builder.RegisterInstance<WebScriptHostManager>(scriptHostManager); SecretManager secretManager = new SecretManager(settings.SecretsPath); // Make sure that host secrets get created on startup if they don't exist secretManager.GetHostSecrets(); builder.RegisterInstance<SecretManager>(secretManager); WebHookReceiverManager webHookReceiverManager = new WebHookReceiverManager(secretManager); builder.RegisterInstance<WebHookReceiverManager>(webHookReceiverManager); if (!settings.IsSelfHost) { HostingEnvironment.QueueBackgroundWorkItem((ct) => scriptHostManager.RunAndBlock(ct)); } else { Task.Run(() => scriptHostManager.RunAndBlock()); } }
public async Task DelayUntilHostReady_HostNotRunning_Returns503() { var settingsManager = ScriptSettingsManager.Instance; var eventManager = new Mock <IScriptEventManager>(); var managerMock = new Mock <WebScriptHostManager>(MockBehavior.Strict, new ScriptHostConfiguration(), new TestSecretManagerFactory(), eventManager.Object, settingsManager, new WebHostSettings { SecretsPath = _secretsDirectory.Path }, null, NullLoggerFactory.Instance, null, null, null, null, null, 1, 50); managerMock.SetupGet(p => p.State).Returns(ScriptHostState.Default); managerMock.SetupGet(p => p.LastError).Returns((Exception)null); var ex = await Assert.ThrowsAsync <HttpException>(async() => await WebScriptHostManager.DelayUntilHostReady(managerMock.Object, 1, 50)); Assert.Equal(HttpStatusCode.ServiceUnavailable, (HttpStatusCode)ex.StatusCode); }
public async Task Warmup_Succeeds() { using (new TestEnvironment()) { var settings = GetWebHostSettings(); var eventManagerMock = new Mock <IScriptEventManager>(); await WebScriptHostManager.WarmUp(settings, eventManagerMock.Object); var hostLogPath = Path.Combine(settings.LogPath, @"host"); var hostLogFile = Directory.GetFiles(hostLogPath).First(); var content = File.ReadAllText(hostLogFile); Assert.Contains("Warm up started", content); Assert.Contains("Executed 'Functions.Test-CSharp' (Succeeded, Id=", content); Assert.Contains("Warm up succeeded", content); } }
private void DisplayHttpFunctionsInfo(HttpSelfHostConfiguration config) { WebScriptHostManager hostManager = config.DependencyResolver.GetService <WebScriptHostManager>(); if (hostManager != null) { foreach (var function in hostManager.Instance.Functions.Where(f => f.Metadata.IsHttpFunction())) { var httpRoute = function.Metadata.Bindings.FirstOrDefault(b => b.Type == "httpTrigger").Raw["route"]?.ToString(); httpRoute = httpRoute ?? function.Name; var hostRoutePrefix = hostManager.Instance.ScriptConfig.HttpRoutePrefix ?? "api/"; hostRoutePrefix = string.IsNullOrEmpty(hostRoutePrefix) || hostRoutePrefix.EndsWith("/") ? hostRoutePrefix : $"{hostRoutePrefix}/"; ColoredConsole.WriteLine($"{TitleColor($"Http Function {function.Name}:")} {config.BaseAddress.ToString()}{hostRoutePrefix}{httpRoute}"); } } }
internal static void Initialize(ContainerBuilder builder) { string logFilePath; string scriptRootPath; string secretsPath; string home = Environment.GetEnvironmentVariable("HOME"); bool isLocal = string.IsNullOrEmpty(home); if (isLocal) { // we're running locally scriptRootPath = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, @"..\..\sample"); logFilePath = Path.Combine(Path.GetTempPath(), @"Functions"); secretsPath = HttpContext.Current.Server.MapPath("~/App_Data/Secrets"); } else { // we're running in Azure scriptRootPath = Path.Combine(home, @"site\wwwroot"); logFilePath = Path.Combine(home, @"LogFiles\Application\Functions"); secretsPath = Path.Combine(home, @"data\Functions\secrets"); } ScriptHostConfiguration scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = scriptRootPath, RootLogPath = logFilePath, FileLoggingEnabled = true }; WebScriptHostManager scriptHostManager = new WebScriptHostManager(scriptHostConfig); builder.RegisterInstance <WebScriptHostManager>(scriptHostManager); SecretManager secretManager = new SecretManager(secretsPath); builder.RegisterInstance <SecretManager>(secretManager); WebHookReceiverManager webHookRecieverManager = new WebHookReceiverManager(secretManager); builder.RegisterInstance <WebHookReceiverManager>(webHookRecieverManager); Task.Run(() => scriptHostManager.RunAndBlock(CancellationToken.None)); }
private async Task <WebScriptHostManager> CreateAndStartWebScriptHostManager(TraceWriter traceWriter) { var functions = new Collection <string> { "TimeoutToken" }; ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = $@"TestScripts\CSharp", TraceWriter = traceWriter, FileLoggingMode = FileLoggingMode.Always, Functions = functions, FunctionTimeout = TimeSpan.FromSeconds(3) }; var manager = new WebScriptHostManager(config, new TestSecretManagerFactory(), _settingsManager, new WebHostSettings()); Task task = Task.Run(() => { manager.RunAndBlock(); }); await TestHelpers.Await(() => manager.State == ScriptHostState.Running); return(manager); }
internal static void Initialize(ContainerBuilder builder) { string logFilePath; string scriptRootPath; string secretsPath; string home = Environment.GetEnvironmentVariable("HOME"); bool isLocal = string.IsNullOrEmpty(home); if (isLocal) { // we're running locally scriptRootPath = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, @"..\..\sample"); logFilePath = Path.Combine(Path.GetTempPath(), @"Functions"); secretsPath = HttpContext.Current.Server.MapPath("~/App_Data/Secrets"); } else { // we're running in Azure scriptRootPath = Path.Combine(home, @"site\wwwroot"); logFilePath = Path.Combine(home, @"LogFiles\Application\Functions"); secretsPath = Path.Combine(home, @"data\Functions\secrets"); } ScriptHostConfiguration scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = scriptRootPath, RootLogPath = logFilePath, FileLoggingEnabled = true }; WebScriptHostManager scriptHostManager = new WebScriptHostManager(scriptHostConfig); builder.RegisterInstance<WebScriptHostManager>(scriptHostManager); SecretManager secretManager = new SecretManager(secretsPath); builder.RegisterInstance<SecretManager>(secretManager); WebHookReceiverManager webHookRecieverManager = new WebHookReceiverManager(secretManager); builder.RegisterInstance<WebHookReceiverManager>(webHookRecieverManager); Task.Run(() => scriptHostManager.RunAndBlock(CancellationToken.None)); }
public async Task Invoke(HttpContext context, WebScriptHostManager manager) { // flow required context through the request pipeline // downstream middleware and filters rely on this context.Items.Add(ScriptConstants.AzureFunctionsHostManagerKey, manager); SetRequestId(context.Request); await _next(context); IFunctionExecutionFeature functionExecution = context.Features.Get <IFunctionExecutionFeature>(); if (functionExecution != null && !context.Response.HasStarted) { IActionResult result = await GetResultAsync(context, functionExecution); var actionContext = new ActionContext { HttpContext = context }; await result.ExecuteResultAsync(actionContext); } }
public async Task Invoke(HttpContext httpContext, WebScriptHostManager manager) { using (Logger.VerifyingHostAvailabilityScope(_logger, httpContext.TraceIdentifier)) { Logger.InitiatingHostAvailabilityCheck(_logger); bool hostReady = await manager.DelayUntilHostReady(throwOnFailure : false); if (!hostReady) { Logger.HostUnavailableAfterCheck(_logger); httpContext.Response.StatusCode = StatusCodes.Status503ServiceUnavailable; await httpContext.Response.WriteAsync("Function host is not running."); return; } Logger.HostAvailabilityCheckSucceeded(_logger); await _next.Invoke(httpContext); } }
public void AddRouteDataToRequest_AddsRequestProperty_WhenRouteDataNotNull() { var mockRouteData = new Mock <IHttpRouteData>(MockBehavior.Strict); IDictionary <string, object> values = new Dictionary <string, object> { { "p1", "abc" }, { "p2", 123 }, { "p3", null }, { "p4", RouteParameter.Optional } }; mockRouteData.Setup(p => p.Values).Returns(values); HttpRequestMessage request = new HttpRequestMessage(); WebScriptHostManager.AddRouteDataToRequest(mockRouteData.Object, request); var result = (IDictionary <string, object>)request.Properties[HttpExtensionConstants.AzureWebJobsHttpRouteDataKey]; Assert.Equal(result["p1"], "abc"); Assert.Equal(result["p2"], 123); Assert.Equal(result["p3"], null); Assert.Equal(result["p4"], null); }
public async Task Invoke(HttpContext context, WebScriptHostManager manager) { // flow required context through the request pipeline // downstream middleware and filters rely on this context.Items.Add(ScriptConstants.AzureFunctionsHostManagerKey, manager); SetRequestId(context.Request); if (_next != null) { await _next(context); } IFunctionExecutionFeature functionExecution = context.Features.Get <IFunctionExecutionFeature>(); int nestedProxiesCount = GetNestedProxiesCount(context, functionExecution); IActionResult result = null; if (functionExecution != null && !context.Response.HasStarted) { result = await GetResultAsync(context, functionExecution); if (nestedProxiesCount > 0) { // if Proxy, the rest of the pipleline will be processed bt Proxies in case there are response overrides and what not. SetProxyResult(context, nestedProxiesCount, result); return; } var actionContext = new ActionContext { HttpContext = context }; await result.ExecuteResultAsync(actionContext); } }
private void DisplayHttpFunctionsInfo(WebScriptHostManager hostManager, Uri baseUri) { if (hostManager != null) { var httpFunctions = hostManager.Instance.Functions.Where(f => f.Metadata.IsHttpFunction()); if (httpFunctions.Any()) { ColoredConsole .WriteLine() .WriteLine(Yellow("Http Functions:")) .WriteLine(); } foreach (var function in httpFunctions) { var binding = function.Metadata.Bindings.FirstOrDefault(b => b.Type != null && b.Type.Equals("httpTrigger", StringComparison.OrdinalIgnoreCase)); var httpRoute = binding?.Raw?.GetValue("route", StringComparison.OrdinalIgnoreCase)?.ToString(); httpRoute = httpRoute ?? function.Name; var extensions = hostManager.Instance.ScriptConfig.HostConfig.GetService <IExtensionRegistry>(); var httpConfig = extensions.GetExtensions <IExtensionConfigProvider>().OfType <HttpExtensionConfiguration>().Single(); string hostRoutePrefix = ""; if (!function.Metadata.IsProxy) { hostRoutePrefix = httpConfig.RoutePrefix ?? "api/"; hostRoutePrefix = string.IsNullOrEmpty(hostRoutePrefix) || hostRoutePrefix.EndsWith("/") ? hostRoutePrefix : $"{hostRoutePrefix}/"; } var url = $"{baseUri.ToString().Replace("0.0.0.0", "localhost")}{hostRoutePrefix}{httpRoute}"; ColoredConsole .WriteLine($"\t{Yellow($"{function.Name}:")} {Green(url)}") .WriteLine(); } } }
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); }
public async Task Invoke(HttpContext context, WebScriptHostManager manager) { await _next(context); IFunctionExecutionFeature functionExecution = context.Features.Get <IFunctionExecutionFeature>(); if (functionExecution == null && context.Request.Path.Value == "/") { IActionResult result = null; if (IsHomepageDisabled || context.Request.IsAntaresInternalRequest()) { result = new NoContentResult(); } else { result = new ContentResult() { Content = GetHomepage(), ContentType = "text/html", StatusCode = 200 }; } if (!context.Response.HasStarted) { var actionContext = new ActionContext { HttpContext = context }; await result.ExecuteResultAsync(actionContext); } } }
public SwaggerController(ISwaggerDocumentManager swaggerDocumentManager, WebScriptHostManager scriptHostManager, TraceWriter traceWriter) { _swaggerDocumentManager = swaggerDocumentManager; _scriptHostManager = scriptHostManager; _traceWriter = traceWriter.WithSource($"{ScriptConstants.TraceSourceSwagger}.Api"); }
public KeysController(WebScriptHostManager scriptHostManager, ISecretManager secretManager, TraceWriter traceWriter) { _scriptHostManager = scriptHostManager; _secretManager = secretManager; _traceWriter = traceWriter.WithSource($"{ScriptConstants.TraceSourceSecretManagement}.Api"); }
public AdminController(WebScriptHostManager scriptHostManager, WebHostSettings webHostSettings, TraceWriter traceWriter) { _scriptHostManager = scriptHostManager; _webHostSettings = webHostSettings; _traceWriter = traceWriter.WithSource($"{ScriptConstants.TraceSourceHostAdmin}.Api"); }
public FunctionsController(WebScriptHostManager scriptHostManager, WebHookReceiverManager webHookReceiverManager) { _scriptHostManager = scriptHostManager; _webHookReceiverManager = webHookReceiverManager; }
public Fixture() { EventGenerator = new TestSystemEventGenerator(); _settingsManager = ScriptSettingsManager.Instance; TestFunctionRoot = Path.Combine(TestHelpers.FunctionsTestDirectory, "Functions"); TestLogsRoot = Path.Combine(TestHelpers.FunctionsTestDirectory, "Logs"); TestSecretsRoot = Path.Combine(TestHelpers.FunctionsTestDirectory, "Secrets"); string testRoot = Path.Combine(TestFunctionRoot, Guid.NewGuid().ToString()); SecretsPath = Path.Combine(TestSecretsRoot, Guid.NewGuid().ToString()); Directory.CreateDirectory(SecretsPath); string logRoot = Path.Combine(TestLogsRoot, Guid.NewGuid().ToString(), @"Functions"); Directory.CreateDirectory(logRoot); FunctionsLogDir = Path.Combine(logRoot, @"Function"); Directory.CreateDirectory(FunctionsLogDir); // Add some secret files (both old and valid) File.WriteAllText(Path.Combine(SecretsPath, ScriptConstants.HostMetadataFileName), string.Empty); File.WriteAllText(Path.Combine(SecretsPath, "WebHookTrigger.json"), string.Empty); File.WriteAllText(Path.Combine(SecretsPath, "QueueTriggerToBlob.json"), string.Empty); File.WriteAllText(Path.Combine(SecretsPath, "Foo.json"), string.Empty); File.WriteAllText(Path.Combine(SecretsPath, "Bar.json"), string.Empty); File.WriteAllText(Path.Combine(SecretsPath, "Invalid.json"), string.Empty); // Add some old file directories CreateTestFunctionLogs(FunctionsLogDir, "Foo"); CreateTestFunctionLogs(FunctionsLogDir, "Bar"); CreateTestFunctionLogs(FunctionsLogDir, "Baz"); CreateTestFunctionLogs(FunctionsLogDir, "Invalid"); ScriptHostConfiguration config = new ScriptHostConfiguration { RootScriptPath = @"TestScripts\Node", RootLogPath = logRoot, FileLoggingMode = FileLoggingMode.Always }; ISecretsRepository repository = new FileSystemSecretsRepository(SecretsPath); ISecretManager secretManager = new SecretManager(_settingsManager, repository, NullTraceWriter.Instance, null); WebHostSettings webHostSettings = new WebHostSettings(); webHostSettings.SecretsPath = SecretsPath; var hostConfig = config.HostConfig; var testEventGenerator = new TestSystemEventGenerator(); hostConfig.AddService <IEventGenerator>(EventGenerator); var mockEventManager = new Mock <IScriptEventManager>(); var mockHostManager = new WebScriptHostManager(config, new TestSecretManagerFactory(secretManager), mockEventManager.Object, _settingsManager, webHostSettings); HostManager = mockHostManager; Task task = Task.Run(() => { HostManager.RunAndBlock(); }); TestHelpers.Await(() => { return(HostManager.State == ScriptHostState.Running); }).GetAwaiter().GetResult(); // verify startup system trace logs string[] expectedPatterns = new string[] { "Info Reading host configuration file", "Info Host configuration file read", "Info Host lock lease acquired by instance ID '(.+)'", "Info Function 'Excluded' is marked as excluded", @"Info Generating ([0-9]+) job function\(s\)", @"Info Starting Host \(HostId=function-tests-node, Version=(.+), ProcessId=[0-9]+, Debug=False, Attempt=0\)", "Info WebJobs.Indexing Found the following functions:", "Info The next 5 occurrences of the schedule will be:", "Info WebJobs.Host Job host started", "Error The following 1 functions are in error:" }; foreach (string pattern in expectedPatterns) { Assert.True(EventGenerator.Events.Any(p => Regex.IsMatch(p, pattern)), $"Expected trace event {pattern} not found."); } }
public EnsureHostRunningHandler() { _scriptHostManager = (WebScriptHostManager)GlobalConfiguration.Configuration.DependencyResolver.GetService(typeof(WebScriptHostManager)); }
public AdminController(WebScriptHostManager scriptHostManager) { _scriptHostManager = scriptHostManager; }
private void Reset() { WebScriptHostManager.ResetStandbyMode(); _settingsManager.SetSetting(EnvironmentSettingNames.AzureWebsitePlaceholderMode, null); }
public FunctionsController(IWebFunctionsManager functionsManager, WebScriptHostManager scriptHostManager, ILoggerFactory loggerFactory) { _functionsManager = functionsManager; _scriptHostManager = scriptHostManager; _logger = loggerFactory?.CreateLogger(ScriptConstants.LogCategoryFunctionsController); }
public KeysController(WebScriptHostManager scriptHostManager, ISecretManager secretManager) { _scriptHostManager = scriptHostManager; _secretManager = secretManager; }