Rename dnup to dotnetup in code

dsplaisted · dsplaisted · commit 02f672e657b0 · 2025-11-19T10:10:22.000-05:00
diff --git a/src/Installer/Microsoft.Dotnet.Installation/Internal/DotnetArchiveDownloader.cs b/src/Installer/Microsoft.Dotnet.Installation/Internal/DotnetArchiveDownloader.cs
@@ -68,10 +68,10 @@ private static HttpClient CreateDefaultHttpClient()
             Timeout = TimeSpan.FromMinutes(10)
         };
 
-        // Set user-agent to identify dnup in telemetry, including version
+        // Set user-agent to identify dotnetup in telemetry, including version
         var informationalVersion = typeof(DotnetArchiveDownloader).Assembly
             .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion;
-        string userAgent = informationalVersion == null ? "dotnetup-dotnet-installer" : $"dnup-dotnet-installer/{informationalVersion}";
+        string userAgent = informationalVersion == null ? "dotnetup-dotnet-installer" : $"dotnetup-dotnet-installer/{informationalVersion}";
 
         client.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
 
diff --git a/src/Installer/Microsoft.Dotnet.Installation/Internal/DotnetArchiveExtractor.cs b/src/Installer/Microsoft.Dotnet.Installation/Internal/DotnetArchiveExtractor.cs
@@ -36,7 +36,7 @@ public void Prepare()
 
         using var archiveDownloader = new DotnetArchiveDownloader();
         var archiveName = $"dotnet-{Guid.NewGuid()}";
