Permit specifying to use workload versions in global.json (#47421)

Uses workloads-update-mode next to where you'd put a specific workload version to determine if we should be in workload set mode when doing install/update. If there's a conflict between this and other flags, it should error or warn (depending on where it is).

Example:
```
{
  "sdk": {
        "workloads-update-mode" : "workload-set"
    }
}
```

Author: Forgind

src/Cli/dotnet/commands/InstallingWorkloadCommand.cs

@@ -47,6 +47,7 @@ internal abstract class InstallingWorkloadCommand : WorkloadCommandBase
     protected readonly IWorkloadManifestUpdater _workloadManifestUpdaterFromConstructor;
     protected IInstaller _workloadInstaller;
     protected IWorkloadManifestUpdater _workloadManifestUpdater;
+    protected bool? _shouldUseWorkloadSets;
     private WorkloadHistoryState _workloadHistoryRecord;
 
     protected bool UseRollback => !string.IsNullOrWhiteSpace(_fromRollbackDefinition);
@@ -86,7 +87,8 @@ public InstallingWorkloadCommand(
         IInstaller workloadInstaller,
         INuGetPackageDownloader nugetPackageDownloader,
         IWorkloadManifestUpdater workloadManifestUpdater,
-        string tempDirPath)
+        string tempDirPath,
+        bool? shouldUseWorkloadSetsFromGlobalJson = null)
         : base(parseResult, reporter: reporter, tempDirPath: tempDirPath, nugetPackageDownloader: nugetPackageDownloader)
     {
         _arguments = parseResult.GetArguments();
@@ -132,7 +134,8 @@ public InstallingWorkloadCommand(
         _workloadManifestUpdaterFromConstructor = workloadManifestUpdater;
 
         _globalJsonPath = SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory);
-        _workloadSetVersionFromGlobalJson = SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.GetWorkloadVersionFromGlobalJson(_globalJsonPath);
+        _workloadSetVersionFromGlobalJson = SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.GetWorkloadVersionFromGlobalJson(_globalJsonPath, out _shouldUseWorkloadSets);
+        _shouldUseWorkloadSets = shouldUseWorkloadSetsFromGlobalJson ?? _shouldUseWorkloadSets;
 
         if (SpecifiedWorkloadSetVersionInGlobalJson && (SpecifiedWorkloadSetVersionOnCommandLine || UseRollback || FromHistory))
         {
@@ -150,6 +153,14 @@ public InstallingWorkloadCommand(
                 InstallingWorkloadCommandParser.WorkloadSetVersionOption.Name,
                 WorkloadUpdateCommandParser.FromHistoryOption.Name), isUserError: true);
         }
+        else if (_shouldUseWorkloadSets == true && (UseRollback || (FromHistory && _WorkloadHistoryRecord.WorkloadSetVersion is null)))
+        {
+            throw new GracefulException(Workloads.Workload.Update.LocalizableStrings.SpecifiedWorkloadVersionAndSpecificNonWorkloadVersion, isUserError: true);
+        }
+        else if (_shouldUseWorkloadSets == false && (SpecifiedWorkloadSetVersionInGlobalJson || SpecifiedWorkloadSetVersionOnCommandLine || (FromHistory && _WorkloadHistoryRecord.WorkloadSetVersion is not null)))
+        {
+            throw new GracefulException(Workloads.Workload.Update.LocalizableStrings.SpecifiedNoWorkloadVersionAndSpecificWorkloadVersion, isUserError: true);
+        }
 
         //  At this point, at most one of SpecifiedWorkloadSetVersionOnCommandLine, UseRollback, FromHistory, and SpecifiedWorkloadSetVersionInGlobalJson is true
     }
