Use workload sets as per user request

src/Cli/Microsoft.DotNet.Cli.Utils/Constants.cs

@@ -28,5 +28,6 @@ public static class Constants
         public static readonly string AnyRid = "any";
 
         public static readonly string RestoreInteractiveOption = "--interactive";
+        public static readonly string workloadSetVersionFileName = "workloadVersion.txt";
     }
 }

src/Cli/Microsoft.DotNet.Cli.Utils/PathUtility.cs

@@ -97,6 +97,30 @@ public static bool TryDeleteDirectory(string directoryPath)
             }
         }
 
+        /// <summary>
+        /// Deletes the provided file. Then deletes the parent directory if empty
+        /// and continues to its parent until it fails. Returns whether it succeeded
+        /// in deleting the file it was intended to delete.
+        /// </summary>
+        public static bool DeleteFileAndEmptyParents(string path)
+        {
+            if (!File.Exists(path))
+            {
+                return false;
+            }
+
+            File.Delete(path);
+            var dir = Path.GetDirectoryName(path);
+
+            while (!Directory.EnumerateFileSystemEntries(dir).Any())
+            {
+                Directory.Delete(dir);
+                dir = Path.GetDirectoryName(dir);
+            }
+
+            return !File.Exists(path);
+        }
+
         /// <summary>
         /// Returns childItem relative to directory, with Path.DirectorySeparatorChar as separator
         /// </summary>

src/Cli/dotnet/Installer/Windows/InstallMessageDispatcher.cs

@@ -192,5 +192,21 @@ public InstallResponseMessage SendUpdateWorkloadModeRequest(SdkFeatureBand sdkFe
                 UseWorkloadSets = newMode,
             });
         }
+
+        /// <summary>
+        /// Send an <see cref="InstallRequestMessage"/> to adjust the workload set version used for installing and updating workloads
+        /// </summary>
+        /// <param name="sdkFeatureBand">The SDK feature band of the install state file to write</param>
+        /// <param name="newVersion">The workload set version</param>
+        /// <returns></returns>
+        public InstallResponseMessage SendUpdateWorkloadSetRequest(SdkFeatureBand sdkFeatureBand, string newVersion)
+        {
+            return Send(new InstallRequestMessage
+            {
+                RequestType = InstallRequestType.AdjustWorkloadSetVersion,
+                SdkFeatureBand = sdkFeatureBand.ToString(),
+                WorkloadSetVersion = newVersion,
+            });
+        }
     }
 }

src/Cli/dotnet/Installer/Windows/InstallRequestMessage.cs

@@ -128,6 +128,14 @@ public bool UseWorkloadSets
             get; set;
         }
 
+        /// <summary>
+        /// The workload set version
+        /// </summary>
+        public string WorkloadSetVersion
+        {
+            get; set;
+        }
+
         /// <summary>
         /// Converts a deserialized array of bytes into an <see cref="InstallRequestMessage"/>.
         /// </summary>

src/Cli/dotnet/Installer/Windows/InstallRequestType.cs

@@ -69,5 +69,10 @@ public enum InstallRequestType
         /// Changes the workload mode
         /// </summary>
         AdjustWorkloadMode,
+
+        /// <summary>
+        /// Changes the workload set version
+        /// </summary>
+        AdjustWorkloadSetVersion,
     }
 }

src/Cli/dotnet/commands/InstallingWorkloadCommand.cs

@@ -34,6 +34,7 @@ internal abstract class InstallingWorkloadCommand : WorkloadCommandBase
         protected readonly SdkFeatureBand _sdkFeatureBand;
         protected readonly ReleaseVersion _targetSdkVersion;
         protected readonly string _fromRollbackDefinition;
+        protected string _workloadSetVersion;
         protected readonly PackageSourceLocation _packageSourceLocation;
         protected readonly IWorkloadResolverFactory _workloadResolverFactory;
         protected IWorkloadResolver _workloadResolver;
@@ -96,6 +97,53 @@ protected static Dictionary<string, string> GetInstallStateContents(IEnumerable<
                     manifestVersionUpdates.Select(update => new WorkloadManifestInfo(update.ManifestId.ToString(), update.NewVersion.ToString(), /* We don't actually use the directory here */ string.Empty, update.NewFeatureBand))
                     ).ToDictionaryForJson();
 
