In validation mode, disable background sync trigger and warmup function (#11024)

patelchandni · web-flow · commit 7d25c4f11946 · 2025-04-25T12:45:06.000-05:00
* In validation mode, disable background sync trigger and warmup function

* GetTriggers API restricted to validation mode

* using existing TryGetFunctionsTargetGroup to get group
diff --git a/src/WebJobs.Script.WebHost/Controllers/HostController.cs b/src/WebJobs.Script.WebHost/Controllers/HostController.cs
@@ -430,14 +430,20 @@ public async Task<IActionResult> GetTriggers()
         {
             _metricsLogger.LogEvent(MetricEventNames.GetTriggersInvoked);
 
-            var result = await _functionsSyncManager.GetTriggersAsync();
+            // This endpoint is only available in validation mode
+            if (_environment.IsInValidationMode())
+            {
+                var result = await _functionsSyncManager.GetTriggersAsync();
 
-            // GetTriggersAsync() does not swallow exceptions,so any failures will still be a 500.
-            // The only result.Success == false we need to consideris when the environment
-            // does not support sync triggers.
-            return result.Success
-                ? Ok(result)
-                : StatusCode(StatusCodes.Status403Forbidden, new { status = result.Error });
+                // GetTriggersAsync() does not swallow exceptions, so any failures will still be a 500.
+                // The only result.Success == false we need to consider is when the environment
+                // does not support sync triggers.
+                return result.Success
+                    ? Ok(result)
+                    : StatusCode(StatusCodes.Status403Forbidden, new { status = result.Error });
+            }
+
+            return StatusCode(StatusCodes.Status403Forbidden, new { status = "GetTriggers operation is not supported in for this instance." });
         }
 
         [HttpPost]
diff --git a/src/WebJobs.Script.WebHost/FunctionsSyncService.cs b/src/WebJobs.Script.WebHost/FunctionsSyncService.cs
@@ -21,17 +21,19 @@ public class FunctionsSyncService : IHostedService, IDisposable
         private readonly IScriptHostManager _scriptHostManager;
         private readonly IPrimaryHostStateProvider _primaryHostStateProvider;
         private readonly IFunctionsSyncManager _functionsSyncManager;
+        private readonly IEnvironment _environment;
         private Timer _syncTimer;
         private bool _disposed = false;
 
-        public FunctionsSyncService(ILoggerFactory loggerFactory, IScriptHostManager scriptHostManager, IPrimaryHostStateProvider primaryHostStateProvider, IFunctionsSyncManager functionsSyncManager)
+        public FunctionsSyncService(ILoggerFactory loggerFactory, IScriptHostManager scriptHostManager, IPrimaryHostStateProvider primaryHostStateProvider, IFunctionsSyncManager functionsSyncManager, IEnvironment environment)
         {
             ArgumentNullException.ThrowIfNull(loggerFactory);
 
             DueTime = 30 * 1000;
             _scriptHostManager = scriptHostManager;
             _primaryHostStateProvider = primaryHostStateProvider;
             _functionsSyncManager = functionsSyncManager;
+            _environment = environment;
             _logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryHostGeneral);
         }
 
@@ -43,7 +45,8 @@ internal bool ShouldSyncTriggers
             get
             {
                 return _primaryHostStateProvider.IsPrimary &&
-                       (_scriptHostManager.State == ScriptHostState.Running);
+                       (_scriptHostManager.State == ScriptHostState.Running) &&
+                       !_environment.IsInValidationMode();
             }
         }
 
diff --git a/src/WebJobs.Script.WebHost/WebScriptHostHttpRoutesManager.cs b/src/WebJobs.Script.WebHost/WebScriptHostHttpRoutesManager.cs
@@ -69,7 +69,7 @@ public void InitializeHttpFunctionRoutes(IScriptJobHost host)
 
                     LogRouteMap(routesLogBuilder, function.Metadata.Name, route, httpTrigger.Methods, isProxy, _httpOptions.Value.RoutePrefix);
                 }
-                else if (warmupRouteBuilder != null && function.IsWarmupFunction())
+                else if (warmupRouteBuilder != null && !_environment.IsInValidationMode() && function.IsWarmupFunction())
                 {
                     warmupRouteBuilder.MapFunctionRoute(function.Metadata.Name, "warmup", function.Metadata.Name);
                 }
diff --git a/src/WebJobs.Script/Description/FunctionGroups.cs b/src/WebJobs.Script/Description/FunctionGroups.cs
@@ -11,6 +11,9 @@ public static class FunctionGroups
         public const string Durable = "durable";
         public const string Blob = "blob";
 
