Add Windows admin PATH management commands and download cache to dotnetup

src/Installer/Microsoft.Dotnet.Installation/Internal/DotnetArchiveDownloader.cs

@@ -28,6 +28,7 @@ internal class DotnetArchiveDownloader : IDisposable
     private readonly HttpClient _httpClient;
     private readonly bool _shouldDisposeHttpClient;
     private ReleaseManifest _releaseManifest;
+    private readonly DownloadCache _downloadCache;
 
     public DotnetArchiveDownloader()
         : this(new ReleaseManifest())
@@ -37,6 +38,7 @@ public DotnetArchiveDownloader()
     public DotnetArchiveDownloader(ReleaseManifest releaseManifest, HttpClient? httpClient = null)
     {
         _releaseManifest = releaseManifest ?? throw new ArgumentNullException(nameof(releaseManifest));
+        _downloadCache = new DownloadCache();
         if (httpClient == null)
         {
             _httpClient = CreateDefaultHttpClient();
@@ -192,6 +194,7 @@ void DownloadArchive(string downloadUrl, string destinationPath, IProgress<Downl
 
     /// <summary>
     /// Downloads the archive for the specified installation and verifies its hash.
+    /// Checks the download cache first to avoid re-downloading.
     /// </summary>
     /// <param name="install">The .NET installation details</param>
     /// <param name="destinationPath">The local path to save the downloaded file</param>
@@ -212,9 +215,43 @@ public void DownloadArchiveWithVerification(DotnetInstallRequest installRequest,
             throw new ArgumentException($"{nameof(downloadUrl)} cannot be null or empty");
         }
 
+        // Check the cache first
+        string? cachedFilePath = _downloadCache.GetCachedFilePath(downloadUrl);
+        if (cachedFilePath != null)
+        {
+            try
+            {
+                // Verify the cached file's hash
+                VerifyFileHash(cachedFilePath, expectedHash);
+
+                // Copy from cache to destination
+                File.Copy(cachedFilePath, destinationPath, overwrite: true);
+
+                // Report 100% progress immediately since we're using cache
+                progress?.Report(new DownloadProgress(100, 100));
+                return;
+            }
+            catch
+            {
+                // If cached file is corrupted, fall through to download
+            }
+        }
+
+        // Download the file if not in cache or cache is invalid
         DownloadArchive(downloadUrl, destinationPath, progress);
 
+        // Verify the downloaded file
         VerifyFileHash(destinationPath, expectedHash);
+
+        // Add the verified file to the cache
+        try
+        {
+            _downloadCache.AddToCache(downloadUrl, destinationPath);
+        }
+        catch
+        {
+            // Ignore errors adding to cache - it's not critical
+        }
     }
 
 

src/Installer/Microsoft.Dotnet.Installation/Internal/DownloadCache.cs

@@ -0,0 +1,146 @@
+// 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.IO;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Dotnet.Installation.Internal;
+
+/// <summary>
+/// JSON serialization context for the download cache index.
+/// </summary>
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(Dictionary<string, string>))]
+internal partial class DownloadCacheJsonContext : JsonSerializerContext
+{
+}
+
+/// <summary>
+/// Manages a cache of downloaded .NET archives to avoid re-downloading files.
+/// </summary>
+internal class DownloadCache
+{
+    private static readonly string CacheDirectory = Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+        "dotnetup",
+        "downloadcache");
+
+    private static readonly string CacheIndexPath = Path.Combine(CacheDirectory, "cache-index.json");
+
+    private Dictionary<string, string> _cacheIndex;
+
+    public DownloadCache()
+    {
+        _cacheIndex = LoadCacheIndex();
+    }
+
+    /// <summary>
+    /// Gets the path to a cached file for the given URL, if it exists.
+    /// </summary>
+    /// <param name="downloadUrl">The URL that was used to download the file</param>
+    /// <returns>The path to the cached file, or null if not found</returns>
+    public string? GetCachedFilePath(string downloadUrl)
+    {
+        if (_cacheIndex.TryGetValue(downloadUrl, out string? fileName))
+        {
+            string filePath = Path.Combine(CacheDirectory, fileName);
+            if (File.Exists(filePath))
+            {
+                return filePath;
+            }
+            // File was deleted, remove from index
+            _cacheIndex.Remove(downloadUrl);
+            SaveCacheIndex();
+        }
+        return null;
+    }
+
+    /// <summary>
+    /// Adds a file to the cache.
+    /// </summary>
+    /// <param name="downloadUrl">The URL the file was downloaded from</param>
+    /// <param name="sourceFilePath">The path to the file to cache</param>
+    public void AddToCache(string downloadUrl, string sourceFilePath)
+    {
+        // Ensure cache directory exists
+        Directory.CreateDirectory(CacheDirectory);
+
+        // Use the filename from the download URL
+        string fileName = GetFileNameFromUrl(downloadUrl);
+        string cachedFilePath = Path.Combine(CacheDirectory, fileName);
+
+        // Skip if this filename is already cached for a different URL
+        // (collision case - we'll download the right file when needed and hash check will catch it)
+        if (_cacheIndex.Values.Contains(fileName) && !_cacheIndex.ContainsKey(downloadUrl))
+        {
+            return;
+        }
+
+        // Copy the file to the cache
+        File.Copy(sourceFilePath, cachedFilePath, overwrite: true);
+
+        // Update the index
+        _cacheIndex[downloadUrl] = fileName;
+        SaveCacheIndex();
+    }
+
+    /// <summary>
+    /// Extracts the filename from a download URL.
+    /// </summary>
+    private string GetFileNameFromUrl(string downloadUrl)
+    {
+        Uri uri = new Uri(downloadUrl);
+        string fileName = Path.GetFileName(uri.LocalPath);
+
+        // Fallback to a default name if we can't extract a filename
+        if (string.IsNullOrEmpty(fileName))
+        {
+            fileName = "download.dat";
+        }
+
+        return fileName;
+    }
+
+    /// <summary>
+    /// Loads the cache index from disk.
+    /// </summary>
+    private Dictionary<string, string> LoadCacheIndex()
+    {
+        if (!File.Exists(CacheIndexPath))
+        {
+            return new Dictionary<string, string>();
+        }
+
+        try
+        {
+            string json = File.ReadAllText(CacheIndexPath);
+            var index = JsonSerializer.Deserialize(json, DownloadCacheJsonContext.Default.DictionaryStringString);
+            return index ?? new Dictionary<string, string>();
+        }
+        catch
+        {
+            // If the index is corrupted, start fresh
+            return new Dictionary<string, string>();
+        }
+    }
+
+    /// <summary>
+    /// Saves the cache index to disk.
+    /// </summary>
+    private void SaveCacheIndex()
+    {
+        try
+        {
+            Directory.CreateDirectory(CacheDirectory);
+            string json = JsonSerializer.Serialize(_cacheIndex, DownloadCacheJsonContext.Default.DictionaryStringString);
+            File.WriteAllText(CacheIndexPath, json);
+        }
+        catch
+        {
+            // Ignore errors saving the cache index - it's not critical
+        }
+    }
+}

