Implement background SyncTriggers (#3565)

Author: mathewc

src/WebJobs.Script.WebHost/Controllers/FunctionsController.cs

@@ -78,11 +78,6 @@ public async Task<IActionResult> CreateOrUpdate(string name, [FromBody] Function
 
             if (success)
             {
-                if (configChanged)
-                {
-                    // TODO: sync triggers
-                }
-
                 return Created(Request.GetDisplayUrl(), functionMetadataResponse);
             }
             else

src/WebJobs.Script.WebHost/Controllers/HostController.cs

@@ -41,14 +41,16 @@ public class HostController : Controller
         private readonly IWebFunctionsManager _functionsManager;
         private readonly IEnvironment _environment;
         private readonly IScriptHostManager _scriptHostManager;
+        private readonly IFunctionsSyncManager _functionsSyncManager;
 
         public HostController(IOptions<ScriptApplicationHostOptions> applicationHostOptions,
             IOptions<JobHostOptions> hostOptions,
             ILoggerFactory loggerFactory,
             IAuthorizationService authorizationService,
             IWebFunctionsManager functionsManager,
             IEnvironment environment,
-            IScriptHostManager scriptHostManager)
+            IScriptHostManager scriptHostManager,
+            IFunctionsSyncManager functionsSyncManager)
         {
             _applicationHostOptions = applicationHostOptions;
             _hostOptions = hostOptions;
@@ -57,6 +59,7 @@ public HostController(IOptions<ScriptApplicationHostOptions> applicationHostOpti
             _functionsManager = functionsManager;
             _environment = environment;
             _scriptHostManager = scriptHostManager;
+            _functionsSyncManager = functionsSyncManager;
         }
 
         [HttpGet]
@@ -151,12 +154,12 @@ public IActionResult LaunchDebugger()
         [Authorize(Policy = PolicyNames.AdminAuthLevel)]
         public async Task<IActionResult> SyncTriggers()
         {
-            (var success, var error) = await _functionsManager.TrySyncTriggers();
+            var result = await _functionsSyncManager.TrySyncTriggersAsync();
 
             // Return a dummy body to make it valid in ARM template action evaluation
-            return success
+            return result.Success
                 ? Ok(new { status = "success" })
-                : StatusCode(StatusCodes.Status500InternalServerError, new { status = error });
+                : StatusCode(StatusCodes.Status500InternalServerError, new { status = result.Error });
         }
 
         [HttpPost]

src/WebJobs.Script.WebHost/Extensions/FunctionMetadataExtensions.cs

@@ -20,16 +20,16 @@ public static class FunctionMetadataExtensions
         /// Maps FunctionMetadata to FunctionMetadataResponse.
         /// </summary>
         /// <param name="functionMetadata">FunctionMetadata to be mapped.</param>
-        /// <param name="request">Current HttpRequest</param>
         /// <param name="hostOptions">The host options</param>
         /// <returns>Promise of a FunctionMetadataResponse</returns>
-        public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(this FunctionMetadata functionMetadata, HttpRequest request, ScriptJobHostOptions hostOptions, string routePrefix)
+        public static async Task<FunctionMetadataResponse> ToFunctionMetadataResponse(this FunctionMetadata functionMetadata, ScriptJobHostOptions hostOptions, string routePrefix, string baseUrl)
         {
             var functionPath = Path.Combine(hostOptions.RootScriptPath, functionMetadata.Name);
             var functionMetadataFilePath = Path.Combine(functionPath, ScriptConstants.FunctionMetadataFileName);
-            var baseUrl = request != null
-                ? $"{request.Scheme}://{request.Host}"
-                : "https://localhost/";
+            if (string.IsNullOrEmpty(baseUrl))
+            {
+                baseUrl = "https://localhost/";
+            }
 
             var response = new FunctionMetadataResponse
             {

src/WebJobs.Script.WebHost/FunctionsSyncService.cs

@@ -0,0 +1,96 @@
+// 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 System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Script.WebHost.Management;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Azure.WebJobs.Script.WebHost
+{
+    /// <summary>
+    /// This hosted service is responsible for performing a background SyncTriggers
+    /// operation after a successful host startup.
+    /// </summary>
+    public class FunctionsSyncService : IHostedService, IDisposable
+    {
+        private readonly ILogger _logger;
+        private readonly IScriptHostManager _scriptHostManager;
+        private readonly IPrimaryHostStateProvider _primaryHostStateProvider;
+        private readonly IFunctionsSyncManager _functionsSyncManager;
+        private Timer _syncTimer;
+        private bool _disposed = false;
+
+        public FunctionsSyncService(ILoggerFactory loggerFactory, IScriptHostManager scriptHostManager, IPrimaryHostStateProvider primaryHostStateProvider, IFunctionsSyncManager functionsSyncManager)
+        {
+            if (loggerFactory == null)
+            {
+                throw new ArgumentNullException(nameof(loggerFactory));
+            }
+
+            DueTime = 30 * 1000;
+            _scriptHostManager = scriptHostManager;
+            _primaryHostStateProvider = primaryHostStateProvider;
+            _functionsSyncManager = functionsSyncManager;
+            _logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryHostGeneral);
+        }
+
+        // exposed for testing
+        internal int DueTime { get; set; }
+
+        internal bool ShouldSyncTriggers
+        {
+            get
+            {
+                return _primaryHostStateProvider.IsPrimary &&
+                       (_scriptHostManager.State == ScriptHostState.Running);
+            }
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            // create a onetime invocation timer
+            _syncTimer = new Timer(OnSyncTimerTick, cancellationToken, DueTime, Timeout.Infinite);
+
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            // cancel the timer
+            _syncTimer.Change(Timeout.Infinite, Timeout.Infinite);
+
+            return Task.CompletedTask;
+        }
+
+        private async void OnSyncTimerTick(object state)
+        {
+            try
+            {
+                var cancellationToken = (CancellationToken)state;
+
+                if (!cancellationToken.IsCancellationRequested && ShouldSyncTriggers)
+                {
+                    _logger.LogDebug("Initiating background SyncTriggers operation");
+                    await _functionsSyncManager.TrySyncTriggersAsync(checkHash: true);
+                }
+            }
+            catch (Exception exc) when (!exc.IsFatal())
+            {
+                // failures are already logged in the sync triggers call
+                // we need to suppress background exceptions from the timer thread
+            }
+        }
+
+        public void Dispose()
+        {
+            if (!_disposed)
+            {
+                _syncTimer?.Dispose();
+                _disposed = true;
+            }
+        }
+    }
+}