Correctly report manifest feature band for side-by-side manifests in WorkloadResolver.GetInstalledManifests

dsplaisted · dsplaisted · commit 0fb6201f3216 · 2023-07-12T12:41:49.000-04:00
diff --git a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs
@@ -54,14 +54,12 @@ internal static void ShowWorkloadsInfo(ParseResult parseResult = null, IWorkload
                 return;
             }
 
+            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 = new WorkloadManifestInfo(
-                    workloadManifest.Id,
-                    workloadManifest.Version,
-                    Path.GetDirectoryName(workloadManifest.ManifestPath)!).ManifestFeatureBand;
+                var workloadFeatureBand = manifestInfoDict[workloadManifest.Id].ManifestFeatureBand;
 
                 const int align = 10;
                 const string separator = "   ";
diff --git a/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommand.cs b/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommand.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.CommandLine.Parsing;
@@ -81,15 +82,17 @@ public override int Execute()
             }
             else
             {
+                var manifestInfoDict = _workloadListHelper.WorkloadResolver.GetInstalledManifests().ToDictionary(info => info.Id, StringComparer.OrdinalIgnoreCase);
+
                 InstalledWorkloadsCollection installedWorkloads = _workloadListHelper.AddInstalledVsWorkloads(installedList);
                 Reporter.WriteLine();
                 PrintableTable<KeyValuePair<string, string>> table = new();
                 table.AddColumn(InformationStrings.WorkloadIdColumn, workload => workload.Key);
                 table.AddColumn(InformationStrings.WorkloadManfiestVersionColumn, workload =>
                 {
                     var m = _workloadListHelper.WorkloadResolver.GetManifestFromWorkload(new WorkloadId(workload.Key));
-                    return m.Version + "/" +
-                    new WorkloadManifestInfo(m.Id, m.Version, Path.GetDirectoryName(m.ManifestPath)!).ManifestFeatureBand;
+                    var manifestInfo = manifestInfoDict[m.Id];
+                    return m.Version + "/" + manifestInfo.ManifestFeatureBand;
                 });
                 table.AddColumn(InformationStrings.WorkloadSourceColumn, workload => workload.Value);
 
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/ReadableWorkloadManifest.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/ReadableWorkloadManifest.cs
@@ -18,16 +18,19 @@ public class ReadableWorkloadManifest
 
         public string ManifestPath { get; }
 
+        public string ManifestFeatureBand { get; }
+
         readonly Func<Stream> _openManifestStreamFunc;
 
 
         readonly Func<Stream?> _openLocalizationStream;
 
-        public ReadableWorkloadManifest(string manifestId, string manifestDirectory, string manifestPath, Func<Stream> openManifestStreamFunc, Func<Stream?> openLocalizationStream)
+        public ReadableWorkloadManifest(string manifestId, string manifestDirectory, string manifestPath, string manifestFeatureBand, Func<Stream> openManifestStreamFunc, Func<Stream?> openLocalizationStream)
         {
             ManifestId = manifestId;
             ManifestPath = manifestPath;
             ManifestDirectory = manifestDirectory;
+            ManifestFeatureBand = manifestFeatureBand;
             _openManifestStreamFunc = openManifestStreamFunc;
             _openLocalizationStream = openLocalizationStream;
         }
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/SdkDirectoryWorkloadManifestProvider.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/SdkDirectoryWorkloadManifestProvider.cs
@@ -128,14 +128,29 @@ internal SdkDirectoryWorkloadManifestProvider(string sdkRootPath, string sdkVers
         public IEnumerable<ReadableWorkloadManifest> GetManifests()
         {
             //  Scan manifest directories
-            var manifestIdsToDirectories = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            var manifestIdsToManifests = new Dictionary<string, ReadableWorkloadManifest>(StringComparer.OrdinalIgnoreCase);
 
-            void ProbeDirectory(string manifestDirectory)
+            void AddManifest(string manifestId, string manifestDirectory, string featureBand)
+            {
+                var workloadManifestPath = Path.Combine(manifestDirectory, "WorkloadManifest.json");
+
+                var readableManifest = new ReadableWorkloadManifest(
+                    manifestId,
+                    manifestDirectory,
+                    workloadManifestPath,
+                    featureBand,
+                    () => File.OpenRead(workloadManifestPath),
+                    () => WorkloadManifestReader.TryOpenLocalizationCatalogForManifest(workloadManifestPath));
+
+                manifestIdsToManifests[manifestId] = readableManifest;
+            }
+
+            void ProbeDirectory(string manifestDirectory, string featureBand)
             {
                 (string? id, string? finalManifestDirectory) = ResolveManifestDirectory(manifestDirectory);
                 if (id != null && finalManifestDirectory != null)
                 {
-                    manifestIdsToDirectories.Add(id, finalManifestDirectory);
+                    AddManifest(id, finalManifestDirectory, featureBand);
                 }
             }
 
@@ -147,7 +162,7 @@ void ProbeDirectory(string manifestDirectory)
                 {
                     foreach (var workloadManifestDirectory in Directory.EnumerateDirectories(manifestVersionBandDirectory))
                     {
-                        ProbeDirectory(workloadManifestDirectory);
+                        ProbeDirectory(workloadManifestDirectory, _sdkVersionBand.ToString());
                     }
                 }
             }
@@ -169,7 +184,7 @@ void ProbeDirectory(string manifestDirectory)
 
                 foreach (var workloadManifestDirectory in directoriesWithManifests.Values)
                 {
-                    ProbeDirectory(workloadManifestDirectory);
+                    ProbeDirectory(workloadManifestDirectory, _sdkVersionBand.ToString());
                 }
             }
 
@@ -184,7 +199,8 @@ void ProbeDirectory(string manifestDirectory)
                     {
                         throw new FileNotFoundException(string.Format(Strings.ManifestFromWorkloadSetNotFound, manifestSpecifier.ToString(), _workloadSet.Version));
                     }
-                    manifestIdsToDirectories[kvp.Key.ToString()] = manifestDirectory;
+                    AddManifest(manifestSpecifier.Id.ToString(), manifestDirectory, manifestSpecifier.FeatureBand.ToString());
+                    
                 }
             }
 
