Shutoff Managed Dependency upgrades after 7.2 EOL (#1091)

* Backport of "Shut off MD module upgrades after 7.2 EOL" (#1084)
* 7.2 specific changes

Author: andystaples

create_new_worker_instructions.md

@@ -0,0 +1,6 @@
+##  Instructions for Upgrading the PowerShell Language Worker to a New PowerShell SDK Minor Version (7.6+)
+Once a new PowerShell SDK version is released on [GiHub](https://github.com/PowerShell/PowerShell/releases), follow these steps to upgrade the PowerShell SDK reference used by the language worker:
+
+- Update the solution targets as needed for whatever .NET version is targeted by the new PowerShell 
+- Follow instructions in upgrade_ps_sdk_instructions.md to update loosely linked dependencies in project files
+- Update the Managed Dependency shutoff date in src/DependencyManagement/WorkerEnvironment.cs

src/DependencyManagement/BackgroundDependencySnapshotMaintainer.cs

@@ -20,6 +20,8 @@ internal class BackgroundDependencySnapshotMaintainer : IBackgroundDependencySna
         private TimeSpan MaxBackgroundUpgradePeriod { get; } =
             PowerShellWorkerConfiguration.GetTimeSpan("MDMaxBackgroundUpgradePeriod") ?? TimeSpan.FromDays(7);
 
+        private Func<bool> _getShouldPerformManagedDependencyUpgrades;
+
         private readonly IDependencyManagerStorage _storage;
         private readonly IDependencySnapshotInstaller _installer;
         private readonly IDependencySnapshotPurger _purger;
@@ -29,11 +31,14 @@ internal class BackgroundDependencySnapshotMaintainer : IBackgroundDependencySna
         public BackgroundDependencySnapshotMaintainer(
             IDependencyManagerStorage storage,
             IDependencySnapshotInstaller installer,
-            IDependencySnapshotPurger purger)
+            IDependencySnapshotPurger purger,
+            Func<bool> getShouldPerformManagedDependencyUpgrades)
         {
             _storage = storage ?? throw new ArgumentNullException(nameof(storage));
             _installer = installer ?? throw new ArgumentNullException(nameof(installer));
             _purger = purger ?? throw new ArgumentNullException(nameof(purger));
+            _getShouldPerformManagedDependencyUpgrades = getShouldPerformManagedDependencyUpgrades;
+
         }
 
         public void Start(string currentSnapshotPath, DependencyManifestEntry[] dependencyManifest, ILogger logger)
@@ -56,6 +61,23 @@ public string InstallAndPurgeSnapshots(Func<PowerShell> pwshFactory, ILogger log
         {
             try
             {
+                if (!_getShouldPerformManagedDependencyUpgrades())
+                {
+                    logger.Log(
+                        isUserOnlyLog: false,
+                        RpcLog.Types.Level.Warning,
+                        PowerShellWorkerStrings.AutomaticUpgradesAreDisabled);
+
+                    // Shutdown the timer that calls this method after the EOL date
+                    if (_installAndPurgeTimer is not null)
+                    {
+                        _installAndPurgeTimer.Dispose();
+                        _installAndPurgeTimer = null;
+                    }
+
+                    return null;
+                }
+
                 // Purge before installing a new snapshot, as we may be able to free some space.
                 _purger.Purge(logger);
 

src/DependencyManagement/DependencyManager.cs

@@ -41,6 +41,9 @@ internal class DependencyManager : IDisposable
 
         private Task _dependencyInstallationTask;
 
+        private bool EnableAutomaticUpgrades { get; } =
+            PowerShellWorkerConfiguration.GetBoolean("MDEnableAutomaticUpgrades") ?? false;
+
         #endregion
 
         public DependencyManager(
@@ -67,7 +70,8 @@ public DependencyManager(
                 maintainer ?? new BackgroundDependencySnapshotMaintainer(
                                     _storage,
                                     _installer,
-                                    new DependencySnapshotPurger(_storage));
+                                    new DependencySnapshotPurger(_storage),
+                                    ShouldEnableManagedDpendencyUpgrades);
             _currentSnapshotContentLogger =
                 currentSnapshotContentLogger ?? new BackgroundDependencySnapshotContentLogger(snapshotContentLogger);
         }
@@ -126,6 +130,18 @@ internal string Initialize(ILogger logger)
             }
         }
 
+        /// <summary>
+        /// Determines whether the function app should enable automatic upgrades for managed dependencies
+        /// </summary>
+        /// <returns>
+        /// True if Managed Dependencies should be upgraded (SDK is not past it's deprecation date OR user has configured this behavior via MDEnableAutomaticUpgrades env var
+        /// False if Managed Dependencies should not be upgraded
+        /// </returns>
+        private bool ShouldEnableManagedDpendencyUpgrades()
+        {
+            return !WorkerEnvironment.IsPowerShellSDKDeprecated() || EnableAutomaticUpgrades;
+        }
+
         /// <summary>
         /// Start dependency installation if needed.
         /// firstPowerShell is the first PowerShell instance created in this process (which this is important for local debugging),

src/DependencyManagement/WorkerEnvironment.cs

@@ -16,6 +16,8 @@ internal static class WorkerEnvironment
         private const string ContainerName = "CONTAINER_NAME";
         private const string LegionServiceHost = "LEGION_SERVICE_HOST";
 
+        private static readonly DateTime PowerShellSDKDeprecationDate = new DateTime(2024, 11, 8);
+
         public static bool IsAppService()
         {
             return !string.IsNullOrEmpty(Environment.GetEnvironmentVariable(AzureWebsiteInstanceId));
@@ -32,5 +34,10 @@ public static bool IsLinuxConsumptionOnLegion()
                    !string.IsNullOrEmpty(Environment.GetEnvironmentVariable(ContainerName)) &&
                    !string.IsNullOrEmpty(Environment.GetEnvironmentVariable(LegionServiceHost));
         }
+
+        public static bool IsPowerShellSDKDeprecated()
+        {
+            return DateTime.Now > PowerShellSDKDeprecationDate;
+        }
     }
 }

src/resources/PowerShellWorkerStrings.resx

@@ -352,6 +352,9 @@
   <data name="DependencySnapshotDoesNotContainAcceptableModuleVersions" xml:space="preserve">
     <value>Dependency snapshot '{0}' does not contain acceptable module versions.</value>
   </data>
+  <data name="WorkerInitCompleted" xml:space="preserve">
+    <value>Worker init request completed in {0} ms.</value>
+  </data>
   <data name="FoundExternalDurableSdkInSession" xml:space="preserve">
     <value>Found external Durable Functions SDK in session: Name='{0}', Version='{1}', Path='{2}'.</value>
   </data>
@@ -361,9 +364,6 @@
   <data name="UnableToInitializeOrchestrator" xml:space="preserve">
     <value>Unable to initialize orchestrator function due to presence of other bindings. Total number of bindings found is '{0}'. Orchestrator Functions should never use any input or output bindings other than the orchestration trigger itself. See: aka.ms/df-bindings</value>
   </data>
-  <data name="WorkerInitCompleted" xml:space="preserve">
-    <value>Worker init request completed in {0} ms.</value>
-  </data>
   <data name="UnexpectedResultCount" xml:space="preserve">
     <value>Operation '{0}' expected '{1}' result(s) but received '{2}'.</value>
   </data>
@@ -388,4 +388,7 @@
   <data name="InvalidOpenTelemetryContext" xml:space="preserve">
     <value>The app is configured to use OpenTelemetry but the TraceContext passed from host was null. </value>
   </data>
+  <data name="AutomaticUpgradesAreDisabled" xml:space="preserve">
+    <value>Automatic upgrades are disabled in PowerShell 7.2 function apps. This warning should not be emitted until PowerShell 7.2's End of Life date. For more information, please see https://azure.microsoft.com/en-us/updates/v2/powershell72-azure-functions-retirement</value>
+  </data>
 </root>

test/Unit/DependencyManagement/BackgroundDependencySnapshotMaintainerTests.cs

@@ -13,8 +13,8 @@ namespace Microsoft.Azure.Functions.PowerShellWorker.Test.DependencyManagement
 
     using Microsoft.Azure.Functions.PowerShellWorker.DependencyManagement;
     using Microsoft.Azure.Functions.PowerShellWorker.Utility;
-
     using LogLevel = Microsoft.Azure.WebJobs.Script.Grpc.Messages.RpcLog.Types.Level;
+    using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
 
     public class BackgroundDependencySnapshotMaintainerTests
     {
@@ -30,7 +30,7 @@ public class BackgroundDependencySnapshotMaintainerTests
         [Fact]
         public void SetsCurrentlyUsedSnapshotOnPurger()
         {
-            using (var maintainer = CreateMaintainerWithMocks())
+            using (var maintainer = CreateMaintainerWithMocks(true))
             {
                 maintainer.Start("current snapshot", _dependencyManifest, _mockLogger.Object);
             }
@@ -56,7 +56,7 @@ public void InstallsSnapshotIfNoRecentlyInstalledSnapshotFound()
                         It.IsAny<ILogger>()));
 
             using (var dummyPowerShell = PowerShell.Create())
-            using (var maintainer = CreateMaintainerWithMocks(_minBackgroundUpgradePeriod))
+            using (var maintainer = CreateMaintainerWithMocks(true, _minBackgroundUpgradePeriod))
             {
                 maintainer.Start("current snapshot", _dependencyManifest, _mockLogger.Object);
 
@@ -73,14 +73,49 @@ public void InstallsSnapshotIfNoRecentlyInstalledSnapshotFound()
             }
         }
 
