Add SDK version suggestion list

Author: jjonescz

src/App/Lab/Settings.razor

@@ -81,11 +81,23 @@ OnLoaded="(e) => SetLuminanceAsync(e.IsDark)" OnLuminanceChanged="(e) => SetLumi
             <h5 style="margin: 0.75rem 0 0 0">Compilers</h5>
 
             @* SDK version select *@
-            <FluentTextField @bind-Value="sdkVersion" @bind-Value:after="() => LoadSdkInfoAsync()"
-            Placeholder="version" Style="width: 100%">
+            <FluentComboboxEx @bind-Value="sdkVersion" @bind-Value:after="() => LoadSdkInfoAsync()"
+            Autocomplete="ComboboxAutocomplete.Both" Placeholder="version" Style="width: 100%">
                 <FluentLabel slot="start">SDK</FluentLabel>
+                @foreach (var info in sdkVersions ?? [])
+                {
+                    <FluentOption TOption="string" Value="@info.Version">
+                        @info.Version
+                        @*
+                            For some reason, we cannot customize the text displayed in the closed combo box after selection
+                            and we don't want it to contain the additional info, so we use this as a workaround.
+                            `option-badge` is a CSS class which puts the `data-text` into `content` of `::after` pseudo-element.
+                        *@
+                        <span class="option-badge" data-text="@info.ReleaseDate"></span>
+                    </FluentOption>
+                }
                 <FluentProgressRing slot="end" title="Loading info..." Visible="loadingSdkInfo" Width="1em" />
-            </FluentTextField>
+            </FluentComboboxEx>
             <FluentLabel Style="opacity: 80%">
                 Enter a .NET SDK version above to automatically get
                 the corresponding Roslyn and Razor version numbers below.
@@ -283,6 +295,7 @@ OnLoaded="(e) => SetLuminanceAsync(e.IsDark)" OnLuminanceChanged="(e) => SetLumi
     private string? sdkVersion, roslynVersion, razorVersion;
     private BuildConfiguration roslynConfiguration, razorConfiguration;
     private bool loadingSdkInfo, loadingRoslynInfo, loadingRazorInfo;
+    private List<SdkVersionInfo>? sdkVersions;
     private SdkInfo? sdkInfo;
     private CompilerDependencyInfo? roslynInfo, razorInfo;
     private string? sdkError, roslynError, razorError;
@@ -441,10 +454,16 @@ OnLoaded="(e) => SetLuminanceAsync(e.IsDark)" OnLuminanceChanged="(e) => SetLumi
         modalHidden = false;
         StateHasChanged();
 
+        Task sdkVersionsTask = Task.CompletedTask;
         Task sdkTask = Task.CompletedTask;
         Task roslynTask = Task.CompletedTask;
         Task razorTask = Task.CompletedTask;
 
+        if (sdkVersions is null)
+        {
+            sdkVersionsTask = LoadSdkVersionsAsync();
+        }
+
         if (sdkInfo is null)
         {
             sdkTask = LoadSdkInfoAsync(saveState: false);
@@ -460,7 +479,7 @@ OnLoaded="(e) => SetLuminanceAsync(e.IsDark)" OnLuminanceChanged="(e) => SetLumi
             razorTask = LoadRazorInfoAsync(saveState: false);
         }
 
-        return Task.WhenAll(sdkTask, roslynTask, razorTask);
+        return Task.WhenAll(sdkVersionsTask, sdkTask, roslynTask, razorTask);
     }
 
     public void CloseModal()
@@ -503,6 +522,12 @@ OnLoaded="(e) => SetLuminanceAsync(e.IsDark)" OnLuminanceChanged="(e) => SetLumi
         return Task.WhenAll(sdkTask, roslynTask, razorTask);
     }
 