@@ -199,26 +215,26 @@ void ProbeDirectory(string manifestDirectory)
                     {
                         throw new FileNotFoundException(string.Format(Strings.ManifestFromInstallStateNotFound, manifestSpecifier.ToString(), _installStateFilePath));
                     }
-                    manifestIdsToDirectories[kvp.Key.ToString()] = manifestDirectory;
+                    AddManifest(manifestSpecifier.Id.ToString(), manifestDirectory, manifestSpecifier.FeatureBand.ToString());
                 }
             }
 
-            if (_knownManifestIdsAndOrder != null && _knownManifestIdsAndOrder.Keys.Any(id => !manifestIdsToDirectories.ContainsKey(id)))
+            if (_knownManifestIdsAndOrder != null && _knownManifestIdsAndOrder.Keys.Any(id => !manifestIdsToManifests.ContainsKey(id)))
             {
-                var missingManifestIds = _knownManifestIdsAndOrder.Keys.Where(id => !manifestIdsToDirectories.ContainsKey(id));
+                var missingManifestIds = _knownManifestIdsAndOrder.Keys.Where(id => !manifestIdsToManifests.ContainsKey(id));
                 foreach (var missingManifestId in missingManifestIds)
                 {
-                    var manifestDir = FallbackForMissingManifest(missingManifestId);
+                    var (manifestDir, featureBand) = FallbackForMissingManifest(missingManifestId);
                     if (!string.IsNullOrEmpty(manifestDir))
                     {
-                        manifestIdsToDirectories.Add(missingManifestId, manifestDir);
+                        AddManifest(missingManifestId, manifestDir, featureBand);
                     }
                 }
             }
 
             //  Return manifests in a stable order.  Manifests in the KnownWorkloadManifests.txt file will be first, and in the same order they appear in that file.
             //  Then the rest of the manifests (if any) will be returned in (ordinal case-insensitive) alphabetical order.
-            return manifestIdsToDirectories
+            return manifestIdsToManifests
                 .OrderBy(kvp =>
                 {
                     if (_knownManifestIdsAndOrder != null &&
@@ -229,19 +245,7 @@ void ProbeDirectory(string manifestDirectory)
                     return int.MaxValue;
                 })
                 .ThenBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)
-                .Select(kvp =>
-                {
-                    var manifestId = kvp.Key;
-                    var manifestDirectory = kvp.Value;
-                    var workloadManifestPath = Path.Combine(manifestDirectory, "WorkloadManifest.json");
-
-                    return new ReadableWorkloadManifest(
-                        manifestId,
-                        manifestDirectory,
-                        workloadManifestPath,
-                        () => File.OpenRead(workloadManifestPath),
-                        () => WorkloadManifestReader.TryOpenLocalizationCatalogForManifest(workloadManifestPath));
-                })
+                .Select(kvp => kvp.Value)
                 .ToList();
         }
 
@@ -282,21 +286,21 @@ void ProbeDirectory(string manifestDirectory)
             return (null, null);
         }
 
