[Bootstrapper] Fetch information from dotnet feeds

src/dotnet-bootstrapper/BootstrapperCommandParser.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
@@ -7,6 +7,9 @@
 using System.CommandLine.Invocation;
 using System.CommandLine.Parsing;
 using System.Reflection;
+using Microsoft.DotNet.Tools.Uninstall.Shared.Configs;
+using Microsoft.DotNet.Tools.Bootstrapper.Commands.Search;
+using Microsoft.DotNet.Tools.Bootstrapper.Commands.Install;
 
 namespace Microsoft.DotNet.Tools.Bootstrapper
 {
@@ -15,30 +18,18 @@ internal static class BootstrapperCommandParser
         public static Parser BootstrapParser;
 
         public static RootCommand BootstrapperRootCommand = new RootCommand("dotnet bootstrapper");
-
-        public static readonly Command VersionCommand = new Command("--version");
-
-        private static readonly Lazy<string> _assemblyVersion =
-            new Lazy<string>(() =>
-            {
-                var assembly = Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly();
-                var assemblyVersionAttribute = assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
-                if (assemblyVersionAttribute == null)
-                {
-                    return assembly.GetName().Version.ToString();
-                }
-                else
-                {
-                    return assemblyVersionAttribute.InformationalVersion;
-                }
-            });
+        public static readonly Command HelpCommand = new("--help");
 
         static BootstrapperCommandParser()
         {
-            BootstrapperRootCommand.AddCommand(VersionCommand);
-            VersionCommand.Handler = CommandHandler.Create(() =>
+            BootstrapperRootCommand.AddCommand(CommandLineConfigs.VersionSubcommand);
+            BootstrapperRootCommand.AddCommand(SearchCommandParser.GetCommand());
+            BootstrapperRootCommand.AddCommand(InstallCommandParser.GetCommand());
+            BootstrapperRootCommand.AddCommand(CommandLineConfigs.RemoveCommand);
+            BootstrapperRootCommand.AddCommand(HelpCommand);
+            HelpCommand.Handler = CommandHandler.Create(() =>
             {
-                Console.WriteLine(_assemblyVersion.Value);
+                Console.WriteLine(LocalizableStrings.BootstrapperHelp);
             });
 
             BootstrapParser = new CommandLineBuilder(BootstrapperRootCommand)

src/dotnet-bootstrapper/CommandBase.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine.Parsing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper
+{
+    public abstract class CommandBase
+    {
+        protected ParseResult _parseResult;
+
+        protected CommandBase(ParseResult parseResult)
+        {
+            _parseResult = parseResult;
+        }
+
+        public abstract int Execute();
+    }
+}

src/dotnet-bootstrapper/Commands/Install/InstallCommand.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine.Parsing;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Deployment.DotNet.Releases;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Install;
+
+internal class InstallCommand(
+    ParseResult parseResult) : CommandBase(parseResult)
+{
+    private string _channel = parseResult.ValueForArgument(InstallCommandParser.ChannelArgument);
+
+    public override int Execute()
+    {
+        string path = Environment.CurrentDirectory;
+        ProductCollection productCollection = ProductCollection.GetAsync().Result;
+        Product product = productCollection
+            .FirstOrDefault(p => string.IsNullOrEmpty(_channel) || p.ProductVersion.Equals(_channel, StringComparison.OrdinalIgnoreCase));
+
+        if (product == null)
+        {
+            Console.WriteLine($"No product found for channel: {_channel}");
+            return 1;
+        }
+
+        ProductRelease latestRelease = product.GetReleasesAsync().Result
+            .Where(release => !release.IsPreview)
+            .OrderByDescending(release => release.ReleaseDate)
+            .FirstOrDefault();
+
+        if (latestRelease == null)
+        {
+            Console.WriteLine($"No releases found for product: {product.ProductName}");
+            return 1;
+        }
+
+        Console.WriteLine($"Installing {product.ProductName} {latestRelease.Version}...");
+
+        foreach (ReleaseComponent component in latestRelease.Components)
+        {
+            Console.WriteLine($"Installing {component.Name} {component.DisplayVersion}...");
+
+            ReleaseFile releaseFile = component.Files.FirstOrDefault(file => file.Rid.Equals(Environment.OSVersion.Platform.ToString(), StringComparison.OrdinalIgnoreCase));
+
+            releaseFile.DownloadAsync(Path.Combine(path, ".net", component.Name)).Wait();
+
+            Console.WriteLine($"Downloaded {component.Name} {component.DisplayVersion} to {Path.Combine(path, component.Name)}");
+        }
+
+        return 0;
+    }
+}

src/dotnet-bootstrapper/Commands/Install/InstallCommandParser.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.CommandLine.Parsing;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Install;
+
+internal class InstallCommandParser
+{
+    internal static Argument<string> ChannelArgument = new Argument<string>(
+        name: "channel",
+        description: "The channel to install sdks for. If not specified, It will take the latest.")
+    {
+        Arity = ArgumentArity.ZeroOrOne
+    };
+
+    private static readonly Command Command = ConstructCommand();
+
+    public static Command GetCommand() => Command;
+
+    private static Command ConstructCommand()
+    {
+        Command command = new("install", "Install SDKs available for installation.");
+        command.AddArgument(ChannelArgument);
+        command.Handler = CommandHandler.Create((ParseResult parseResult) =>
+        {
+            return new InstallCommand(parseResult).Execute();
+        });
+        return command;
+    }
+}

src/dotnet-bootstrapper/Commands/Search/SearchCommand.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine.Parsing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Deployment.DotNet.Releases;
+using Spectre.Console;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Search;
+
+internal class SearchCommand(
+    ParseResult parseResult) : CommandBase(parseResult)
+{
+    private string _channel = parseResult.ValueForArgument(SearchCommandParser.ChannelArgument);
+    private bool _allowPreviews = parseResult.ValueForOption(SearchCommandParser.AllowPreviews);
+    public override int Execute()
+    {
+        List<Product> productCollection = [.. ProductCollection.GetAsync().Result];
+        productCollection = [.. 
+            productCollection.Where(product => !product.IsOutOfSupport() && (product.SupportPhase != SupportPhase.Preview || _allowPreviews))];
+
+        if (!string.IsNullOrEmpty(_channel))
+        {
+            productCollection = [.. productCollection.Where(product => product.ProductVersion.Equals(_channel, StringComparison.OrdinalIgnoreCase))];
+        }
+
+        foreach (Product product in productCollection)
+        {
+            string productHeader = $"{product.ProductName} {product.ProductVersion}";
+            Console.WriteLine(productHeader);
+
+            Table productMetadataTable = new Table()
+                .AddColumn("Version")
+                .AddColumn("Release Date")
+                .AddColumn("SDK")
+                .AddColumn("Runtime")
+                .AddColumn("ASP.NET Runtime")
+                .AddColumn("Windows Desktop Runtime");
+
+            List<ProductRelease> releases = product.GetReleasesAsync().Result.ToList()
+                .Where(relase => !relase.IsPreview || _allowPreviews).ToList();
+
+            foreach (ProductRelease release in releases)
+            {
+                productMetadataTable.AddRow(
+                    release.Version.ToString(), 
+                    release.ReleaseDate.ToString("yyyy-MM-dd"), 
+                    release.Sdks.FirstOrDefault()?.DisplayVersion ?? "N/A",
+                    release.Runtime?.DisplayVersion ?? "N/A", 
+                    release.AspNetCoreRuntime?.DisplayVersion ?? "N/A", 
+                    release.WindowsDesktopRuntime?.DisplayVersion ?? "N/A");
+            }
+            AnsiConsole.Write(productMetadataTable);
+            Console.WriteLine();
+        }
+
+        return 0;
+    }
+}

src/dotnet-bootstrapper/Commands/Search/SearchCommandParser.cs

@@ -0,0 +1,35 @@
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.CommandLine.Parsing;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Search;
+
+internal class SearchCommandParser
+{
+    internal static Argument<string> ChannelArgument = new Argument<string>(
+        name: "channel",
+        description: "The channel to list sdks for. If not specified, all sdks will be listed.")
+    {
+        Arity = ArgumentArity.ZeroOrOne
+    };
+
+    internal static Option<bool> AllowPreviews = new Option<bool>(
+        "--allow-previews",
+        description: "Allow preview releases to be listed.");
+
+    private static readonly Command Command = ConstructCommand();
+    public static Command GetCommand() => Command;
+    private static Command ConstructCommand()
+    {
+        Command command = new("search", "Search for SDKs available for installation.");
+        command.AddArgument(ChannelArgument);
+        command.AddOption(AllowPreviews);
+
+        command.Handler = CommandHandler.Create((ParseResult parseResult) =>
+        {
+            return new SearchCommand(parseResult).Execute();
+        });
+
+        return command;
+    }
+}

src/dotnet-bootstrapper/LocalizableStrings.resx

@@ -117,4 +117,7 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="BootstrapperHelp" xml:space="preserve">
+    <value>Bootstrapper help text</value>
+  </data>
 </root>

src/dotnet-bootstrapper/dotnet-bootstrapper.csproj

@@ -22,9 +22,12 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.VisualStudio.Setup.Configuration.Interop" Version="$(MicrosoftVisualStudioSetupConfigurationPackageVersion)" />
     <PackageReference Include="NuGet.Versioning" Version="6.9.1" />
+    <PackageReference Include="Spectre.Console" Version="0.49.1" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
     <PackageReference Include="System.CommandLine.Rendering" Version="0.3.0-alpha.20574.7" />
     <PackageReference Include="System.Resources.Extensions" Version="8.0.0" />
+    <ProjectReference Include="..\dotnet-core-uninstall\dotnet-core-uninstall.csproj" />
+    <PackageReference Include="Microsoft.Deployment.DotNet.Releases" Version="1.0.1" />
   </ItemGroup>
 
   <ItemGroup>
@@ -39,6 +42,7 @@
     <EmbeddedResource Update="LocalizableStrings.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>LocalizableStrings.Designer.cs</LastGenOutput>
+      <CustomToolNamespace>Microsoft.DotNet.Tools.Bootstrapper</CustomToolNamespace>
     </EmbeddedResource>
   </ItemGroup>