-        _archivePath = Path.Combine(scratchDownloadDirectory, archiveName + DnupUtilities.GetArchiveFileExtensionForPlatform());
+        _archivePath = Path.Combine(scratchDownloadDirectory, archiveName + DotnetupUtilities.GetArchiveFileExtensionForPlatform());
 
         using (var progressReporter = _progressTarget.CreateProgressReporter())
         {
@@ -105,7 +105,7 @@ private MuxerHandlingConfig ConfigureMuxerHandling(IEnumerable<ReleaseVersion> e
         ReleaseVersion newRuntimeVersion = _resolvedVersion;
         bool shouldUpdateMuxer = existingMuxerVersion is null || newRuntimeVersion.CompareTo(existingMuxerVersion) > 0;
 
-        string muxerName = DnupUtilities.GetDotnetExeName();
+        string muxerName = DotnetupUtilities.GetDotnetExeName();
         string muxerTargetPath = Path.Combine(_request.InstallRoot.Path!, muxerName);
 
         return new MuxerHandlingConfig(
@@ -253,7 +253,7 @@ private void HandleMuxerUpdateFromTar(TarEntry entry, string muxerTargetPath)
         try
         {
             // Replace the muxer using the utility that handles locking
-            DnupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);
+            DotnetupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);
         }
         finally
         {
@@ -335,7 +335,7 @@ private void HandleMuxerUpdateFromZip(ZipArchiveEntry entry, string muxerTargetP
         try
         {
             // Replace the muxer using the utility that handles locking
-            DnupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);
+            DotnetupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);
         }
         finally
         {
diff --git a/src/Installer/Microsoft.Dotnet.Installation/Internal/DotnetupUtilities.cs b/src/Installer/Microsoft.Dotnet.Installation/Internal/DotnetupUtilities.cs
@@ -9,7 +9,7 @@
 
 namespace Microsoft.Dotnet.Installation.Internal;
 
-internal static class DnupUtilities
+internal static class DotnetupUtilities
 {
     public static string ExeSuffix = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : "";
 
diff --git a/src/Installer/Microsoft.Dotnet.Installation/Internal/ReleaseManifest.cs b/src/Installer/Microsoft.Dotnet.Installation/Internal/ReleaseManifest.cs
@@ -112,8 +112,8 @@ public ProductCollection GetReleasesIndex()
     /// </summary>
     private static ReleaseFile? FindMatchingFile(ReleaseComponent release, DotnetInstallRequest installRequest, ReleaseVersion resolvedVersion)
     {
-        var rid = DnupUtilities.GetRuntimeIdentifier(installRequest.InstallRoot.Architecture);
-        var fileExtension = DnupUtilities.GetArchiveFileExtensionForPlatform();
+        var rid = DotnetupUtilities.GetRuntimeIdentifier(installRequest.InstallRoot.Architecture);
+        var fileExtension = DotnetupUtilities.GetArchiveFileExtensionForPlatform();
 
         var matchingFiles = release.Files
              .Where(f => f.Rid == rid) // TODO: Do we support musl here?
diff --git a/src/Installer/dotnetup/ArchiveInstallationValidator.cs b/src/Installer/dotnetup/ArchiveInstallationValidator.cs
@@ -32,7 +32,7 @@ public bool Validate(DotnetInstall install)
             return false;
         }
 
-        string dotnetMuxerPath = Path.Combine(installRoot, DnupUtilities.GetDotnetExeName());
+        string dotnetMuxerPath = Path.Combine(installRoot, DotnetupUtilities.GetDotnetExeName());
         if (!File.Exists(dotnetMuxerPath))
         {
             return false;
@@ -82,7 +82,7 @@ private bool ValidateWithHostFxr(string installRoot, ReleaseVersion resolvedVers
                 string expectedPath = Path.Combine(installRoot, "sdk", resolvedVersion.ToString());
                 return environmentInfo.SdkInfo.Any(sdk =>
                     string.Equals(sdk.Version.ToString(), resolvedVersion.ToString(), StringComparison.OrdinalIgnoreCase) &&
-                    DnupUtilities.PathsEqual(sdk.Path, expectedPath));
+                    DotnetupUtilities.PathsEqual(sdk.Path, expectedPath));
             }
 
             if (!RuntimeMonikerByComponent.TryGetValue(component, out string? runtimeMoniker))
@@ -94,7 +94,7 @@ private bool ValidateWithHostFxr(string installRoot, ReleaseVersion resolvedVers
             return environmentInfo.RuntimeInfo.Any(runtime =>
                 string.Equals(runtime.Name, runtimeMoniker, StringComparison.OrdinalIgnoreCase) &&
                 string.Equals(runtime.Version.ToString(), resolvedVersion.ToString(), StringComparison.OrdinalIgnoreCase) &&
-                DnupUtilities.PathsEqual(runtime.Path, expectedRuntimePath));
+                DotnetupUtilities.PathsEqual(runtime.Path, expectedRuntimePath));
         }
         catch
         {
diff --git a/src/Installer/dotnetup/Commands/Sdk/Install/SdkInstallCommand.cs b/src/Installer/dotnetup/Commands/Sdk/Install/SdkInstallCommand.cs
@@ -39,7 +39,7 @@ public override int Execute()
             installPathFromGlobalJson = globalJsonInfo.SdkPath;
 
             if (installPathFromGlobalJson is not null && _installPath is not null &&
-                !DnupUtilities.PathsEqual(installPathFromGlobalJson, _installPath))
+                !DotnetupUtilities.PathsEqual(installPathFromGlobalJson, _installPath))
             {
                 //  TODO: Add parameter to override error
                 Console.Error.WriteLine($"Error: The install path specified in global.json ({installPathFromGlobalJson}) does not match the install path provided ({_installPath}).");
@@ -140,7 +140,7 @@ public override int Execute()
                 }
                 else if (currentDotnetInstallRoot.InstallType == InstallType.User)
                 {
-                    if (DnupUtilities.PathsEqual(resolvedInstallPath, currentDotnetInstallRoot.Path))
+                    if (DotnetupUtilities.PathsEqual(resolvedInstallPath, currentDotnetInstallRoot.Path))
                     {
                         //  No need to prompt here, the default install is already set up.
                     }
diff --git a/src/Installer/dotnetup/Commands/Sdk/Install/SdkInstallCommandParser.cs b/src/Installer/dotnetup/Commands/Sdk/Install/SdkInstallCommandParser.cs
@@ -52,7 +52,7 @@ public static Command GetSdkInstallCommand()
         return SdkInstallCommand;
     }
 
-    //  Trying to use the same command object for both "dnup install" and "dnup sdk install" causes the following exception:
+    //  Trying to use the same command object for both "dotnetup install" and "dotnetup sdk install" causes the following exception:
     //  System.InvalidOperationException: Command install has more than one child named "channel".
     //  So we create a separate instance for each case
     private static readonly Command RootInstallCommand = ConstructCommand();
diff --git a/src/Installer/dotnetup/Commands/Sdk/Update/SdkUpdateCommandParser.cs b/src/Installer/dotnetup/Commands/Sdk/Update/SdkUpdateCommandParser.cs
@@ -31,7 +31,7 @@ public static Command GetSdkUpdateCommand()
         return SdkUpdateCommand;
     }
 
-    //  Trying to use the same command object for both "dnup udpate" and "dnup sdk update" causes an InvalidOperationException
+    //  Trying to use the same command object for both "dotnetup udpate" and "dotnetup sdk update" causes an InvalidOperationException
     //  So we create a separate instance for each case
     private static readonly Command RootUpdateCommand = ConstructCommand();
 
diff --git a/src/Installer/dotnetup/Constants.cs b/src/Installer/dotnetup/Constants.cs
@@ -4,7 +4,7 @@
 namespace Microsoft.DotNet.Tools.Bootstrapper
 {
     /// <summary>
-    /// Shared constants for the dnup application.
+    /// Shared constants for the dotnetup application.
     /// </summary>
     internal static class Constants
     {
@@ -17,7 +17,7 @@ public static class MutexNames
             /// Mutex used during the final installation phase to protect the manifest file and extracting folder(s).
             /// Mutex names MUST be valid file names on Unix. https://learn.microsoft.com/dotnet/api/system.threading.mutex.openexisting?view=net-9.0
             /// </summary>
-            public const string ModifyInstallationStates = "Global\\DnupFinalize";
+            public const string ModifyInstallationStates = "Global\\DotnetupFinalize";
         }
     }
 }
