new api to get triggers (#11021)

* new api to get triggers

* GetTriggers will return 403 instead of 500

* GetTriggersAsync will throw ex

* Added comment on why string content

Author: patelchandni

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

@@ -421,6 +421,25 @@ public async Task<IActionResult> SyncTriggers()
                 : StatusCode(StatusCodes.Status500InternalServerError, new { status = result.Error });
         }
 
+        [HttpGet]
+        [Route("admin/host/triggers")]
+        [Authorize(Policy = PolicyNames.AdminAuthLevelOrInternal)]
+        [ResourceContainsSecrets]
+        [RequiresRunningHost]
+        public async Task<IActionResult> GetTriggers()
+        {
+            _metricsLogger.LogEvent(MetricEventNames.GetTriggersInvoked);
+
+            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 });
+        }
+
         [HttpPost]
         [Route("admin/host/restart")]
         [Authorize(Policy = PolicyNames.AdminAuthLevel)]

src/WebJobs.Script.WebHost/Management/FunctionsSyncManager.cs

@@ -92,9 +92,9 @@ internal bool ArmCacheEnabled
             }
         }
 
-        public async Task<SyncTriggersResult> TrySyncTriggersAsync(bool isBackgroundSync = false)
+        public async Task<TriggersOperationResult> TrySyncTriggersAsync(bool isBackgroundSync = false)
         {
-            var result = new SyncTriggersResult
+            var result = new TriggersOperationResult
             {
                 Success = true
             };
@@ -111,8 +111,6 @@ public async Task<SyncTriggersResult> TrySyncTriggersAsync(bool isBackgroundSync
             {
                 await _syncSemaphore.WaitAsync();
 
-                PrepareSyncTriggers();
-
                 var hashBlobClient = await GetHashBlobAsync();
                 if (isBackgroundSync && hashBlobClient == null && !_environment.IsAnyKubernetesEnvironment())
                 {
@@ -308,6 +306,8 @@ internal async Task<BlobClient> GetHashBlobAsync()
 
         private async Task<SyncTriggersPayload> GetSyncTriggersPayload()
         {
+            PrepareSyncTriggers();
+
             var hostOptions = _applicationHostOptions.CurrentValue.ToHostOptions();
             var functionsMetadata = _functionMetadataManager.GetFunctionMetadata().Where(m => !m.IsProxy());
 
@@ -786,6 +786,26 @@ internal HttpRequestMessage BuildSetTriggersRequest()
             }
         }
 
+        public async Task<TriggersResult> GetTriggersAsync()
+        {
+            var result = new TriggersResult
+            {
+                Success = true
+            };
+
+            if (!IsSyncTriggersEnvironment(_webHostEnvironment, _environment))
+            {
+                result.Success = false;
+                result.Error = "Invalid environment for GetTriggers operation.";
+                _logger.LogWarning(result.Error);
+                return result;
+            }
+
+            var payload = await GetSyncTriggersPayload();
+            result.Content = payload.Content;
+            return result;
+        }
+
         public void Dispose()
         {
             _syncSemaphore.Dispose();

src/WebJobs.Script.WebHost/Management/IFunctionsSyncManager.cs

@@ -11,7 +11,13 @@ public interface IFunctionsSyncManager
         /// Sync function triggers with Antares infrastructure.
         /// </summary>
         /// <param name="isBackgroundSync">Indicates whether this is a background sync operation.</param>
-        /// <returns>The <see cref="SyncTriggersResult"/> for the request.</returns>
-        Task<SyncTriggersResult> TrySyncTriggersAsync(bool isBackgroundSync = false);
+        /// <returns>The <see cref="TriggersOperationResult"/> for the request.</returns>
+        Task<TriggersOperationResult> TrySyncTriggersAsync(bool isBackgroundSync = false);
+
+        /// <summary>
+        /// Get function triggers payload.
+        /// </summary>
+        /// <returns>The <see cref="TriggersResult"/> for the request.</returns>
+        Task<TriggersResult> GetTriggersAsync();
     }
 }

src/WebJobs.Script.WebHost/Management/SyncTriggersResult.cs renamed to src/WebJobs.Script.WebHost/Management/TriggersOperationResult.cs

@@ -3,15 +3,15 @@
 
 namespace Microsoft.Azure.WebJobs.Script.WebHost.Management
 {
-    public class SyncTriggersResult
+    public class TriggersOperationResult
     {
         /// <summary>
-        /// Gets or sets a value indicating whether the sync operation was successful.
+        /// Gets or sets a value indicating whether the operation was successful.
         /// </summary>
         public bool Success { get; set; }
 
         /// <summary>
-        /// Gets or sets the error string in the case of a failed sync operation.
+        /// Gets or sets the error string in the case of a failed operation.
         /// </summary>
         public string Error { get; set; }
     }

src/WebJobs.Script.WebHost/Management/TriggersResult.cs

@@ -0,0 +1,18 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+namespace Microsoft.Azure.WebJobs.Script.WebHost.Management
+{
+    public sealed class TriggersResult : TriggersOperationResult
+    {
+        /// <summary>
+        /// Gets or sets the triggers payload.
+        /// </summary>
+        /// <remarks>
+        /// Use of an already formatted JSON string here as opposed to a JObject is by design.
+        /// We want to ensure that the result we return here is the exact same JSON payload
+        /// as is generated during a sync triggers operation (down to whitespacing).
+        /// </remarks>
+        public string Content { get; set; }
+    }
+}

src/WebJobs.Script/Diagnostics/MetricEventNames.cs

@@ -23,6 +23,7 @@ public static class MetricEventNames
         public const string HISStrictModeEnabled = "host.hismode.strict";
         public const string HISStrictModeWarn = "host.hismode.warn";
         public const string SyncTriggersInvoked = "host.synctriggers.invoke";
+        public const string GetTriggersInvoked = "host.gettriggers.invoke";
 
         // Script host level events
         public const string ScriptHostManagerBuildScriptHost = "scripthostmanager.buildscripthost.latency";

test/WebJobs.Script.Tests.Integration/Management/FunctionsSyncManagerTests.cs

@@ -256,6 +256,22 @@ private void ResetMockFileSystem(string hostJsonContent = null, string extension
             FileUtility.Instance = fileSystem;
         }
 
+        [Fact]
+        public async Task GetTriggersAsync_ReturnsExpectedContent()
+        {
+            // Act
+            var result = await _functionsSyncManager.GetTriggersAsync();
+
+            // Assert
+            Assert.True(result.Success);
+            Assert.Null(result.Error);
+            Assert.NotNull(result.Content);
+
+            var content = JObject.Parse(result.Content);
+            var triggers = content["triggers"];
+            Assert.Equal(GetExpectedTriggersPayload(durableVersion: "V1"), triggers.ToString(Formatting.None));
+        }
+
         [Fact]
         public async Task TrySyncTriggers_StandbyMode_ReturnsFalse()
         {

test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/CodelessEndToEndTests.cs

@@ -244,7 +244,7 @@ private TestFunctionHost StartLocalHost(string baseTestPath, string sourceFuncti
             string testLogPath = Path.Combine(baseTestPath, "Logs");
 
             var syncTriggerMock = new Mock<IFunctionsSyncManager>(MockBehavior.Strict);
-            syncTriggerMock.Setup(p => p.TrySyncTriggersAsync(It.IsAny<bool>())).ReturnsAsync(new SyncTriggersResult { Success = true });
+            syncTriggerMock.Setup(p => p.TrySyncTriggersAsync(It.IsAny<bool>())).ReturnsAsync(new TriggersOperationResult { Success = true });
 
             FileUtility.CopyDirectory(sourceFunctionApp, appContent);
             var host = new TestFunctionHost(sourceFunctionApp, testLogPath,

test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/EndToEndTestFixture.cs

@@ -148,7 +148,7 @@ string GetDestPath(int counter)
             }
 
             FunctionsSyncManagerMock = new Mock<IFunctionsSyncManager>(MockBehavior.Strict);
-            FunctionsSyncManagerMock.Setup(p => p.TrySyncTriggersAsync(It.IsAny<bool>())).ReturnsAsync(new SyncTriggersResult { Success = true });
+            FunctionsSyncManagerMock.Setup(p => p.TrySyncTriggersAsync(It.IsAny<bool>())).ReturnsAsync(new TriggersOperationResult { Success = true });
 
             string azuriteConnectionString = _azurite.GetConnectionString();
             Host = new TestFunctionHost(_copiedRootPath, logPath, addTestSettings: _addTestSettings,

test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/MultiLanguageEndToEndTests.cs

@@ -199,7 +199,7 @@ private TestFunctionHost StartLocalHost(string baseTestPath, string sourceFuncti
             string testLogPath = Path.Combine(baseTestPath, "Logs");
 
             var syncTriggerMock = new Mock<IFunctionsSyncManager>(MockBehavior.Strict);
-            syncTriggerMock.Setup(p => p.TrySyncTriggersAsync(It.IsAny<bool>())).ReturnsAsync(new SyncTriggersResult { Success = true });
+            syncTriggerMock.Setup(p => p.TrySyncTriggersAsync(It.IsAny<bool>())).ReturnsAsync(new TriggersOperationResult { Success = true });
 
             FileUtility.CopyDirectory(sourceFunctionApp, appContent);
             var host = new TestFunctionHost(sourceFunctionApp, testLogPath,