Support setting workload set versions in global.json

src/Cli/dotnet/commands/InstallingWorkloadCommand.cs

@@ -33,8 +33,6 @@ internal abstract class InstallingWorkloadCommand : WorkloadCommandBase
         protected readonly string _dotnetPath;
         protected readonly string _userProfileDir;
         protected readonly bool _checkIfManifestExist;
-        protected readonly ReleaseVersion _sdkVersion;
-        protected readonly ReleaseVersion _installedSdkVersion;
         protected readonly SdkFeatureBand _sdkFeatureBand;
         protected readonly SdkFeatureBand _installedFeatureBand;
         protected readonly string _fromRollbackDefinition;
@@ -63,22 +61,32 @@ public InstallingWorkloadCommand(
             _fromCacheOption = parseResult.GetValueForOption(InstallingWorkloadCommandParser.FromCacheOption);
             _includePreviews = parseResult.GetValueForOption(InstallingWorkloadCommandParser.IncludePreviewOption);
             _downloadToCacheOption = parseResult.GetValueForOption(InstallingWorkloadCommandParser.DownloadToCacheOption);
-            _dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
-            _userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
-            _checkIfManifestExist = !(_printDownloadLinkOnly);      // don't check for manifest existence when print download link is passed
-            _sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(InstallingWorkloadCommandParser.VersionOption), version, _dotnetPath, _userProfileDir, _checkIfManifestExist);
-            _sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
-            _installedSdkVersion = new ReleaseVersion(version ?? Product.Version);
-            _installedFeatureBand = new SdkFeatureBand(installedFeatureBand ?? Product.Version);
 
             _fromRollbackDefinition = parseResult.GetValueForOption(InstallingWorkloadCommandParser.FromRollbackFileOption);
             var configOption = parseResult.GetValueForOption(InstallingWorkloadCommandParser.ConfigOption);
             var sourceOption = parseResult.GetValueForOption(InstallingWorkloadCommandParser.SourceOption);
             _packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
                 new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
 
-            var sdkWorkloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _installedSdkVersion.ToString(), userProfileDir);
-            _workloadResolver = workloadResolver ?? WorkloadResolver.Create(sdkWorkloadManifestProvider, _dotnetPath, _installedSdkVersion.ToString(), _userProfileDir);
+            var creationParameters = new WorkloadResolverFactory.CreationParameters()
+            {
+                DotnetPath = dotnetDir,
+                UserProfileDir = userProfileDir,
+                GlobalJsonStartDir = null,
+                SdkVersionFromOption = parseResult.GetValueForOption(InstallingWorkloadCommandParser.VersionOption),
+                VersionForTesting = version,
+                CheckIfFeatureBandManifestExists = !(_printDownloadLinkOnly),    // don't check for manifest existence when print download link is passed
+                WorkloadResolverForTesting = workloadResolver,
+                UseInstalledSdkVersionForResolver = true
+            };
+
+            var creationResult = WorkloadResolverFactory.Create(creationParameters);
+
+            _dotnetPath = creationResult.DotnetPath;
+            _userProfileDir = creationResult.UserProfileDir;
+            _sdkFeatureBand = new SdkFeatureBand(creationResult.SdkVersion);
+            _installedFeatureBand = new SdkFeatureBand(creationResult.InstalledSdkVersion);
+            _workloadResolver = creationResult.WorkloadResolver;
 
             _workloadInstallerFromConstructor = workloadInstaller;
             _workloadManifestUpdaterFromConstructor = workloadManifestUpdater;

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

@@ -43,7 +43,7 @@ public WorkloadInfoHelper(
                     string.IsNullOrWhiteSpace(_targetSdkVersion)
                         ? currentSdkReleaseVersion.ToString()
                         : _targetSdkVersion,
-                    userProfileDir);
+                    userProfileDir, SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory));
             WorkloadResolver = workloadResolver ?? NET.Sdk.WorkloadManifestReader.WorkloadResolver.Create(
                 workloadManifestProvider, dotnetPath,
                 currentSdkReleaseVersion.ToString(), userProfileDir);

src/Cli/dotnet/commands/dotnet-workload/install/WorkloadManifestUpdater.cs

@@ -66,7 +66,7 @@ private static WorkloadManifestUpdater GetInstance(string userProfileDir)
             var reporter = new NullReporter();
             var dotnetPath = Path.GetDirectoryName(Environment.ProcessPath);
             var sdkVersion = Product.Version;
