tool-path option -- "Session tool" (#8716)

* Change to escape string via XML

* tool-path option -- "Session tool"

From the beginning design, shim and packageInstaller take package location from constructor and don't have assumption anymore. From previous discussion, tool-path will simply change global location to the one user want, and everything else is the same.

However, this "override" need to happen during the call, that means InstallToolCommand will create different shim and packageInstaller object according to the tool-path during the call instead of constructor DI.

* global package location change

* block of leading dot as command name

* Localization of tool-path option

Author: William Lee

src/Microsoft.DotNet.Configurer/CliFolderPathCalculator.cs

@@ -4,25 +4,19 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using NuGet.Common;
 
 namespace Microsoft.DotNet.Configurer
 {
     public class CliFolderPathCalculator
     {
-        // ToolsShimFolderName ToolPackageFolderName cannot be the same
-        // or if the PackageId is the same as CommandName, they will conflict on unix.
-        private const string ToolsShimFolderName = "tools";
-        private const string ToolPackageFolderName = "toolspkgs";
         private const string DotnetProfileDirectoryName = ".dotnet";
+        private const string ToolsShimFolderName = "tools";
 
         public string CliFallbackFolderPath => Environment.GetEnvironmentVariable("DOTNET_CLI_TEST_FALLBACKFOLDER") ??
                                                Path.Combine(new DirectoryInfo(AppContext.BaseDirectory).Parent.FullName, "NuGetFallbackFolder");
-        
         public string ToolsShimPath => Path.Combine(DotnetUserProfileFolderPath, ToolsShimFolderName);
-        public string ToolsPackagePath => Path.Combine(DotnetUserProfileFolderPath, ToolPackageFolderName);
+        public string ToolsPackagePath => ToolPackageFolderPathCalculator.GetToolPackageFolderPath(ToolsShimPath);
         public BashPathUnderHomeDirectory ToolsShimPathInUnix
         {
             get

src/Microsoft.DotNet.Configurer/ToolPackageFolderPathCalculator.cs

@@ -0,0 +1,16 @@
+// 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.IO;
+
+namespace Microsoft.DotNet.Configurer
+{
+    public static class ToolPackageFolderPathCalculator
+    {
+        private const string NestedToolPackageFolderName = ".store";
+        public static string GetToolPackageFolderPath(string toolsShimPath)
+        {
+            return Path.Combine(toolsShimPath, NestedToolPackageFolderName);
+        }
+    }
+}

src/Microsoft.DotNet.InternalAbstractions/DirectoryPath.cs

@@ -34,6 +34,11 @@ public string ToQuotedString()
             return $"\"{Value}\"";
         }
 
+        public string ToXmlEncodeString()
+        {
+            return System.Net.WebUtility.HtmlEncode(Value);
+        }
+
         public override string ToString()
         {
             return ToQuotedString();

src/dotnet/CommonLocalizableStrings.resx

@@ -625,4 +625,7 @@ setx PATH "%PATH%;{0}"
   <data name="ColumnMaxWidthMustBeGreaterThanZero" xml:space="preserve">
     <value>Column maximum width must be greater than zero.</value>
   </data>
+  <data name="ToolSettingsInvalidLeadingDotCommandName" xml:space="preserve">
+    <value>Command '{0}' has a leading dot.</value>
+  </data>
 </root>

src/dotnet/ShellShim/ShellShimRepositoryFactory.cs

@@ -0,0 +1,22 @@
+// 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 Microsoft.DotNet.Configurer;
+using Microsoft.Extensions.EnvironmentAbstractions;
+
+namespace Microsoft.DotNet.ShellShim
+{
+    internal static class ShellShimRepositoryFactory
+    {
+        public static IShellShimRepository CreateShellShimRepository(DirectoryPath? nonGlobalLocation = null)
+        {
+            return new ShellShimRepository(nonGlobalLocation ?? GetShimLocation());
+        }
+
+        private static DirectoryPath GetShimLocation()
+        {
+            var cliFolderPathCalculator = new CliFolderPathCalculator();
+            return new DirectoryPath(cliFolderPathCalculator.ToolsShimPath);
+        }
+    }
+}

src/dotnet/ToolPackage/ToolConfiguration.cs

@@ -27,6 +27,7 @@ public ToolConfiguration(
                         commandName));
             }
 
+            EnsureNoLeadingDot(commandName);
             EnsureNoInvalidFilenameCharacters(commandName);
 
             CommandName = commandName;
@@ -46,6 +47,17 @@ private void EnsureNoInvalidFilenameCharacters(string commandName)
             }
         }
 
+        private void EnsureNoLeadingDot(string commandName)
+        {
+            if (commandName.StartsWith(".", StringComparison.OrdinalIgnoreCase))
+            {
+                throw new ToolConfigurationException(
+                    string.Format(
+                        CommonLocalizableStrings.ToolSettingsInvalidLeadingDotCommandName,
+                        commandName));
+            }
+        }
+
         public string CommandName { get; }
         public string ToolAssemblyEntryPoint { get; }
     }

