Atomic install tool (#8518)

* Make dotnet install tool atomic

Apply TransactionScope to tool install. It can handle the correct timing
of roll back and commit.

Convert existing ToolPackageObtainer and ShellShimMaker by passing logic
via lambda to an object that has IEnlistmentNotification interface. It
turns out the very clean.

Use .stage as staging place to verify of package content, and shim. It
should roll back when something is wrong. When there is ctrl-c, there
will be garbage in .stage folder but not the root of the package folder.

Author: William Lee

src/Microsoft.DotNet.InternalAbstractions/DirectoryWrapper.cs

@@ -47,5 +47,10 @@ public void CreateDirectory(string path)
         {
             Directory.CreateDirectory(path);
         }
+
+        public void Delete(string path, bool recursive)
+        {
+            Directory.Delete(path, recursive);
+        }
     }
 }

src/Microsoft.DotNet.InternalAbstractions/FileWrapper.cs

@@ -45,5 +45,10 @@ public void WriteAllText(string path, string content)
         {
             File.WriteAllText(path, content);
         }
+
+        public void Delete(string path)
+        {
+            File.Delete(path);
+        }
     }
 }

src/Microsoft.DotNet.InternalAbstractions/IDirectory.cs

@@ -16,5 +16,7 @@ internal interface IDirectory
         string GetDirectoryFullName(string path);
 
         void CreateDirectory(string path);
+
+        void Delete(string path, bool recursive);
     }
 }

src/Microsoft.DotNet.InternalAbstractions/IFile.cs

@@ -24,5 +24,7 @@ Stream OpenFile(
         void CreateEmptyFile(string path);
 
         void WriteAllText(string path, string content);
+
+        void Delete(string path);
     }
 }

src/dotnet/CommonLocalizableStrings.resx

@@ -588,4 +588,7 @@ Output: {1}</value>
   <data name="ToolPackageMissingSettingsFile" xml:space="preserve">
     <value>Package '{0}' is missing tool settings file DotnetToolSettings.xml.</value>
   </data>
-</root>
+  <data name="ToolPackageConflictPackageId" xml:space="preserve">
+    <value>Tool '{0}' is already installed.</value>
+  </data>
+</root>

src/dotnet/ShellShim/CreateShimTransaction.cs

@@ -0,0 +1,52 @@
+// 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;
+using System.Collections.Generic;
+using System.Transactions;
+using Microsoft.Extensions.EnvironmentAbstractions;
+
+namespace Microsoft.DotNet.ShellShim
+{
+    internal class CreateShimTransaction : IEnlistmentNotification
+    {
+        private readonly Action<List<FilePath>> _createShim;
+        private readonly Action<List<FilePath>> _rollback;
+        private List<FilePath> _locationOfShimDuringTransaction = new List<FilePath>();
+
+        public CreateShimTransaction(
+            Action<List<FilePath>> createShim,
+            Action<List<FilePath>> rollback)
+        {
+            _createShim = createShim ?? throw new ArgumentNullException(nameof(createShim));
+            _rollback = rollback ?? throw new ArgumentNullException(nameof(rollback));
+        }
+
+        public void CreateShim()
+        {
+            _createShim(_locationOfShimDuringTransaction);
+        }
+
+        public void Commit(Enlistment enlistment)
+        {
+            enlistment.Done();
+        }
+
+        public void InDoubt(Enlistment enlistment)
+        {
+            Rollback(enlistment);
+        }
+
+        public void Prepare(PreparingEnlistment preparingEnlistment)
+        {
+            preparingEnlistment.Done();
+        }
+
+        public void Rollback(Enlistment enlistment)
+        {
+            _rollback(_locationOfShimDuringTransaction);
+
+            enlistment.Done();
+        }
+    }
+}

src/dotnet/ShellShim/ShellShimMaker.cs

@@ -2,10 +2,12 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Transactions;
 using System.Xml.Linq;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools;
@@ -22,11 +24,38 @@ public class ShellShimMaker : IShellShimMaker
 
         public ShellShimMaker(string pathToPlaceShim)
         {
-            _pathToPlaceShim =
-                pathToPlaceShim ?? throw new ArgumentNullException(nameof(pathToPlaceShim));
+            _pathToPlaceShim = pathToPlaceShim ?? throw new ArgumentNullException(nameof(pathToPlaceShim));
         }
 
         public void CreateShim(FilePath packageExecutable, string shellCommandName)