-            var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, sdkVersion, userProfileDir);
+            var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, sdkVersion, userProfileDir, SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory));
             var workloadResolver = WorkloadResolver.Create(workloadManifestProvider, dotnetPath, sdkVersion, userProfileDir);
             var tempPackagesDir = new DirectoryPath(PathUtilities.CreateTempSubdirectory());
             var nugetPackageDownloader = new NuGetPackageDownloader(tempPackagesDir,

src/Cli/dotnet/commands/dotnet-workload/install/WorkloadResolverFactory.cs

@@ -0,0 +1,106 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Deployment.DotNet.Releases;
+using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Configurer;
+using Microsoft.NET.Sdk.WorkloadManifestReader;
+using Product = Microsoft.DotNet.Cli.Utils.Product;
+
+namespace Microsoft.DotNet.Workloads.Workload.Install
+{
+    internal static class WorkloadResolverFactory
+    {
+        public class CreationParameters
+        {
+            public string DotnetPath { get; set; }
+            public string UserProfileDir { get; set; }
+            public string GlobalJsonStartDir { get; set; }
+            public string SdkVersionFromOption { get; set; }
+            public string VersionForTesting { get; set; }
+            public bool CheckIfFeatureBandManifestExists { get; set; }
+            public IWorkloadResolver WorkloadResolverForTesting { get; set; }
+
+            public bool UseInstalledSdkVersionForResolver { get; set; }
+        }
+
+        public class CreationResult
+        {
+            public string DotnetPath { get; set; }
+            public string UserProfileDir { get; set; }
+            public ReleaseVersion SdkVersion { get; set; }
+            public ReleaseVersion InstalledSdkVersion { get; set; }
+            public IWorkloadResolver WorkloadResolver { get; set; }
+
+        }
+
+        public static CreationResult Create(CreationParameters parameters)
+        {
+            var result = new CreationResult();
+
+            result.InstalledSdkVersion = new ReleaseVersion(parameters.VersionForTesting ?? Product.Version);
+
+            bool manifestsNeedValidation;
+            if (string.IsNullOrEmpty(parameters.SdkVersionFromOption))
+            {
+                result.SdkVersion = result.InstalledSdkVersion;
+                manifestsNeedValidation = false;
+            }
+            else
+            {
+                result.SdkVersion = new ReleaseVersion(parameters.SdkVersionFromOption);
+                manifestsNeedValidation = true;
+            }
+
+            result.DotnetPath = parameters.DotnetPath ?? Path.GetDirectoryName(Environment.ProcessPath);
+            result.UserProfileDir = parameters.UserProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
+            string globalJsonStartDir = parameters.GlobalJsonStartDir ?? Environment.CurrentDirectory;
+
+            string globalJsonPath = SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(globalJsonStartDir);
+
+            var sdkWorkloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(result.DotnetPath, result.SdkVersion.ToString(), result.UserProfileDir, globalJsonPath);
+
+            if (manifestsNeedValidation)
+            {
+                var manifests = sdkWorkloadManifestProvider.GetManifests();
+                if (parameters.CheckIfFeatureBandManifestExists && !manifests.Any())
+                {
+                    throw new GracefulException(string.Format(LocalizableStrings.NoManifestsExistForFeatureBand, result.SdkVersion.ToString()), isUserError: false);
+                }
+                try
+                {
+                    foreach (var readableManifest in manifests)
+                    {
+                        using (var manifestStream = readableManifest.OpenManifestStream())
+                        using (var localizationStream = readableManifest.OpenLocalizationStream())
+                        {
+                            var manifest = WorkloadManifestReader.ReadWorkloadManifest(readableManifest.ManifestId, manifestStream, localizationStream, readableManifest.ManifestPath);
+                        }
+                    }
+                }
+                catch
+                {
+                    throw new GracefulException(string.Format(LocalizableStrings.IncompatibleManifests, parameters.SdkVersionFromOption), isUserError: false);
+                }
+            }
+
+            ReleaseVersion versionForResolver = parameters.UseInstalledSdkVersionForResolver ? result.InstalledSdkVersion : result.SdkVersion;
+            if (parameters.UseInstalledSdkVersionForResolver && !result.InstalledSdkVersion.Equals(result.SdkVersion))
+            {
+                //  Create new manifest provider using installed SDK version instead of the target SDK version
+                sdkWorkloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(result.DotnetPath, result.InstalledSdkVersion.ToString(), result.UserProfileDir, globalJsonPath);
+            }
+
+            result.WorkloadResolver = parameters.WorkloadResolverForTesting ?? WorkloadResolver.Create(sdkWorkloadManifestProvider, result.DotnetPath, result.SdkVersion.ToString(), result.UserProfileDir);
+
+            return result;
+        }
+    }
+}

src/Cli/dotnet/commands/dotnet-workload/repair/WorkloadRepairCommand.cs

@@ -40,22 +40,33 @@ public WorkloadRepairCommand(
             string userProfileDir = null)
             : base(parseResult, reporter: reporter, nugetPackageDownloader: nugetPackageDownloader)
         {
-            _dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
-            userProfileDir ??= CliFolderPathCalculator.DotnetUserProfileFolderPath;
-            _sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadRepairCommandParser.VersionOption), version, _dotnetPath, userProfileDir, true);
-
             var configOption = parseResult.GetValueForOption(WorkloadRepairCommandParser.ConfigOption);
             var sourceOption = parseResult.GetValueForOption(WorkloadRepairCommandParser.SourceOption);
             _packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
                 new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
 