+        public static bool ShouldUseWorkloadSetMode(SdkFeatureBand sdkFeatureBand, string dotnetDir)
+        {
+            string path = Path.Combine(WorkloadInstallType.GetInstallStateFolder(sdkFeatureBand, dotnetDir), "default.json");
+            var installStateContents = File.Exists(path) ? InstallStateContents.FromString(File.ReadAllText(path)) : new InstallStateContents();
+            return installStateContents.UseWorkloadSets ?? false;
+        }
+
+        protected IEnumerable<ManifestVersionUpdate> HandleWorkloadUpdateFromVersion(ITransactionContext context, DirectoryPath? offlineCache)
+        {
+            // Ensure workload set mode is set to 'workloadset'
+            // Do not skip checking the mode first, as setting it triggers
+            // an admin authorization popup for MSI-based installs.
+            if (!ShouldUseWorkloadSetMode(_sdkFeatureBand, _dotnetPath))
+            {
+                _workloadInstaller.UpdateInstallMode(_sdkFeatureBand, true);
+            }
+
+            _workloadManifestUpdater.DownloadWorkloadSet(_workloadSetVersion, offlineCache);
+            return InstallWorkloadSet(context);
+        }
+
+        public IEnumerable<ManifestVersionUpdate> InstallWorkloadSet(ITransactionContext context)
+        {
+            var advertisingPackagePath = Path.Combine(_userProfileDir, "sdk-advertising", _sdkFeatureBand.ToString(), "microsoft.net.workloads");
+            if (File.Exists(Path.Combine(advertisingPackagePath, Constants.workloadSetVersionFileName)))
+            {
+                // This file isn't created in tests.
+                PrintWorkloadSetTransition(File.ReadAllText(Path.Combine(advertisingPackagePath, Constants.workloadSetVersionFileName)));
+            }
+            var workloadSetPath = _workloadInstaller.InstallWorkloadSet(context, advertisingPackagePath);
+            var files = Directory.EnumerateFiles(workloadSetPath, "*.workloadset.json");
+            return _workloadManifestUpdater.ParseRollbackDefinitionFiles(files);
+        }
+
+        private void PrintWorkloadSetTransition(string newVersion)
+        {
+            var currentVersion = _workloadResolver.GetWorkloadVersion();
+            if (currentVersion == null)
+            {
+                Reporter.WriteLine(string.Format(Strings.NewWorkloadSet, newVersion));
+            }
+            else
+            {
+                Reporter.WriteLine(string.Format(Strings.WorkloadSetUpgrade, currentVersion, newVersion));
+            }
+        }
+
         protected async Task<List<WorkloadDownload>> GetDownloads(IEnumerable<WorkloadId> workloadIds, bool skipManifestUpdate, bool includePreview, string downloadFolder = null)
         {
             List<WorkloadDownload> ret = new();
@@ -202,6 +250,11 @@ internal static class InstallingWorkloadCommandParser
             Hidden = true
         };
 
+        public static readonly CliOption<string> WorkloadSetVersionOption = new("--version")
+        {
+            Description = Strings.WorkloadSetVersionOptionDescription
+        };
+
         public static readonly CliOption<bool> PrintDownloadLinkOnlyOption = new("--print-download-link-only")
         {
             Description = Strings.PrintDownloadLinkOnlyDescription,

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

@@ -4,6 +4,8 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
+#pragma warning disable CS8632
+
 namespace Microsoft.DotNet.Workloads.Workload
 {
     internal class InstallStateContents
@@ -12,17 +14,21 @@ internal class InstallStateContents
         public bool? UseWorkloadSets { get; set; }
 
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
-        public Dictionary<string, string> Manifests { get; set; }
+        public Dictionary<string, string>? Manifests { get; set; }
+
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        public string? WorkloadVersion { get; set; }
 
         private static readonly JsonSerializerOptions s_options = new()
         {
             PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
             WriteIndented = true,
+            AllowTrailingCommas = true,
         };
 
         public static InstallStateContents FromString(string contents)
         {
-            return JsonSerializer.Deserialize<InstallStateContents>(contents, s_options);
+            return JsonSerializer.Deserialize<InstallStateContents>(contents, s_options) ?? new InstallStateContents();
         }
 
         public static InstallStateContents FromPath(string path)
@@ -35,4 +41,6 @@ public override string ToString()
             return JsonSerializer.Serialize<InstallStateContents>(this, s_options);
         }
     }
-}
+}
+
+#pragma warning restore CS8632

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

