Ensuring function route mapping happens prior to initialized state.

Author: fabiocav

src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/DependencyValidator.cs

@@ -42,7 +42,6 @@ private static ExpectedDependencyBuilder CreateExpectedDependencies()
             expected.ExpectCollection<IHostedService>()
                 .Expect<JobHostService>("Microsoft.Azure.WebJobs.Hosting.OptionsLoggingService")
                 .Expect<PrimaryHostCoordinator>()
-                .Expect<HttpInitializationService>()
                 .Expect<FileMonitoringService>()
                 .Expect<LanguageWorkerConsoleLogService>()
                 .Optional<FunctionsScaleMonitorService>()

src/WebJobs.Script.WebHost/WebScriptHostBuilderExtension.cs

@@ -46,6 +46,8 @@ public static IHostBuilder AddWebScriptHost(this IHostBuilder builder, IServiceP
                     configureWebJobs?.Invoke(webJobsBuilder);
 
                     ConfigureRegisteredBuilders(webJobsBuilder, rootServiceProvider);
+
+                    webJobsBuilder.Services.AddSingleton<IHttpRoutesManager, WebScriptHostHttpRoutesManager>();
                 })
                 .ConfigureAppConfiguration(configurationBuilder =>
                 {
@@ -95,7 +97,6 @@ public static IHostBuilder AddWebScriptHost(this IHostBuilder builder, IServiceP
                     services.AddSingleton<IEventCollectorProvider, FunctionInstanceLogCollectorProvider>();
 
                     // Hosted services
-                    services.TryAddEnumerable(ServiceDescriptor.Singleton<IHostedService, HttpInitializationService>());
                     services.TryAddEnumerable(ServiceDescriptor.Singleton<IHostedService, FileMonitoringService>());
 
                     ConfigureRegisteredBuilders(services, rootServiceProvider);

src/WebJobs.Script.WebHost/HttpInitializationService.cs renamed to src/WebJobs.Script.WebHost/WebScriptHostHttpRoutesManager.cs

@@ -1,62 +1,46 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
+using System;
+using System.Text;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.AspNetCore.Routing.Constraints;
 using Microsoft.Azure.WebJobs.Extensions.Http;
-using Microsoft.Azure.WebJobs.Script.Description;
-using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
 namespace Microsoft.Azure.WebJobs.Script.WebHost
 {
-    /// <summary>
-    /// An <see cref="IHostedService"/> responsible for HTTP function initialization.
-    /// </summary>
-    public class HttpInitializationService : IHostedService
+    internal sealed partial class WebScriptHostHttpRoutesManager : IHttpRoutesManager
     {
+        private static readonly string[] _allMethods = new string[] { "all" };
         private readonly IOptions<HttpOptions> _httpOptions;
         private readonly IWebJobsRouter _router;
         private readonly ILoggerFactory _loggerFactory;
-        private readonly IScriptJobHost _host;
         private readonly IEnvironment _environment;
 
-        public HttpInitializationService(IOptions<HttpOptions> httpOptions, IWebJobsRouter router, ILoggerFactory loggerFactory, IScriptJobHost host, IEnvironment environment)
+        public WebScriptHostHttpRoutesManager(IOptions<HttpOptions> httpOptions, IWebJobsRouter router, ILoggerFactory loggerFactory, IEnvironment environment)
         {
             _httpOptions = httpOptions;
             _router = router;
             _loggerFactory = loggerFactory;
-            _host = host;
             _environment = environment;
         }
 
-        public Task StartAsync(CancellationToken cancellationToken)
+        public void InitializeHttpFunctionRoutes(IScriptJobHost host)
         {
-            InitializeHttpFunctions(_host.Functions, _httpOptions.Value);
+            var routesLogBuilder = new StringBuilder();
+            routesLogBuilder.AppendLine("Initializing function HTTP routes");
 
-            return Task.CompletedTask;
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken)
-        {
-            return Task.CompletedTask;
-        }
-
-        private void InitializeHttpFunctions(IEnumerable<FunctionDescriptor> functions, HttpOptions httpOptions)
-        {
             _router.ClearRoutes();
 
             // TODO: FACAVAL Instantiation of the ScriptRouteHandler should be cleaned up
-            WebJobsRouteBuilder routesBuilder = _router.CreateBuilder(new ScriptRouteHandler(_loggerFactory, _host, _environment, false), httpOptions.RoutePrefix);
+            WebJobsRouteBuilder routesBuilder = _router.CreateBuilder(new ScriptRouteHandler(_loggerFactory, host, _environment, false), _httpOptions.Value.RoutePrefix);
 
             // Proxies do not honor the route prefix defined in host.json
-            WebJobsRouteBuilder proxiesRoutesBuilder = _router.CreateBuilder(new ScriptRouteHandler(_loggerFactory, _host, _environment, true), routePrefix: null);
+            WebJobsRouteBuilder proxiesRoutesBuilder = _router.CreateBuilder(new ScriptRouteHandler(_loggerFactory, host, _environment, true), routePrefix: null);
 
-            foreach (var function in functions)
+            foreach (var function in host.Functions)
             {
                 var httpTrigger = function.GetTriggerAttributeOrNull<HttpTriggerAttribute>();
                 if (httpTrigger != null)
@@ -76,23 +60,50 @@ private void InitializeHttpFunctions(IEnumerable<FunctionDescriptor> functions,
 
                     WebJobsRouteBuilder builder = function.Metadata.IsProxy ? proxiesRoutesBuilder : routesBuilder;
                     builder.MapFunctionRoute(function.Metadata.Name, route, constraints, function.Metadata.Name);
+
+                    LogRouteMap(routesLogBuilder, function.Metadata.Name, route, httpTrigger.Methods, function.Metadata.IsProxy, _httpOptions.Value.RoutePrefix);
                 }
             }
 
             IRouter proxyRouter = null;
             IRouter functionRouter = null;
 
-            if (proxiesRoutesBuilder.Count > 0)
+            if (routesBuilder.Count == 0 && proxiesRoutesBuilder.Count == 0)
             {
-                proxyRouter = proxiesRoutesBuilder.Build();
+                routesLogBuilder.AppendLine("No HTTP routes mapped");
             }
-
-            if (routesBuilder.Count > 0)
+            else
             {
-                functionRouter = routesBuilder.Build();
+                if (proxiesRoutesBuilder.Count > 0)
+                {
+                    proxyRouter = proxiesRoutesBuilder.Build();
+                }
+
+                if (routesBuilder.Count > 0)
+                {
+                    functionRouter = routesBuilder.Build();
+                }
             }
 
             _router.AddFunctionRoutes(functionRouter, proxyRouter);
+
+            ILogger logger = _loggerFactory.CreateLogger("Host.HttpRoutes");
+            logger.LogInformation(routesLogBuilder.ToString());
+        }
+
+        private void LogRouteMap(StringBuilder builder, string functionName, string route, string[] methods, bool isProxy, string prefix)
+        {
+            methods = methods ?? _allMethods;
+            string methodList = string.Join(',', methods);
+
+            if (isProxy)
+            {
+                builder.AppendLine($"Mapped proxy route '{route}' [{methodList}] to '{functionName}'");
+            }
+            else
+            {
+                builder.AppendLine($"Mapped function route '{prefix}/{route}' [{methodList}] to '{functionName}'");
+            }
         }
     }
 }

src/WebJobs.Script/Host/ScriptHost.cs

@@ -45,6 +45,7 @@ public class ScriptHost : JobHost, IScriptJobHost
         private readonly IDistributedLockManager _distributedLockManager;
         private readonly IFunctionMetadataManager _functionMetadataManager;
         private readonly IHostIdProvider _hostIdProvider;
+        private readonly IHttpRoutesManager _httpRoutesManager;
         private readonly IProxyMetadataManager _proxyMetadataManager;
         private readonly IEnumerable<WorkerConfig> _workerConfigs;
         private readonly IMetricsLogger _metricsLogger = null;
@@ -80,7 +81,6 @@ public ScriptHost(IOptions<JobHostOptions> options,
             IJobHostContextFactory jobHostContextFactory,
             IConfiguration configuration,
             IDistributedLockManager distributedLockManager,
-            IScriptHostManager scriptHostManager,
             IScriptEventManager eventManager,
             ILoggerFactory loggerFactory,
             IFunctionDispatcher functionDispatcher,
@@ -95,6 +95,7 @@ public ScriptHost(IOptions<JobHostOptions> options,
             IPrimaryHostStateProvider primaryHostStateProvider,
             IJobHostMetadataProvider metadataProvider,
             IHostIdProvider hostIdProvider,
+            IHttpRoutesManager httpRoutesManager,
             ScriptSettingsManager settingsManager = null)
             : base(options, jobHostContextFactory)
         {
@@ -109,6 +110,7 @@ public ScriptHost(IOptions<JobHostOptions> options,
             _distributedLockManager = distributedLockManager;
             _functionMetadataManager = functionMetadataManager;
             _hostIdProvider = hostIdProvider;
+            _httpRoutesManager = httpRoutesManager;
             _proxyMetadataManager = proxyMetadataManager;
             _workerConfigs = languageWorkerOptions.Value.WorkerConfigs;
             ScriptOptions = scriptHostOptions.Value;
@@ -845,6 +847,8 @@ protected override void OnHostInitialized()
         {
             ApplyJobHostMetadata();
 
+            _httpRoutesManager.InitializeHttpFunctionRoutes(this);
+
             _logger.ScriptHostInitialized(_stopwatch.ElapsedMilliseconds);
 
             HostInitialized?.Invoke(this, EventArgs.Empty);

src/WebJobs.Script/Http/DefaultHttpRouteManager.cs

@@ -0,0 +1,16 @@
+// 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 Microsoft.Azure.WebJobs.Script.WebHost;
+
+namespace Microsoft.Azure.WebJobs.Script.Http
+{
+    internal class DefaultHttpRouteManager : IHttpRoutesManager
+    {
+        public void InitializeHttpFunctionRoutes(IScriptJobHost host)
+        {
+            // noop
+        }
+    }
+}

src/WebJobs.Script/Http/IHttpRoutesManager.cs

@@ -0,0 +1,12 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.Azure.WebJobs.Script
+{
+    public interface IHttpRoutesManager
+    {
+        void InitializeHttpFunctionRoutes(IScriptJobHost host);
+    }
+}

src/WebJobs.Script/ScriptHostBuilderExtensions.cs

@@ -22,6 +22,7 @@
 using Microsoft.Azure.WebJobs.Script.FileProvisioning;
 using Microsoft.Azure.WebJobs.Script.Grpc;
 using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
+using Microsoft.Azure.WebJobs.Script.Http;
 using Microsoft.Azure.WebJobs.Script.ManagedDependencies;
 using Microsoft.Azure.WebJobs.Script.Rpc;
 using Microsoft.Azure.WebJobs.Script.Scale;
@@ -134,6 +135,7 @@ public static IHostBuilder AddScriptHostCore(this IHostBuilder builder, ScriptAp
                 services.AddSingleton<ITypeLocator, ScriptTypeLocator>();
                 services.AddSingleton<ScriptSettingsManager>();
                 services.AddTransient<IExtensionsManager, ExtensionsManager>();
+                services.TryAddSingleton<IHttpRoutesManager, DefaultHttpRouteManager>();
                 services.TryAddSingleton<IMetricsLogger, MetricsLogger>();
                 services.TryAddSingleton<IScriptJobHostEnvironment, ConsoleScriptJobHostEnvironment>();
                 services.AddTransient<IExtensionBundleContentProvider, ExtensionBundleContentProvider>();

test/WebJobs.Script.Tests.Integration/ApplicationInsights/ApplicationInsightsEndToEndTestsBase.cs

@@ -274,7 +274,7 @@ await TestHelpers.Await(() =>
                 !t.Message.StartsWith("Host Status")
             ).ToArray();
 
-            int expectedCount = 13;
+            int expectedCount = 14;
             Assert.True(traces.Length == expectedCount, $"Expected {expectedCount} messages, but found {traces.Length}. Actual logs:{Environment.NewLine}{string.Join(Environment.NewLine, traces.Select(t => t.Message))}");
 
             int idx = 0;
@@ -286,6 +286,8 @@ await TestHelpers.Await(() =>
             ValidateTrace(traces[idx++], "Host initialized (", LogCategories.Startup);
             ValidateTrace(traces[idx++], "Host lock lease acquired by instance ID", ScriptConstants.LogCategoryHostGeneral);
             ValidateTrace(traces[idx++], "Host started (", LogCategories.Startup);
+            ValidateTrace(traces[idx++], "Initializing function HTTP routes" + Environment.NewLine 
+                + "Mapped function route 'api/HttpTrigger-Scenarios'", "Host.HttpRoutes");
             ValidateTrace(traces[idx++], "Initializing Host", LogCategories.Startup);
             ValidateTrace(traces[idx++], "Initializing Warmup Extension", LogCategories.CreateTriggerCategory("Warmup"));
             ValidateTrace(traces[idx++], "Job host started", LogCategories.Startup);