-            var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString(), userProfileDir);
-            _workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, _dotnetPath, _sdkVersion.ToString(), userProfileDir);
+            var creationParameters = new WorkloadResolverFactory.CreationParameters()
+            {
+                DotnetPath = dotnetDir,
+                UserProfileDir = userProfileDir,
+                GlobalJsonStartDir = null,
+                SdkVersionFromOption = parseResult.GetValueForOption(WorkloadRepairCommandParser.VersionOption),
+                VersionForTesting = version,
+                CheckIfFeatureBandManifestExists = true,
+                WorkloadResolverForTesting = workloadResolver,
+                UseInstalledSdkVersionForResolver = false
+            };
+
+            var creationResult = WorkloadResolverFactory.Create(creationParameters);
+
+            _dotnetPath = creationResult.DotnetPath;
+            _sdkVersion = creationResult.SdkVersion;
             var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
-
+            _workloadResolver = creationResult.WorkloadResolver;
+
             _workloadInstaller = workloadInstaller ??
                                  WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand,
-                                     _workloadResolver, Verbosity, userProfileDir, VerifySignatures, PackageDownloader, dotnetDir, TempDirectoryPath,
+                                     _workloadResolver, Verbosity, creationResult.UserProfileDir, VerifySignatures, PackageDownloader, dotnetDir, TempDirectoryPath,
                                      _packageSourceLocation, _parseResult.ToRestoreActionConfig());
         }
 

src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchCommand.cs

@@ -30,11 +30,23 @@ public WorkloadSearchCommand(
             string userProfileDir = null) : base(result, CommonOptions.HiddenVerbosityOption, reporter)
         {
             _workloadIdStub = result.GetValueForArgument(WorkloadSearchCommandParser.WorkloadIdStubArgument);
-            var dotnetPath = Path.GetDirectoryName(Environment.ProcessPath);
-            userProfileDir ??= CliFolderPathCalculator.DotnetUserProfileFolderPath;
-            _sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(result.GetValueForOption(WorkloadSearchCommandParser.VersionOption), version, dotnetPath, userProfileDir, true);
-            var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString(), userProfileDir);
-            _workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, dotnetPath, _sdkVersion.ToString(), userProfileDir);
+
+            var creationParameters = new WorkloadResolverFactory.CreationParameters()
+            {
+                DotnetPath = null,
+                UserProfileDir = userProfileDir,
+                GlobalJsonStartDir = null,
+                SdkVersionFromOption = result.GetValueForOption(WorkloadSearchCommandParser.VersionOption),
+                VersionForTesting = version,
+                CheckIfFeatureBandManifestExists = true,
+                WorkloadResolverForTesting = workloadResolver,
+                UseInstalledSdkVersionForResolver = true
+            };
+
+            var creationResult = WorkloadResolverFactory.Create(creationParameters);
+
+            _sdkVersion = creationResult.SdkVersion;
+            _workloadResolver = creationResult.WorkloadResolver;
         }
 
         public override int Execute()

src/Cli/dotnet/commands/dotnet-workload/uninstall/WorkloadUninstallCommand.cs

@@ -39,15 +39,25 @@ public WorkloadUninstallCommand(
         {
             _workloadIds = parseResult.GetValueForArgument(WorkloadUninstallCommandParser.WorkloadIdArgument)
                 .Select(workloadId => new WorkloadId(workloadId)).ToList().AsReadOnly();
-            var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
-            userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
-            _sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadUninstallCommandParser.VersionOption), version, dotnetPath, userProfileDir, true);
 
-            var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString(), userProfileDir);
-            workloadResolver ??= WorkloadResolver.Create(workloadManifestProvider, dotnetPath, _sdkVersion.ToString(), userProfileDir);
+            var creationParameters = new WorkloadResolverFactory.CreationParameters()
+            {
+                DotnetPath = dotnetDir,
+                UserProfileDir = userProfileDir,
+                GlobalJsonStartDir = null,
+                SdkVersionFromOption = parseResult.GetValueForOption(WorkloadUninstallCommandParser.VersionOption),
+                VersionForTesting = version,
+                CheckIfFeatureBandManifestExists = true,
+                WorkloadResolverForTesting = workloadResolver,
+                UseInstalledSdkVersionForResolver = true
+            };
+
+            var creationResult = WorkloadResolverFactory.Create(creationParameters);
+
+            _sdkVersion = creationResult.SdkVersion;
 
             var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
-            _workloadInstaller = WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand, workloadResolver, Verbosity, userProfileDir, VerifySignatures, PackageDownloader, dotnetPath);
+            _workloadInstaller = WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand, creationResult.WorkloadResolver, Verbosity, creationResult.UserProfileDir, VerifySignatures, PackageDownloader, creationResult.DotnetPath);
         }
 
         public override int Execute()