[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,19 @@ 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(SearchCommandParser.GetCommand());
+            BootstrapperRootCommand.AddCommand(InstallCommandParser.GetCommand());
+            BootstrapperRootCommand.AddCommand(CommandLineConfigs.RemoveCommand);
+            BootstrapperRootCommand.AddCommand(CommandLineConfigs.VersionSubcommand);
+            BootstrapperRootCommand.AddCommand(HelpCommand);
+
+            HelpCommand.Handler = CommandHandler.Create(() =>
             {
-                Console.WriteLine(_assemblyVersion.Value);
+                Console.WriteLine(LocalizableStrings.BootstrapperHelp);
             });
 
             BootstrapParser = new CommandLineBuilder(BootstrapperRootCommand)

src/dotnet-bootstrapper/BootstrapperUtilities.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using System.Text.Json;
+using Microsoft.Deployment.DotNet.Releases;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper
+{
+    internal static class BootstrapperUtilities
+    {
+        public static string GetRID()
+        {
+            string operatingSystem = RuntimeInformation.OSDescription switch
+            {
+                string os when os.Contains("Windows") => "win",
+                string os when os.Contains("Linux") => "linux",
+                string os when os.Contains("Darwin") => "osx",
+                _ => null
+            };
+            string architecture = RuntimeInformation.OSArchitecture switch
+            {
+                Architecture.X64 => "x64",
+                Architecture.X86 => "x86",
+                Architecture.Arm => "arm",
+                Architecture.Arm64 => "arm64",
+                _ => null
+            };
+
+            if (operatingSystem == null || architecture == null)
+            {
+                throw new PlatformNotSupportedException("Unsupported OS or architecture.");
+            }
+
+            return $"{operatingSystem}-{architecture}";
+        }
+
+        public static string GetMajorVersionToInstallInDirectory(string basePath)
+        {
+            // Get the nearest global.json file.
+            JsonElement globalJson = GlobalJsonUtilities.GetNearestGlobalJson(basePath);
+            string sdkVersion = globalJson
+                .GetProperty("tools")
+                .GetProperty("dotnet")
+                .ToString();
+
+            ReleaseVersion version = ReleaseVersion.Parse(sdkVersion);
+            Console.WriteLine($"Found version {version.Major}.0 in global.json");
+            return $"{version.Major}.0";
+        }
+
+        public static string GetInstallationDirectoryPath()
+        {
+            string globalJsonPath = GlobalJsonUtilities.GetNearestGlobalJsonPath(Environment.CurrentDirectory);
+            if (globalJsonPath == null)
+            {
+                throw new FileNotFoundException("No global.json file found in the directory tree.");
+            }
+            string directoryPath = Path.GetDirectoryName(globalJsonPath);
+            if (directoryPath == null)
+            {
+                throw new DirectoryNotFoundException("Directory path is null.");
+            }
+
+            // TODO: Replace with the actual installation directory.
+            return Path.Combine(directoryPath, ".dotnet.local");
+        }
+    }
+}

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/Common.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands
+{
+    internal static class Common
+    {
+        internal static Option<bool> AllowPreviewsOptions = new Option<bool>(
+            "--allow-previews",
+            description: "Include pre-release sdk versions");
+    }
+}

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

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine.Parsing;
+using System.IO;
+using System.IO.Compression;
+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 _version = parseResult.ValueForArgument(InstallCommandParser.VersionArgument);
+    private string _rid = BootstrapperUtilities.GetRID();
+    private bool _allowPreviews = parseResult.ValueForOption(InstallCommandParser.AllowPreviewsOption);
+
+
+    public override int Execute()
+    {
+        // If no channel is specified, use the default channel.
+        if (string.IsNullOrEmpty(_version))
+        {
+            _version = BootstrapperUtilities.GetMajorVersionToInstallInDirectory(
+                Environment.CurrentDirectory);
+        }
+
+        ProductCollection productCollection = ProductCollection.GetAsync().Result;
+        Product product = productCollection
+            .FirstOrDefault(p => string.IsNullOrEmpty(_version) || p.ProductVersion.Equals(_version, StringComparison.OrdinalIgnoreCase));
+
+        if (product == null)
+        {
+            Console.WriteLine($"No product found for channel: {_version}");
+            return 1;
+        }
+
+        ProductRelease latestRelease = product.GetReleasesAsync().Result
+            .Where(release => !release.IsPreview || _allowPreviews)
+            .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}...");
+
+        string installationDirectoryPath = BootstrapperUtilities.GetInstallationDirectoryPath();
+
+        foreach (ReleaseComponent component in latestRelease.Components)
+        {
+            Console.WriteLine($"Installing {component.Name}...");
+            DownloadAndExtractReleaseComponentFiles(component, installationDirectoryPath);
+        }
+
+        return 0;
+    }
+
+    private static void DownloadAndExtractReleaseComponentFiles(ReleaseComponent component, string basePath)
+    {
+        if (component is WindowsDesktopReleaseComponent && !OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
+        ReleaseFile releaseFile = component.Files.FirstOrDefault(file =>
+            file.Rid.Equals(BootstrapperUtilities.GetRID(), StringComparison.OrdinalIgnoreCase) && (file.Name.EndsWith(".zip") || file.Name.EndsWith(".tar.gz")));
+
+        if (string.IsNullOrEmpty(releaseFile?.FileName))
+        {
+            Console.WriteLine($"\tNo suitable file found for {component.Name}");
+            return;
+        }
+
+        string zipPath = Path.Combine(basePath, releaseFile.FileName);
+
+        if (File.Exists(zipPath))
+        {
+            Console.WriteLine($"\t{component.Name} already exists at {zipPath}");
+            return;
+        }
+
+        try
+        {
+            releaseFile.DownloadAsync(zipPath)?.Wait();
+
+            // Extract the downloaded file
+            ZipFile.ExtractToDirectory(zipPath, Path.ChangeExtension(zipPath, ""));
+
+            Console.WriteLine($"\tExtracted {component.Name} to {Path.ChangeExtension(zipPath, "")}");
+
+            // Delete the downloaded file
+            File.Delete(zipPath);
+        }
+        catch (IOException)
+        {
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+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> VersionArgument = new Argument<string>(
+        name: "version",
+        description: "SDK version to install. If not specified, It will take the latest.")
+    {
+        Arity = ArgumentArity.ZeroOrOne,
+    };
+
+    internal static Option<bool> AllowPreviewsOption = Common.AllowPreviewsOptions;
+
+    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(VersionArgument);
+
+        command.AddOption(AllowPreviewsOption);
+
+        command.Handler = CommandHandler.Create((ParseResult parseResult) =>
+        {
+            return new InstallCommand(parseResult).Execute();
+        });
+        return command;
+    }
+}

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

@@ -0,0 +1,65 @@
+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.AllowPreviewsOption);
+    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("Latest 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)
+            {
+                // Get release.Sdks latest version
+                var latestSdk = release.Sdks
+                    .OrderByDescending(sdk => sdk.Version)
+                    .FirstOrDefault();
+
+                productMetadataTable.AddRow(
+                    release.Version.ToString(), 
+                    release.ReleaseDate.ToString("yyyy-MM-dd"), 
+                    latestSdk?.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;
+    }
+}