-        private string FallbackForMissingManifest(string manifestId)
+        private (string manifestDirectory, string manifestFeatureBand) FallbackForMissingManifest(string manifestId)
         {
             //  Only use the last manifest root (usually the dotnet folder itself) for fallback
             var sdkManifestPath = _manifestRoots.Last();
             if (!Directory.Exists(sdkManifestPath))
             {
-                return string.Empty;
+                return (string.Empty, string.Empty);
             }
 
             var candidateFeatureBands = Directory.GetDirectories(sdkManifestPath)
                 .Select(dir => Path.GetFileName(dir))
                 .Select(featureBand => new SdkFeatureBand(featureBand))
                 .Where(featureBand => featureBand < _sdkVersionBand || _sdkVersionBand.ToStringWithoutPrerelease().Equals(featureBand.ToString(), StringComparison.Ordinal));
 
-            var matchingManifestFatureBandsAndResolvedManifestDirectories = candidateFeatureBands
+            var matchingManifestFeatureBandsAndResolvedManifestDirectories = candidateFeatureBands
                 //  Calculate path to <FeatureBand>\<ManifestID>
                 .Select(featureBand => (featureBand, manifestDirectory: Path.Combine(sdkManifestPath, featureBand.ToString(), manifestId)))
                 //  Filter out directories that don't exist
@@ -307,14 +311,15 @@ private string FallbackForMissingManifest(string manifestId)
                 .Where(t => t.res.id != null && t.res.manifestDirectory != null)
                 .ToList();
 
-            if (matchingManifestFatureBandsAndResolvedManifestDirectories.Any())
+            if (matchingManifestFeatureBandsAndResolvedManifestDirectories.Any())
             {
-                return matchingManifestFatureBandsAndResolvedManifestDirectories.OrderByDescending(t => t.featureBand).First().res.manifestDirectory!;
+                var selectedFeatureBandAndManifestDirectory = matchingManifestFeatureBandsAndResolvedManifestDirectories.OrderByDescending(t => t.featureBand).First();
+                return (selectedFeatureBandAndManifestDirectory.res.manifestDirectory!, selectedFeatureBandAndManifestDirectory.featureBand.ToString());
             }
             else
             {
                 // Manifest does not exist
-                return string.Empty;
+                return (string.Empty, string.Empty);
             }
         }
 
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/TempDirectoryWorkloadManifestProvider.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/TempDirectoryWorkloadManifestProvider.cs
@@ -37,6 +37,7 @@ public IEnumerable<ReadableWorkloadManifest>
                     manifestId,
                     workloadManifestDirectory,
                     workloadManifestPath,