@@ -17,6 +17,7 @@ internal class WorkloadInfoHelper : IWorkloadInfoHelper
     {
         public readonly SdkFeatureBand _currentSdkFeatureBand;
         private readonly string _targetSdkVersion;
+        public string DotnetPath { get; }
 
         public WorkloadInfoHelper(
             bool isInteractive,
@@ -30,20 +31,20 @@ public WorkloadInfoHelper(
             string userProfileDir = null,
             IWorkloadResolver workloadResolver = null)
         {
-            string dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
+            DotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
             ReleaseVersion currentSdkReleaseVersion = new(currentSdkVersion ?? Product.Version);
             _currentSdkFeatureBand = new SdkFeatureBand(currentSdkReleaseVersion);
 
             _targetSdkVersion = targetSdkVersion;
             userProfileDir ??= CliFolderPathCalculator.DotnetUserProfileFolderPath;
             ManifestProvider =
-                new SdkDirectoryWorkloadManifestProvider(dotnetPath,
+                new SdkDirectoryWorkloadManifestProvider(DotnetPath,
                     string.IsNullOrWhiteSpace(_targetSdkVersion)
                         ? currentSdkReleaseVersion.ToString()
                         : _targetSdkVersion,
                     userProfileDir, SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory));
             WorkloadResolver = workloadResolver ?? NET.Sdk.WorkloadManifestReader.WorkloadResolver.Create(
-                ManifestProvider, dotnetPath,
+                ManifestProvider, DotnetPath,
                 currentSdkReleaseVersion.ToString(), userProfileDir);
 
             var restoreConfig = new RestoreActionConfig(Interactive: isInteractive);

src/Cli/dotnet/commands/dotnet-workload/clean/WorkloadCleanCommand.cs

@@ -59,7 +59,7 @@ public override int Execute()
 
         private void ExecuteGarbageCollection()
         {
-            _workloadInstaller.GarbageCollect(workloadSetVersion => _workloadResolverFactory.CreateForWorkloadSet(_dotnetPath, _sdkVersion.ToString(), _userProfileDir, workloadSetVersion),
+            _workloadInstaller.GarbageCollect(workloadVersion => _workloadResolverFactory.CreateForWorkloadSet(_dotnetPath, _sdkVersion.ToString(), _userProfileDir, workloadVersion),
                 cleanAllPacks: _cleanAll);
 
             DisplayUninstallableVSWorkloads();

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

@@ -13,7 +13,7 @@
 using NuGet.Common;
 using NuGet.Versioning;
 using static Microsoft.NET.Sdk.WorkloadManifestReader.WorkloadResolver;
-
+using PathUtility = Microsoft.DotNet.Tools.Common.PathUtility;
 
 namespace Microsoft.DotNet.Workloads.Workload.Install
 {
@@ -85,6 +85,31 @@ IEnumerable<PackInfo> GetPacksInWorkloads(IEnumerable<WorkloadId> workloadIds)
             return packs;
         }
 
+        public string InstallWorkloadSet(ITransactionContext context, string advertisingPackagePath)
+        {
+            var workloadVersion = File.ReadAllText(Path.Combine(advertisingPackagePath, Constants.workloadSetVersionFileName));
+            var workloadSetPath = Path.Combine(_dotnetDir, "sdk-manifests", _sdkFeatureBand.ToString(), "workloadsets", workloadVersion);
+            context.Run(
+                action: () =>
+                {
+                    Directory.CreateDirectory(workloadSetPath);
+
+                    foreach (var file in Directory.EnumerateFiles(advertisingPackagePath))
+                    {
+                        File.Copy(file, Path.Combine(workloadSetPath, Path.GetFileName(file)), overwrite: true);
+                    }
+                },
+                rollback: () =>
+                {
+                    foreach (var file in Directory.EnumerateFiles(workloadSetPath))
+                    {
+                        PathUtility.DeleteFileAndEmptyParents(file);
+                    }
+                });
+
+            return workloadSetPath;
+        }
+
         public void InstallWorkloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand sdkFeatureBand, ITransactionContext transactionContext, DirectoryPath? offlineCache = null)
         {
             var packInfos = GetPacksInWorkloads(workloadIds);
@@ -452,6 +477,15 @@ public void GarbageCollect(Func<string, IWorkloadResolver> getResolverForWorkloa
 
         }
 
+        public void AdjustWorkloadSetInInstallState(SdkFeatureBand sdkFeatureBand, string workloadVersion)
+        {
+            string path = Path.Combine(WorkloadInstallType.GetInstallStateFolder(_sdkFeatureBand, _dotnetDir), "default.json");
+            Directory.CreateDirectory(Path.GetDirectoryName(path));
+            var installStateContents = InstallStateContents.FromPath(path);
+            installStateContents.WorkloadVersion = workloadVersion;
+            File.WriteAllText(path, installStateContents.ToString());
+        }
+
         public void RemoveManifestsFromInstallState(SdkFeatureBand sdkFeatureBand)
         {
             string path = Path.Combine(WorkloadInstallType.GetInstallStateFolder(_sdkFeatureBand, _dotnetDir), "default.json");
@@ -509,7 +543,14 @@ public void Shutdown()
 
         public PackageId GetManifestPackageId(ManifestId manifestId, SdkFeatureBand featureBand)
         {
-            return new PackageId($"{manifestId}.Manifest-{featureBand}");
+            if (manifestId.ToString().Equals("Microsoft.NET.Workloads", StringComparison.OrdinalIgnoreCase))
+            {
+                return new PackageId($"{manifestId}.{featureBand}");
+            }
+            else
+            {
+                return new PackageId($"{manifestId}.Manifest-{featureBand}");
+            }
         }
 
         public async Task ExtractManifestAsync(string nupkgPath, string targetPath)

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

@@ -13,6 +13,8 @@ internal interface IInstaller : IWorkloadManifestInstaller
     {
         int ExitCode { get; }
 
+        string InstallWorkloadSet(ITransactionContext context, string advertisingPackagePath);
+
         void InstallWorkloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand sdkFeatureBand, ITransactionContext transactionContext, DirectoryPath? offlineCache = null);
 
         void RepairWorkloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand sdkFeatureBand, DirectoryPath? offlineCache = null);
@@ -25,6 +27,8 @@ internal interface IInstaller : IWorkloadManifestInstaller
 
         IEnumerable<WorkloadDownload> GetDownloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand sdkFeatureBand, bool includeInstalledItems);
 
+        void AdjustWorkloadSetInInstallState(SdkFeatureBand sdkFeatureBand, string workloadVersion);
+
         /// <summary>
         /// Replace the workload resolver used by this installer. Typically used to call <see cref="GetDownloads(IEnumerable{WorkloadId}, SdkFeatureBand, bool)"/>
         /// for a set of workload manifests that isn't currently installed

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

@@ -8,19 +8,22 @@ namespace Microsoft.DotNet.Workloads.Workload.Install
 {
     internal interface IWorkloadManifestUpdater
     {
-        Task UpdateAdvertisingManifestsAsync(bool includePreviews, DirectoryPath? offlineCache = null);
+        Task UpdateAdvertisingManifestsAsync(bool includePreviews, bool useWorkloadSets = false, DirectoryPath? offlineCache = null);
 
         Task BackgroundUpdateAdvertisingManifestsWhenRequiredAsync();
 
         IEnumerable<ManifestUpdateWithWorkloads> CalculateManifestUpdates();
 
         IEnumerable<ManifestVersionUpdate> CalculateManifestRollbacks(string rollbackDefinitionFilePath);
+        IEnumerable<ManifestVersionUpdate> ParseRollbackDefinitionFiles(IEnumerable<string> files);
 
         Task<IEnumerable<WorkloadDownload>> GetManifestPackageDownloadsAsync(bool includePreviews, SdkFeatureBand providedSdkFeatureBand, SdkFeatureBand installedSdkFeatureBand);
 
         IEnumerable<WorkloadId> GetUpdatableWorkloadsToAdvertise(IEnumerable<WorkloadId> installedWorkloads);
 
         void DeleteUpdatableWorkloadsFile();
+
+        void DownloadWorkloadSet(string version, DirectoryPath? offlineCache);
     }
 
     internal record ManifestUpdateWithWorkloads(ManifestVersionUpdate ManifestUpdate, WorkloadCollection Workloads);

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

@@ -346,4 +346,13 @@
   <data name="ManifestMsiNotFoundInNuGetPackage" xml:space="preserve">
     <value>Manifest MSI not found in NuGet package {0}</value>
   </data>
+  <data name="WorkloadSetVersionOptionDescription" xml:space="preserve">
+    <value>Update to the specified workload version.</value>
+  </data>
+  <data name="NewWorkloadSet" xml:space="preserve">
+    <value>Installing workload version {0}.</value>
+  </data>
+  <data name="WorkloadSetUpgrade" xml:space="preserve">
+    <value>Updating workload version from {0} to {1}.</value>
+  </data>
 </root>