Add interfaces for installation library

dnup.slnf

@@ -3,6 +3,7 @@
     "path": "sdk.slnx",
     "projects": [
       "src\\Installer\\dnup\\dnup.csproj",
+      "src\\Installer\\Microsoft.Dotnet.Installation\\Microsoft.Dotnet.Installation.csproj",
       "test\\dnup.Tests\\dnup.Tests.csproj",
     ]
   }

sdk.slnx

@@ -87,6 +87,7 @@
   </Folder>
   <Folder Name="/src/Installer/">
     <Project Path="src/Installer/dnup/dnup.csproj" />
+    <Project Path="src/Installer/Microsoft.Dotnet.Installation/Microsoft.Dotnet.Installation.csproj" />
   </Folder>
   <Folder Name="/src/Layout/">
     <Project Path="src/Layout/finalizer/finalizer.csproj" />
@@ -289,12 +290,12 @@
     <Project Path="test/ArgumentForwarding.Tests/ArgumentForwarding.Tests.csproj" />
     <Project Path="test/ArgumentsReflector/ArgumentsReflector.csproj" />
     <Project Path="test/containerize.UnitTests/containerize.UnitTests.csproj" />
+    <Project Path="test/dnup.Tests/dnup.Tests.csproj" />
     <Project Path="test/dotnet-format.UnitTests/dotnet-format.UnitTests.csproj" />
     <Project Path="test/dotnet-MsiInstallation.Tests/dotnet-MsiInstallation.Tests.csproj" />
     <Project Path="test/dotnet-new.IntegrationTests/dotnet-new.IntegrationTests.csproj" />
     <Project Path="test/dotnet-watch.Tests/dotnet-watch.Tests.csproj" />
     <Project Path="test/dotnet.Tests/dotnet.Tests.csproj" />
-    <Project Path="test/dnup.Tests/dnup.Tests.csproj" />
     <Project Path="test/EndToEnd.Tests/EndToEnd.Tests.csproj" />
     <Project Path="test/HelixTasks/HelixTasks.csproj" />
     <Project Path="test/Microsoft.AspNetCore.Watch.BrowserRefresh.Tests/Microsoft.AspNetCore.Watch.BrowserRefresh.Tests.csproj" />

src/Installer/Microsoft.Dotnet.Installation/DotnetInstallRoot.cs

@@ -0,0 +1,11 @@
+// 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.Text;
+
+namespace Microsoft.Dotnet.Installation;
+public record DotnetInstallRoot(
+    string Path,
+    InstallArchitecture Architecture);

src/Installer/Microsoft.Dotnet.Installation/IDotnetInstallDiscoverer.cs

@@ -0,0 +1,16 @@
+// 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.Text;
+using Microsoft.Deployment.DotNet.Releases;
+
+namespace Microsoft.Dotnet.Installation;
+
+public interface IDotnetInstallDiscoverer
+{
+    DotnetInstallRoot GetDotnetInstallRootFromPath();
+
+    IEnumerable<ReleaseVersion> GetInstalledVersions(DotnetInstallRoot dotnetRoot, InstallComponent component);
+}

src/Installer/Microsoft.Dotnet.Installation/IDotnetInstaller.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.Deployment.DotNet.Releases;
+
+namespace Microsoft.Dotnet.Installation;
+
+public interface IDotnetInstaller
+{
+    void Install(DotnetInstallRoot dotnetRoot, InstallComponent component, ReleaseVersion version);
+    void Uninstall(DotnetInstallRoot dotnetRoot, InstallComponent component, ReleaseVersion version);
+}

src/Installer/Microsoft.Dotnet.Installation/IDotnetReleaseInfoProvider.cs

@@ -0,0 +1,28 @@
+// 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.Text;
+using Microsoft.Deployment.DotNet.Releases;
+
+namespace Microsoft.Dotnet.Installation;
+
+public interface IDotnetReleaseInfoProvider
+{
+    IEnumerable<string> GetAvailableChannels();
+
+    ReleaseVersion GetLatestVersion(InstallComponent component, string channel);
+
+    // Get all versions in a channel - do we have a scenario for this?
+    //IEnumerable<ReleaseVersion> GetAllVersions(InstallComponent component, string channel);
+
+    SupportType GetSupportType(InstallComponent component, ReleaseVersion version);
+}
+
+public enum SupportType
+{
+    OutOfSupport,
+    LongTermSupport,
+    StandardTermSupport
+}

src/Installer/dnup/InstallArchitecture.cs → src/Installer/Microsoft.Dotnet.Installation/InstallArchitecture.cs

