[in-proc backport] Support release channel settings in extension bundles resolution (#10915)

Author: satvu

release_notes.md

@@ -6,4 +6,5 @@
 - Update Java Worker Version to [2.18.1](https://github.com/Azure/azure-functions-java-worker/releases/tag/2.18.1)
 - Add support for new FeatureFlag `EnableAzureMonitorTimeIsoFormat` to enable iso time format for azmon logs for Linux Dedicated/EP Skus. (part of #7864)
 - Update PowerShell worker to 4.0.4175 (sets defaultRuntimeVersion to 7.4 in worker.config.json)
-- Fixing default DateTime bug with TimeZones in TimerTrigger (#10906)
+- Fixing default DateTime bug with TimeZones in TimerTrigger (#10906)
+- Add support for the release channel setting `WEBSITE_PlatformReleaseChannel` and use this value in extension bundles resolution.

src/WebJobs.Script/Environment/EnvironmentSettingNames.cs

@@ -141,6 +141,9 @@ public static class EnvironmentSettingNames
         public const string AntaresPlatformVersionWindows = "WEBSITE_PLATFORM_VERSION";
         public const string AntaresPlatformVersionLinux = "PLATFORM_VERSION";
 
+        // Antares Release Channel / RU Feed Settings
+        public const string AntaresPlatformReleaseChannel = "WEBSITE_PlatformReleaseChannel";
+
         // Machine identifier
         public const string AntaresComputerName = "COMPUTERNAME";
 

src/WebJobs.Script/ExtensionBundle/ExtensionBundleManager.cs

@@ -5,10 +5,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
-using System.IO.Pipes;
 using System.Linq;
 using System.Net.Http;
-using System.Resources;
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Configuration;
@@ -27,15 +25,17 @@ public class ExtensionBundleManager : IExtensionBundleManager
         private readonly FunctionsHostingConfigOptions _configOption;
         private readonly ILogger _logger;
         private readonly string _cdnUri;
+        private readonly string _platformReleaseChannel;
         private string _extensionBundleVersion;
 
         public ExtensionBundleManager(ExtensionBundleOptions options, IEnvironment environment, ILoggerFactory loggerFactory, FunctionsHostingConfigOptions configOption)
         {
             _environment = environment ?? throw new ArgumentNullException(nameof(environment));
             _logger = loggerFactory.CreateLogger<ExtensionBundleManager>() ?? throw new ArgumentNullException(nameof(loggerFactory));
-            _cdnUri = _environment.GetEnvironmentVariable(EnvironmentSettingNames.ExtensionBundleSourceUri) ?? ScriptConstants.ExtensionBundleDefaultSourceUri;
             _options = options ?? throw new ArgumentNullException(nameof(options));
             _configOption = configOption ?? throw new ArgumentNullException(nameof(configOption));
+            _cdnUri = _environment.GetEnvironmentVariable(EnvironmentSettingNames.ExtensionBundleSourceUri) ?? ScriptConstants.ExtensionBundleDefaultSourceUri;
+            _platformReleaseChannel = _environment.GetEnvironmentVariable(EnvironmentSettingNames.AntaresPlatformReleaseChannel) ?? ScriptConstants.LatestPlatformChannelNameUpper;
         }
 
         public async Task<ExtensionBundleDetails> GetExtensionBundleDetails()
@@ -250,7 +250,7 @@ private async Task<string> GetLatestMatchingBundleVersionAsync(HttpClient httpCl
             return matchingBundleVersion;
         }
 
-        internal static string FindBestVersionMatch(VersionRange versionRange, IEnumerable<string> versions, string bundleId, FunctionsHostingConfigOptions configOption)
+        internal string FindBestVersionMatch(VersionRange versionRange, IEnumerable<string> versions, string bundleId, FunctionsHostingConfigOptions configOption)
         {
             var bundleVersions = versions.Select(p =>
             {
@@ -261,9 +261,9 @@ internal static string FindBestVersionMatch(VersionRange versionRange, IEnumerab
                     version = versionRange.Satisfies(version) ? version : null;
                 }
                 return version;
-            }).Where(v => v != null);
+            }).Where(v => v != null).OrderByDescending(version => version.Version).ToList();
 
-            var matchingVersion = bundleVersions.OrderByDescending(version => version.Version).FirstOrDefault();
+            var matchingVersion = ResolvePlatformReleaseChannelVersion(bundleVersions);
 
             if (bundleId != ScriptConstants.DefaultExtensionBundleId)
             {
@@ -293,6 +293,42 @@ internal static string FindBestVersionMatch(VersionRange versionRange, IEnumerab
             return matchingVersion?.ToString();
         }
 
+        private NuGetVersion ResolvePlatformReleaseChannelVersion(IList<NuGetVersion> orderedByDescBundles) => _platformReleaseChannel switch
+        {
+            ScriptConstants.StandardPlatformChannelNameUpper or ScriptConstants.ExtendedPlatformChannelNameUpper => GetStandardOrExtendedBundleVersion(orderedByDescBundles),
+            ScriptConstants.LatestPlatformChannelNameUpper or "" => GetLatestBundleVersion(orderedByDescBundles),
+            _ => HandleUnknownPlatformReleaseChannelName(orderedByDescBundles)
+        };
+
+        // Standard: Resolves to the version prior to the latest(n-1), if that version is available.
+        // Extended: Resolves to the version two releases prior to the latest(n-2), if that version is available.
+        // However, Functions and Rapid Update should treat Standard and Extended the same, resolving to n-1.
+        private NuGetVersion GetStandardOrExtendedBundleVersion(IList<NuGetVersion> orderedByDescBundlesList)
+        {
+            if (orderedByDescBundlesList.Count > 1)
+            {
+                // These channels should resolve to the version prior to latest. This list is in descending order, which makes latest [0], and prior-to-latest [1].
+                return orderedByDescBundlesList[1];
+            }
+
+            // keep the latest version, log a notice
+            var latest = orderedByDescBundlesList.FirstOrDefault();
+            _logger.LogInformation("Unable to apply platform release channel configuration {platformReleaseChannelName}. Only one matching bundle version is available. {latestBundleVersion} will be used", _platformReleaseChannel, latest);
+            return latest;
+        }
+
+        private static NuGetVersion GetLatestBundleVersion(IList<NuGetVersion> orderedByDescBundlesList)
+        {
+            return orderedByDescBundlesList.FirstOrDefault();
+        }
+
+        private NuGetVersion HandleUnknownPlatformReleaseChannelName(IList<NuGetVersion> orderedByDescBundlesList)
+        {
+            var latest = GetLatestBundleVersion(orderedByDescBundlesList);
+            _logger.LogInformation("Unknown platform release channel name {platformReleaseChannelName}. The latest bundle version, {latestBundleVersion}, will be used.", _platformReleaseChannel, latest);
+            return latest;
+        }
+
         public async Task<string> GetExtensionBundleBinPathAsync()
         {
             string bundlePath = await GetExtensionBundlePath();

src/WebJobs.Script/ScriptConstants.cs

@@ -215,6 +215,11 @@ public static class ScriptConstants
         public const string LogicAppDefaultExtensionBundleVersion = "[1.*, 2.0.0)";
         public const string DefaultExtensionBundleVersion = "[4.*, 5.0.0)";
 
+        // Antares Platform Channel Names, used in extension bundle resolution
+        public const string LatestPlatformChannelNameUpper = "LATEST";
+        public const string StandardPlatformChannelNameUpper = "STANDARD";
+        public const string ExtendedPlatformChannelNameUpper = "EXTENDED";
+
         public const string AzureMonitorTraceCategory = "FunctionAppLogs";
 
         public const string KubernetesManagedAppName = "K8SE_APP_NAME";

test/WebJobs.Script.Tests/ExtensionBundle/ExtensionBundleManagerTests.cs

@@ -9,20 +9,14 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
-using System.Reflection;
 using System.Runtime.InteropServices;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Configuration;
 using Microsoft.Azure.WebJobs.Script.ExtensionBundle;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-using Microsoft.Extensions.Options;
 using Moq;
-using Newtonsoft.Json;
 using NuGet.Versioning;
 using Xunit;
 using static Microsoft.Azure.WebJobs.Script.EnvironmentSettingNames;
@@ -407,22 +401,122 @@ public void LimitMaxVersion(string versionRange, string hostConfigVersion, strin
                 }
             }
 
-            var resolvedVersion = ExtensionBundleManager.FindBestVersionMatch(range, new List<string>()
-            { "3.7.0", "3.10.0", "3.11.0", "3.15.0", "3.14.0", "2.16.0", "3.13.0", "3.12.0", "3.9.1", "2.12.1", "2.18.0", "3.16.0", "2.19.0", "3.17.0", "4.0.2", "2.20.0", "3.18.0", "4.1.0", "4.2.0", "2.21.0", "3.19.0", "3.19.2", "4.3.0", "3.20.0" },
-            ScriptConstants.DefaultExtensionBundleId, hostingConfiguration);
+            var options = GetTestExtensionBundleOptions(BundleId, versionRange);
+            var manager = GetExtensionBundleManager(options, GetTestAppServiceEnvironment());
+
+            var resolvedVersion = manager.FindBestVersionMatch(range, GetLargeVersionsList(), ScriptConstants.DefaultExtensionBundleId, hostingConfiguration);
+
+            Assert.Equal(expectedVersion, resolvedVersion);
+        }
+
+        [Theory]
+        [InlineData(ScriptConstants.LatestPlatformChannelNameUpper, "[4.*, 5.0.0)", "4.2.0", "4.2.0")]
+        [InlineData(ScriptConstants.StandardPlatformChannelNameUpper, "[4.*, 5.0.0)", "4.2.0", "4.2.0")]
+        [InlineData(ScriptConstants.ExtendedPlatformChannelNameUpper, "[4.*, 5.0.0)", "4.2.0", "4.2.0")]
+        [InlineData(ScriptConstants.StandardPlatformChannelNameUpper, "[4.*, 5.0.0)", "4.3.0", "4.2.0")]
+        [InlineData(ScriptConstants.ExtendedPlatformChannelNameUpper, "[4.*, 5.0.0)", "4.3.0", "4.2.0")]
+        [InlineData(ScriptConstants.StandardPlatformChannelNameUpper, "[4.*, 5.0.0)", "4.1.0", "4.1.0")]
+        [InlineData(ScriptConstants.ExtendedPlatformChannelNameUpper, "[4.*, 5.0.0)", "4.1.0", "4.1.0")]
+        [InlineData(ScriptConstants.LatestPlatformChannelNameUpper, "[4.*, 5.0.0)", null, "4.3.0")]
+        [InlineData(ScriptConstants.StandardPlatformChannelNameUpper, "[4.*, 5.0.0)", null, "4.2.0")]
+        [InlineData(ScriptConstants.ExtendedPlatformChannelNameUpper, "[4.*, 5.0.0)", null, "4.2.0")]
+        public void WhenPlatformReleaseChannelSet_ExpectedVersionChosen(string platformReleaseChannelName, string versionRange, string hostConfigMaxVersion, string expectedVersion)
+        {
+            var range = VersionRange.Parse(versionRange);
+            var hostingConfiguration = new FunctionsHostingConfigOptions();
+
+            if (!string.IsNullOrEmpty(hostConfigMaxVersion))
+            {
+                if (range.MinVersion.Major == 3)
+                {
+                    hostingConfiguration.Features.Add(ScriptConstants.MaximumBundleV3Version, hostConfigMaxVersion);
+                }
+
+                if (range.MinVersion.Major == 4)
+                {
+                    hostingConfiguration.Features.Add(ScriptConstants.MaximumBundleV4Version, hostConfigMaxVersion);
+                }
+            }
+
+            var options = GetTestExtensionBundleOptions(BundleId, versionRange);
+            var testEnvironment = GetTestAppServiceEnvironment(platformReleaseChannelName);
+            var manager = GetExtensionBundleManager(options, testEnvironment);
+
+            var versions = GetLargeVersionsList();
+
+            var resolvedVersion = manager.FindBestVersionMatch(range, versions, ScriptConstants.DefaultExtensionBundleId, hostingConfiguration);
 
             Assert.Equal(expectedVersion, resolvedVersion);
         }
 
-        private ExtensionBundleManager GetExtensionBundleManager(ExtensionBundleOptions bundleOptions, TestEnvironment environment = null)
+        [Theory]
+        [InlineData(ScriptConstants.ExtendedPlatformChannelNameUpper)]
+        [InlineData(ScriptConstants.StandardPlatformChannelNameUpper)]
+        public void StandardExtendedReleaseChannel_OneBundleVersionOnDisk_Handled(string platformReleaseChannelName)
+        {
+            // these release channels take the version prior to the latest version
+            // however, if there is only one bundle version available on disk, that bundle should be chosen and information logged
+
+            var versions = new List<string>() { "4.20.0" }; // only one bundle version available on disk
+            var versionRange = "[4.*, 5.0.0)";
+            var expected = "4.20.0";
+
+            var loggedString = $"Unable to apply platform release channel configuration {platformReleaseChannelName}. Only one matching bundle version is available. {expected} will be used";
+            var mockLogger = GetVerifiableMockLogger(loggedString);
+            var mockLoggerFactory = new Mock<ILoggerFactory>();
+            mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny<string>())).Returns(() => mockLogger.Object);
+
+            var options = GetTestExtensionBundleOptions(BundleId, versionRange);
+            var testEnvironment = GetTestAppServiceEnvironment(platformReleaseChannelName);
+            var manager = GetExtensionBundleManager(options, testEnvironment, mockLoggerFactory);
+
+            var resolvedVersion = manager.FindBestVersionMatch(VersionRange.Parse(versionRange), versions, ScriptConstants.DefaultExtensionBundleId, new FunctionsHostingConfigOptions());
+
+            Assert.Equal(expected, resolvedVersion);
+            mockLogger.Verify();
+        }
+
+        [Fact]
+        public void UnknownReleaseChannel_ExpectedVersionChosen()
+        {
+            var versions = new List<string>() { "4.20.0" };
+            var versionRange = "[4.*, 5.0.0)";
+            var expected = "4.20.0";
+
+            var incorrectChannelName = "someIncorrectReleaseChannelName";
+            var loggedString = $"Unknown platform release channel name {incorrectChannelName}. The latest bundle version, {expected}, will be used.";
+            var mockLogger = GetVerifiableMockLogger(loggedString);
+            var mockLoggerFactory = new Mock<ILoggerFactory>();
+            mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny<string>())).Returns(() => mockLogger.Object);
+
+            var options = GetTestExtensionBundleOptions(BundleId, versionRange);
+            var testEnvironment = GetTestAppServiceEnvironment(incorrectChannelName);
+            var manager = GetExtensionBundleManager(options, testEnvironment, mockLoggerFactory);
+
+            var resolvedVersion = manager.FindBestVersionMatch(VersionRange.Parse(versionRange), versions, ScriptConstants.DefaultExtensionBundleId, new FunctionsHostingConfigOptions());
+
+            Assert.Equal(expected, resolvedVersion); // unknown release channel should default to latest and log information
+            mockLogger.Verify();
+        }
+
+        private ExtensionBundleManager GetExtensionBundleManager(ExtensionBundleOptions bundleOptions, TestEnvironment environment = null, Mock<ILoggerFactory> mockLoggerFactory = null)
         {
             environment = environment ?? new TestEnvironment();
-            return new ExtensionBundleManager(bundleOptions, environment, MockNullLoggerFactory.CreateLoggerFactory(), new FunctionsHostingConfigOptions());
+
+            if (mockLoggerFactory is null)
+            {
+                return new ExtensionBundleManager(bundleOptions, environment, MockNullLoggerFactory.CreateLoggerFactory(), new FunctionsHostingConfigOptions());
+            }
+            else
+            {
+                return new ExtensionBundleManager(bundleOptions, environment, mockLoggerFactory.Object, new FunctionsHostingConfigOptions());
+            }
         }
 