@@ -161,23 +172,19 @@ protected static Dictionary<string, string> GetInstallStateContents(IEnumerable<
 
     InstallStateContents GetCurrentInstallState()
     {
-        return GetCurrentInstallState(_sdkFeatureBand, _workloadRootDir);
-    }
-
-    static InstallStateContents GetCurrentInstallState(SdkFeatureBand sdkFeatureBand, string dotnetDir)
-    {
-        string path = Path.Combine(WorkloadInstallType.GetInstallStateFolder(sdkFeatureBand, dotnetDir), "default.json");
+        string path = Path.Combine(WorkloadInstallType.GetInstallStateFolder(_sdkFeatureBand, _workloadRootDir), "default.json");
         return InstallStateContents.FromPath(path);
     }
 
     public static bool ShouldUseWorkloadSetMode(SdkFeatureBand sdkFeatureBand, string dotnetDir)
     {
-        return GetCurrentInstallState(sdkFeatureBand, dotnetDir).ShouldUseWorkloadSets();
+        return WorkloadManifestUpdater.ShouldUseWorkloadSetMode(sdkFeatureBand, dotnetDir);
     }
 
     protected void UpdateWorkloadManifests(WorkloadHistoryRecorder recorder, ITransactionContext context, DirectoryPath? offlineCache)
     {
-        var updateToLatestWorkloadSet = ShouldUseWorkloadSetMode(_sdkFeatureBand, _workloadRootDir) && !SpecifiedWorkloadSetVersionInGlobalJson;
+        var shouldUseWorkloadSetsPerInstallState = ShouldUseWorkloadSetMode(_sdkFeatureBand, _workloadRootDir);
+        var updateToLatestWorkloadSet = _shouldUseWorkloadSets ?? shouldUseWorkloadSetsPerInstallState && !SpecifiedWorkloadSetVersionInGlobalJson;
         if (FromHistory && !string.IsNullOrWhiteSpace(_WorkloadHistoryRecord.WorkloadSetVersion))
         {
             // This is essentially the same as updating to a specific workload set version, and we're now past the error check,
@@ -192,6 +199,12 @@ protected void UpdateWorkloadManifests(WorkloadHistoryRecorder recorder, ITransa
             updateToLatestWorkloadSet = false;
         }
 
+        string resolvedWorkloadSetVersion = _workloadSetVersionFromGlobalJson;
+        if (SpecifiedWorkloadSetVersionInGlobalJson && recorder is not null)
+        {
+            recorder.HistoryRecord.GlobalJsonVersion = _workloadSetVersionFromGlobalJson;
+        }
+
         if (SpecifiedWorkloadSetVersionOnCommandLine)
         {
             updateToLatestWorkloadSet = false;
@@ -204,45 +217,37 @@ protected void UpdateWorkloadManifests(WorkloadHistoryRecorder recorder, ITransa
                 _workloadInstaller.UpdateInstallMode(_sdkFeatureBand, true);
             }
 
-            if (SpecifiedWorkloadSetVersionInGlobalJson && recorder is not null)
-            {
-                recorder.HistoryRecord.GlobalJsonVersion = _workloadSetVersionFromGlobalJson;
-            }
-        }
-
-        string resolvedWorkloadSetVersion = null;
-
-        if (_workloadSetVersionFromCommandLine?.Any(v => v.Contains('@')) == true)
-        {
-            var versions = WorkloadSearchVersionsCommand.FindBestWorkloadSetsFromComponents(
-                _sdkFeatureBand,
-                _workloadInstaller is not NetSdkMsiInstallerClient ? _workloadInstaller : null,
-                _sdkFeatureBand.IsPrerelease,
-                PackageDownloader,
-                _workloadSetVersionFromCommandLine,
-                _workloadResolver,
-                numberOfWorkloadSetsToTake: 1);
-
-            if (versions is null)
+            if (_workloadSetVersionFromCommandLine.Any(v => v.Contains('@')))
             {
-                return;
-            }
-            else if (!versions.Any())
-            {
-                Reporter.WriteLine(Workloads.Workload.Update.LocalizableStrings.NoWorkloadUpdateFound);
-                return;
+                var versions = WorkloadSearchVersionsCommand.FindBestWorkloadSetsFromComponents(
+                    _sdkFeatureBand,
+                    _workloadInstaller is not NetSdkMsiInstallerClient ? _workloadInstaller : null,
+                    _sdkFeatureBand.IsPrerelease,
+                    PackageDownloader,
+                    _workloadSetVersionFromCommandLine,
+                    _workloadResolver,
+                    numberOfWorkloadSetsToTake: 1);
+
+                if (versions is null)
+                {
+                    return;
+                }
+                else if (!versions.Any())
+                {
+                    Reporter.WriteLine(Workloads.Workload.Update.LocalizableStrings.NoWorkloadUpdateFound);
+                    return;
+                }
+                else
+                {
+                    resolvedWorkloadSetVersion = versions.Single();
+                }
             }
             else
             {
-                resolvedWorkloadSetVersion = versions.Single();
+                resolvedWorkloadSetVersion = _workloadSetVersionFromCommandLine.Single();
             }
         }
-        else if (SpecifiedWorkloadSetVersionOnCommandLine)
-        {
-            resolvedWorkloadSetVersion = _workloadSetVersionFromCommandLine.Single();
-        }
 
-        resolvedWorkloadSetVersion = _workloadSetVersionFromGlobalJson ?? resolvedWorkloadSetVersion;
         if (string.IsNullOrWhiteSpace(resolvedWorkloadSetVersion) && !UseRollback && !FromHistory)
         {
             _workloadManifestUpdater.UpdateAdvertisingManifestsAsync(_includePreviews, updateToLatestWorkloadSet, offlineCache).Wait();
@@ -270,17 +275,11 @@ protected void UpdateWorkloadManifests(WorkloadHistoryRecorder recorder, ITransa
             return;
         }
 
-        IEnumerable<ManifestVersionUpdate> manifestsToUpdate;
-        if (resolvedWorkloadSetVersion != null)
-        {
-            manifestsToUpdate = InstallWorkloadSet(context, resolvedWorkloadSetVersion);
-        }
-        else
-        {
-            manifestsToUpdate = UseRollback ? _workloadManifestUpdater.CalculateManifestRollbacks(_fromRollbackDefinition, recorder) :
-                                FromHistory ? _workloadManifestUpdater.CalculateManifestUpdatesFromHistory(_WorkloadHistoryRecord) :
-                                              _workloadManifestUpdater.CalculateManifestUpdates().Select(m => m.ManifestUpdate);
-        }
+        IEnumerable<ManifestVersionUpdate> manifestsToUpdate =
+            resolvedWorkloadSetVersion != null ? InstallWorkloadSet(context, resolvedWorkloadSetVersion) :
+                                   UseRollback ? _workloadManifestUpdater.CalculateManifestRollbacks(_fromRollbackDefinition, recorder) :
+                                   FromHistory ? _workloadManifestUpdater.CalculateManifestUpdatesFromHistory(_WorkloadHistoryRecord) :
+                                                 _workloadManifestUpdater.CalculateManifestUpdates().Select(m => m.ManifestUpdate);
 
         InstallStateContents oldInstallState = GetCurrentInstallState();
 

src/Cli/dotnet/commands/dotnet-workload/GlobalJsonWorkloadSetFile.cs

@@ -102,7 +102,7 @@ string GetWorkloadVersionFromGlobalJson(string globalJsonPath)
     {
         try
         {
-            return SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.GetWorkloadVersionFromGlobalJson(globalJsonPath);
+            return SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.GetWorkloadVersionFromGlobalJson(globalJsonPath, out _);
         }
         catch (SdkDirectoryWorkloadManifestProvider.JsonFormatException)
         {

src/Cli/dotnet/commands/dotnet-workload/config/LocalizableStrings.resx

@@ -124,4 +124,7 @@ To display a value, specify the corresponding command-line option without provid
   <data name="UpdateModeDescription" xml:space="preserve">
     <value>Controls whether updates should look for workload sets or the latest version of each individual manifest.</value>
   </data>
+  <data name="UpdateModeDoesNotMatchGlobalJson" xml:space="preserve">
+    <value>Specified to update workloads using {0} from the command line, but global.json file at {1} specified to use {2}.</value>
+  </data>
 </root>

src/Cli/dotnet/commands/dotnet-workload/config/WorkloadConfigCommand.cs

@@ -6,6 +6,7 @@
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Cli.Utils.Extensions;
 using Microsoft.DotNet.Workloads.Workload.Install;
 using Microsoft.NET.Sdk.WorkloadManifestReader;
 
@@ -53,17 +54,34 @@ public override int Execute()
         //  It seems that the parser doesn't give us a good way to do that, however
         if (_hasUpdateMode)
         {
+            string globalJsonPath = SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory);
+            var globalJsonVersion = SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.GetWorkloadVersionFromGlobalJson(globalJsonPath, out bool? shouldUseWorkloadSets);
+            shouldUseWorkloadSets ??= string.IsNullOrWhiteSpace(globalJsonVersion) ? null : true;
             if (WorkloadConfigCommandParser.UpdateMode_WorkloadSet.Equals(_updateMode, StringComparison.InvariantCultureIgnoreCase))
             {
-                _workloadInstaller.UpdateInstallMode(_sdkFeatureBand, true);
+                if (shouldUseWorkloadSets == false)
+                {
+                    Reporter.WriteLine(string.Format(LocalizableStrings.UpdateModeDoesNotMatchGlobalJson, WorkloadConfigCommandParser.UpdateMode_WorkloadSet, globalJsonPath, WorkloadConfigCommandParser.UpdateMode_Manifests).Yellow());
+                }
+                else
+                {
+                    _workloadInstaller.UpdateInstallMode(_sdkFeatureBand, true);
+                }
             }
             else if (WorkloadConfigCommandParser.UpdateMode_Manifests.Equals(_updateMode, StringComparison.InvariantCultureIgnoreCase))
             {
-                _workloadInstaller.UpdateInstallMode(_sdkFeatureBand, false);
+                if (shouldUseWorkloadSets == true)
+                {
+                    Reporter.WriteLine(string.Format(LocalizableStrings.UpdateModeDoesNotMatchGlobalJson, WorkloadConfigCommandParser.UpdateMode_Manifests, globalJsonPath, WorkloadConfigCommandParser.UpdateMode_WorkloadSet).Yellow());
+                }
+                else
+                {
+                    _workloadInstaller.UpdateInstallMode(_sdkFeatureBand, false);
+                }
             }
             else if (string.IsNullOrEmpty(_updateMode))
             {
-                if (InstallingWorkloadCommand.ShouldUseWorkloadSetMode(_sdkFeatureBand, _dotnetPath))
+                if (shouldUseWorkloadSets ?? InstallingWorkloadCommand.ShouldUseWorkloadSetMode(_sdkFeatureBand, _dotnetPath))
                 {
                     Reporter.WriteLine(WorkloadConfigCommandParser.UpdateMode_WorkloadSet);
                 }