+        {
+            var createShimTransaction = new CreateShimTransaction(
+                createShim: locationOfShimDuringTransaction =>
+                {
+                    EnsureCommandNameUniqueness(shellCommandName);
+                    PlaceShim(packageExecutable, shellCommandName, locationOfShimDuringTransaction);
+                },
+                rollback: locationOfShimDuringTransaction =>
+                {
+                    foreach (FilePath f in locationOfShimDuringTransaction)
+                    {
+                        if (File.Exists(f.Value))
+                        {
+                            File.Delete(f.Value);
+                        }
+                    }
+                });
+
+            using (var transactionScope = new TransactionScope())
+            {
+                Transaction.Current.EnlistVolatile(createShimTransaction, EnlistmentOptions.None);
+                createShimTransaction.CreateShim();
+
+                transactionScope.Complete();
+            }
+        }
+
+        private void PlaceShim(FilePath packageExecutable, string shellCommandName, List<FilePath> locationOfShimDuringTransaction)
         {
             FilePath shimPath = GetShimPath(shellCommandName);
 
@@ -37,12 +66,20 @@ public void CreateShim(FilePath packageExecutable, string shellCommandName)
 
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                CreateConfigFile(shimPath.Value + ".config", entryPoint: packageExecutable, runner: "dotnet");
+                FilePath windowsConfig = GetWindowsConfigPath(shellCommandName);
+                CreateConfigFile(
+                    windowsConfig,
+                    entryPoint: packageExecutable,
+                    runner: "dotnet");
+
+                locationOfShimDuringTransaction.Add(windowsConfig);
+
                 using (var shim = File.Create(shimPath.Value))
                 using (var exe = typeof(ShellShimMaker).Assembly.GetManifestResourceStream(LauncherExeResourceName))
                 {
                     exe.CopyTo(shim);
                 }
+                locationOfShimDuringTransaction.Add(shimPath);
             }
             else
             {
@@ -51,37 +88,43 @@ public void CreateShim(FilePath packageExecutable, string shellCommandName)
                 script.AppendLine($"dotnet {packageExecutable.ToQuotedString()} \"$@\"");
 
                 File.WriteAllText(shimPath.Value, script.ToString());
+                locationOfShimDuringTransaction.Add(shimPath);
 
                 SetUserExecutionPermissionToShimFile(shimPath);
             }
         }
 
         public void EnsureCommandNameUniqueness(string shellCommandName)
         {
-            if (File.Exists(Path.Combine(_pathToPlaceShim, shellCommandName)))
+            if (File.Exists(GetShimPath(shellCommandName).Value))
             {
                 throw new GracefulException(
                     string.Format(CommonLocalizableStrings.FailInstallToolSameName,
                         shellCommandName));
             }
         }
 
-        internal void CreateConfigFile(string outputPath, FilePath entryPoint, string runner)
+        internal void CreateConfigFile(FilePath outputPath, FilePath entryPoint, string runner)
         {
             XDocument config;
-            using (var resource = typeof(ShellShimMaker).Assembly.GetManifestResourceStream(LauncherConfigResourceName))
+            using(var resource = typeof(ShellShimMaker).Assembly.GetManifestResourceStream(LauncherConfigResourceName))
             {
                 config = XDocument.Load(resource);
             }
 
             var appSettings = config.Descendants("appSettings").First();
             appSettings.Add(new XElement("add", new XAttribute("key", "entryPoint"), new XAttribute("value", entryPoint.Value)));
             appSettings.Add(new XElement("add", new XAttribute("key", "runner"), new XAttribute("value", runner ?? string.Empty)));
-            config.Save(outputPath);
+            config.Save(outputPath.Value);
         }
 
         public void Remove(string shellCommandName)
         {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                File.Delete(GetWindowsConfigPath(shellCommandName).Value);
+            }
+
             File.Delete(GetShimPath(shellCommandName).Value);
         }
 
@@ -96,6 +139,11 @@ private FilePath GetShimPath(string shellCommandName)
             return new FilePath(scriptPath);
         }
 
+        private FilePath GetWindowsConfigPath(string shellCommandName)
+        {
+            return new FilePath(GetShimPath(shellCommandName).Value + ".config");
+        }
+
         private static void SetUserExecutionPermissionToShimFile(FilePath scriptPath)
         {
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

src/dotnet/ToolPackage/ToolPackageObtainTransaction.cs

@@ -0,0 +1,52 @@
+// 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;
+using System.Collections.Generic;
+using System.Transactions;
+using Microsoft.Extensions.EnvironmentAbstractions;
+
+namespace Microsoft.DotNet.ToolPackage
+{
+    internal class ToolPackageObtainTransaction : IEnlistmentNotification
+    {
+        private readonly Func<List<DirectoryPath>, ToolConfigurationAndExecutablePath> _obtainAndReturnExecutablePath;
+        private readonly Action<List<DirectoryPath>> _rollback;
+        private List<DirectoryPath> _locationOfPackageDuringTransaction = new List<DirectoryPath>();
+
+        public ToolPackageObtainTransaction(
+            Func<List<DirectoryPath>, ToolConfigurationAndExecutablePath> obtainAndReturnExecutablePath,
+            Action<List<DirectoryPath>> rollback)
+        {
+            _obtainAndReturnExecutablePath = obtainAndReturnExecutablePath ?? throw new ArgumentNullException(nameof(obtainAndReturnExecutablePath));
+            _rollback = rollback ?? throw new ArgumentNullException(nameof(rollback));
+        }
+
+        public ToolConfigurationAndExecutablePath ObtainAndReturnExecutablePath()
+        {
+            return _obtainAndReturnExecutablePath(_locationOfPackageDuringTransaction);
+        }
+
+        public void Commit(Enlistment enlistment)
+        {
+            enlistment.Done();
+        }
+
+        public void InDoubt(Enlistment enlistment)
+        {
+            Rollback(enlistment);
+        }
+
+        public void Prepare(PreparingEnlistment preparingEnlistment)
+        {
+            preparingEnlistment.Done();
+        }
+
+        public void Rollback(Enlistment enlistment)
+        {
+            _rollback(_locationOfPackageDuringTransaction);
+
+            enlistment.Done();
+        }
+    }
+}