+        // Function group for validation worker used by Functions Deployment Manager
+        public const string ValidationWorker = "deployment:validation";
+
         public static string ForFunction(string function)
         {
             return $"function:{function}";
diff --git a/src/WebJobs.Script/Environment/EnvironmentExtensions.cs b/src/WebJobs.Script/Environment/EnvironmentExtensions.cs
@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using Microsoft.Azure.WebJobs.Script.Config;
+using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
 using static Microsoft.Azure.WebJobs.Script.EnvironmentSettingNames;
 
@@ -748,5 +749,14 @@ public static bool TryGetFunctionsTargetGroup(this IEnvironment environment, out
 
             return group is not null;
         }
+
+        /// <summary>
+        /// Returns true if the worker is running in validation mode.
+        /// </summary>
+        public static bool IsInValidationMode(this IEnvironment environment)
+        {
+            return environment.TryGetFunctionsTargetGroup(out string group)
+                && string.Equals(group, FunctionGroups.ValidationWorker, StringComparison.InvariantCultureIgnoreCase);
+        }
     }
 }
diff --git a/test/WebJobs.Script.Tests/Extensions/EnvironmentExtensionsTests.cs b/test/WebJobs.Script.Tests/Extensions/EnvironmentExtensionsTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
 using Microsoft.WebJobs.Script.Tests;
 using Xunit;
@@ -530,5 +531,20 @@ public void IsInProc_WithRuntimeParameter_ReturnsExpectedResult(string value, bo
             var environment = new TestEnvironment();
             Assert.Equal(expected, environment.IsInProc(value));
         }
+
+        [Theory]
+        [InlineData(FunctionGroups.ValidationWorker, true)]
+        [InlineData("function:http", false)]
+        [InlineData(null, false)]
+        public void IsInValidationMode_ReturnsExpectedResult(string functionGroup, bool expected)
+        {
+            IEnvironment env = new TestEnvironment();
+            if (!string.IsNullOrEmpty(functionGroup))
+            {
+                env.SetEnvironmentVariable(EnvironmentSettingNames.FunctionsTargetGroup, functionGroup);
+            }
+
+            Assert.Equal(expected, env.IsInValidationMode());
+        }
     }
 }
diff --git a/test/WebJobs.Script.Tests/FunctionsSyncServiceTests.cs b/test/WebJobs.Script.Tests/FunctionsSyncServiceTests.cs
@@ -6,6 +6,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Hosting;
+using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Azure.WebJobs.Script.WebHost.Management;
 using Microsoft.Extensions.Logging;
@@ -18,6 +19,7 @@ namespace Microsoft.Azure.WebJobs.Script.Tests
     public class FunctionsSyncServiceTests
     {
         private readonly TestLoggerProvider _loggerProvider;
+        private readonly LoggerFactory _loggerFactory;
         private readonly FunctionsSyncService _syncService;
         private readonly Mock<IScriptHostManager> _mockScriptHostManager;
         private readonly Mock<IPrimaryHostStateProvider> _mockPrimaryHostStateProviderMock;
@@ -29,8 +31,8 @@ public class FunctionsSyncServiceTests
         public FunctionsSyncServiceTests()
         {
             _loggerProvider = new TestLoggerProvider();
-            var loggerFactory = new LoggerFactory();
-            loggerFactory.AddProvider(_loggerProvider);
+            _loggerFactory = new LoggerFactory();
+            _loggerFactory.AddProvider(_loggerProvider);
 
             _mockScriptHostManager = new Mock<IScriptHostManager>(MockBehavior.Strict);
             _mockPrimaryHostStateProviderMock = new Mock<IPrimaryHostStateProvider>(MockBehavior.Strict);
@@ -44,8 +46,9 @@ public FunctionsSyncServiceTests()
             _mockEnvironment = new Mock<IEnvironment>(MockBehavior.Strict);
             _mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteContainerReady)).Returns("1");
             _mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.CoreToolsEnvironment)).Returns((string)null);
+            _mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.FunctionsTargetGroup)).Returns((string)null);
 
-            _syncService = new FunctionsSyncService(loggerFactory, _mockScriptHostManager.Object, _mockPrimaryHostStateProviderMock.Object, _mockSyncManager.Object);
+            _syncService = new FunctionsSyncService(_loggerFactory, _mockScriptHostManager.Object, _mockPrimaryHostStateProviderMock.Object, _mockSyncManager.Object, _mockEnvironment.Object);
             _syncService.DueTime = _testDueTime;
         }
 
@@ -63,6 +66,27 @@ public void ShouldSyncTriggers_ReturnsExpectedResult(bool isPrimary, ScriptHostS
             Assert.Equal(expected, _syncService.ShouldSyncTriggers);
         }
 