diff --git a/src/Installer/dotnetup/DotnetInstallManager.cs b/src/Installer/dotnetup/DotnetInstallManager.cs
@@ -40,7 +40,7 @@ public DotnetInstallManager(IEnvironmentProvider? environmentProvider = null)
 
         var installRoot = new DotnetInstallRoot(installDir, InstallerUtilities.GetDefaultInstallArchitecture());
 
-        bool isSetAsDotnetRoot = DnupUtilities.PathsEqual(dotnetRoot, installDir);
+        bool isSetAsDotnetRoot = DotnetupUtilities.PathsEqual(dotnetRoot, installDir);
 
         return new(installRoot, isAdminInstall ? InstallType.Admin : InstallType.User, IsOnPath: true, isSetAsDotnetRoot);
     }
diff --git a/src/Installer/dotnetup/DotnetupDebugHelper.cs b/src/Installer/dotnetup/DotnetupDebugHelper.cs
@@ -8,7 +8,7 @@
 namespace Microsoft.DotNet.Tools.Bootstrapper;
 
 // Copy of DebugHelper.cs in the SDK - port eventually.
-internal static class DnupDebugHelper
+internal static class DotnetupDebugHelper
 {
     [Conditional("DEBUG")]
     public static void HandleDebugSwitch(ref string[] args)
diff --git a/src/Installer/dotnetup/DotnetupManifestJsonContext.cs b/src/Installer/dotnetup/DotnetupManifestJsonContext.cs
@@ -14,5 +14,5 @@ namespace Microsoft.DotNet.Tools.Bootstrapper
     [JsonSerializable(typeof(InstallArchitecture))]
     [JsonSerializable(typeof(InstallType))]
     [JsonSerializable(typeof(ManagementCadence))]
-    internal partial class DnupManifestJsonContext : JsonSerializerContext { }
+    internal partial class DotnetupManifestJsonContext : JsonSerializerContext { }
 }
diff --git a/src/Installer/dotnetup/DotnetupSharedManifest.cs b/src/Installer/dotnetup/DotnetupSharedManifest.cs
@@ -11,11 +11,11 @@
 
 namespace Microsoft.DotNet.Tools.Bootstrapper;
 