+        [Fact]
+        public void DoesNothingIfManagedDependenciesUpgradesAreDisabled()
+        {
+            _mockStorage.Setup(_ => _.GetInstalledAndInstallingSnapshots()).Returns(new[] { "older snapshot" });
+            _mockStorage.Setup(_ => _.GetSnapshotCreationTimeUtc("older snapshot"))
+                .Returns(DateTime.UtcNow - _minBackgroundUpgradePeriod - TimeSpan.FromSeconds(1));
+
+            _mockStorage.Setup(_ => _.CreateNewSnapshotPath()).Returns("new snapshot path");
+
+            _mockInstaller.Setup(
+                _ => _.InstallSnapshot(
+                        It.IsAny<DependencyManifestEntry[]>(),
+                        It.IsAny<string>(),
+                        It.IsAny<PowerShell>(),
+                        It.IsAny<DependencySnapshotInstallationMode>(),
+                        It.IsAny<ILogger>()));
+
+            using (var dummyPowerShell = PowerShell.Create())
+            using (var maintainer = CreateMaintainerWithMocks(false, _minBackgroundUpgradePeriod))
+            {
+                maintainer.Start("current snapshot", _dependencyManifest, _mockLogger.Object);
+
+                // ReSharper disable once AccessToDisposedClosure
+                var installedSnapshotPath = maintainer.InstallAndPurgeSnapshots(() => dummyPowerShell, _mockLogger.Object);
+                Assert.Equal(null, installedSnapshotPath);
+
+                // ReSharper disable once AccessToDisposedClosure
+                _mockInstaller.Verify(
+                    _ => _.InstallSnapshot(_dependencyManifest, "new snapshot path", dummyPowerShell, DependencySnapshotInstallationMode.Optional, _mockLogger.Object),
+                    Times.Never);
+
+                _mockLogger.Verify(_ => _.Log(false, LogLevel.Warning, PowerShellWorkerStrings.AutomaticUpgradesAreDisabled, null), Times.Once);
+            }
+        }
+
         [Fact]
         public void DoesNotInstallSnapshotIfRecentlyInstalledSnapshotFound()
         {
             _mockStorage.Setup(_ => _.GetInstalledAndInstallingSnapshots()).Returns(new[] { "older snapshot" });
             _mockStorage.Setup(_ => _.GetSnapshotCreationTimeUtc("older snapshot"))
                 .Returns(DateTime.UtcNow - _minBackgroundUpgradePeriod + TimeSpan.FromSeconds(1));
 
-            using (var maintainer = CreateMaintainerWithMocks(_minBackgroundUpgradePeriod))
+            using (var maintainer = CreateMaintainerWithMocks(true, _minBackgroundUpgradePeriod))
             {
                 maintainer.Start("current snapshot", _dependencyManifest, _mockLogger.Object);
 
@@ -112,7 +147,7 @@ public void LogsWarningIfCannotInstallSnapshot()
                 .Throws(injectedException);
 
             using (var dummyPowerShell = PowerShell.Create())
-            using (var maintainer = CreateMaintainerWithMocks(_minBackgroundUpgradePeriod))
+            using (var maintainer = CreateMaintainerWithMocks(true, _minBackgroundUpgradePeriod))
             {
                 maintainer.Start("current snapshot", _dependencyManifest, _mockLogger.Object);
 
@@ -129,12 +164,13 @@ public void LogsWarningIfCannotInstallSnapshot()
                 Times.Once);
         }
 
-        private BackgroundDependencySnapshotMaintainer CreateMaintainerWithMocks(TimeSpan? minBackgroundUpgradePeriod = null)
+        private BackgroundDependencySnapshotMaintainer CreateMaintainerWithMocks(bool shouldPerformManagedDependenciesUpgrades, TimeSpan? minBackgroundUpgradePeriod = null)
         {
             var maintainer = new BackgroundDependencySnapshotMaintainer(
                                     _mockStorage.Object,
                                     _mockInstaller.Object,
-                                    _mockPurger.Object);
+                                    _mockPurger.Object, 
+                                    () => { return shouldPerformManagedDependenciesUpgrades; });
 
             if (minBackgroundUpgradePeriod != null)
             {