@@ -5,12 +5,11 @@
 using System.Collections.Generic;
 using System.Text;
 
-namespace Microsoft.DotNet.Tools.Bootstrapper
+namespace Microsoft.Dotnet.Installation;
+
+public enum InstallArchitecture
 {
-    public enum InstallArchitecture
-    {
-        x86,
-        x64,
-        arm64
-    }
+    x86,
+    x64,
+    arm64
 }

src/Installer/Microsoft.Dotnet.Installation/InstallComponent.cs

@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Dotnet.Installation;
+
+public enum InstallComponent
+{
+    SDK,
+    Runtime,
+    ASPNETCore,
+    WindowsDesktop
+}

src/Installer/Microsoft.Dotnet.Installation/Microsoft.Dotnet.Installation.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsAotCompatible>true</IsAotCompatible>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Deployment.DotNet.Releases" />
+  </ItemGroup>
+
+</Project>

src/Installer/dnup/BootstrapperController.cs

@@ -19,13 +19,13 @@ public BootstrapperController(IEnvironmentProvider? environmentProvider = null)
         _environmentProvider = environmentProvider ?? new EnvironmentProvider();
     }
 
-    public DotnetInstallRoot GetConfiguredInstallType()
+    public DotnetInstallRootConfiguration? GetConfiguredInstallType()
     {
 
         string? foundDotnet = _environmentProvider.GetCommandPath("dotnet");
         if (string.IsNullOrEmpty(foundDotnet))
         {
-            return new(null, InstallType.None, DnupUtilities.GetDefaultInstallArchitecture());
+            return null;
         }
 
         string installDir = Path.GetDirectoryName(foundDotnet)!;
@@ -36,27 +36,12 @@ public DotnetInstallRoot GetConfiguredInstallType()
         string programFilesX86 = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);
         bool isAdminInstall = installDir.StartsWith(Path.Combine(programFiles, "dotnet"), StringComparison.OrdinalIgnoreCase) ||
                               installDir.StartsWith(Path.Combine(programFilesX86, "dotnet"), StringComparison.OrdinalIgnoreCase);
-
-        if (isAdminInstall)
-        {
-            // Admin install: DOTNET_ROOT should not be set, or if set, should match installDir
-            if (!string.IsNullOrEmpty(dotnetRoot) && !DnupUtilities.PathsEqual(dotnetRoot, installDir) &&
-                !dotnetRoot.StartsWith(Path.Combine(programFiles, "dotnet"), StringComparison.OrdinalIgnoreCase) &&
-                !dotnetRoot.StartsWith(Path.Combine(programFilesX86, "dotnet"), StringComparison.OrdinalIgnoreCase))
-            {
-                return new(installDir, InstallType.Inconsistent, DnupUtilities.GetDefaultInstallArchitecture());
-            }
-            return new(installDir, InstallType.Admin, DnupUtilities.GetDefaultInstallArchitecture());
-        }
-        else
-        {
-            // User install: DOTNET_ROOT must be set and match installDir
-            if (string.IsNullOrEmpty(dotnetRoot) || !DnupUtilities.PathsEqual(dotnetRoot, installDir))
-            {
-                return new(installDir, InstallType.Inconsistent, DnupUtilities.GetDefaultInstallArchitecture());
-            }
-            return new(installDir, InstallType.User, DnupUtilities.GetDefaultInstallArchitecture());
-        }
+
+        var installRoot = new DotnetInstallRoot(installDir, DnupUtilities.GetDefaultInstallArchitecture());
+
+        bool isSetAsDotnetRoot = DnupUtilities.PathsEqual(dotnetRoot, installDir);
+
+        return new(installRoot, isAdminInstall ? InstallType.Admin : InstallType.User, IsOnPath: true, isSetAsDotnetRoot);
     }
 
     public string GetDefaultDotnetInstallPath()
@@ -153,10 +138,6 @@ public void ConfigureInstallType(InstallType installType, string? dotnetRoot = n
                 // Unset DOTNET_ROOT
                 Environment.SetEnvironmentVariable("DOTNET_ROOT", null, EnvironmentVariableTarget.User);
                 break;
-            case InstallType.None:
-                // Unset DOTNET_ROOT
-                Environment.SetEnvironmentVariable("DOTNET_ROOT", null, EnvironmentVariableTarget.User);
-                break;
             default:
                 throw new ArgumentException($"Unknown install type: {installType}", nameof(installType));
         }

src/Installer/dnup/Commands/Sdk/Install/EnvironmentVariableMockDotnetInstaller.cs