+    private async Task LoadSdkVersionsAsync()
+    {
+        sdkVersions = await Worker.GetSdkVersionsAsync();
+        await RefreshAsync();
+    }
+
     private async Task LoadSdkInfoAsync(bool saveState = true)
     {
         var versionToLoad = sdkVersion;
@@ -540,7 +565,7 @@ OnLoaded="(e) => SetLuminanceAsync(e.IsDark)" OnLuminanceChanged="(e) => SetLumi
         catch (Exception ex)
         {
             Logger.LogError(ex, "Failed to load SDK info.");
-            error = ex.Message;
+            error = ex is WorkerException w ? w.Failure.Message : ex.Message;
             info = null;
         }
 

src/App/Lab/WorkerController.cs

@@ -430,6 +430,13 @@ public Task<CompilerDependencyInfo> GetCompilerDependencyInfoAsync(CompilerKind
             deserializeAs: default(CompilerDependencyInfo));
     }
 
+    public Task<List<SdkVersionInfo>> GetSdkVersionsAsync()
+    {
+        return PostAndReceiveMessageAsync(
+            new WorkerInputMessage.GetSdkVersions() { Id = messageId++ },
+            deserializeAs: default(List<SdkVersionInfo>));
+    }
+
     public Task<SdkInfo> GetSdkInfoAsync(string versionToLoad)
     {
         return PostAndReceiveMessageAsync(

src/App/Utils/FluentUI/FluentComboboxEx.cs

@@ -0,0 +1,15 @@
+using Microsoft.FluentUI.AspNetCore.Components;
+
+namespace DotNetLab;
+
+public sealed class FluentComboboxEx : FluentCombobox<string>
+{
+    protected override Task ChangeHandlerAsync(ChangeEventArgs e)
+    {
+        // Ensures that when user writes a custom text into the combobox, it propagates to the bound Value.
+        // For some reason that doesn't work automatically when using FluentOptions as ChildContent ourselves.
+        string? value = e.Value?.ToString();
+        Value = value;
+        return ValueChanged.InvokeAsync(value);
+    }
+}

src/App/wwwroot/css/app.css

@@ -101,6 +101,13 @@ code {
     color: #c02d76;
 }
 
+.option-badge::after {
+    content: attr(data-text);
+    font-size: small;
+    color: var(--input-placeholder-rest);
+    margin-left: 0.5em;
+}
+
 /*
     Causes Monaco Editor to resize properly.
     See https://github.com/microsoft/monaco-editor/issues/3512.

src/Worker/Executor.cs

@@ -87,28 +87,34 @@ public async Task<string> HandleAsync(WorkerInputMessage.GetOutput message)
         }
     }
 
-    public async Task<bool> HandleAsync(WorkerInputMessage.UseCompilerVersion message)
+    public Task<bool> HandleAsync(WorkerInputMessage.UseCompilerVersion message)
     {
         var compilerDependencyProvider = services.GetRequiredService<CompilerDependencyProvider>();
-        return await compilerDependencyProvider.UseAsync(message.CompilerKind, message.Version, message.Configuration);
+        return compilerDependencyProvider.UseAsync(message.CompilerKind, message.Version, message.Configuration);
     }
 
-    public async Task<CompilerDependencyInfo> HandleAsync(WorkerInputMessage.GetCompilerDependencyInfo message)
+    public Task<CompilerDependencyInfo> HandleAsync(WorkerInputMessage.GetCompilerDependencyInfo message)
     {
         var compilerDependencyProvider = services.GetRequiredService<CompilerDependencyProvider>();
-        return await compilerDependencyProvider.GetLoadedInfoAsync(message.CompilerKind);
+        return compilerDependencyProvider.GetLoadedInfoAsync(message.CompilerKind);
     }
 
-    public async Task<SdkInfo> HandleAsync(WorkerInputMessage.GetSdkInfo message)
+    public Task<List<SdkVersionInfo>> HandleAsync(WorkerInputMessage.GetSdkVersions message)
     {
         var sdkDownloader = services.GetRequiredService<SdkDownloader>();
-        return await sdkDownloader.GetInfoAsync(message.VersionToLoad);
+        return sdkDownloader.GetListAsync();
     }
 
-    public async Task<string?> HandleAsync(WorkerInputMessage.TryGetSubRepoCommitHash message)
+    public Task<SdkInfo> HandleAsync(WorkerInputMessage.GetSdkInfo message)
     {
         var sdkDownloader = services.GetRequiredService<SdkDownloader>();
-        return await sdkDownloader.TryGetSubRepoCommitHashAsync(message.MonoRepoCommitHash, message.SubRepoUrl);
+        return sdkDownloader.GetInfoAsync(message.VersionToLoad);
+    }
+
+    public Task<string?> HandleAsync(WorkerInputMessage.TryGetSubRepoCommitHash message)
+    {
+        var sdkDownloader = services.GetRequiredService<SdkDownloader>();
+        return sdkDownloader.TryGetSubRepoCommitHashAsync(message.MonoRepoCommitHash, message.SubRepoUrl);
     }
 
     public async Task<string> HandleAsync(WorkerInputMessage.ProvideCompletionItems message)

src/Worker/Lab/LabWorkerJsonContext.cs

@@ -9,3 +9,8 @@ namespace DotNetLab.Lab;
 [JsonSerializable(typeof(SourceManifest))]
 [JsonSerializable(typeof(Dictionary<string, string>))]
 internal sealed partial class LabWorkerJsonContext : JsonSerializerContext;
+
+[JsonSourceGenerationOptions(JsonSerializerDefaults.Web, PropertyNamingPolicy = JsonKnownNamingPolicy.KebabCaseLower)]
+[JsonSerializable(typeof(DotNetReleaseIndex))]
+[JsonSerializable(typeof(DotNetReleaseIndex.ReleaseList))]
+internal sealed partial class LabWorkerKebabCaseJsonContext : JsonSerializerContext;

src/Worker/Lab/SdkDownloader.cs

@@ -1,3 +1,6 @@
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Xml.Serialization;
 
 namespace DotNetLab.Lab;
@@ -16,9 +19,22 @@ internal sealed class SdkDownloader(
     private const string razorRepoUrl = "https://github.com/dotnet/razor";
     private const string versionDetailsRelativePath = "eng/Version.Details.xml";
     private const string sourceManifestRelativePath = "src/source-manifest.json";
+    private const string releasesIndexUrl = "https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json";
 
     private static readonly XmlSerializer versionDetailsSerializer = new(typeof(Dependencies));
 
+    public async Task<List<SdkVersionInfo>> GetListAsync()
+    {
+        try
+        {
+            var index = await client.GetFromJsonAsync(releasesIndexUrl.WithCorsProxy(), LabWorkerKebabCaseJsonContext.Default.DotNetReleaseIndex);
+            var lists = await Task.WhenAll(index.ReleasesIndex.Select(entry => client.GetFromJsonAsync(entry.ReleasesJson.WithCorsProxy(), LabWorkerKebabCaseJsonContext.Default.ReleaseList)));
+            return lists.SelectMany(static list => list.Releases.Select(static release => release.ToVersionInfo())).ToList();
+        }
+        catch (HttpRequestException) { return []; }
+        catch (JsonException) { return []; }
+    }
+
     public async Task<SdkInfo> GetInfoAsync(string version)
     {
         CommitLink commit = await getCommitAsync(version);
@@ -91,12 +107,11 @@ async Task<SdkInfo> getInfoAsync(string version, CommitLink commit)
     {
         using var response = await SendGitHubRequestAsync($"https://api.github.com/repos/{monoRepoOwner}/{monoRepoName}/contents/{sourceManifestRelativePath}?ref={monoRepoCommitHash}");
 
-        if (response.StatusCode == HttpStatusCode.NotFound)
+        if (!response.IsSuccessStatusCode)
         {
             return null;
         }
 
-        response.EnsureSuccessStatusCode();
         using var stream = await response.Content.ReadAsStreamAsync();
         return await response.Content.TryReadFromJsonAsync(LabWorkerJsonContext.Default.SourceManifest);
     }
@@ -165,3 +180,45 @@ public CommitLink GetCommitLink()
         }
     }
 }
+
+/// <summary>
+/// For JSON from <see cref="SdkDownloader.releasesIndexUrl"/>.
+/// </summary>
+internal readonly struct DotNetReleaseIndex
+{
+    public required ImmutableArray<ChannelInfo> ReleasesIndex { get; init; }
+
+    public readonly struct ChannelInfo
+    {
+        [JsonPropertyName("releases.json")]
+        public required string ReleasesJson { get; init; }
+    }
+
+    /// <summary>
+    /// For JSON from <see cref="ChannelInfo.ReleasesJson"/>.
+    /// </summary>
+    public readonly struct ReleaseList
+    {
+        public required ImmutableArray<Release> Releases { get; init; }
+    }
+
+    public readonly struct Release
+    {
+        public required string ReleaseDate { get; init; }
+        public required SdkInfo Sdk { get; init; }
+
+        public SdkVersionInfo ToVersionInfo()
+        {
+            return new SdkVersionInfo
+            {
+                Version = Sdk.Version,
+                ReleaseDate = ReleaseDate,
+            };
+        }
+    }
+
+    public readonly struct SdkInfo
+    {
+        public required string Version { get; init; }
+    }
+}

src/WorkerApi/InputMessage.cs

@@ -12,6 +12,7 @@ namespace DotNetLab;
 [JsonDerivedType(typeof(GetOutput), nameof(GetOutput))]
 [JsonDerivedType(typeof(UseCompilerVersion), nameof(UseCompilerVersion))]
 [JsonDerivedType(typeof(GetCompilerDependencyInfo), nameof(GetCompilerDependencyInfo))]
+[JsonDerivedType(typeof(GetSdkVersions), nameof(GetSdkVersions))]
 [JsonDerivedType(typeof(GetSdkInfo), nameof(GetSdkInfo))]
 [JsonDerivedType(typeof(TryGetSubRepoCommitHash), nameof(TryGetSubRepoCommitHash))]
 [JsonDerivedType(typeof(ProvideCompletionItems), nameof(ProvideCompletionItems))]
@@ -97,6 +98,14 @@ public override Task<CompilerDependencyInfo> HandleAsync(IExecutor executor)
         }
     }
 
+    public sealed record GetSdkVersions : WorkerInputMessage<List<SdkVersionInfo>>
+    {
+        public override Task<List<SdkVersionInfo>> HandleAsync(IExecutor executor)
+        {
+            return executor.HandleAsync(this);
+        }
+    }
+
     public sealed record GetSdkInfo(string VersionToLoad) : WorkerInputMessage<SdkInfo>
     {
         public override Task<SdkInfo> HandleAsync(IExecutor executor)
@@ -193,6 +202,7 @@ public interface IExecutor
         Task<string> HandleAsync(GetOutput message);
         Task<bool> HandleAsync(UseCompilerVersion message);
         Task<CompilerDependencyInfo> HandleAsync(GetCompilerDependencyInfo message);
+        Task<List<SdkVersionInfo>> HandleAsync(GetSdkVersions message);
         Task<SdkInfo> HandleAsync(GetSdkInfo message);
         Task<string?> HandleAsync(TryGetSubRepoCommitHash message);
         Task<string> HandleAsync(ProvideCompletionItems message);

src/WorkerApi/Lab/CompilerDependency.cs

@@ -219,6 +219,12 @@ public override void Write(Utf8JsonWriter writer, NuGetVersion value, JsonSerial
     }
 }
 
+public readonly struct SdkVersionInfo
+{
+    public required string Version { get; init; }
+    public required string ReleaseDate { get; init; }
+}
+
 public sealed record SdkInfo
 {
     public required string SdkVersion { get; init; }

src/WorkerApi/WorkerJsonContext.cs

@@ -8,6 +8,7 @@ namespace DotNetLab;
 [JsonSerializable(typeof(WorkerOutputMessage))]
 [JsonSerializable(typeof(CompiledAssembly))]
 [JsonSerializable(typeof(CompilerDependencyInfo))]
+[JsonSerializable(typeof(List<SdkVersionInfo>))]
 [JsonSerializable(typeof(SdkInfo))]
 [JsonSerializable(typeof(ImmutableArray<MarkerData>))]
 public sealed partial class WorkerJsonContext : JsonSerializerContext;