Add "not installed" and other messages for workloads

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

@@ -224,7 +224,7 @@ public InstallResponseMessage SendGetGlobalJsonWorkloadSetVersionsRequest(SdkFea
         {
             return Send(new InstallRequestMessage
             {
-                RequestType = InstallRequestType.RecordWorkloadSetInGlobalJson,
+                RequestType = InstallRequestType.GetGlobalJsonWorkloadSetVersions,
                 SdkFeatureBand = sdkFeatureBand.ToString(),
             });
         }

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

@@ -45,7 +45,10 @@ internal static string GetWorkloadsVersion(WorkloadInfoHelper workloadInfoHelper
         {
             workloadInfoHelper ??= new WorkloadInfoHelper(false);
 
-            return workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
+            var versionInfo = workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
+
+            // The explicit space here is intentional, as it's easy to miss in localization and crucial for parsing
+            return versionInfo.Version + (versionInfo.VersionNotInstalledMessage is not null ? ' ' + Workloads.Workload.List.LocalizableStrings.WorkloadVersionNotInstalledShort : string.Empty);
         }
 
         internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadInfoHelper workloadInfoHelper = null, IReporter reporter = null, string dotnetDir = null, bool showVersion = true)
@@ -56,46 +59,68 @@ internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadI
             reporter ??= Utils.Reporter.Output;
             string dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
 
+
+
+            var versionInfo = workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
+
+            void WriteUpdateModeAndAnyError(string indent = "")
+            {
+                var useWorkloadSets = InstallStateContents.FromPath(Path.Combine(WorkloadInstallType.GetInstallStateFolder(workloadInfoHelper._currentSdkFeatureBand, workloadInfoHelper.UserLocalPath), "default.json")).UseWorkloadSets;
+                var workloadSetsString = useWorkloadSets == true ? "workload sets" : "loose manifests";
+                reporter.WriteLine(indent + string.Format(CommonStrings.WorkloadManifestInstallationConfiguration, workloadSetsString));
+
+                var additionalMessage = versionInfo.VersionNotInstalledMessage ?? versionInfo.UpdateModeMessage;
+                if (additionalMessage != null)
+                {
+                    reporter.WriteLine(indent + additionalMessage);
+                }
+            }
+
             if (showVersion)
             {
-                reporter.WriteLine($" Workload version: {workloadInfoHelper.ManifestProvider.GetWorkloadVersion()}");
+                reporter.WriteLine($" Workload version: {GetWorkloadsVersion()}");
+
+                WriteUpdateModeAndAnyError(indent: " ");
+                reporter.WriteLine();
             }
 
-            var useWorkloadSets = InstallStateContents.FromPath(Path.Combine(WorkloadInstallType.GetInstallStateFolder(workloadInfoHelper._currentSdkFeatureBand, workloadInfoHelper.UserLocalPath), "default.json")).UseWorkloadSets;
-            var workloadSetsString = useWorkloadSets == true ? "workload sets" : "loose manifests";
-            reporter.WriteLine(string.Format(CommonStrings.WorkloadManifestInstallationConfiguration, workloadSetsString));
-
             if (installedWorkloads.Count == 0)
             {
                 reporter.WriteLine(CommonStrings.NoWorkloadsInstalledInfoWarning);
-                return;
             }
+            else
+            {
+                var manifestInfoDict = workloadInfoHelper.WorkloadResolver.GetInstalledManifests().ToDictionary(info => info.Id, StringComparer.OrdinalIgnoreCase);
 
-            var manifestInfoDict = workloadInfoHelper.WorkloadResolver.GetInstalledManifests().ToDictionary(info => info.Id, StringComparer.OrdinalIgnoreCase);
+                foreach (var workload in installedWorkloads.AsEnumerable())
+                {
+                    var workloadManifest = workloadInfoHelper.WorkloadResolver.GetManifestFromWorkload(new WorkloadId(workload.Key));
+                    var workloadFeatureBand = manifestInfoDict[workloadManifest.Id].ManifestFeatureBand;
 
-            foreach (var workload in installedWorkloads.AsEnumerable())
-            {
-                var workloadManifest = workloadInfoHelper.WorkloadResolver.GetManifestFromWorkload(new WorkloadId(workload.Key));
-                var workloadFeatureBand = manifestInfoDict[workloadManifest.Id].ManifestFeatureBand;
+                    const int align = 10;
+                    const string separator = "   ";
 
-                const int align = 10;
-                const string separator = "   ";
+                    reporter.WriteLine($" [{workload.Key}]");
 
-                reporter.WriteLine($" [{workload.Key}]");
+                    reporter.Write($"{separator}{CommonStrings.WorkloadSourceColumn}:");
+                    reporter.WriteLine($" {workload.Value,align}");
 
-                reporter.Write($"{separator}{CommonStrings.WorkloadSourceColumn}:");
-                reporter.WriteLine($" {workload.Value,align}");
+                    reporter.Write($"{separator}{CommonStrings.WorkloadManifestVersionColumn}:");
+                    reporter.WriteLine($"    {workloadManifest.Version + '/' + workloadFeatureBand,align}");
 
-                reporter.Write($"{separator}{CommonStrings.WorkloadManifestVersionColumn}:");
-                reporter.WriteLine($"    {workloadManifest.Version + '/' + workloadFeatureBand,align}");
+                    reporter.Write($"{separator}{CommonStrings.WorkloadManifestPathColumn}:");
+                    reporter.WriteLine($"       {workloadManifest.ManifestPath,align}");
 
-                reporter.Write($"{separator}{CommonStrings.WorkloadManifestPathColumn}:");
-                reporter.WriteLine($"       {workloadManifest.ManifestPath,align}");
+                    reporter.Write($"{separator}{CommonStrings.WorkloadInstallTypeColumn}:");
+                    reporter.WriteLine($"       {WorkloadInstallType.GetWorkloadInstallType(new SdkFeatureBand(Utils.Product.Version), dotnetPath).ToString(),align}"
+                    );
+                    reporter.WriteLine("");
+                }
+            }
 
-                reporter.Write($"{separator}{CommonStrings.WorkloadInstallTypeColumn}:");
-                reporter.WriteLine($"       {WorkloadInstallType.GetWorkloadInstallType(new SdkFeatureBand(Utils.Product.Version), dotnetPath).ToString(),align}"
-                );
-                reporter.WriteLine("");
+            if (!showVersion)
+            {
+                WriteUpdateModeAndAnyError();
             }
         }
 

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

@@ -54,17 +54,17 @@ public void Run(Action workloadAction)
         private WorkloadHistoryState GetWorkloadState()
         {
             var resolver = _workloadResolverFunc();
-            var currentWorkloadInfo = resolver.GetWorkloadVersion();
+            var currentWorkloadVersion = resolver.GetWorkloadVersion().Version;
             return new WorkloadHistoryState()
             {
                 ManifestVersions = resolver.GetInstalledManifests().ToDictionary(manifest => manifest.Id.ToString(), manifest => $"{manifest.Version}/{manifest.ManifestFeatureBand}"),
                 InstalledWorkloads = _workloadInstaller.GetWorkloadInstallationRecordRepository()
                                                        .GetInstalledWorkloads(new SdkFeatureBand(_workloadResolver.GetSdkFeatureBand()))
                                                        .Select(id => id.ToString())
                                                        .ToList(),
-                WorkloadSetVersion = resolver.GetWorkloadVersion()
+                WorkloadSetVersion = currentWorkloadVersion
             };
 
         }
     }
