Patch Durable Extension version check (#9331)

Author: davidmrdavid

release_notes.md

@@ -3,6 +3,8 @@
 <!-- Please add your release notes in the following format:
 - My change description (#PR)
 -->
+
+- Patch Durable Functions Extension version check (https://github.com/Azure/azure-functions-host/pull/9331)
 - Update Java Worker Version to [2.12.0](https://github.com/Azure/azure-functions-java-worker/releases/tag/2.12.0)
 - Update Python Worker Version to [4.14.0](https://github.com/Azure/azure-functions-python-worker/releases/tag/4.14.0)
 - Update protobuf to [v1.9.0-protofile](https://github.com/Azure/azure-functions-language-worker-protobuf/releases/tag/v1.9.0-protofile)

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

@@ -14,6 +14,8 @@
 using Azure.Storage.Blobs;
 using Microsoft.Azure.WebJobs.Host.Executors;
 using Microsoft.Azure.WebJobs.Host.Storage;
+using Microsoft.Azure.WebJobs.Script.Config;
+using Microsoft.Azure.WebJobs.Script.DependencyInjection;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Models;
 using Microsoft.Azure.WebJobs.Script.WebHost.Extensions;
@@ -447,6 +449,7 @@ internal async Task<IEnumerable<JObject>> GetFunctionTriggers(IEnumerable<Functi
                 .WhenAll())
                 .Where(t => t != null);
 
+            // TODO: We should remove extension-specific logic from the Host. See: https://github.com/Azure/azure-functions-host/issues/5390
             if (triggers.Any(IsDurableTrigger))
             {
                 DurableConfig durableTaskConfig = await ReadDurableTaskConfig();
@@ -545,19 +548,39 @@ private async Task<DurableConfig> ReadDurableTaskConfig()
         // This is a stopgap approach to get the Durable extension version. It duplicates some logic in ExtensionManager.cs.
         private async Task<string> GetDurableMajorVersionAsync(JObject hostJson, ScriptJobHostOptions hostOptions)
         {
+            string metadataFilePath;
             bool isUsingBundles = hostJson != null && hostJson.TryGetValue("extensionBundle", StringComparison.OrdinalIgnoreCase, out _);
-            if (isUsingBundles)
+            // This feature flag controls whether to opt out of the SyncTrigger metadata fix for OOProc DF apps from https://github.com/Azure/azure-functions-host/pull/9331
+            if (FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagEnableLegacyDurableVersionCheck))
             {
-                // TODO: As of 2019-12-12, there are no extension bundles for version 2.x of Durable.
-                // This may change in the future.
-                return "1";
-            }
+                // using legacy behavior, which concludes that out of process DF apps (including .NET isolated) are using DF Extension V1.x
+                // as a result, the SyncTriggers payload for these apps will be missing some metadata like "taskHubName"
+                if (isUsingBundles)
+                {
+                    return "1";
+                }
 
-            string binPath = binPath = Path.Combine(hostOptions.RootScriptPath, "bin");
-            string metadataFilePath = Path.Combine(binPath, ScriptConstants.ExtensionsMetadataFileName);
-            if (!FileUtility.FileExists(metadataFilePath))
+                string binPath = binPath = Path.Combine(hostOptions.RootScriptPath, "bin");
+                metadataFilePath = Path.Combine(binPath, ScriptConstants.ExtensionsMetadataFileName);
+                if (!FileUtility.FileExists(metadataFilePath))
+                {
+                    return null;
+                }
+            }
+            else
             {
-                return null;
+                if (isUsingBundles)
+                {
+                    // From Functions runtime V4 onwards, only bundles >= V2.x is supported, which implies the app should be using DF V2 or greater.
+                    return "2";
+                }
+
+                // If the app is not using bundles, we look for extensions.json
+                if (!Utility.TryResolveExtensionsMetadataPath(hostOptions.RootScriptPath, out string metadataDirectoryPath, out _))
+                {
+                    return null;
+                }
+                metadataFilePath = Path.Combine(metadataDirectoryPath, ScriptConstants.ExtensionsMetadataFileName);
             }
 
             var extensionMetadata = JObject.Parse(await FileUtility.ReadAsync(metadataFilePath));

src/WebJobs.Script/DependencyInjection/ScriptStartupTypeLocator.cs

@@ -126,33 +126,10 @@ public async Task<IEnumerable<Type>> GetExtensionsStartupTypesAsync()
             else
             {
                 extensionsMetadataPath = Path.Combine(_rootScriptPath, "bin");
-
-                // Verify if the file exists and apply fallback paths
-                // The fallback order is:
-                //   1 - Script root
-                //       - If the system folder exists with metadata file at the root, use that as the base probing path
-                //   2 - System folder
-                if (!File.Exists(Path.Combine(extensionsMetadataPath, ScriptConstants.ExtensionsMetadataFileName)))
+                if (Utility.TryResolveExtensionsMetadataPath(_rootScriptPath, out string resolvedPath, out baseProbingPath))
                 {
-                    string systemPath = Path.Combine(_rootScriptPath, ScriptConstants.AzureFunctionsSystemDirectoryName);
-
-                    if (File.Exists(Path.Combine(_rootScriptPath, ScriptConstants.ExtensionsMetadataFileName)))
-                    {
-                        // As a fallback, allow extensions.json in the root path.
-                        extensionsMetadataPath = _rootScriptPath;
-
-                        // If the system path exists, that should take precedence as the base probing path
-                        if (Directory.Exists(systemPath))
-                        {
-                            baseProbingPath = systemPath;
-                        }
-                    }
-                    else if (File.Exists(Path.Combine(systemPath, ScriptConstants.ExtensionsMetadataFileName)))
-                    {
-                        extensionsMetadataPath = systemPath;
-                    }
+                      extensionsMetadataPath = resolvedPath;
                 }
-
                 _logger.ScriptStartNotLoadingExtensionBundle(extensionsMetadataPath, bundleConfigured, isPrecompiledFunctionApp, isLegacyExtensionBundle);
             }
 

src/WebJobs.Script/ScriptConstants.cs

@@ -129,6 +129,7 @@ public static class ScriptConstants
         public const string FeatureFlagEnableHttpProxying = "EnableHttpProxying";
         public const string HostingConfigDisableLinuxAppServiceDetailedExecutionEvents = "DisableLinuxExecutionDetails";
         public const string HostingConfigDisableLinuxAppServiceExecutionEventLogBackoff = "DisableLinuxLogBackoff";
+        public const string FeatureFlagEnableLegacyDurableVersionCheck = "EnableLegacyDurableVersionCheck";
 
         public const string SiteAzureFunctionsUriFormat = "https://{0}.azurewebsites.net/azurefunctions";
         public const string ScmSiteUriFormat = "https://{0}.scm.azurewebsites.net";

src/WebJobs.Script/Utility.cs

@@ -782,6 +782,41 @@ public static void ExecuteAfterColdStartDelay(IEnvironment environment, Action t
             }
         }
 
+        public static bool TryResolveExtensionsMetadataPath(string rootScriptPath, out string extensionsMetadataPath, out string baseProbingPath)
+        {
+            baseProbingPath = null;
+
+            // Verify if the file exists and apply fallback paths
+            // The fallback order is:
+            //   1 - Script root
+            //       - If the system folder exists with metadata file at the root, use that as the base probing path
+            //   2 - System folder
+            extensionsMetadataPath = Path.Combine(rootScriptPath, "bin");
+            if (!FileUtility.FileExists(Path.Combine(extensionsMetadataPath, ScriptConstants.ExtensionsMetadataFileName)))
+            {
+                extensionsMetadataPath = null;
+                string systemPath = Path.Combine(rootScriptPath, ScriptConstants.AzureFunctionsSystemDirectoryName);
+
+                if (FileUtility.FileExists(Path.Combine(rootScriptPath, ScriptConstants.ExtensionsMetadataFileName)))
+                {
+                    // As a fallback, allow extensions.json in the root path.
+                    extensionsMetadataPath = rootScriptPath;
+
+                    // If the system path exists, that should take precedence as the base probing path
+                    if (Directory.Exists(systemPath))
+                    {
+                        baseProbingPath = systemPath;
+                    }
+                }
+                else if (FileUtility.FileExists(Path.Combine(systemPath, ScriptConstants.ExtensionsMetadataFileName)))
+                {
+                    extensionsMetadataPath = systemPath;
+                }
+            }
+            bool foundMetadata = !string.IsNullOrEmpty(extensionsMetadataPath);
+            return foundMetadata;
+        }
+
         public static bool TryCleanUrl(string url, out string cleaned)
         {
             cleaned = null;

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

@@ -454,7 +454,7 @@ public async Task TrySyncTriggers_BackgroundSync_SetTriggersFailure_HashNotUpdat
         }
 
         [Fact]
-        public async Task TrySyncTriggers_NoDurableTaskHub_UsesBundles_V1DefaultsPosted()
+        public async Task TrySyncTriggers_NoDurableTaskHub_UsesBundles_V2DefaultsPosted()
         {
             _mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteName)).Returns("TestHubValue");
 
@@ -474,7 +474,7 @@ public async Task TrySyncTriggers_NoDurableTaskHub_UsesBundles_V1DefaultsPosted(
                 Assert.True(syncResult.Success, "SyncTriggers should return success true");
                 Assert.True(string.IsNullOrEmpty(syncResult.Error), "Error should be null or empty");
 
-                VerifyResultWithCacheOn(expectedTaskHub: null, connection: null);
+                VerifyResultWithCacheOn(expectedTaskHub: "TestHubValue", connection: null);
             }
 
         }