@@ -27,16 +27,16 @@ public string GetDefaultDotnetInstallPath()
             return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "dotnet");
         }
 
-        public DotnetInstallRoot GetConfiguredInstallType()
+        public DotnetInstallRootConfiguration? GetConfiguredInstallType()
         {
             var testHookDefaultInstall = Environment.GetEnvironmentVariable("DOTNET_TESTHOOK_DEFAULT_INSTALL");
-            InstallType installtype = InstallType.None;
+            InstallType installtype;
             if (!Enum.TryParse<InstallType>(testHookDefaultInstall, out installtype))
             {
-                installtype = InstallType.None;
+                return null;
             }
-            var installPath = Environment.GetEnvironmentVariable("DOTNET_TESTHOOK_CURRENT_INSTALL_PATH");
-            return new(installPath, installtype, DnupUtilities.GetDefaultInstallArchitecture());
+            var installPath = Environment.GetEnvironmentVariable("DOTNET_TESTHOOK_CURRENT_INSTALL_PATH") ?? GetDefaultDotnetInstallPath();
+            return new(new(installPath, DnupUtilities.GetDefaultInstallArchitecture()), installtype, true, true);
         }
 
         public string? GetLatestInstalledAdminVersion()

src/Installer/dnup/Commands/Sdk/Install/EnvironmentVariableMockReleaseInfoProvider.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.Deployment.DotNet.Releases;
 using Microsoft.DotNet.Tools.Bootstrapper.Commands.Sdk.Install;
 
 namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Sdk.Install
 {
-    internal class EnvironmentVariableMockReleaseInfoProvider : IReleaseInfoProvider
+    internal class EnvironmentVariableMockReleaseInfoProvider : IDotnetReleaseInfoProvider
     {
-        public List<string> GetAvailableChannels()
+        IEnumerable<string> IDotnetReleaseInfoProvider.GetAvailableChannels()
         {
             var channels = Environment.GetEnvironmentVariable("DOTNET_TESTHOOK_AVAILABLE_CHANNELS");
             if (string.IsNullOrEmpty(channels))
@@ -16,34 +17,45 @@ public List<string> GetAvailableChannels()
             }
             return channels.Split(',').ToList();
         }
-        public string GetLatestVersion(string channel)
+        public ReleaseVersion GetLatestVersion(InstallComponent component, string channel)
         {
+            if (component != InstallComponent.SDK)
+            {
+                throw new NotImplementedException("Only SDK component is supported in this mock provider");
+            }
+
+            string version;
             if (channel == "preview")
             {
-                return "11.0.100-preview.1.42424";
+                version = "11.0.100-preview.1.42424";
             }
             else if (channel == "latest" || channel == "10" || channel == "10.0.2xx")
             {
-                return "10.0.0-preview.7";
+                version = "10.0.0-preview.7";
             }
             else if (channel == "10.0.1xx")
             {
-                return "10.0.106";
+                version = "10.0.106";
             }
             else if (channel == "9" || channel == "9.0.3xx")
             {
-                return "9.0.309";
+                version = "9.0.309";
             }
             else if (channel == "9.0.2xx")
             {
-                return "9.0.212";
+                version = "9.0.212";
             }
             else if (channel == "9.0.1xx")
             {
-                return "9.0.115";
+                version = "9.0.115";
             }
 
-            return channel;
+            version = channel;
+
+            return new ReleaseVersion(version);
         }
+
+        public SupportType GetSupportType(InstallComponent component, ReleaseVersion version) => throw new NotImplementedException();
+
     }
 }

src/Installer/dnup/Commands/Sdk/Install/SdkInstallCommand.cs

@@ -22,7 +22,7 @@ internal class SdkInstallCommand(ParseResult result) : CommandBase(result)
     private readonly bool _interactive = result.GetValue(SdkInstallCommandParser.InteractiveOption);
 
     private readonly IBootstrapperController _dotnetInstaller = new BootstrapperController();
-    private readonly IReleaseInfoProvider _releaseInfoProvider = new EnvironmentVariableMockReleaseInfoProvider();
+    private readonly IDotnetReleaseInfoProvider _releaseInfoProvider = new EnvironmentVariableMockReleaseInfoProvider();
     private readonly ManifestChannelVersionResolver _channelVersionResolver = new ManifestChannelVersionResolver();
 
     public override int Execute()
@@ -54,7 +54,7 @@ public override int Execute()
             resolvedInstallPath = _installPath;
         }
 