-}
+}

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

@@ -20,6 +20,7 @@ internal class WorkloadInstallCommand : InstallingWorkloadCommand
     {
         private bool _skipManifestUpdate;
         private readonly IReadOnlyCollection<string> _workloadIds;
+        private readonly bool _shouldShutdownInstaller;
 
         public bool IsRunningRestore { get; set; }
 
@@ -45,6 +46,7 @@ public WorkloadInstallCommand(
                                  WorkloadInstallerFactory.GetWorkloadInstaller(resolvedReporter, _sdkFeatureBand,
                                      _workloadResolver, Verbosity, _userProfileDir, VerifySignatures, PackageDownloader, _dotnetPath, TempDirectoryPath,
                                      _packageSourceLocation, RestoreActionConfiguration, elevationRequired: !_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption));
+            _shouldShutdownInstaller = _workloadInstallerFromConstructor != null;
 
             _workloadManifestUpdater = _workloadManifestUpdaterFromConstructor ?? new WorkloadManifestUpdater(resolvedReporter, _workloadResolver, PackageDownloader, _userProfileDir,
                 _workloadInstaller.GetWorkloadInstallationRecordRepository(), _workloadInstaller, _packageSourceLocation, displayManifestUpdates: Verbosity.IsDetailedOrDiagnostic());
@@ -120,7 +122,9 @@ public override int Execute()
                 throw new GracefulException(string.Format(LocalizableStrings.CannotCombineSkipManifestAndVersion,
                     WorkloadInstallCommandParser.SkipManifestUpdateOption.Name, InstallingWorkloadCommandParser.VersionOption.Name), isUserError: true);
             }