-internal class DnupSharedManifest : IDnupManifest
+internal class DotnetupSharedManifest : IDotnetupManifest
 {
     private string ManifestPath => GetManifestPath();
 
-    public DnupSharedManifest(string? manifestPath = null)
+    public DotnetupSharedManifest(string? manifestPath = null)
     {
         _customManifestPath = manifestPath;
         EnsureManifestExists();
@@ -26,7 +26,7 @@ private void EnsureManifestExists()
         if (!File.Exists(ManifestPath))
         {
             Directory.CreateDirectory(Path.GetDirectoryName(ManifestPath)!);
-            File.WriteAllText(ManifestPath, JsonSerializer.Serialize(new List<DotnetInstall>(), DnupManifestJsonContext.Default.ListDotnetInstall));
+            File.WriteAllText(ManifestPath, JsonSerializer.Serialize(new List<DotnetInstall>(), DotnetupManifestJsonContext.Default.ListDotnetInstall));
         }
     }
 
@@ -50,8 +50,8 @@ private string GetManifestPath()
         // Default location
         return Path.Combine(
             RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) : Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
-            "dnup",
-            "dnup_manifest.json");
+            "dotnetup",
+            "dotnetup_manifest.json");
     }
 
     private void AssertHasFinalizationMutex()
@@ -61,7 +61,7 @@ private void AssertHasFinalizationMutex()
         // implemented in ScopedMutex. This ensures we only assert based on a lock we actually obtained.
         if (!ScopedMutex.CurrentThreadHoldsMutex)
         {
-            throw new InvalidOperationException("The dnup manifest was accessed without holding the installation state mutex.");
+            throw new InvalidOperationException("The dotnetup manifest was accessed without holding the installation state mutex.");
         }
     }
 
@@ -73,7 +73,7 @@ public IEnumerable<DotnetInstall> GetInstalledVersions(IInstallationValidator? v
         var json = File.ReadAllText(ManifestPath);
         try
         {
-            var installs = JsonSerializer.Deserialize(json, DnupManifestJsonContext.Default.ListDotnetInstall);
+            var installs = JsonSerializer.Deserialize(json, DotnetupManifestJsonContext.Default.ListDotnetInstall);
             var validInstalls = installs ?? [];
 
             if (validator is not null)
@@ -82,15 +82,15 @@ public IEnumerable<DotnetInstall> GetInstalledVersions(IInstallationValidator? v
                 if (invalids.Count > 0)
                 {
                     validInstalls = validInstalls.Except(invalids).ToList();
-                    var newJson = JsonSerializer.Serialize(validInstalls, DnupManifestJsonContext.Default.ListDotnetInstall);
+                    var newJson = JsonSerializer.Serialize(validInstalls, DotnetupManifestJsonContext.Default.ListDotnetInstall);
                     File.WriteAllText(ManifestPath, newJson);
                 }
             }
             return validInstalls;
         }
         catch (JsonException ex)
         {
-            throw new InvalidOperationException($"The dnup manifest is corrupt or inaccessible", ex);
+            throw new InvalidOperationException($"The dotnetup manifest is corrupt or inaccessible", ex);
         }
     }
 
@@ -106,7 +106,7 @@ public IEnumerable<DotnetInstall> GetInstalledVersions(DotnetInstallRoot install
         var installedVersions = GetInstalledVersions(validator);
         var expectedInstallRootPath = Path.GetFullPath(installRoot.Path);
         var installedVersionsInRoot = installedVersions
-            .Where(install => DnupUtilities.PathsEqual(Path.GetFullPath(install.InstallRoot.Path!), expectedInstallRootPath));
+            .Where(install => DotnetupUtilities.PathsEqual(Path.GetFullPath(install.InstallRoot.Path!), expectedInstallRootPath));
         return installedVersionsInRoot;
     }
 
@@ -117,7 +117,7 @@ public void AddInstalledVersion(DotnetInstall version)
 
         var installs = GetInstalledVersions().ToList();
         installs.Add(version);
-        var json = JsonSerializer.Serialize(installs, DnupManifestJsonContext.Default.ListDotnetInstall);
+        var json = JsonSerializer.Serialize(installs, DotnetupManifestJsonContext.Default.ListDotnetInstall);
         Directory.CreateDirectory(Path.GetDirectoryName(ManifestPath)!);
         File.WriteAllText(ManifestPath, json);
     }