-        if (resolvedInstallPath == null && currentDotnetInstallRoot.Type == InstallType.User)
+        if (resolvedInstallPath == null && currentDotnetInstallRoot != null && currentDotnetInstallRoot.InstallType == InstallType.User)
         {
             //  If a user installation is already set up, we don't need to prompt for the install path
             resolvedInstallPath = currentDotnetInstallRoot.Path;
@@ -132,13 +132,13 @@ public override int Execute()
             //  If global.json specified an install path, we don't prompt for setting the default install path (since you probably don't want to do that for a repo-local path)
             if (_interactive && installPathFromGlobalJson == null)
             {
-                if (currentDotnetInstallRoot.Type == InstallType.None)
+                if (currentDotnetInstallRoot == null)
                 {
                     resolvedSetDefaultInstall = SpectreAnsiConsole.Confirm(
                         $"Do you want to set the install path ({resolvedInstallPath}) as the default dotnet install? This will update the PATH and DOTNET_ROOT environment variables.",
                         defaultValue: true);
                 }
-                else if (currentDotnetInstallRoot.Type == InstallType.User)
+                else if (currentDotnetInstallRoot.InstallType == InstallType.User)
                 {
                     if (DnupUtilities.PathsEqual(resolvedInstallPath, currentDotnetInstallRoot.Path))
                     {
@@ -151,7 +151,7 @@ public override int Execute()
                             defaultValue: false);
                     }
                 }
-                else if (currentDotnetInstallRoot.Type == InstallType.Admin)
+                else if (currentDotnetInstallRoot.InstallType == InstallType.Admin)
                 {
                     SpectreAnsiConsole.WriteLine($"You have an existing admin install of .NET in {currentDotnetInstallRoot.Path}. We can configure your system to use the new install of .NET " +
                         $"in {resolvedInstallPath} instead. This would mean that the admin install of .NET would no longer be accessible from the PATH or from Visual Studio.");
@@ -160,11 +160,8 @@ public override int Execute()
                         $"Do you want to set the user install path ({resolvedInstallPath}) as the default dotnet install? This will update the PATH and DOTNET_ROOT environment variables.",
                         defaultValue: true);
                 }
-                else if (currentDotnetInstallRoot.Type == InstallType.Inconsistent)
-                {
-                    //  TODO: Figure out what to do here
-                    resolvedSetDefaultInstall = false;
-                }
+
+                //  TODO: Add checks for whether PATH and DOTNET_ROOT need to be updated, or if the install is in an inconsistent state
             }
             else
             {
@@ -176,14 +173,14 @@ public override int Execute()
 
         // Create a request and resolve it using the channel version resolver
         var installRequest = new DotnetInstallRequest(
-            new DotnetInstallRoot(resolvedInstallPath, InstallType.User, DnupUtilities.GetInstallArchitecture(RuntimeInformation.ProcessArchitecture)),
+            new DotnetInstallRoot(resolvedInstallPath, DnupUtilities.GetInstallArchitecture(RuntimeInformation.ProcessArchitecture)),
             new UpdateChannel(resolvedChannel),
             InstallComponent.SDK,
             new InstallRequestOptions());
 
         var resolvedVersion = _channelVersionResolver.Resolve(installRequest);
 
-        if (resolvedSetDefaultInstall == true && currentDotnetInstallRoot.Type == InstallType.Admin)
+        if (resolvedSetDefaultInstall == true && currentDotnetInstallRoot?.InstallType == InstallType.Admin)
         {
             if (_interactive)
             {
@@ -227,7 +224,7 @@ public override int Execute()
         {
             // Create the request for the additional version
             var additionalRequest = new DotnetInstallRequest(
-                new DotnetInstallRoot(resolvedInstallPath, InstallType.User, DnupUtilities.GetInstallArchitecture(RuntimeInformation.ProcessArchitecture)),
+                new DotnetInstallRoot(resolvedInstallPath, DnupUtilities.GetInstallArchitecture(RuntimeInformation.ProcessArchitecture)),
                 new UpdateChannel(additionalVersion),
                 InstallComponent.SDK,
                 new InstallRequestOptions());

src/Installer/dnup/DnupManifestJsonContext.cs

@@ -11,7 +11,7 @@ namespace Microsoft.DotNet.Tools.Bootstrapper
     [JsonSerializable(typeof(List<DotnetInstall>))]
     [JsonSerializable(typeof(DotnetVersion))]
     [JsonSerializable(typeof(DotnetVersionType))]
-    [JsonSerializable(typeof(InstallMode))]
+    [JsonSerializable(typeof(InstallComponent))]
     [JsonSerializable(typeof(InstallArchitecture))]
     [JsonSerializable(typeof(InstallType))]
     [JsonSerializable(typeof(ManagementCadence))]