+                    _sdkVersionBand,
                     () => File.OpenRead(workloadManifestPath),
                     () => WorkloadManifestReader.TryOpenLocalizationCatalogForManifest(workloadManifestPath)
                 );
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/WorkloadManifestInfo.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/WorkloadManifestInfo.cs
@@ -12,12 +12,12 @@ namespace Microsoft.NET.Sdk.WorkloadManifestReader
 {
     public class WorkloadManifestInfo
     {
-        public WorkloadManifestInfo(string id, string version, string manifestDirectory)
+        public WorkloadManifestInfo(string id, string version, string manifestDirectory, string manifestFeatureBand)
         {
             Id = id;
             Version = version;
             ManifestDirectory = manifestDirectory;
-            ManifestFeatureBand = Path.GetFileName(Path.GetDirectoryName(manifestDirectory))!;
+            ManifestFeatureBand = manifestFeatureBand;
         }
 
         public string Id { get; }
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/WorkloadResolver.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/WorkloadResolver.cs
@@ -21,7 +21,7 @@ namespace Microsoft.NET.Sdk.WorkloadManifestReader
     /// </remarks>
     public class WorkloadResolver : IWorkloadResolver
     {
-        private readonly Dictionary<string, WorkloadManifest> _manifests = new(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, (WorkloadManifest manifest, WorkloadManifestInfo info)> _manifests = new(StringComparer.OrdinalIgnoreCase);
         private readonly Dictionary<WorkloadId, (WorkloadDefinition workload, WorkloadManifest manifest)> _workloads = new();
         private readonly Dictionary<WorkloadPackId, (WorkloadPack pack, WorkloadManifest manifest)> _packs = new();
         private IWorkloadManifestProvider? _manifestProvider;
@@ -118,9 +118,10 @@ private void LoadManifestsFromProvider(IWorkloadManifestProvider manifestProvide
                 using (Stream? localizationStream = readableManifest.OpenLocalizationStream())
                 {
                     var manifest = WorkloadManifestReader.ReadWorkloadManifest(readableManifest.ManifestId, manifestStream, localizationStream, readableManifest.ManifestPath);
-                    if (!_manifests.TryAdd(readableManifest.ManifestId, manifest))
+                    var manifestInfo = new WorkloadManifestInfo(manifest.Id, manifest.Version, readableManifest.ManifestDirectory, readableManifest.ManifestFeatureBand);
+                    if (!_manifests.TryAdd(readableManifest.ManifestId, (manifest, manifestInfo)))
                     {
-                        var existingManifest = _manifests[readableManifest.ManifestId];
+                        var existingManifest = _manifests[readableManifest.ManifestId].manifest;
                         throw new WorkloadManifestCompositionException(Strings.DuplicateManifestID, manifestProvider.GetType().FullName, readableManifest.ManifestId, readableManifest.ManifestPath, existingManifest.ManifestPath);
                     }
                 }
@@ -134,14 +135,15 @@ private void ComposeWorkloadManifests()
 
             Dictionary<WorkloadId, (WorkloadRedirect redirect, WorkloadManifest manifest)>? redirects = null;
 
-            foreach (var manifest in _manifests.Values)
+            foreach (var (manifest, info) in _manifests.Values)
             {
                 if (manifest.DependsOnManifests != null)
                 {
                     foreach (var dependency in manifest.DependsOnManifests)
                     {
-                        if (_manifests.TryGetValue(dependency.Key, out var resolvedDependency))
+                        if (_manifests.TryGetValue(dependency.Key, out var t))
                         {
+                            var resolvedDependency = t.manifest;
                             if (FXVersion.Compare(dependency.Value, resolvedDependency.ParsedVersion) > 0)
                             {
                                 throw new WorkloadManifestCompositionException(Strings.ManifestDependencyVersionTooLow, dependency.Key, resolvedDependency.Version, dependency.Value, manifest.Id, manifest.ManifestPath);
@@ -711,11 +713,17 @@ private bool IsWorkloadPlatformCompatible(WorkloadDefinition workload, WorkloadM
 
         private bool IsWorkloadImplicitlyAbstract(WorkloadDefinition workload, WorkloadManifest manifest) => !GetPacksInWorkload(workload, manifest).Any();
 
-        public string GetManifestVersion(string manifestId) =>
-            (_manifests.TryGetValue(manifestId, out WorkloadManifest? value)? value : null)?.Version
-            ?? throw new Exception($"Manifest with id {manifestId} does not exist.");
+        public string GetManifestVersion(string manifestId)
+        {
+            if (_manifests.TryGetValue(manifestId, out var value))
+            {
+                return value.manifest.Version;
+            }
+            throw new Exception($"Manifest with id {manifestId} does not exist.");
+        }
+            
 
-        public IEnumerable<WorkloadManifestInfo> GetInstalledManifests() => _manifests.Select(m => new WorkloadManifestInfo(m.Value.Id, m.Value.Version, Path.GetDirectoryName(m.Value.ManifestPath)!));
+        public IEnumerable<WorkloadManifestInfo> GetInstalledManifests() => _manifests.Select(t => t.Value.info);
     }
 
     static class DictionaryExtensions
diff --git a/src/Tests/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/FakeManifestProvider.cs b/src/Tests/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/FakeManifestProvider.cs
@@ -26,8 +26,6 @@ public FakeManifestProvider(params (string manifest, string? localizationCatalog
             _filePaths = filePaths;
         }
 
-        public IEnumerable<string> GetManifestDirectories() => throw new NotImplementedException();
-
         public IEnumerable<ReadableWorkloadManifest> GetManifests()
         {
             foreach (var filePath in _filePaths)
@@ -36,6 +34,7 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()
                     Path.GetFileNameWithoutExtension(filePath.manifest),
                     Path.GetDirectoryName(filePath.manifest)!,
                     filePath.manifest,
+                    "8.0.100",
                     () => new FileStream(filePath.manifest, FileMode.Open, FileAccess.Read),
                     () => filePath.localizationCatalog != null ? new FileStream(filePath.localizationCatalog, FileMode.Open, FileAccess.Read) : null
                 );
@@ -50,13 +49,13 @@ internal class InMemoryFakeManifestProvider : IWorkloadManifestProvider, IEnumer
         readonly List<(string id, byte[] content)> _manifests = new List<(string, byte[])>();
 
         public void Add(string id, string content) => _manifests.Add((id, Encoding.UTF8.GetBytes(content)));
-        public IEnumerable<string> GetManifestDirectories() => throw new NotImplementedException();
 
         public IEnumerable<ReadableWorkloadManifest> GetManifests()
             => _manifests.Select(m => new ReadableWorkloadManifest(
                 m.id,
                 $@"C:\fake\{m.id}",
                 $@"C:\fake\{m.id}\WorkloadManifest.json",
+                "8.0.100",
                 (Func<Stream>)(() => new MemoryStream(m.content)),
                 (Func<Stream?>)(() => null)
             ));
diff --git a/src/Tests/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/SdkDirectoryWorkloadManifestProviderTests.cs b/src/Tests/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/SdkDirectoryWorkloadManifestProviderTests.cs
diff --git a/src/Tests/dotnet-workload-install.Tests/GivenWorkloadManifestUpdater.cs b/src/Tests/dotnet-workload-install.Tests/GivenWorkloadManifestUpdater.cs
diff --git a/src/Tests/dotnet-workload-install.Tests/MockManifestProvider.cs b/src/Tests/dotnet-workload-install.Tests/MockManifestProvider.cs

Original file line number	Diff line number	Diff line change
`@@ -54,14 +54,12 @@ internal static void ShowWorkloadsInfo(ParseResult parseResult = null, IWorkload`
`54`	`54`	`return;`
`55`	`55`	`}`
`56`	`56`
	`57`	`+ var manifestInfoDict = workloadInfoHelper.WorkloadResolver.GetInstalledManifests().ToDictionary(info => info.Id, StringComparer.OrdinalIgnoreCase);`
`57`	`58`
`58`	`59`	`foreach (var workload in installedWorkloads.AsEnumerable())`
`59`	`60`	`{`
`60`	`61`	`var workloadManifest = workloadInfoHelper.WorkloadResolver.GetManifestFromWorkload(new WorkloadId(workload.Key));`
`61`		`- var workloadFeatureBand = new WorkloadManifestInfo(`
`62`		`- workloadManifest.Id,`
`63`		`- workloadManifest.Version,`
`64`		`- Path.GetDirectoryName(workloadManifest.ManifestPath)!).ManifestFeatureBand;`
	`62`	`+ var workloadFeatureBand = manifestInfoDict[workloadManifest.Id].ManifestFeatureBand;`
`65`	`63`
`66`	`64`	`const int align = 10;`
`67`	`65`	`const string separator = " ";`
Original file line number	Diff line number	Diff line change
`@@ -128,14 +128,29 @@ internal SdkDirectoryWorkloadManifestProvider(string sdkRootPath, string sdkVers`
`128`	`128`	`public IEnumerable<ReadableWorkloadManifest> GetManifests()`
`129`	`129`	`{`
`130`	`130`	`// Scan manifest directories`
`131`		`- var manifestIdsToDirectories = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);`
	`131`	`+ var manifestIdsToManifests = new Dictionary<string, ReadableWorkloadManifest>(StringComparer.OrdinalIgnoreCase);`
`132`	`132`
`133`		`- void ProbeDirectory(string manifestDirectory)`
	`133`	`+ void AddManifest(string manifestId, string manifestDirectory, string featureBand)`
	`134`	`+ {`
	`135`	`+ var workloadManifestPath = Path.Combine(manifestDirectory, "WorkloadManifest.json");`
	`136`	`+`
	`137`	`+ var readableManifest = new ReadableWorkloadManifest(`
	`138`	`+ manifestId,`
	`139`	`+ manifestDirectory,`
	`140`	`+ workloadManifestPath,`
	`141`	`+ featureBand,`
	`142`	`+ () => File.OpenRead(workloadManifestPath),`
	`143`	`+ () => WorkloadManifestReader.TryOpenLocalizationCatalogForManifest(workloadManifestPath));`
	`144`	`+`
	`145`	`+ manifestIdsToManifests[manifestId] = readableManifest;`
	`146`	`+ }`
	`147`	`+`
	`148`	`+ void ProbeDirectory(string manifestDirectory, string featureBand)`
`134`	`149`	`{`
`135`	`150`	`(string? id, string? finalManifestDirectory) = ResolveManifestDirectory(manifestDirectory);`
`136`	`151`	`if (id != null && finalManifestDirectory != null)`
`137`	`152`	`{`
`138`		`- manifestIdsToDirectories.Add(id, finalManifestDirectory);`
	`153`	`+ AddManifest(id, finalManifestDirectory, featureBand);`
`139`	`154`	`}`
`140`	`155`	`}`
`141`	`156`
`@@ -147,7 +162,7 @@ void ProbeDirectory(string manifestDirectory)`
`147`	`162`	`{`
`148`	`163`	`foreach (var workloadManifestDirectory in Directory.EnumerateDirectories(manifestVersionBandDirectory))`
`149`	`164`	`{`
`150`		`- ProbeDirectory(workloadManifestDirectory);`
	`165`	`+ ProbeDirectory(workloadManifestDirectory, _sdkVersionBand.ToString());`
`151`	`166`	`}`
`152`	`167`	`}`
`153`	`168`	`}`
`@@ -169,7 +184,7 @@ void ProbeDirectory(string manifestDirectory)`
`169`	`184`
`170`	`185`	`foreach (var workloadManifestDirectory in directoriesWithManifests.Values)`
`171`	`186`	`{`
`172`		`- ProbeDirectory(workloadManifestDirectory);`
	`187`	`+ ProbeDirectory(workloadManifestDirectory, _sdkVersionBand.ToString());`
`173`	`188`	`}`
`174`	`189`	`}`
`175`	`190`
`@@ -184,7 +199,8 @@ void ProbeDirectory(string manifestDirectory)`
`184`	`199`	`{`
`185`	`200`	`throw new FileNotFoundException(string.Format(Strings.ManifestFromWorkloadSetNotFound, manifestSpecifier.ToString(), _workloadSet.Version));`
`186`	`201`	`}`
`187`		`- manifestIdsToDirectories[kvp.Key.ToString()] = manifestDirectory;`
	`202`	`+ AddManifest(manifestSpecifier.Id.ToString(), manifestDirectory, manifestSpecifier.FeatureBand.ToString());`
	`203`	`+`
`188`	`204`	`}`
`189`	`205`	`}`
`190`	`206`
`@@ -199,26 +215,26 @@ void ProbeDirectory(string manifestDirectory)`
`199`	`215`	`{`
`200`	`216`	`throw new FileNotFoundException(string.Format(Strings.ManifestFromInstallStateNotFound, manifestSpecifier.ToString(), _installStateFilePath));`
`201`	`217`	`}`
`202`		`- manifestIdsToDirectories[kvp.Key.ToString()] = manifestDirectory;`
	`218`	`+ AddManifest(manifestSpecifier.Id.ToString(), manifestDirectory, manifestSpecifier.FeatureBand.ToString());`
`203`	`219`	`}`
`204`	`220`	`}`
`205`	`221`
`206`		`- if (_knownManifestIdsAndOrder != null && _knownManifestIdsAndOrder.Keys.Any(id => !manifestIdsToDirectories.ContainsKey(id)))`
	`222`	`+ if (_knownManifestIdsAndOrder != null && _knownManifestIdsAndOrder.Keys.Any(id => !manifestIdsToManifests.ContainsKey(id)))`
`207`	`223`	`{`
`208`		`- var missingManifestIds = _knownManifestIdsAndOrder.Keys.Where(id => !manifestIdsToDirectories.ContainsKey(id));`
	`224`	`+ var missingManifestIds = _knownManifestIdsAndOrder.Keys.Where(id => !manifestIdsToManifests.ContainsKey(id));`
`209`	`225`	`foreach (var missingManifestId in missingManifestIds)`
`210`	`226`	`{`
`211`		`- var manifestDir = FallbackForMissingManifest(missingManifestId);`
	`227`	`+ var (manifestDir, featureBand) = FallbackForMissingManifest(missingManifestId);`
`212`	`228`	`if (!string.IsNullOrEmpty(manifestDir))`
`213`	`229`	`{`
`214`		`- manifestIdsToDirectories.Add(missingManifestId, manifestDir);`
	`230`	`+ AddManifest(missingManifestId, manifestDir, featureBand);`
`215`	`231`	`}`
`216`	`232`	`}`
`217`	`233`	`}`
`218`	`234`
`219`	`235`	`// Return manifests in a stable order. Manifests in the KnownWorkloadManifests.txt file will be first, and in the same order they appear in that file.`
`220`	`236`	`// Then the rest of the manifests (if any) will be returned in (ordinal case-insensitive) alphabetical order.`
`221`		`- return manifestIdsToDirectories`
	`237`	`+ return manifestIdsToManifests`
`222`	`238`	`.OrderBy(kvp =>`
`223`	`239`	`{`
`224`	`240`	`if (_knownManifestIdsAndOrder != null &&`
`@@ -229,19 +245,7 @@ void ProbeDirectory(string manifestDirectory)`
`229`	`245`	`return int.MaxValue;`
`230`	`246`	`})`
`231`	`247`	`.ThenBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)`
`232`		`- .Select(kvp =>`
`233`		`- {`
`234`		`- var manifestId = kvp.Key;`
`235`		`- var manifestDirectory = kvp.Value;`
`236`		`- var workloadManifestPath = Path.Combine(manifestDirectory, "WorkloadManifest.json");`
`237`		`-`
`238`		`- return new ReadableWorkloadManifest(`
`239`		`- manifestId,`
`240`		`- manifestDirectory,`
`241`		`- workloadManifestPath,`
`242`		`- () => File.OpenRead(workloadManifestPath),`
`243`		`- () => WorkloadManifestReader.TryOpenLocalizationCatalogForManifest(workloadManifestPath));`
`244`		`- })`
	`248`	`+ .Select(kvp => kvp.Value)`
`245`	`249`	`.ToList();`
`246`	`250`	`}`
`247`	`251`
`@@ -282,21 +286,21 @@ void ProbeDirectory(string manifestDirectory)`
`282`	`286`	`return (null, null);`
`283`	`287`	`}`
`284`	`288`
`285`		`- private string FallbackForMissingManifest(string manifestId)`
	`289`	`+ private (string manifestDirectory, string manifestFeatureBand) FallbackForMissingManifest(string manifestId)`
`286`	`290`	`{`
`287`	`291`	`// Only use the last manifest root (usually the dotnet folder itself) for fallback`
`288`	`292`	`var sdkManifestPath = _manifestRoots.Last();`
`289`	`293`	`if (!Directory.Exists(sdkManifestPath))`
`290`	`294`	`{`
`291`		`- return string.Empty;`
	`295`	`+ return (string.Empty, string.Empty);`
`292`	`296`	`}`
`293`	`297`
`294`	`298`	`var candidateFeatureBands = Directory.GetDirectories(sdkManifestPath)`
`295`	`299`	`.Select(dir => Path.GetFileName(dir))`
`296`	`300`	`.Select(featureBand => new SdkFeatureBand(featureBand))`
`297`	`301`	`.Where(featureBand => featureBand < _sdkVersionBand \|\| _sdkVersionBand.ToStringWithoutPrerelease().Equals(featureBand.ToString(), StringComparison.Ordinal));`
`298`	`302`
`299`		`- var matchingManifestFatureBandsAndResolvedManifestDirectories = candidateFeatureBands`
	`303`	`+ var matchingManifestFeatureBandsAndResolvedManifestDirectories = candidateFeatureBands`
`300`	`304`	`// Calculate path to <FeatureBand>\<ManifestID>`
`301`	`305`	`.Select(featureBand => (featureBand, manifestDirectory: Path.Combine(sdkManifestPath, featureBand.ToString(), manifestId)))`
`302`	`306`	`// Filter out directories that don't exist`
`@@ -307,14 +311,15 @@ private string FallbackForMissingManifest(string manifestId)`
`307`	`311`	`.Where(t => t.res.id != null && t.res.manifestDirectory != null)`
`308`	`312`	`.ToList();`
`309`	`313`
`310`		`- if (matchingManifestFatureBandsAndResolvedManifestDirectories.Any())`
	`314`	`+ if (matchingManifestFeatureBandsAndResolvedManifestDirectories.Any())`
`311`	`315`	`{`
`312`		`- return matchingManifestFatureBandsAndResolvedManifestDirectories.OrderByDescending(t => t.featureBand).First().res.manifestDirectory!;`
	`316`	`+ var selectedFeatureBandAndManifestDirectory = matchingManifestFeatureBandsAndResolvedManifestDirectories.OrderByDescending(t => t.featureBand).First();`
	`317`	`+ return (selectedFeatureBandAndManifestDirectory.res.manifestDirectory!, selectedFeatureBandAndManifestDirectory.featureBand.ToString());`
`313`	`318`	`}`
`314`	`319`	`else`
`315`	`320`	`{`
`316`	`321`	`// Manifest does not exist`
`317`		`- return string.Empty;`
	`322`	`+ return (string.Empty, string.Empty);`
`318`	`323`	`}`
`319`	`324`	`}`
`320`	`325`
Original file line number	Diff line number	Diff line change
`@@ -12,12 +12,12 @@ namespace Microsoft.NET.Sdk.WorkloadManifestReader`
`12`	`12`	`{`
`13`	`13`	`public class WorkloadManifestInfo`
`14`	`14`	`{`
`15`		`- public WorkloadManifestInfo(string id, string version, string manifestDirectory)`
	`15`	`+ public WorkloadManifestInfo(string id, string version, string manifestDirectory, string manifestFeatureBand)`
`16`	`16`	`{`
`17`	`17`	`Id = id;`
`18`	`18`	`Version = version;`
`19`	`19`	`ManifestDirectory = manifestDirectory;`
`20`		`- ManifestFeatureBand = Path.GetFileName(Path.GetDirectoryName(manifestDirectory))!;`
	`20`	`+ ManifestFeatureBand = manifestFeatureBand;`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`public string Id { get; }`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ namespace Microsoft.NET.Sdk.WorkloadManifestReader`
`21`	`21`	`/// </remarks>`
`22`	`22`	`public class WorkloadResolver : IWorkloadResolver`
`23`	`23`	`{`
`24`		`- private readonly Dictionary<string, WorkloadManifest> _manifests = new(StringComparer.OrdinalIgnoreCase);`
	`24`	`+ private readonly Dictionary<string, (WorkloadManifest manifest, WorkloadManifestInfo info)> _manifests = new(StringComparer.OrdinalIgnoreCase);`
`25`	`25`	`private readonly Dictionary<WorkloadId, (WorkloadDefinition workload, WorkloadManifest manifest)> _workloads = new();`
`26`	`26`	`private readonly Dictionary<WorkloadPackId, (WorkloadPack pack, WorkloadManifest manifest)> _packs = new();`
`27`	`27`	`private IWorkloadManifestProvider? _manifestProvider;`
`@@ -118,9 +118,10 @@ private void LoadManifestsFromProvider(IWorkloadManifestProvider manifestProvide`
`118`	`118`	`using (Stream? localizationStream = readableManifest.OpenLocalizationStream())`
`119`	`119`	`{`
`120`	`120`	`var manifest = WorkloadManifestReader.ReadWorkloadManifest(readableManifest.ManifestId, manifestStream, localizationStream, readableManifest.ManifestPath);`
`121`		`- if (!_manifests.TryAdd(readableManifest.ManifestId, manifest))`
	`121`	`+ var manifestInfo = new WorkloadManifestInfo(manifest.Id, manifest.Version, readableManifest.ManifestDirectory, readableManifest.ManifestFeatureBand);`
	`122`	`+ if (!_manifests.TryAdd(readableManifest.ManifestId, (manifest, manifestInfo)))`
`122`	`123`	`{`
`123`		`- var existingManifest = _manifests[readableManifest.ManifestId];`
	`124`	`+ var existingManifest = _manifests[readableManifest.ManifestId].manifest;`
`124`	`125`	`throw new WorkloadManifestCompositionException(Strings.DuplicateManifestID, manifestProvider.GetType().FullName, readableManifest.ManifestId, readableManifest.ManifestPath, existingManifest.ManifestPath);`
`125`	`126`	`}`
`126`	`127`	`}`
`@@ -134,14 +135,15 @@ private void ComposeWorkloadManifests()`
`134`	`135`
`135`	`136`	`Dictionary<WorkloadId, (WorkloadRedirect redirect, WorkloadManifest manifest)>? redirects = null;`
`136`	`137`
`137`		`- foreach (var manifest in _manifests.Values)`
	`138`	`+ foreach (var (manifest, info) in _manifests.Values)`
`138`	`139`	`{`
`139`	`140`	`if (manifest.DependsOnManifests != null)`
`140`	`141`	`{`
`141`	`142`	`foreach (var dependency in manifest.DependsOnManifests)`
`142`	`143`	`{`
`143`		`- if (_manifests.TryGetValue(dependency.Key, out var resolvedDependency))`
	`144`	`+ if (_manifests.TryGetValue(dependency.Key, out var t))`
`144`	`145`	`{`
	`146`	`+ var resolvedDependency = t.manifest;`
`145`	`147`	`if (FXVersion.Compare(dependency.Value, resolvedDependency.ParsedVersion) > 0)`
`146`	`148`	`{`
`147`	`149`	`throw new WorkloadManifestCompositionException(Strings.ManifestDependencyVersionTooLow, dependency.Key, resolvedDependency.Version, dependency.Value, manifest.Id, manifest.ManifestPath);`
`@@ -711,11 +713,17 @@ private bool IsWorkloadPlatformCompatible(WorkloadDefinition workload, WorkloadM`
`711`	`713`
`712`	`714`	`private bool IsWorkloadImplicitlyAbstract(WorkloadDefinition workload, WorkloadManifest manifest) => !GetPacksInWorkload(workload, manifest).Any();`
`713`	`715`
`714`		`- public string GetManifestVersion(string manifestId) =>`
`715`		`- (_manifests.TryGetValue(manifestId, out WorkloadManifest? value)? value : null)?.Version`
`716`		`- ?? throw new Exception($"Manifest with id {manifestId} does not exist.");`
	`716`	`+ public string GetManifestVersion(string manifestId)`
	`717`	`+ {`
	`718`	`+ if (_manifests.TryGetValue(manifestId, out var value))`
	`719`	`+ {`
	`720`	`+ return value.manifest.Version;`
	`721`	`+ }`
	`722`	`+ throw new Exception($"Manifest with id {manifestId} does not exist.");`
	`723`	`+ }`
	`724`	`+`
`717`	`725`
`718`		`- public IEnumerable<WorkloadManifestInfo> GetInstalledManifests() => _manifests.Select(m => new WorkloadManifestInfo(m.Value.Id, m.Value.Version, Path.GetDirectoryName(m.Value.ManifestPath)!));`
	`726`	`+ public IEnumerable<WorkloadManifestInfo> GetInstalledManifests() => _manifests.Select(t => t.Value.info);`
`719`	`727`	`}`
`720`	`728`
`721`	`729`	`static class DictionaryExtensions`