@@ -128,8 +128,8 @@ public void RemoveInstalledVersion(DotnetInstall version)
         EnsureManifestExists();
 
         var installs = GetInstalledVersions().ToList();
-        installs.RemoveAll(i => DnupUtilities.PathsEqual(i.InstallRoot.Path, version.InstallRoot.Path) && i.Version.Equals(version.Version));
-        var json = JsonSerializer.Serialize(installs, DnupManifestJsonContext.Default.ListDotnetInstall);
+        installs.RemoveAll(i => DotnetupUtilities.PathsEqual(i.InstallRoot.Path, version.InstallRoot.Path) && i.Version.Equals(version.Version));
+        var json = JsonSerializer.Serialize(installs, DotnetupManifestJsonContext.Default.ListDotnetInstall);
         File.WriteAllText(ManifestPath, json);
     }
 }
diff --git a/src/Installer/dotnetup/IDotnetupManifest.cs b/src/Installer/dotnetup/IDotnetupManifest.cs
@@ -7,7 +7,7 @@
 
 namespace Microsoft.DotNet.Tools.Bootstrapper
 {
-    internal interface IDnupManifest
+    internal interface IDotnetupManifest
     {
         IEnumerable<DotnetInstall> GetInstalledVersions(IInstallationValidator? validator = null);
         IEnumerable<DotnetInstall> GetInstalledVersions(DotnetInstallRoot installRoot, IInstallationValidator? validator = null);
diff --git a/src/Installer/dotnetup/InstallerOrchestratorSingleton.cs b/src/Installer/dotnetup/InstallerOrchestratorSingleton.cs
@@ -70,7 +70,7 @@ private InstallerOrchestratorSingleton()
             ArchiveInstallationValidator validator = new();
             if (validator.Validate(install))
             {
-                DnupSharedManifest manifestManager = new(customManifestPath);
+                DotnetupSharedManifest manifestManager = new(customManifestPath);
                 manifestManager.AddInstalledVersion(install);
             }
             else
@@ -87,7 +87,7 @@ private InstallerOrchestratorSingleton()
     /// </summary>
     private IEnumerable<DotnetInstall> GetExistingInstalls(DotnetInstallRoot installRoot, string? customManifestPath = null)
     {
-        var manifestManager = new DnupSharedManifest(customManifestPath);
+        var manifestManager = new DotnetupSharedManifest(customManifestPath);
         // Use the overload that filters by muxer directory
         return manifestManager.GetInstalledVersions(installRoot);
     }
diff --git a/src/Installer/dotnetup/ManagementCadence.cs b/src/Installer/dotnetup/ManagementCadence.cs
@@ -5,7 +5,7 @@ namespace Microsoft.DotNet.Tools.Bootstrapper
 {
     public enum ManagementCadenceType
     {
-        DNUP,
+        Dotnetup,
         GlobalJson,
         Standalone
     }
@@ -14,7 +14,7 @@ public struct ManagementCadence
     {
         public ManagementCadence()
         {
-            Type = ManagementCadenceType.DNUP;
+            Type = ManagementCadenceType.Dotnetup;
             Metadata = new Dictionary<string, string>();
         }
         public ManagementCadence(ManagementCadenceType managementStyle) : this()
diff --git a/src/Installer/dotnetup/Program.cs b/src/Installer/dotnetup/Program.cs
@@ -3,13 +3,13 @@
 
 namespace Microsoft.DotNet.Tools.Bootstrapper
 {
-    internal class DnupProgram
+    internal class DotnetupProgram
     {
         public static int Main(string[] args)
         {
             // Handle --debug flag using the standard .NET SDK pattern
             // This is DEBUG-only and removes the --debug flag from args
-            DnupDebugHelper.HandleDebugSwitch(ref args);
+            DotnetupDebugHelper.HandleDebugSwitch(ref args);
 
             var parseResult = Parser.Parse(args);
             return Parser.Invoke(parseResult);
diff --git a/test/dotnetup.Tests/ChannelVersionResolverTests.cs b/test/dotnetup.Tests/ChannelVersionResolverTests.cs
@@ -3,7 +3,7 @@
 using Microsoft.Dotnet.Installation.Internal;
 using Xunit;
 
-namespace Microsoft.DotNet.Tools.Dnup.Tests
+namespace Microsoft.DotNet.Tools.Dotnetup.Tests
 {
     public class ChannelVersionResolverTests(ITestOutputHelper log)
     {
diff --git a/test/dotnetup.Tests/DnupCollections.cs b/test/dotnetup.Tests/DnupCollections.cs
@@ -3,13 +3,13 @@
 
 using Xunit;
 
-namespace Microsoft.DotNet.Tools.Dnup.Tests;
+namespace Microsoft.DotNet.Tools.Dotnetup.Tests;
 
 /// <summary>
 /// Collection definition that allows tests to run in parallel.
 /// </summary>
-[CollectionDefinition("DnupInstallCollection", DisableParallelization = false)]
-public class DnupInstallCollection
+[CollectionDefinition("DotnetupInstallCollection", DisableParallelization = false)]
+public class DotnetupInstallCollection
 {
     // This class has no code, and is never created. Its purpose is to be the place to apply
     // [CollectionDefinition] and all the collection settings.
@@ -18,8 +18,8 @@ public class DnupInstallCollection
 /// <summary>
 /// Collection definition for reuse tests that allows tests to run in parallel.
 /// </summary>
-[CollectionDefinition("DnupReuseCollection", DisableParallelization = false)]
-public class DnupReuseCollection
+[CollectionDefinition("DotnetupReuseCollection", DisableParallelization = false)]
+public class DotnetupReuseCollection
 {
     // This class has no code, and is never created. Its purpose is to be the place to apply
     // [CollectionDefinition] and all the collection settings.
@@ -28,8 +28,8 @@ public class DnupReuseCollection
 /// <summary>
 /// Collection definition for concurrency tests that allows tests to run in parallel.
 /// </summary>
-[CollectionDefinition("DnupConcurrencyCollection", DisableParallelization = false)]
-public class DnupConcurrencyCollection
+[CollectionDefinition("DotnetupConcurrencyCollection", DisableParallelization = false)]
+public class DotnetupConcurrencyCollection
 {
     // This class has no code, and is never created. Its purpose is to be the place to apply
     // [CollectionDefinition] and all the collection settings.
diff --git a/test/dotnetup.Tests/DnupE2Etest.cs b/test/dotnetup.Tests/DnupE2Etest.cs
diff --git a/test/dotnetup.Tests/LibraryTests.cs b/test/dotnetup.Tests/LibraryTests.cs
diff --git a/test/dotnetup.Tests/ParserTests.cs b/test/dotnetup.Tests/ParserTests.cs
diff --git a/test/dotnetup.Tests/Utilities/ConsoleOutputCapture.cs b/test/dotnetup.Tests/Utilities/ConsoleOutputCapture.cs
diff --git a/test/dotnetup.Tests/Utilities/DotnetupTestUtilities.cs b/test/dotnetup.Tests/Utilities/DotnetupTestUtilities.cs
diff --git a/test/dotnetup.Tests/Utilities/TestEnvironment.cs b/test/dotnetup.Tests/Utilities/TestEnvironment.cs
diff --git a/test/dotnetup.Tests/Utilities/UpdateChannelExtensions.cs b/test/dotnetup.Tests/Utilities/UpdateChannelExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public void Prepare()`
`36`	`36`
`37`	`37`	`using var archiveDownloader = new DotnetArchiveDownloader();`
`38`	`38`	`var archiveName = $"dotnet-{Guid.NewGuid()}";`
`39`		`- _archivePath = Path.Combine(scratchDownloadDirectory, archiveName + DnupUtilities.GetArchiveFileExtensionForPlatform());`
	`39`	`+ _archivePath = Path.Combine(scratchDownloadDirectory, archiveName + DotnetupUtilities.GetArchiveFileExtensionForPlatform());`
`40`	`40`
`41`	`41`	`using (var progressReporter = _progressTarget.CreateProgressReporter())`
`42`	`42`	`{`
`@@ -105,7 +105,7 @@ private MuxerHandlingConfig ConfigureMuxerHandling(IEnumerable<ReleaseVersion> e`
`105`	`105`	`ReleaseVersion newRuntimeVersion = _resolvedVersion;`
`106`	`106`	`bool shouldUpdateMuxer = existingMuxerVersion is null \|\| newRuntimeVersion.CompareTo(existingMuxerVersion) > 0;`
`107`	`107`
`108`		`- string muxerName = DnupUtilities.GetDotnetExeName();`
	`108`	`+ string muxerName = DotnetupUtilities.GetDotnetExeName();`
`109`	`109`	`string muxerTargetPath = Path.Combine(_request.InstallRoot.Path!, muxerName);`
`110`	`110`
`111`	`111`	`return new MuxerHandlingConfig(`
`@@ -253,7 +253,7 @@ private void HandleMuxerUpdateFromTar(TarEntry entry, string muxerTargetPath)`
`253`	`253`	`try`
`254`	`254`	`{`
`255`	`255`	`// Replace the muxer using the utility that handles locking`
`256`		`- DnupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);`
	`256`	`+ DotnetupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);`
`257`	`257`	`}`
`258`	`258`	`finally`
`259`	`259`	`{`
`@@ -335,7 +335,7 @@ private void HandleMuxerUpdateFromZip(ZipArchiveEntry entry, string muxerTargetP`
`335`	`335`	`try`
`336`	`336`	`{`
`337`	`337`	`// Replace the muxer using the utility that handles locking`
`338`		`- DnupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);`
	`338`	`+ DotnetupUtilities.ForceReplaceFile(tempMuxerPath, muxerTargetPath);`
`339`	`339`	`}`
`340`	`340`	`finally`
`341`	`341`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`namespace Microsoft.Dotnet.Installation.Internal;`
`11`	`11`
`12`		`-internal static class DnupUtilities`
	`12`	`+internal static class DotnetupUtilities`
`13`	`13`	`{`
`14`	`14`	`public static string ExeSuffix = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : "";`
`15`	`15`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public bool Validate(DotnetInstall install)`
`32`	`32`	`return false;`
`33`	`33`	`}`
`34`	`34`
`35`		`- string dotnetMuxerPath = Path.Combine(installRoot, DnupUtilities.GetDotnetExeName());`
	`35`	`+ string dotnetMuxerPath = Path.Combine(installRoot, DotnetupUtilities.GetDotnetExeName());`
`36`	`36`	`if (!File.Exists(dotnetMuxerPath))`
`37`	`37`	`{`
`38`	`38`	`return false;`
`@@ -82,7 +82,7 @@ private bool ValidateWithHostFxr(string installRoot, ReleaseVersion resolvedVers`
`82`	`82`	`string expectedPath = Path.Combine(installRoot, "sdk", resolvedVersion.ToString());`
`83`	`83`	`return environmentInfo.SdkInfo.Any(sdk =>`
`84`	`84`	`string.Equals(sdk.Version.ToString(), resolvedVersion.ToString(), StringComparison.OrdinalIgnoreCase) &&`
`85`		`- DnupUtilities.PathsEqual(sdk.Path, expectedPath));`
	`85`	`+ DotnetupUtilities.PathsEqual(sdk.Path, expectedPath));`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`if (!RuntimeMonikerByComponent.TryGetValue(component, out string? runtimeMoniker))`
`@@ -94,7 +94,7 @@ private bool ValidateWithHostFxr(string installRoot, ReleaseVersion resolvedVers`
`94`	`94`	`return environmentInfo.RuntimeInfo.Any(runtime =>`
`95`	`95`	`string.Equals(runtime.Name, runtimeMoniker, StringComparison.OrdinalIgnoreCase) &&`
`96`	`96`	`string.Equals(runtime.Version.ToString(), resolvedVersion.ToString(), StringComparison.OrdinalIgnoreCase) &&`
`97`		`- DnupUtilities.PathsEqual(runtime.Path, expectedRuntimePath));`
	`97`	`+ DotnetupUtilities.PathsEqual(runtime.Path, expectedRuntimePath));`
`98`	`98`	`}`
`99`	`99`	`catch`
`100`	`100`	`{`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public override int Execute()`
`39`	`39`	`installPathFromGlobalJson = globalJsonInfo.SdkPath;`
`40`	`40`
`41`	`41`	`if (installPathFromGlobalJson is not null && _installPath is not null &&`
`42`		`- !DnupUtilities.PathsEqual(installPathFromGlobalJson, _installPath))`
	`42`	`+ !DotnetupUtilities.PathsEqual(installPathFromGlobalJson, _installPath))`
`43`	`43`	`{`
`44`	`44`	`// TODO: Add parameter to override error`
`45`	`45`	`Console.Error.WriteLine($"Error: The install path specified in global.json ({installPathFromGlobalJson}) does not match the install path provided ({_installPath}).");`
`@@ -140,7 +140,7 @@ public override int Execute()`
`140`	`140`	`}`
`141`	`141`	`else if (currentDotnetInstallRoot.InstallType == InstallType.User)`
`142`	`142`	`{`
`143`		`- if (DnupUtilities.PathsEqual(resolvedInstallPath, currentDotnetInstallRoot.Path))`
	`143`	`+ if (DotnetupUtilities.PathsEqual(resolvedInstallPath, currentDotnetInstallRoot.Path))`
`144`	`144`	`{`
`145`	`145`	`// No need to prompt here, the default install is already set up.`
`146`	`146`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public static Command GetSdkInstallCommand()`
`52`	`52`	`return SdkInstallCommand;`
`53`	`53`	`}`
`54`	`54`
`55`		`- // Trying to use the same command object for both "dnup install" and "dnup sdk install" causes the following exception:`
	`55`	`+ // Trying to use the same command object for both "dotnetup install" and "dotnetup sdk install" causes the following exception:`
`56`	`56`	`// System.InvalidOperationException: Command install has more than one child named "channel".`
`57`	`57`	`// So we create a separate instance for each case`
`58`	`58`	`private static readonly Command RootInstallCommand = ConstructCommand();`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public static Command GetSdkUpdateCommand()`
`31`	`31`	`return SdkUpdateCommand;`
`32`	`32`	`}`
`33`	`33`
`34`		`- // Trying to use the same command object for both "dnup udpate" and "dnup sdk update" causes an InvalidOperationException`
	`34`	`+ // Trying to use the same command object for both "dotnetup udpate" and "dotnetup sdk update" causes an InvalidOperationException`
`35`	`35`	`// So we create a separate instance for each case`
`36`	`36`	`private static readonly Command RootUpdateCommand = ConstructCommand();`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`namespace Microsoft.DotNet.Tools.Bootstrapper`
`5`	`5`	`{`
`6`	`6`	`/// <summary>`
`7`		`- /// Shared constants for the dnup application.`
	`7`	`+ /// Shared constants for the dotnetup application.`
`8`	`8`	`/// </summary>`
`9`	`9`	`internal static class Constants`
`10`	`10`	`{`
`@@ -17,7 +17,7 @@ public static class MutexNames`
`17`	`17`	`/// Mutex used during the final installation phase to protect the manifest file and extracting folder(s).`
`18`	`18`	`/// Mutex names MUST be valid file names on Unix. https://learn.microsoft.com/dotnet/api/system.threading.mutex.openexisting?view=net-9.0`
`19`	`19`	`/// </summary>`
`20`		`- public const string ModifyInstallationStates = "Global\\DnupFinalize";`
	`20`	`+ public const string ModifyInstallationStates = "Global\\DotnetupFinalize";`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public DotnetInstallManager(IEnvironmentProvider? environmentProvider = null)`
`40`	`40`
`41`	`41`	`var installRoot = new DotnetInstallRoot(installDir, InstallerUtilities.GetDefaultInstallArchitecture());`
`42`	`42`
`43`		`- bool isSetAsDotnetRoot = DnupUtilities.PathsEqual(dotnetRoot, installDir);`
	`43`	`+ bool isSetAsDotnetRoot = DotnetupUtilities.PathsEqual(dotnetRoot, installDir);`
`44`	`44`
`45`	`45`	`return new(installRoot, isAdminInstall ? InstallType.Admin : InstallType.User, IsOnPath: true, isSetAsDotnetRoot);`
`46`	`46`	`}`