+        [Theory]
+        [InlineData(FunctionGroups.ValidationWorker, false)]
+        [InlineData("function:http", true)]
+        [InlineData(null, true)]
+        public void ShouldSyncTriggers_DisabledForValidationPod(string functionGroup, bool expected)
+        {
+            _mockPrimaryHostStateProviderMock.Setup(p => p.IsPrimary).Returns(true);
+            _mockScriptHostManager.Setup(p => p.State).Returns(ScriptHostState.Running);
+
+            var mockEnvironment = new Mock<IEnvironment>(MockBehavior.Strict);
+            mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteContainerReady)).Returns("1");
+            mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.CoreToolsEnvironment)).Returns((string)null);
+            mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.FunctionsTargetGroup)).Returns(functionGroup);
+
+            var syncService = new FunctionsSyncService(_loggerFactory, _mockScriptHostManager.Object, _mockPrimaryHostStateProviderMock.Object, _mockSyncManager.Object,
+                                                        mockEnvironment.Object);
+            syncService.DueTime = _testDueTime;
+
+            Assert.Equal(expected, syncService.ShouldSyncTriggers);
+        }
+
         [Fact]
         public async Task StartAsync_PrimaryHost_Running_SyncsTriggers_AfterTimeout()
         {

Original file line number	Diff line number	Diff line change
`@@ -21,17 +21,19 @@ public class FunctionsSyncService : IHostedService, IDisposable`
`21`	`21`	`private readonly IScriptHostManager _scriptHostManager;`
`22`	`22`	`private readonly IPrimaryHostStateProvider _primaryHostStateProvider;`
`23`	`23`	`private readonly IFunctionsSyncManager _functionsSyncManager;`
	`24`	`+ private readonly IEnvironment _environment;`
`24`	`25`	`private Timer _syncTimer;`
`25`	`26`	`private bool _disposed = false;`
`26`	`27`
`27`		`- public FunctionsSyncService(ILoggerFactory loggerFactory, IScriptHostManager scriptHostManager, IPrimaryHostStateProvider primaryHostStateProvider, IFunctionsSyncManager functionsSyncManager)`
	`28`	`+ public FunctionsSyncService(ILoggerFactory loggerFactory, IScriptHostManager scriptHostManager, IPrimaryHostStateProvider primaryHostStateProvider, IFunctionsSyncManager functionsSyncManager, IEnvironment environment)`
`28`	`29`	`{`
`29`	`30`	`ArgumentNullException.ThrowIfNull(loggerFactory);`
`30`	`31`
`31`	`32`	`DueTime = 30 * 1000;`
`32`	`33`	`_scriptHostManager = scriptHostManager;`
`33`	`34`	`_primaryHostStateProvider = primaryHostStateProvider;`
`34`	`35`	`_functionsSyncManager = functionsSyncManager;`
	`36`	`+ _environment = environment;`
`35`	`37`	`_logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryHostGeneral);`
`36`	`38`	`}`
`37`	`39`
`@@ -43,7 +45,8 @@ internal bool ShouldSyncTriggers`
`43`	`45`	`get`
`44`	`46`	`{`
`45`	`47`	`return _primaryHostStateProvider.IsPrimary &&`
`46`		`- (_scriptHostManager.State == ScriptHostState.Running);`
	`48`	`+ (_scriptHostManager.State == ScriptHostState.Running) &&`
	`49`	`+ !_environment.IsInValidationMode();`
`47`	`50`	`}`
`48`	`51`	`}`
`49`	`52`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ public void InitializeHttpFunctionRoutes(IScriptJobHost host)`
`69`	`69`
`70`	`70`	`LogRouteMap(routesLogBuilder, function.Metadata.Name, route, httpTrigger.Methods, isProxy, _httpOptions.Value.RoutePrefix);`
`71`	`71`	`}`
`72`		`- else if (warmupRouteBuilder != null && function.IsWarmupFunction())`
	`72`	`+ else if (warmupRouteBuilder != null && !_environment.IsInValidationMode() && function.IsWarmupFunction())`
`73`	`73`	`{`
`74`	`74`	`warmupRouteBuilder.MapFunctionRoute(function.Metadata.Name, "warmup", function.Metadata.Name);`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,9 @@ public static class FunctionGroups`
`11`	`11`	`public const string Durable = "durable";`
`12`	`12`	`public const string Blob = "blob";`
`13`	`13`
	`14`	`+ // Function group for validation worker used by Functions Deployment Manager`
	`15`	`+ public const string ValidationWorker = "deployment:validation";`
	`16`	`+`
`14`	`17`	`public static string ForFunction(string function)`
`15`	`18`	`{`
`16`	`19`	`return $"function:{function}";`