-            else if (_skipManifestUpdate && SpecifiedWorkloadSetVersionInGlobalJson)
+            else if ((_skipManifestUpdate && SpecifiedWorkloadSetVersionInGlobalJson) &&
+                !IsRunningRestore)  //  When running restore, we first update workloads, then query the projects to figure out what workloads should be installed, then run the install command.
+                                    //  When we run the install command we set skipManifestUpdate to true as an optimization to avoid trying to update twice
             {
                 throw new GracefulException(string.Format(LocalizableStrings.CannotUseSkipManifestWithGlobalJsonWorkloadVersion,
                     WorkloadInstallCommandParser.SkipManifestUpdateOption.Name, _globalJsonPath), isUserError: true);
@@ -146,14 +150,21 @@ public override int Execute()
                 }
                 catch (Exception e)
                 {
-                    _workloadInstaller.Shutdown();
+                    if (_shouldShutdownInstaller)
+                    {
+                        _workloadInstaller.Shutdown();
+                    }
 
                     // Don't show entire stack trace
                     throw new GracefulException(string.Format(LocalizableStrings.WorkloadInstallationFailed, e.Message), e, isUserError: false);
                 }
             }
 
-            _workloadInstaller.Shutdown();
+            if (_shouldShutdownInstaller)
+            {
+                _workloadInstaller.Shutdown();
+            }
+
             return _workloadInstaller.ExitCode;
         }
 

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

@@ -134,6 +134,9 @@
   <data name="WorkloadSetFromGlobalJsonInstalled" xml:space="preserve">
     <value>Found workload version {0} pinned in the global.json file at {1}.</value>
   </data>
+  <data name="WorkloadVersionNotInstalledShort" xml:space="preserve">
+    <value>(not installed)</value>
+  </data>
   <data name="WorkloadSetFromGlobalJsonNotInstalled" xml:space="preserve">
     <value>Found workload version {0} pinned in the global.json file at {1}, but it was not installed. Running `dotnet workload install`, `dotnet workload update`, or `dotnet workload restore` may fix this.</value>
   </data>

src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommand.cs

@@ -93,7 +93,7 @@ public override int Execute()
                     }
                     else
                     {
-                        Reporter.WriteLine(string.Format(LocalizableStrings.WorkloadSetVersion, _workloadListHelper.WorkloadResolver.GetWorkloadVersion() ?? "unknown"));
+                        Reporter.WriteLine(string.Format(LocalizableStrings.WorkloadSetVersion, _workloadListHelper.WorkloadResolver.GetWorkloadVersion().Version ?? "unknown"));
                     }
 
                     Reporter.WriteLine();

src/Cli/dotnet/commands/dotnet-workload/restore/WorkloadRestoreCommand.cs

@@ -51,7 +51,7 @@ public override int Execute()
             recorder.Run(() =>
             {
                 // First update manifests and install a workload set as necessary
-                new WorkloadUpdateCommand(_result, recorder: recorder).Execute();
+                new WorkloadUpdateCommand(_result, recorder: recorder, isRestoring: true).Execute();
 
                 var allProjects = DiscoverAllProjects(Directory.GetCurrentDirectory(), _slnOrProjectArgument).Distinct();
                 List<WorkloadId> allWorkloadId = RunTargetToGetWorkloadIds(allProjects);
@@ -64,6 +64,8 @@ public override int Execute()
                     IsRunningRestore = true
                 }.Execute();
             });
+
+            workloadInstaller.Shutdown();
 
             return 0;
         }