fix bug in workload history recorder

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

@@ -45,7 +45,7 @@ internal static string GetWorkloadsVersion(WorkloadInfoHelper workloadInfoHelper
         {
             workloadInfoHelper ??= new WorkloadInfoHelper(false);
 
-            return workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
+            return workloadInfoHelper.ManifestProvider.GetWorkloadVersion().Version;
         }
 
         internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadInfoHelper workloadInfoHelper = null, IReporter reporter = null, string dotnetDir = null, bool showVersion = true)
@@ -58,7 +58,7 @@ internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadI
 
             if (showVersion)
             {
-                reporter.WriteLine($" Workload version: {workloadInfoHelper.ManifestProvider.GetWorkloadVersion()}");
+                reporter.WriteLine($" Workload version: {workloadInfoHelper.ManifestProvider.GetWorkloadVersion().Version}");
             }
 
             var useWorkloadSets = InstallStateContents.FromPath(Path.Combine(WorkloadInstallType.GetInstallStateFolder(workloadInfoHelper._currentSdkFeatureBand, workloadInfoHelper.UserLocalPath), "default.json")).UseWorkloadSets;

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

@@ -54,15 +54,16 @@ public void Run(Action workloadAction)
         private WorkloadHistoryState GetWorkloadState()
         {
             var resolver = _workloadResolverFunc();
-            var currentWorkloadInfo = resolver.GetWorkloadVersion();
+            var currentWorkloadVersion = resolver.GetWorkloadVersion();
+            var versionString = currentWorkloadVersion.WorkloadInstallType == WorkloadVersion.Type.LooseManifest ? string.Empty : currentWorkloadVersion.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 = versionString
             };
 
         }

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/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/IWorkloadManifestProvider.cs

@@ -14,8 +14,20 @@ public interface IWorkloadManifestProvider
 
         string GetSdkFeatureBand();
 
-        string? GetWorkloadVersion();
+        WorkloadVersion GetWorkloadVersion();
 
         Dictionary<string, WorkloadSet> GetAvailableWorkloadSets();
     }
+
+    public record WorkloadVersion
+    {
+        public enum Type
+        {
+            WorkloadSet,
+            LooseManifest
+        }
+
+        public string? Version;
+        public Type WorkloadInstallType;
+    }
 }

src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/IWorkloadResolver.cs

@@ -20,7 +20,7 @@ public interface IWorkloadResolver
         string GetManifestFeatureBand(string manifestId);
         IEnumerable<WorkloadManifestInfo> GetInstalledManifests();
         string GetSdkFeatureBand();
-        string? GetWorkloadVersion();
+        WorkloadVersion GetWorkloadVersion();
         IEnumerable<WorkloadId> GetUpdatedWorkloads(WorkloadResolver advertisingManifestResolver, IEnumerable<WorkloadId> installedWorkloads);
         WorkloadManifest GetManifestFromWorkload(WorkloadId workloadId);
 

src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/SdkDirectoryWorkloadManifestProvider.cs

@@ -243,18 +243,26 @@ void ThrowExceptionIfManifestsNotAvailable()
             }
         }
 
-        public string? GetWorkloadVersion()
+        public WorkloadVersion GetWorkloadVersion()
         {
             if (_globalJsonWorkloadSetVersion != null)
             {
-                return _globalJsonWorkloadSetVersion;
+                return new WorkloadVersion()
+                {
+                    Version = _globalJsonWorkloadSetVersion,
+                    WorkloadInstallType = WorkloadVersion.Type.WorkloadSet
+                };
             }
 
             ThrowExceptionIfManifestsNotAvailable();
 
             if (_workloadSet?.Version is not null)
             {
-                return _workloadSet?.Version!;
+                return new WorkloadVersion()
+                {
+                    Version = _workloadSet.Version,
+                    WorkloadInstallType = WorkloadVersion.Type.WorkloadSet
+                };
             }
 
             using (SHA256 sha256Hash = SHA256.Create())
@@ -271,7 +279,11 @@ void ThrowExceptionIfManifestsNotAvailable()
                     sb.Append(bytes[b].ToString("x2"));
                 }
 
-                return $"{_sdkVersionBand.ToStringWithoutPrerelease()}-manifests.{sb}";
+                return new WorkloadVersion()
+                {
+                    Version = $"{_sdkVersionBand.ToStringWithoutPrerelease()}-manifests.{sb}",
+                    WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+                };
             }
         }
 

src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/TempDirectoryWorkloadManifestProvider.cs