src/Installer/dotnetup/Commands/DefaultInstall/DefaultInstallCommand.cs

@@ -0,0 +1,112 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.DefaultInstall;
+
+internal class DefaultInstallCommand : CommandBase
+{
+    private readonly string _installType;
+    private readonly InstallRootManager _installRootManager;
+
+    public DefaultInstallCommand(ParseResult result, IDotnetInstallManager? dotnetInstaller = null) : base(result)
+    {
+        _installType = result.GetValue(DefaultInstallCommandParser.InstallTypeArgument)!;
+        _installRootManager = new InstallRootManager(dotnetInstaller);
+    }
+
+    public override int Execute()
+    {
+        return _installType.ToLowerInvariant() switch
+        {
+            DefaultInstallCommandParser.UserInstallType => SetUserInstallRoot(),
+            DefaultInstallCommandParser.AdminInstallType => SetAdminInstallRoot(),
+            _ => throw new InvalidOperationException($"Unknown install type: {_installType}")
+        };
+    }
+
+    private int SetUserInstallRoot()
+    {
+        try
+        {
+            if (OperatingSystem.IsWindows())
+            {
+                var changes = _installRootManager.GetUserInstallRootChanges();
+
+                if (!changes.NeedsChange())
+                {
+                    Console.WriteLine($"User install root already configured for {changes.UserDotnetPath}");
+                    return 0;
+                }
+
+                Console.WriteLine($"Setting up user install root at: {changes.UserDotnetPath}");
+
+                bool succeeded = _installRootManager.ApplyUserInstallRoot(
+                    changes,
+                    Console.WriteLine,
+                    Console.Error.WriteLine);
+
+                if (!succeeded)
+                {
+                    // UAC prompt was cancelled
+                    return 1;
+                }
+
+                Console.WriteLine("Succeeded. NOTE: You may need to restart your terminal or application for the changes to take effect.");
+                return 0;
+            }
+            else
+            {
+                Console.Error.WriteLine("Error: Non-Windows platforms not yet supported");
+                return 1;
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: Failed to configure user install root: {ex.ToString()}");
+            return 1;
+        }
+    }
+
+    private int SetAdminInstallRoot()
+    {
+        try
+        {
+            if (OperatingSystem.IsWindows())
+            {
+                var changes = _installRootManager.GetAdminInstallRootChanges();
+
+                if (!changes.NeedsChange())
+                {
+                    Console.WriteLine("Admin install root already configured.");
+                    return 0;
+                }
+
+                bool succeeded = _installRootManager.ApplyAdminInstallRoot(
+                    changes,
+                    Console.WriteLine,
+                    Console.Error.WriteLine);
+
+                if (!succeeded)
+                {
+                    // Elevation was cancelled
+                    return 1;
+                }
+
+                Console.WriteLine("Succeeded. NOTE: You may need to restart your terminal or application for the changes to take effect.");
+                return 0;
+            }
+            else
+            {
+                Console.Error.WriteLine("Error: Admin install root is only supported on Windows.");
+                return 1;
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: Failed to configure admin install root: {ex.ToString()}");
+            return 1;
+        }
+    }
+}

src/Installer/dotnetup/Commands/DefaultInstall/DefaultInstallCommandParser.cs

@@ -0,0 +1,44 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.DefaultInstall;
+
+internal static class DefaultInstallCommandParser
+{
+    public const string UserInstallType = "user";
+    public const string AdminInstallType = "admin";
+
+    public static readonly Argument<string> InstallTypeArgument = CreateInstallTypeArgument();
+
+    private static Argument<string> CreateInstallTypeArgument()
+    {
+        var argument = new Argument<string>("installtype")
+        {
+            HelpName = "INSTALL_TYPE",
+            Description = $"The type of installation root to set: '{UserInstallType}' or '{AdminInstallType}'",
+            Arity = ArgumentArity.ExactlyOne,
+        };
+        argument.AcceptOnlyFromAmong(UserInstallType, AdminInstallType);
+        return argument;
+    }
+
+    private static readonly Command DefaultInstallCommand = ConstructCommand();
+
+    public static Command GetCommand()
+    {
+        return DefaultInstallCommand;
+    }
+
+    private static Command ConstructCommand()
+    {
+        Command command = new("defaultinstall", "Sets the default dotnet installation");
+
+        command.Arguments.Add(InstallTypeArgument);
+
+        command.SetAction(parseResult => new DefaultInstallCommand(parseResult).Execute());
+
+        return command;
+    }
+}