src/dotnet/ToolPackage/ToolPackageFactory.cs

@@ -0,0 +1,41 @@
+// 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 Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Configurer;
+using Microsoft.DotNet.Tools.Install.Tool;
+using Microsoft.Extensions.EnvironmentAbstractions;
+
+namespace Microsoft.DotNet.ToolPackage
+{
+    internal static class ToolPackageFactory
+    {
+        public static (IToolPackageStore, IToolPackageInstaller) CreateToolPackageStoreAndInstaller(
+            DirectoryPath? nonGlobalLocation = null)
+        {
+            IToolPackageStore toolPackageStore = CreateToolPackageStore(nonGlobalLocation);
+            var toolPackageInstaller = new ToolPackageInstaller(
+                toolPackageStore,
+                new ProjectRestorer(Reporter.Output));
+
+            return (toolPackageStore, toolPackageInstaller);
+        }
+
+        public static IToolPackageStore CreateToolPackageStore(
+            DirectoryPath? nonGlobalLocation = null)
+        {
+            var toolPackageStore =
+                new ToolPackageStore(nonGlobalLocation.HasValue
+                ? new DirectoryPath(ToolPackageFolderPathCalculator.GetToolPackageFolderPath(nonGlobalLocation.Value.Value))
+                : GetPackageLocation());
+
+            return toolPackageStore;
+        }
+
+        private static DirectoryPath GetPackageLocation()
+        {
+            var cliFolderPathCalculator = new CliFolderPathCalculator();
+            return new DirectoryPath(cliFolderPathCalculator.ToolsPackagePath);
+        }
+    }
+}

src/dotnet/commands/dotnet-install/dotnet-install-tool/InstallToolCommand.cs

@@ -17,14 +17,16 @@
 
 namespace Microsoft.DotNet.Tools.Install.Tool
 {
+    internal delegate IShellShimRepository CreateShellShimRepository(DirectoryPath? nonGlobalLocation = null);
+    internal delegate (IToolPackageStore, IToolPackageInstaller) CreateToolPackageStoreAndInstaller(DirectoryPath? nonGlobalLocation = null);
+
     internal class InstallToolCommand : CommandBase
     {
-        private readonly IToolPackageStore _toolPackageStore;
-        private readonly IToolPackageInstaller _toolPackageInstaller;
-        private readonly IShellShimRepository _shellShimRepository;
         private readonly IEnvironmentPathInstruction _environmentPathInstruction;
         private readonly IReporter _reporter;
         private readonly IReporter _errorReporter;
+        private CreateShellShimRepository _createShellShimRepository;
+        private CreateToolPackageStoreAndInstaller _createToolPackageStoreAndInstaller;
 
         private readonly PackageId _packageId;
         private readonly string _packageVersion;
@@ -33,13 +35,13 @@ internal class InstallToolCommand : CommandBase
         private readonly string _source;
         private readonly bool _global;
         private readonly string _verbosity;
+        private readonly string _toolPath;
 
         public InstallToolCommand(
             AppliedOption appliedCommand,
             ParseResult parseResult,
-            IToolPackageStore toolPackageStore = null,
-            IToolPackageInstaller toolPackageInstaller = null,
-            IShellShimRepository shellShimRepository = null,
+            CreateToolPackageStoreAndInstaller createToolPackageStoreAndInstaller = null,
+            CreateShellShimRepository createShellShimRepository = null,
             IEnvironmentPathInstruction environmentPathInstruction = null,
             IReporter reporter = null)
             : base(parseResult)
@@ -56,32 +58,30 @@ public InstallToolCommand(
             _source = appliedCommand.ValueOrDefault<string>("source");
             _global = appliedCommand.ValueOrDefault<bool>("global");
             _verbosity = appliedCommand.SingleArgumentOrDefault("verbosity");
+            _toolPath = appliedCommand.SingleArgumentOrDefault("tool-path");
 
             var cliFolderPathCalculator = new CliFolderPathCalculator();
 
-            _toolPackageStore = toolPackageStore
-                ?? new ToolPackageStore(new DirectoryPath(cliFolderPathCalculator.ToolsPackagePath));
-
-            _toolPackageInstaller = toolPackageInstaller
-                ?? new ToolPackageInstaller(
-                    _toolPackageStore,
-                    new ProjectRestorer(_reporter));
+            _createToolPackageStoreAndInstaller = createToolPackageStoreAndInstaller ?? ToolPackageFactory.CreateToolPackageStoreAndInstaller;
 
             _environmentPathInstruction = environmentPathInstruction
                 ?? EnvironmentPathFactory.CreateEnvironmentPathInstruction();
-
-            _shellShimRepository = shellShimRepository
-                ?? new ShellShimRepository(new DirectoryPath(cliFolderPathCalculator.ToolsShimPath));
+            _createShellShimRepository = createShellShimRepository ?? ShellShimRepositoryFactory.CreateShellShimRepository;
 
             _reporter = (reporter ?? Reporter.Output);
             _errorReporter = (reporter ?? Reporter.Error);
         }
 
         public override int Execute()
         {
-            if (!_global)
+            if (string.IsNullOrWhiteSpace(_toolPath) && !_global)
             {
-                throw new GracefulException(LocalizableStrings.InstallToolCommandOnlySupportGlobal);
+                throw new GracefulException(LocalizableStrings.InstallToolCommandNeedGlobalOrToolPath);
+            }
+
+            if (!string.IsNullOrWhiteSpace(_toolPath) && _global)
+            {
+                throw new GracefulException(LocalizableStrings.InstallToolCommandInvalidGlobalAndToolPath);
             }
 
             if (_configFilePath != null && !File.Exists(_configFilePath))
@@ -92,6 +92,7 @@ public override int Execute()
                         Path.GetFullPath(_configFilePath)));
             }
 