@@ -53,7 +53,11 @@ public IEnumerable<string> GetManifestDirectories()
         }
 
         public string GetSdkFeatureBand() => _sdkVersionBand;
-        public string? GetWorkloadVersion() => _sdkVersionBand.ToString() + ".2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+        {
+            Version = _sdkVersionBand + ".2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
         public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => new();
     }
 }

src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/WorkloadResolver.cs

@@ -115,7 +115,7 @@ public void RefreshWorkloadManifests()
             InitializeManifests();
         }
 
-        public string? GetWorkloadVersion() => _manifestProvider.GetWorkloadVersion();
+        public WorkloadVersion GetWorkloadVersion() => _manifestProvider.GetWorkloadVersion();
 
         private void LoadManifestsFromProvider(IWorkloadManifestProvider manifestProvider)
         {
@@ -778,7 +778,11 @@ public void RefreshWorkloadManifests() { }
             public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => new();
             public IEnumerable<ReadableWorkloadManifest> GetManifests() => Enumerable.Empty<ReadableWorkloadManifest>();
             public string GetSdkFeatureBand() => _sdkFeatureBand;
-            public string? GetWorkloadVersion() => _sdkFeatureBand.ToString() + ".2";
+            public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+            {
+                Version = _sdkFeatureBand + ".2",
+                WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+            };
         }
     }
 

test/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/FakeManifestProvider.cs

@@ -40,7 +40,11 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()
 
         public string GetSdkFeatureBand() => "8.0.100";
         public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => throw new NotImplementedException();
-        public string? GetWorkloadVersion() => "8.0.100.2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+                                                           {
+                                                               Version = "8.0.100.2",
+                                                               WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+                                                           };
     }
 
     internal class InMemoryFakeManifestProvider : IWorkloadManifestProvider, IEnumerable<(string id, string content)>
@@ -67,6 +71,10 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()
         IEnumerator IEnumerable.GetEnumerator() => throw new NotImplementedException();
         public string GetSdkFeatureBand() => "8.0.100";
         public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => throw new NotImplementedException();
-        public string? GetWorkloadVersion() => "8.0.100.2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+        {
+            Version = "8.0.100.2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
     }
 }

test/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/SdkDirectoryWorkloadManifestProviderTests.cs

@@ -93,14 +93,14 @@ var sdkDirectoryWorkloadManifestProvider
 
             if (useWorkloadSet)
             {
-                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Should().Be("8.0.200");
+                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Version.Should().Be("8.0.200");
             }
             else
             {
                 string[] manifests = sdkDirectoryWorkloadManifestProvider.GetManifests().OrderBy(m => m.ManifestId).Select(m => $"{m.ManifestId}.{m.ManifestFeatureBand}.{m.ManifestVersion}").ToArray();
                 manifests.Length.Should().Be(1);
                 manifests.Should().Contain("android.8.0.200.33.0.2-rc.1");
-                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Should().Be("8.0.200-manifests.4ba11739");
+                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Version.Should().Be("8.0.200-manifests.4ba11739");
             }
 
             Directory.Delete(Path.Combine(_manifestRoot, "8.0.100"), recursive: true);

test/dotnet-workload-install.Tests/MockManifestProvider.cs

@@ -48,6 +48,10 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()
         }
 
         public string GetSdkFeatureBand() => SdkFeatureBand.ToString();
-        public string GetWorkloadVersion() => SdkFeatureBand.ToString() + ".2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+        {
+            Version = GetSdkFeatureBand() + ".2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
     }
 }

test/dotnet-workload-search.Tests/MockWorkloadResolver.cs

@@ -39,7 +39,11 @@ public void RefreshWorkloadManifests() { /* noop */ }
         public IEnumerable<WorkloadManifestInfo> GetInstalledManifests() => _installedManifests ?? throw new NotImplementedException();
         public IWorkloadResolver CreateOverlayResolver(IWorkloadManifestProvider overlayManifestProvider) => throw new NotImplementedException();
         public string GetSdkFeatureBand() => "12.0.400";
-        public string GetWorkloadVersion() => "12.0.400.2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion()
+        {
+            Version = "12.0.400.2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
         public IEnumerable<WorkloadId> GetUpdatedWorkloads(WorkloadResolver advertisingManifestResolver, IEnumerable<WorkloadId> installedWorkloads) => throw new NotImplementedException();
         WorkloadResolver IWorkloadResolver.CreateOverlayResolver(IWorkloadManifestProvider overlayManifestProvider) => throw new NotImplementedException();
         WorkloadManifest IWorkloadResolver.GetManifestFromWorkload(WorkloadId workloadId) => throw new NotImplementedException();