-        private TestEnvironment GetTestAppServiceEnvironment()
+        private TestEnvironment GetTestAppServiceEnvironment(string platformReleaseChannel = null)
         {
             var environment = new TestEnvironment();
+            environment.SetEnvironmentVariable(AntaresPlatformReleaseChannel, platformReleaseChannel);
             environment.SetEnvironmentVariable(AzureWebsiteInstanceId, Guid.NewGuid().ToString("N"));
             string downloadPath = string.Empty;
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
@@ -473,6 +567,26 @@ public void Dispose()
             FileUtility.Instance = null;
         }
 
+        private IList<string> GetLargeVersionsList()
+        {
+            return new List<string>()
+            { "3.7.0", "3.10.0", "3.11.0", "3.15.0", "3.14.0", "2.16.0", "3.13.0", "3.12.0", "3.9.1", "2.12.1", "2.18.0", "3.16.0", "2.19.0", "3.17.0", "4.0.2", "2.20.0", "3.18.0", "4.1.0", "4.2.0", "2.21.0", "3.19.0", "3.19.2", "4.3.0", "3.20.0" };
+        }
+
+        private Mock<ILogger> GetVerifiableMockLogger(string stringToVerify)
+        {
+            var mockLogger = new Mock<ILogger>();
+            mockLogger
+                .Setup(x => x.Log(
+                    LogLevel.Information,
+                    It.IsAny<EventId>(),
+                    It.Is<It.IsAnyType>((v, t) => v.ToString().Contains(stringToVerify)),
+                    It.IsAny<Exception>(),
+                    It.IsAny<Func<It.IsAnyType, Exception, string>>()))
+                .Verifiable();
+            return mockLogger;
+        }
+
         private class MockHttpHandler : HttpClientHandler
         {
             private readonly string _version;