+
             VersionRange versionRange = null;
             if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange))
             {
@@ -101,7 +102,18 @@ public override int Execute()
                         _packageVersion));
             }
 
-            if (_toolPackageStore.EnumeratePackageVersions(_packageId).FirstOrDefault() != null)
+            DirectoryPath? toolPath = null;
+            if (_toolPath != null)
+            {
+                toolPath = new DirectoryPath(_toolPath);
+            }
+
+            (IToolPackageStore toolPackageStore, IToolPackageInstaller toolPackageInstaller) =
+                _createToolPackageStoreAndInstaller(toolPath);
+            IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath);
+
+            // Prevent installation if any version of the package is installed
+            if (toolPackageStore.EnumeratePackageVersions(_packageId).FirstOrDefault() != null)
             {
                 _errorReporter.WriteLine(string.Format(LocalizableStrings.ToolAlreadyInstalled, _packageId).Red());
                 return 1;
@@ -120,7 +132,7 @@ public override int Execute()
                     TransactionScopeOption.Required,
                     TimeSpan.Zero))
                 {
-                    package = _toolPackageInstaller.InstallPackage(
+                    package = toolPackageInstaller.InstallPackage(
                         packageId: _packageId,
                         versionRange: versionRange,
                         targetFramework: _framework,
@@ -130,13 +142,16 @@ public override int Execute()
 
                     foreach (var command in package.Commands)
                     {
-                        _shellShimRepository.CreateShim(command.Executable, command.Name);
+                        shellShimRepository.CreateShim(command.Executable, command.Name);
                     }
 
                     scope.Complete();
                 }
 
-                _environmentPathInstruction.PrintAddPathInstructionIfPathDoesNotExist();
+                if (_global)
+                {
+                    _environmentPathInstruction.PrintAddPathInstructionIfPathDoesNotExist();
+                }
 
                 _reporter.WriteLine(
                     string.Format(

src/dotnet/commands/dotnet-install/dotnet-install-tool/InstallToolCommandParser.cs

@@ -19,6 +19,10 @@ public static Command InstallTool()
                     "-g|--global",
                     LocalizableStrings.GlobalOptionDescription,
                     Accept.NoArguments()),
+                Create.Option(
+                    "--tool-path",
+                    LocalizableStrings.ToolPathDescription,
+                    Accept.ExactlyOneArgument()),
                 Create.Option(
                     "--version",
                     LocalizableStrings.VersionOptionDescription,

src/dotnet/commands/dotnet-install/dotnet-install-tool/LocalizableStrings.resx

@@ -157,9 +157,6 @@ Tool '{1}' (version '{2}') was successfully installed.</value>
   <data name="InstallFullCommandNameLocalized" xml:space="preserve">
     <value>.NET Install Command</value>
   </data>
-  <data name="InstallToolCommandOnlySupportGlobal" xml:space="preserve">
-    <value>The --global switch (-g) is currently required because only user wide tools are supported.</value>
-  </data>
   <data name="InvalidToolConfiguration" xml:space="preserve">
     <value>The settings file in the tool's NuGet package is invalid: {0}</value>
   </data>
@@ -181,4 +178,13 @@ Tool '{1}' (version '{2}') was successfully installed.</value>
   <data name="InvalidNuGetVersionRange" xml:space="preserve">
     <value>Specified version '{0}' is not a valid NuGet version range.</value>
   </data>
-</root>
+  <data name="InstallToolCommandNeedGlobalOrToolPath" xml:space="preserve">
+    <value>Need either global or tool-path provided.</value>
+  </data>
+  <data name="InstallToolCommandInvalidGlobalAndToolPath" xml:space="preserve">
+    <value>Cannot have global and tool-path as opinion at the same time.</value>
+  </data>
+  <data name="ToolPathDescription" xml:space="preserve">
+    <value>Location of shim to access tool</value>
+  </data>
+</root>