public override int Execute()
{
ValidateArguments();
DirectoryPath?toolPath = null;
if (_toolPath != null)
{
toolPath = new DirectoryPath(_toolPath);
}
(IToolPackageStore toolPackageStore,
IToolPackageStoreQuery toolPackageStoreQuery,
IToolPackageInstaller toolPackageInstaller,
IToolPackageUninstaller toolPackageUninstaller) = _createToolPackageStoreInstallerUninstaller(toolPath, _forwardRestoreArguments);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath);
IToolPackage oldPackageNullable = GetOldPackage(toolPackageStoreQuery);
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
if (oldPackageNullable != null)
{
RunWithHandlingUninstallError(() =>
{
foreach (RestoredCommand command in oldPackageNullable.Commands)
{
shellShimRepository.RemoveShim(command.Name);
}
toolPackageUninstaller.Uninstall(oldPackageNullable.PackageDirectory);
});
}
RunWithHandlingInstallError(() =>
{
IToolPackage newInstalledPackage = toolPackageInstaller.InstallPackage(
new PackageLocation(nugetConfig: GetConfigFile(), additionalFeeds: _additionalFeeds),
packageId: _packageId,
targetFramework: _framework,
verbosity: _verbosity);
foreach (RestoredCommand command in newInstalledPackage.Commands)
{
shellShimRepository.CreateShim(command.Executable, command.Name);
}
PrintSuccessMessage(oldPackageNullable, newInstalledPackage);
});
scope.Complete();
}
return(0);
}
public UninstallToolCommand(
AppliedOption options,
ParseResult result,
IToolPackageStore toolPackageStore = null,
IShellShimRepository shellShimRepository = null,
IReporter reporter = null)
: base(result)
{
var pathCalculator = new CliFolderPathCalculator();
_options = options ?? throw new ArgumentNullException(nameof(options));
_toolPackageStore = toolPackageStore ?? new ToolPackageStore(
new DirectoryPath(pathCalculator.ToolsPackagePath));
_shellShimRepository = shellShimRepository ?? new ShellShimRepository(
new DirectoryPath(pathCalculator.ToolsShimPath));
_reporter = reporter ?? Reporter.Output;
_errorReporter = reporter ?? Reporter.Error;
}
public InstallToolCommand(
AppliedOption appliedCommand,
ParseResult parseResult,
IToolPackageStore toolPackageStore = null,
IToolPackageInstaller toolPackageInstaller = null,
IShellShimRepository shellShimRepository = null,
IEnvironmentPathInstruction environmentPathInstruction = null,
IReporter reporter = null)
: base(parseResult)
{
if (appliedCommand == null)
{
throw new ArgumentNullException(nameof(appliedCommand));
}
_packageId = new PackageId(appliedCommand.Arguments.Single());
_packageVersion = appliedCommand.ValueOrDefault <string>("version");
_configFilePath = appliedCommand.ValueOrDefault <string>("configfile");
_framework = appliedCommand.ValueOrDefault <string>("framework");
_source = appliedCommand.ValueOrDefault <string>("source");
_global = appliedCommand.ValueOrDefault <bool>("global");
_verbosity = appliedCommand.SingleArgumentOrDefault("verbosity");
var cliFolderPathCalculator = new CliFolderPathCalculator();
_toolPackageStore = toolPackageStore
?? new ToolPackageStore(new DirectoryPath(cliFolderPathCalculator.ToolsPackagePath));
_toolPackageInstaller = toolPackageInstaller
?? new ToolPackageInstaller(
_toolPackageStore,
new ProjectRestorer(_reporter));
_environmentPathInstruction = environmentPathInstruction
?? EnvironmentPathFactory.CreateEnvironmentPathInstruction();
_shellShimRepository = shellShimRepository
?? new ShellShimRepository(new DirectoryPath(cliFolderPathCalculator.ToolsShimPath));
_reporter = (reporter ?? Reporter.Output);
_errorReporter = (reporter ?? Reporter.Error);
}
public override int Execute()
{
var global = _options.ValueOrDefault <bool>("global");
var toolPath = _options.SingleArgumentOrDefault("tool-path");
if (string.IsNullOrWhiteSpace(toolPath) && !global)
{
throw new GracefulException(LocalizableStrings.UninstallToolCommandNeedGlobalOrToolPath);
}
if (!string.IsNullOrWhiteSpace(toolPath) && global)
{
throw new GracefulException(LocalizableStrings.UninstallToolCommandInvalidGlobalAndToolPath);
}
DirectoryPath?toolDirectoryPath = null;
if (!string.IsNullOrWhiteSpace(toolPath))
{
toolDirectoryPath = new DirectoryPath(toolPath);
}
IToolPackageStore toolPackageStore = _createToolPackageStoreAndInstaller(toolDirectoryPath);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolDirectoryPath);
var packageId = new PackageId(_options.Arguments.Single());
IToolPackage package = null;
try
{
package = toolPackageStore.EnumeratePackageVersions(packageId).SingleOrDefault();
if (package == null)
{
throw new GracefulException(
messages: new[]
{
string.Format(
LocalizableStrings.ToolNotInstalled,
packageId),
},
isUserError: false);
}
}
catch (InvalidOperationException)
{
throw new GracefulException(
messages: new[]
{
string.Format(
LocalizableStrings.ToolHasMultipleVersionsInstalled,
packageId),
},
isUserError: false);
}
try
{
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
foreach (var command in package.Commands)
{
shellShimRepository.RemoveShim(command.Name);
}
package.Uninstall();
scope.Complete();
}
_reporter.WriteLine(
string.Format(
LocalizableStrings.UninstallSucceeded,
package.Id,
package.Version.ToNormalizedString()).Green());
return(0);
}
catch (ToolPackageException ex)
{
throw new GracefulException(
messages: new[]
{
ex.Message
},
verboseMessages: new[] { ex.ToString() },
isUserError: false);
}
catch (Exception ex) when(ex is ToolConfigurationException || ex is ShellShimException)
{
throw new GracefulException(
messages: new[]
{
string.Format(
LocalizableStrings.FailedToUninstallTool,
packageId,
ex.Message)
},
verboseMessages: new[] { ex.ToString() },
isUserError: false);
}
}
public override int Execute()
{
if (string.IsNullOrWhiteSpace(_toolPath) && !_global)
{
throw new GracefulException(LocalizableStrings.InstallToolCommandNeedGlobalOrToolPath);
}
if (!string.IsNullOrWhiteSpace(_toolPath) && _global)
{
throw new GracefulException(LocalizableStrings.InstallToolCommandInvalidGlobalAndToolPath);
}
if (_configFilePath != null && !File.Exists(_configFilePath))
{
throw new GracefulException(
string.Format(
LocalizableStrings.NuGetConfigurationFileDoesNotExist,
Path.GetFullPath(_configFilePath)));
}
VersionRange versionRange = null;
if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange))
{
throw new GracefulException(
string.Format(
LocalizableStrings.InvalidNuGetVersionRange,
_packageVersion));
}
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);
}
FilePath?configFile = null;
if (_configFilePath != null)
{
configFile = new FilePath(_configFilePath);
}
try
{
IToolPackage package = null;
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
package = toolPackageInstaller.InstallPackage(
packageId: _packageId,
versionRange: versionRange,
targetFramework: _framework,
nugetConfig: configFile,
additionalFeeds: _source,
verbosity: _verbosity);
foreach (var command in package.Commands)
{
shellShimRepository.CreateShim(command.Executable, command.Name, package.PackagedShims);
}
scope.Complete();
}
foreach (string w in package.Warnings)
{
_reporter.WriteLine(w.Yellow());
}
if (_global)
{
_environmentPathInstruction.PrintAddPathInstructionIfPathDoesNotExist();
}
_reporter.WriteLine(
string.Format(
LocalizableStrings.InstallationSucceeded,
string.Join(", ", package.Commands.Select(c => c.Name)),
package.Id,
package.Version.ToNormalizedString()).Green());
return(0);
}
catch (Exception ex) when(InstallToolCommandLowLevelErrorConverter.ShouldConvertToUserFacingError(ex))
{
throw new GracefulException(
messages: InstallToolCommandLowLevelErrorConverter.GetUserFacingMessages(ex, _packageId),
verboseMessages: new[] { ex.ToString() },
isUserError: false);
}
}
public override int Execute()
{
ValidateArguments();
DirectoryPath?toolPath = null;
if (_toolPath != null)
{
toolPath = new DirectoryPath(_toolPath);
}
(IToolPackageStore toolPackageStore, IToolPackageInstaller toolPackageInstaller) =
_createToolPackageStoreAndInstaller(toolPath);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath);
IToolPackage oldPackage;
try
{
oldPackage = toolPackageStore.EnumeratePackageVersions(_packageId).SingleOrDefault();
if (oldPackage == null)
{
throw new GracefulException(
messages: new[]
{
string.Format(
LocalizableStrings.ToolNotInstalled,
_packageId),
},
isUserError: false);
}
}
catch (InvalidOperationException)
{
throw new GracefulException(
messages: new[]
{
string.Format(
LocalizableStrings.ToolHasMultipleVersionsInstalled,
_packageId),
},
isUserError: false);
}
FilePath?configFile = null;
if (_configFilePath != null)
{
configFile = new FilePath(_configFilePath);
}
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
RunWithHandlingUninstallError(() =>
{
foreach (CommandSettings command in oldPackage.Commands)
{
shellShimRepository.RemoveShim(command.Name);
}
oldPackage.Uninstall();
});
RunWithHandlingInstallError(() =>
{
IToolPackage newInstalledPackage = toolPackageInstaller.InstallPackage(
packageId: _packageId,
targetFramework: _framework,
nugetConfig: configFile,
source: _source,
verbosity: _verbosity);
foreach (CommandSettings command in newInstalledPackage.Commands)
{
shellShimRepository.CreateShim(command.Executable, command.Name);
}
PrintSuccessMessage(oldPackage, newInstalledPackage);
});
scope.Complete();
}
return(0);
}
public override int Execute()
{
ValidateArguments();
DirectoryPath?toolPath = null;
if (!string.IsNullOrEmpty(_toolPath))
{
toolPath = new DirectoryPath(_toolPath);
}
VersionRange versionRange = null;
if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange))
{
throw new GracefulException(
string.Format(
LocalizableStrings.InvalidNuGetVersionRange,
_packageVersion));
}
(IToolPackageStore toolPackageStore,
IToolPackageStoreQuery toolPackageStoreQuery,
IToolPackageInstaller toolPackageInstaller,
IToolPackageUninstaller toolPackageUninstaller) = _createToolPackageStoreInstallerUninstaller(toolPath, _forwardRestoreArguments);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath);
IToolPackage oldPackageNullable = GetOldPackage(toolPackageStoreQuery);
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
if (oldPackageNullable != null)
{
RunWithHandlingUninstallError(() =>
{
foreach (RestoredCommand command in oldPackageNullable.Commands)
{
shellShimRepository.RemoveShim(command.Name);
}
toolPackageUninstaller.Uninstall(oldPackageNullable.PackageDirectory);
});
}
RunWithHandlingInstallError(() =>
{
IToolPackage newInstalledPackage = toolPackageInstaller.InstallPackage(
new PackageLocation(nugetConfig: GetConfigFile(), additionalFeeds: _additionalFeeds),
packageId: _packageId,
targetFramework: _framework,
versionRange: versionRange,
verbosity: _verbosity);
EnsureVersionIsHigher(oldPackageNullable, newInstalledPackage);
foreach (RestoredCommand command in newInstalledPackage.Commands)
{
shellShimRepository.CreateShim(command.Executable, command.Name);
}
PrintSuccessMessage(oldPackageNullable, newInstalledPackage);
});
scope.Complete();
}
return(0);
}
public override int Execute()
{
var global = _parseResult.ValueForOption <bool>(ToolAppliedOption.GlobalOptionAliases.First());
var toolPath = _parseResult.ValueForOption <string>(ToolAppliedOption.ToolPathOptionAlias);
DirectoryPath?toolDirectoryPath = null;
if (!string.IsNullOrWhiteSpace(toolPath))
{
if (!Directory.Exists(toolPath))
{
throw new GracefulException(
string.Format(
LocalizableStrings.InvalidToolPathOption,
toolPath));
}
toolDirectoryPath = new DirectoryPath(toolPath);
}
(IToolPackageStore toolPackageStore, IToolPackageStoreQuery toolPackageStoreQuery, IToolPackageUninstaller toolPackageUninstaller)
= _createToolPackageStoresAndUninstaller(toolDirectoryPath);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolDirectoryPath);
var packageId = new PackageId(_parseResult.ValueForArgument <string>(ToolInstallCommandParser.PackageIdArgument));
IToolPackage package = null;
try
{
package = toolPackageStoreQuery.EnumeratePackageVersions(packageId).SingleOrDefault();
if (package == null)
{
throw new GracefulException(
messages: new[]
{
string.Format(
LocalizableStrings.ToolNotInstalled,
packageId),
},
isUserError: false);
}
}
catch (InvalidOperationException)
{
throw new GracefulException(
messages: new[]
{
string.Format(
LocalizableStrings.ToolHasMultipleVersionsInstalled,
packageId),
},
isUserError: false);
}
try
{
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
foreach (var command in package.Commands)
{
shellShimRepository.RemoveShim(command.Name);
}
toolPackageUninstaller.Uninstall(package.PackageDirectory);
scope.Complete();
}
_reporter.WriteLine(
string.Format(
LocalizableStrings.UninstallSucceeded,
package.Id,
package.Version.ToNormalizedString()).Green());
return(0);
}
catch (Exception ex) when(ToolUninstallCommandLowLevelErrorConverter.ShouldConvertToUserFacingError(ex))
{
throw new GracefulException(
messages: ToolUninstallCommandLowLevelErrorConverter.GetUserFacingMessages(ex, packageId),
verboseMessages: new[] { ex.ToString() },
isUserError: false);
}
}
public override int Execute()
{
if (!string.IsNullOrEmpty(_configFilePath) && !File.Exists(_configFilePath))
{
throw new GracefulException(
string.Format(
LocalizableStrings.NuGetConfigurationFileDoesNotExist,
Path.GetFullPath(_configFilePath)));
}
VersionRange versionRange = _parseResult.GetVersionRange();
DirectoryPath?toolPath = null;
if (!string.IsNullOrEmpty(_toolPath))
{
toolPath = new DirectoryPath(_toolPath);
}
(IToolPackageStore toolPackageStore, IToolPackageStoreQuery toolPackageStoreQuery, IToolPackageInstaller toolPackageInstaller) =
_createToolPackageStoresAndInstaller(toolPath, _forwardRestoreArguments);
// Prevent installation if any version of the package is installed
if (toolPackageStoreQuery.EnumeratePackageVersions(_packageId).FirstOrDefault() != null)
{
_errorReporter.WriteLine(string.Format(LocalizableStrings.ToolAlreadyInstalled, _packageId).Red());
return(1);
}
FilePath?configFile = null;
if (!string.IsNullOrEmpty(_configFilePath))
{
configFile = new FilePath(_configFilePath);
}
try
{
IToolPackage package = null;
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
package = toolPackageInstaller.InstallPackage(
new PackageLocation(nugetConfig: configFile, additionalFeeds: _source),
packageId: _packageId,
versionRange: versionRange,
targetFramework: _framework, verbosity: _verbosity);
NuGetFramework framework;
if (string.IsNullOrEmpty(_framework) && package.Frameworks.Count() > 0)
{
framework = package.Frameworks
.Where(f => f.Version < (new NuGetVersion(Product.Version)).Version)
.MaxBy(f => f.Version);
}
else
{
framework = string.IsNullOrEmpty(_framework) ?
null :
NuGetFramework.Parse(_framework);
}
string appHostSourceDirectory = _shellShimTemplateFinder.ResolveAppHostSourceDirectoryAsync(_architectureOption, framework, RuntimeInformation.ProcessArchitecture).Result;
IShellShimRepository shellShimRepository = _createShellShimRepository(appHostSourceDirectory, toolPath);
foreach (var command in package.Commands)
{
shellShimRepository.CreateShim(command.Executable, command.Name, package.PackagedShims);
}
scope.Complete();
}
foreach (string w in package.Warnings)
{
_reporter.WriteLine(w.Yellow());
}
if (_global)
{
_environmentPathInstruction.PrintAddPathInstructionIfPathDoesNotExist();
}
_reporter.WriteLine(
string.Format(
LocalizableStrings.InstallationSucceeded,
string.Join(", ", package.Commands.Select(c => c.Name)),
package.Id,
package.Version.ToNormalizedString()).Green());
return(0);
}
catch (Exception ex) when(InstallToolCommandLowLevelErrorConverter.ShouldConvertToUserFacingError(ex))
{
throw new GracefulException(
messages: InstallToolCommandLowLevelErrorConverter.GetUserFacingMessages(ex, _packageId),
verboseMessages: new[] { ex.ToString() },
isUserError: false);
}
}
