public void WhenRunWithPrereleaseAndPackageVersionItShouldSucceed()
{
ParseResult result =
Parser.Instance.Parse($"dotnet tool install {_packageIdA.ToString()} --prerelease");
var installLocalCommand = new ToolInstallLocalCommand(
result,
GetToolToolPackageInstallerWithPreviewInFeed(),
_toolManifestFinder,
_toolManifestEditor,
_localToolsResolverCache,
_reporter);
installLocalCommand.Execute().Should().Be(0);
var manifestPackages = _toolManifestFinder.Find();
manifestPackages.Should().HaveCount(1);
var addedPackage = manifestPackages.Single();
_localToolsResolverCache.TryLoad(new RestoredCommandIdentifier(
addedPackage.PackageId,
new NuGetVersion("2.0.1-preview1"),
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
addedPackage.CommandNames.Single()),
out RestoredCommand restoredCommand
).Should().BeTrue();
_fileSystem.File.Exists(restoredCommand.Executable.Value);
}
private (FilePath, LocalToolsCommandResolver) DefaultSetup(string toolCommand)
{
NuGetVersion packageVersionA = NuGetVersion.Parse("1.0.4");
_fileSystem.File.WriteAllText(Path.Combine(_testDirectoryRoot, ManifestFilename),
_jsonContent.Replace("$TOOLCOMMAND$", toolCommand));
ToolManifestFinder toolManifest =
new ToolManifestFinder(new DirectoryPath(_testDirectoryRoot), _fileSystem, new FakeDangerousFileDetector());
ToolCommandName toolCommandNameA = new ToolCommandName(toolCommand);
FilePath fakeExecutable = _nugetGlobalPackagesFolder.WithFile("fakeExecutable.dll");
_fileSystem.Directory.CreateDirectory(_nugetGlobalPackagesFolder.Value);
_fileSystem.File.CreateEmptyFile(fakeExecutable.Value);
_localToolsResolverCache.Save(
new Dictionary <RestoredCommandIdentifier, RestoredCommand>
{
[new RestoredCommandIdentifier(
new PackageId("local.tool.console.a"),
packageVersionA,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
toolCommandNameA)]
= new RestoredCommand(toolCommandNameA, "dotnet", fakeExecutable)
});
var localToolsCommandResolver = new LocalToolsCommandResolver(
toolManifest,
_localToolsResolverCache,
_fileSystem);
return(fakeExecutable, localToolsCommandResolver);
}
public void WhenRunItCanSaveCommandsToCache()
{
IToolManifestFinder manifestFinder =
new MockManifestFinder(new[]
{
new ToolManifestPackage(_packageIdA, _packageVersionA,
new[] { _toolCommandNameA },
new DirectoryPath(_temporaryDirectory)),
new ToolManifestPackage(_packageIdB, _packageVersionB,
new[] { _toolCommandNameB },
new DirectoryPath(_temporaryDirectory))
});
ToolRestoreCommand toolRestoreCommand = new ToolRestoreCommand(_parseResult,
_toolPackageInstallerMock,
manifestFinder,
_localToolsResolverCache,
_fileSystem,
_reporter
);
toolRestoreCommand.Execute().Should().Be(0);
_localToolsResolverCache.TryLoad(
new RestoredCommandIdentifier(
_packageIdA,
_packageVersionA,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
_toolCommandNameA), out RestoredCommand restoredCommand)
.Should().BeTrue();
_fileSystem.File.Exists(restoredCommand.Executable.Value)
.Should().BeTrue($"Cached command should be found at {restoredCommand.Executable.Value}");
}
private CommandSpec GetPackageCommandSpecUsingMuxer(CommandResolverArguments arguments,
ToolCommandName toolCommandName)
{
if (!_toolManifest.TryFind(toolCommandName, out var toolManifestPackage))
{
return(null);
}
if (_localToolsResolverCache.TryLoad(
new RestoredCommandIdentifier(
toolManifestPackage.PackageId,
toolManifestPackage.Version,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
toolCommandName),
_nugetGlobalPackagesFolder,
out var restoredCommand))
{
if (!_fileSystem.File.Exists(restoredCommand.Executable.Value))
{
throw new GracefulException(string.Format(LocalizableStrings.NeedRunToolRestore,
toolCommandName.ToString()));
}
return(MuxerCommandSpecMaker.CreatePackageCommandSpecUsingMuxer(
restoredCommand.Executable.Value,
arguments.CommandArguments));
}
return(null);
}
public ToolInstallLocalInstaller(
ParseResult parseResult,
IToolPackageInstaller toolPackageInstaller = null)
{
_parseResult = parseResult;
_packageId = new PackageId(parseResult.GetValueForArgument(ToolInstallCommandParser.PackageIdArgument));
_packageVersion = parseResult.GetValueForOption(ToolInstallCommandParser.VersionOption);
_configFilePath = parseResult.GetValueForOption(ToolInstallCommandParser.ConfigOption);
_sources = parseResult.GetValueForOption(ToolInstallCommandParser.AddSourceOption);
_verbosity = Enum.GetName(parseResult.GetValueForOption(ToolInstallCommandParser.VerbosityOption));
if (toolPackageInstaller == null)
{
(IToolPackageStore,
IToolPackageStoreQuery,
IToolPackageInstaller installer)toolPackageStoresAndInstaller
= ToolPackageFactory.CreateToolPackageStoresAndInstaller(
additionalRestoreArguments: parseResult.OptionValuesToBeForwarded(ToolInstallCommandParser.GetCommand()));
_toolPackageInstaller = toolPackageStoresAndInstaller.installer;
}
else
{
_toolPackageInstaller = toolPackageInstaller;
}
TargetFrameworkToInstall = BundledTargetFramework.GetTargetFrameworkMoniker();
}
public IToolPackage InstallPackageToExternalManagedLocation(PackageLocation packageLocation,
PackageId packageId,
VersionRange versionRange = null,
string targetFramework = null,
string verbosity = null)
{
var tempDirectoryForAssetJson = new DirectoryPath(Path.GetTempPath())
.WithSubDirectories(Path.GetRandomFileName());
Directory.CreateDirectory(tempDirectoryForAssetJson.Value);
var tempProject = CreateTempProject(
packageId: packageId,
versionRange: versionRange,
targetFramework: targetFramework ?? BundledTargetFramework.GetTargetFrameworkMoniker(),
assetJsonOutputDirectory: tempDirectoryForAssetJson,
restoreDirectory: null,
rootConfigDirectory: packageLocation.RootConfigDirectory,
additionalFeeds: packageLocation.AdditionalFeeds);
try
{
_projectRestorer.Restore(
tempProject,
packageLocation,
verbosity: verbosity);
}
finally
{
File.Delete(tempProject.Value);
}
return(ToolPackageInstance.CreateFromAssetFile(packageId, tempDirectoryForAssetJson));
}
public void GivenManifestFileConflictItShouldNotAddToCache()
{
_toolManifestEditor.Add(
new FilePath(_manifestFilePath),
_packageIdA,
new NuGetVersion(1, 1, 1),
new[] { _toolCommandNameA });
var toolInstallLocalCommand = GetDefaultTestToolInstallLocalCommand();
Action a = () => toolInstallLocalCommand.Execute();
a.ShouldThrow <GracefulException>();
_localToolsResolverCache.TryLoad(new RestoredCommandIdentifier(
_packageIdA,
_packageVersionA,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
_toolCommandNameA),
_nugetGlobalPackagesFolder,
out RestoredCommand restoredCommand
).Should().BeFalse("it should not add to cache if add to manifest failed. " +
"But restore do not need to 'revert' since it just set in nuget global directory");
}
public ToolInstallLocalInstaller(
AppliedOption appliedOption,
IToolPackageInstaller toolPackageInstaller = null)
{
if (appliedOption == null)
{
throw new ArgumentNullException(nameof(appliedOption));
}
_packageId = new PackageId(appliedOption.Arguments.Single());
_packageVersion = appliedOption.ValueOrDefault <string>("version");
_configFilePath = appliedOption.ValueOrDefault <string>("configfile");
_sources = appliedOption.ValueOrDefault <string[]>("add-source");
_verbosity = appliedOption.SingleArgumentOrDefault("verbosity");
if (toolPackageInstaller == null)
{
(IToolPackageStore,
IToolPackageStoreQuery,
IToolPackageInstaller installer)toolPackageStoresAndInstaller
= ToolPackageFactory.CreateToolPackageStoresAndInstaller(
additionalRestoreArguments: appliedOption.OptionValuesToBeForwarded());
_toolPackageInstaller = toolPackageStoresAndInstaller.installer;
}
else
{
_toolPackageInstaller = toolPackageInstaller;
}
TargetFrameworkToInstall = BundledTargetFramework.GetTargetFrameworkMoniker();
}
public void GivenAllButNoTargetFrameworkItCanDownloadThePackage()
{
var nugetConfigPath = WriteNugetConfigFileToPointToTheFeed();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var packageObtainer =
new ToolPackageObtainer(
new DirectoryPath(toolsPath),
GetUniqueTempProjectPathEachTest,
new Lazy <string>(() => BundledTargetFramework.GetTargetFrameworkMoniker()),
new PackageToProjectFileAdder(),
new ProjectRestorer());
ToolConfigurationAndExecutableDirectory toolConfigurationAndExecutableDirectory =
packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
nugetconfig: nugetConfigPath);
var executable = toolConfigurationAndExecutableDirectory
.ExecutableDirectory
.WithFile(
toolConfigurationAndExecutableDirectory
.Configuration
.ToolAssemblyEntryPoint);
File.Exists(executable.Value)
.Should()
.BeTrue(executable + " should have the executable");
}
private ToolRestoreResult InstallPackages(
ToolManifestPackage package,
FilePath?configFile)
{
string targetFramework = BundledTargetFramework.GetTargetFrameworkMoniker();
if (PackageHasBeenRestored(package, targetFramework))
{
return(ToolRestoreResult.Success(
saveToCache: Array.Empty <(RestoredCommandIdentifier, RestoredCommand)>(),
message: string.Format(
LocalizableStrings.RestoreSuccessful, package.PackageId,
package.Version.ToNormalizedString(), string.Join(", ", package.CommandNames))));
}
try
{
IToolPackage toolPackage =
_toolPackageInstaller.InstallPackageToExternalManagedLocation(
new PackageLocation(
nugetConfig: configFile,
additionalFeeds: _sources,
rootConfigDirectory: package.FirstEffectDirectory),
package.PackageId, ToVersionRangeWithOnlyOneVersion(package.Version), targetFramework,
verbosity: _verbosity);
if (!ManifestCommandMatchesActualInPackage(package.CommandNames, toolPackage.Commands))
{
return(ToolRestoreResult.Failure(
string.Format(LocalizableStrings.CommandsMismatch,
JoinBySpaceWithQuote(package.CommandNames.Select(c => c.Value.ToString())),
package.PackageId,
JoinBySpaceWithQuote(toolPackage.Commands.Select(c => c.Name.ToString())))));
}
return(ToolRestoreResult.Success(
saveToCache: toolPackage.Commands.Select(command => (
new RestoredCommandIdentifier(
toolPackage.Id,
toolPackage.Version,
NuGetFramework.Parse(targetFramework),
Constants.AnyRid,
command.Name),
command)).ToArray(),
message: string.Format(
LocalizableStrings.RestoreSuccessful,
package.PackageId,
package.Version.ToNormalizedString(),
string.Join(" ", package.CommandNames))));
}
catch (ToolPackageException e)
{
return(ToolRestoreResult.Failure(package.PackageId, e));
}
}
public void GivenAllButNoTargetFrameworkItCanDownloadThePackage(bool testMockBehaviorIsInSync)
{
var reporter = new BufferedReporter();
var nugetConfigPath = WriteNugetConfigFileToPointToTheFeed();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
IToolPackageObtainer packageObtainer;
if (testMockBehaviorIsInSync)
{
packageObtainer = new ToolPackageObtainerMock(additionalFeeds:
new List <MockFeed>
{
new MockFeed
{
Type = MockFeedType.ExplicitNugetConfig,
Uri = nugetConfigPath.Value,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = TestPackageId,
Version = "1.0.4"
}
}
}
},
toolsPath: toolsPath);
}
else
{
packageObtainer = new ToolPackageObtainer(
new DirectoryPath(toolsPath),
new DirectoryPath("no such path"),
GetUniqueTempProjectPathEachTest,
new Lazy <string>(() => BundledTargetFramework.GetTargetFrameworkMoniker()),
new ProjectRestorer(reporter));
}
ToolConfigurationAndExecutablePath toolConfigurationAndExecutablePath =
packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
nugetconfig: nugetConfigPath);
reporter.Lines.Should().BeEmpty();
var executable = toolConfigurationAndExecutablePath.Executable;
File.Exists(executable.Value)
.Should()
.BeTrue(executable + " should have the executable");
File.Delete(executable.Value);
}
public void VersionCommandDisplaysCorrectVersion()
{
var filePath = Path.Combine(
AppContext.BaseDirectory,
"ExpectedTargetFrameworkMoniker.txt");
var targetFrameworkMoniker = GetTargetFrameworkMonikerFromFile(filePath);
var shortFolderName = NuGetFramework
.Parse(targetFrameworkMoniker)
.GetShortFolderName();
BundledTargetFramework
.GetTargetFrameworkMoniker()
.Should().Be(shortFolderName);
}
public void ItCanResolveAmbiguityCausedByPrefixDotnetDash()
{
_fileSystem.File.WriteAllText(Path.Combine(_testDirectoryRoot, ManifestFilename),
_jsonContentWithDotnetDash);
ToolManifestFinder toolManifest =
new ToolManifestFinder(new DirectoryPath(_testDirectoryRoot), _fileSystem);
var fakeExecutableA = _nugetGlobalPackagesFolder.WithFile("fakeExecutable-a.dll");
var fakeExecutableDotnetA = _nugetGlobalPackagesFolder.WithFile("fakeExecutable-a.dll");
_fileSystem.Directory.CreateDirectory(_nugetGlobalPackagesFolder.Value);
_fileSystem.File.CreateEmptyFile(fakeExecutableA.Value);
_fileSystem.File.CreateEmptyFile(fakeExecutableDotnetA.Value);
_localToolsResolverCache.Save(
new Dictionary <RestoredCommandIdentifier, RestoredCommand>
{
[new RestoredCommandIdentifier(
new PackageId("local.tool.console.a"),
NuGetVersion.Parse("1.0.4"),
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
new ToolCommandName("a"))]
= new RestoredCommand(new ToolCommandName("a"), "dotnet", fakeExecutableA),
[new RestoredCommandIdentifier(
new PackageId("local.tool.console.dotnet.a"),
NuGetVersion.Parse("1.0.4"),
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
new ToolCommandName("dotnet-a"))]
= new RestoredCommand(new ToolCommandName("dotnet-a"), "dotnet", fakeExecutableDotnetA)
}, _nugetGlobalPackagesFolder);
var localToolsCommandResolver = new LocalToolsCommandResolver(
toolManifest,
_localToolsResolverCache,
_fileSystem,
_nugetGlobalPackagesFolder);
localToolsCommandResolver.Resolve(new CommandResolverArguments()
{
CommandName = "dotnet-a",
}).Args.Trim('"').Should().Be(fakeExecutableA.Value);
localToolsCommandResolver.Resolve(new CommandResolverArguments()
{
CommandName = "dotnet-dotnet-a",
}).Args.Trim('"').Should().Be(fakeExecutableDotnetA.Value);
}
public void WhenManifestPackageAreFromDifferentDirectoryItCanFindTheRightNugetConfigAndSaveToCache()
{
IToolManifestFinder manifestFileFinder =
new MockManifestFileFinder(new[]
{
new ToolManifestPackage(_packageIdA, _packageVersionA,
new[] { _toolCommandNameA },
new DirectoryPath(Path.GetDirectoryName(_nugetConfigUnderTestRoot))),
new ToolManifestPackage(_packageIdB, _packageVersionB,
new[] { _toolCommandNameB },
new DirectoryPath(Path.GetDirectoryName(_nugetConfigUnderSubDir)))
});
ToolRestoreCommand toolRestoreCommand = new ToolRestoreCommand(_appliedCommand,
_parseResult,
_toolPackageInstallerMock,
manifestFileFinder,
_localToolsResolverCache,
_fileSystem,
_nugetGlobalPackagesFolder,
_reporter
);
toolRestoreCommand.Execute().Should()
.Be(0, "if nuget probed from sub dir, it will find only the nuget.config under sub dir. " +
"And it does not have the feed to package A. However, since package A is set in " +
"manifest file under repository root, nuget should prob from manifest file directory " +
"and there is another nuget.config set beside the manifest file under repository root");
_localToolsResolverCache.TryLoad(
new RestoredCommandIdentifier(
_packageIdA,
_packageVersionA,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
_toolCommandNameA), _nugetGlobalPackagesFolder, out RestoredCommand _)
.Should().BeTrue();
_localToolsResolverCache.TryLoad(
new RestoredCommandIdentifier(
_packageIdB,
_packageVersionB,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
_toolCommandNameB), _nugetGlobalPackagesFolder, out RestoredCommand _)
.Should().BeTrue();
}
private void AssertDefaultInstallSuccess()
{
var manifestPackages = _toolManifestFinder.Find();
manifestPackages.Should().HaveCount(1);
var addedPackage = manifestPackages.Single();
_localToolsResolverCache.TryLoad(new RestoredCommandIdentifier(
addedPackage.PackageId,
addedPackage.Version,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
addedPackage.CommandNames.Single()),
out RestoredCommand restoredCommand
).Should().BeTrue();
_fileSystem.File.Exists(restoredCommand.Executable.Value);
}
public void ItCanFindToolExecutable()
{
var toolCommand = "a";
NuGetVersion packageVersionA = NuGetVersion.Parse("1.0.4");
_fileSystem.File.WriteAllText(Path.Combine(_testDirectoryRoot, ManifestFilename),
_jsonContent.Replace("$TOOLCOMMAND$", toolCommand));
ToolManifestFinder toolManifest =
new ToolManifestFinder(new DirectoryPath(_testDirectoryRoot), _fileSystem);
ToolCommandName toolCommandNameA = new ToolCommandName(toolCommand);
var fakeExecutable = _nugetGlobalPackagesFolder.WithFile("fakeExecutable.dll");
_fileSystem.Directory.CreateDirectory(_nugetGlobalPackagesFolder.Value);
_fileSystem.File.CreateEmptyFile(fakeExecutable.Value);
_localToolsResolverCache.Save(
new Dictionary <RestoredCommandIdentifier, RestoredCommand>
{
[new RestoredCommandIdentifier(
new PackageId("local.tool.console.a"),
packageVersionA,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
toolCommandNameA)]
= new RestoredCommand(toolCommandNameA, "dotnet", fakeExecutable)
}, _nugetGlobalPackagesFolder);
var localToolsCommandResolver = new LocalToolsCommandResolver(
toolManifest,
_localToolsResolverCache,
_fileSystem,
_nugetGlobalPackagesFolder);
var result = localToolsCommandResolver.Resolve(new CommandResolverArguments()
{
CommandName = "dotnet-a",
});
result.Should().NotBeNull();
var commandPath = result.Args.Trim('"');
_fileSystem.File.Exists(commandPath).Should().BeTrue("the following path exists: " + commandPath);
commandPath.Should().Be(fakeExecutable.Value);
}
public void WhenNuGetGlobalPackageLocationIsCleanedAfterRestoreItShowError()
{
ToolCommandName toolCommandNameA = new ToolCommandName("a");
NuGetVersion packageVersionA = NuGetVersion.Parse("1.0.4");
_fileSystem.File.WriteAllText(Path.Combine(_testDirectoryRoot, ManifestFilename),
_jsonContent.Replace("$TOOLCOMMAND$", toolCommandNameA.Value));
ToolManifestFinder toolManifest =
new ToolManifestFinder(new DirectoryPath(_testDirectoryRoot), _fileSystem);
var fakeExecutable = _nugetGlobalPackagesFolder.WithFile("fakeExecutable.dll");
_fileSystem.Directory.CreateDirectory(_nugetGlobalPackagesFolder.Value);
_fileSystem.File.CreateEmptyFile(fakeExecutable.Value);
_localToolsResolverCache.Save(
new Dictionary <RestoredCommandIdentifier, RestoredCommand>
{
[new RestoredCommandIdentifier(
new PackageId("local.tool.console.a"),
packageVersionA,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
toolCommandNameA)]
= new RestoredCommand(toolCommandNameA, "dotnet", fakeExecutable)
}, _nugetGlobalPackagesFolder);
var localToolsCommandResolver = new LocalToolsCommandResolver(
toolManifest,
_localToolsResolverCache,
_fileSystem,
_nugetGlobalPackagesFolder);
_fileSystem.File.Delete(fakeExecutable.Value);
Action action = () => localToolsCommandResolver.Resolve(new CommandResolverArguments()
{
CommandName = $"dotnet-{toolCommandNameA.ToString()}",
});
action.ShouldThrow <GracefulException>(string.Format(CommandFactory.LocalizableStrings.NeedRunToolRestore,
toolCommandNameA.ToString()));
}
public void WhenSomePackageFailedToRestoreItCanRestorePartiallySuccessful()
{
IToolManifestFinder manifestFinder =
new MockManifestFinder(new[]
{
new ToolManifestPackage(_packageIdA, _packageVersionA,
new[] { _toolCommandNameA },
new DirectoryPath(_temporaryDirectory)),
new ToolManifestPackage(new PackageId("non-exists"), NuGetVersion.Parse("1.0.0"),
new[] { new ToolCommandName("non-exists") },
new DirectoryPath(_temporaryDirectory))
});
ToolRestoreCommand toolRestoreCommand = new ToolRestoreCommand(_appliedCommand,
_parseResult,
_toolPackageInstallerMock,
manifestFinder,
_localToolsResolverCache,
_fileSystem,
_nugetGlobalPackagesFolder,
_reporter
);
int executeResult = toolRestoreCommand.Execute();
_reporter.Lines.Should()
.Contain(l => l.Contains(string.Format(LocalizableStrings.PackageFailedToRestore,
"non-exists", "")));
_reporter.Lines.Should().Contain(l => l.Contains(LocalizableStrings.RestorePartiallyFailed));
executeResult.Should().Be(1);
_localToolsResolverCache.TryLoad(
new RestoredCommandIdentifier(
_packageIdA,
_packageVersionA,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
_toolCommandNameA), _nugetGlobalPackagesFolder, out _)
.Should().BeTrue("Existing package will succeed despite other package failed");
}
private void AssertUpdateSuccess(FilePath?manifestFile = null, NuGetVersion packageVersion = null)
{
packageVersion ??= _packageNewVersionA;
IReadOnlyCollection <ToolManifestPackage> manifestPackages = _toolManifestFinder.Find(manifestFile);
manifestPackages.Should().HaveCount(1);
ToolManifestPackage addedPackage = manifestPackages.Single();
addedPackage.Version.Should().Be(packageVersion);
_localToolsResolverCache.TryLoad(new RestoredCommandIdentifier(
addedPackage.PackageId,
addedPackage.Version,
NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
Constants.AnyRid,
addedPackage.CommandNames.Single()),
out RestoredCommand restoredCommand
).Should().BeTrue();
_fileSystem.File.Exists(restoredCommand.Executable.Value);
}
public override int Execute()
{
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));
}
FilePath?configFile = null;
if (_configFilePath != null)
{
configFile = new FilePath(_configFilePath);
}
string targetFramework = BundledTargetFramework.GetTargetFrameworkMoniker();
try
{
FilePath manifestFile = GetManifestFilePath();
IToolPackage toolDownloadedPackage =
_toolPackageInstaller.InstallPackageToExternalManagedLocation(
new PackageLocation(
nugetConfig: configFile,
additionalFeeds: _sources,
rootConfigDirectory: manifestFile.GetDirectoryPath()),
_packageId,
versionRange,
targetFramework,
verbosity: _verbosity);
_toolManifestEditor.Add(
manifestFile,
toolDownloadedPackage.Id,
toolDownloadedPackage.Version,
toolDownloadedPackage.Commands.Select(c => c.Name).ToArray());
foreach (var restoredCommand in toolDownloadedPackage.Commands)
{
_localToolsResolverCache.Save(
new Dictionary <RestoredCommandIdentifier, RestoredCommand>
{
[new RestoredCommandIdentifier(
toolDownloadedPackage.Id,
toolDownloadedPackage.Version,
NuGetFramework.Parse(targetFramework),
Constants.AnyRid,
restoredCommand.Name)] =
restoredCommand
});
}
_reporter.WriteLine(
string.Format(
LocalizableStrings.LocalToolInstallationSucceeded,
string.Join(", ", toolDownloadedPackage.Commands.Select(c => c.Name)),
toolDownloadedPackage.Id,
toolDownloadedPackage.Version.ToNormalizedString(),
manifestFile.Value).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 IToolPackage InstallPackage(
string packageId,
string packageVersion = null,
string targetFramework = null,
FilePath?nugetConfig = null,
string source = null,
string verbosity = null)
{
if (packageId == null)
{
throw new ArgumentNullException(nameof(packageId));
}
var packageRootDirectory = _store.Root.WithSubDirectories(packageId);
string rollbackDirectory = null;
return(TransactionalAction.Run <IToolPackage>(
action: () => {
try
{
var stageDirectory = _store.Root.WithSubDirectories(StagingDirectory, Path.GetRandomFileName());
Directory.CreateDirectory(stageDirectory.Value);
rollbackDirectory = stageDirectory.Value;
var tempProject = CreateTempProject(
packageId: packageId,
packageVersion: packageVersion,
targetFramework: targetFramework ?? BundledTargetFramework.GetTargetFrameworkMoniker(),
restoreDirectory: stageDirectory);
try
{
_projectRestorer.Restore(
tempProject,
stageDirectory,
nugetConfig,
source,
verbosity);
}
finally
{
File.Delete(tempProject.Value);
}
packageVersion = Path.GetFileName(
Directory.EnumerateDirectories(
stageDirectory.WithSubDirectories(packageId).Value).Single());
var packageDirectory = packageRootDirectory.WithSubDirectories(packageVersion);
if (Directory.Exists(packageDirectory.Value))
{
throw new ToolPackageException(
string.Format(
CommonLocalizableStrings.ToolPackageConflictPackageId,
packageId,
packageVersion));
}
Directory.CreateDirectory(packageRootDirectory.Value);
Directory.Move(stageDirectory.Value, packageDirectory.Value);
rollbackDirectory = packageDirectory.Value;
return new ToolPackageInstance(
_store,
packageId,
packageVersion,
packageDirectory);
}
catch (Exception ex) when(ex is UnauthorizedAccessException || ex is IOException)
{
throw new ToolPackageException(
string.Format(
CommonLocalizableStrings.FailedToInstallToolPackage,
packageId,
ex.Message),
ex);
}
},
rollback: () => {
if (!string.IsNullOrEmpty(rollbackDirectory) && Directory.Exists(rollbackDirectory))
{
Directory.Delete(rollbackDirectory, true);
}
// Delete the root if it is empty
if (Directory.Exists(packageRootDirectory.Value) &&
!Directory.EnumerateFileSystemEntries(packageRootDirectory.Value).Any())
{
Directory.Delete(packageRootDirectory.Value, false);
}
}));
}
public override int Execute()
{
FilePath?customManifestFileLocation = GetCustomManifestFileLocation();
FilePath?configFile = null;
if (_configFilePath != null)
{
configFile = new FilePath(_configFilePath);
}
IReadOnlyCollection <ToolManifestPackage> packagesFromManifest;
try
{
packagesFromManifest = _toolManifestFinder.Find(customManifestFileLocation);
}
catch (ToolManifestCannotBeFoundException e)
{
_reporter.WriteLine(e.Message.Yellow());
return(0);
}
Dictionary <RestoredCommandIdentifier, RestoredCommand> dictionary =
new Dictionary <RestoredCommandIdentifier, RestoredCommand>();
Dictionary <PackageId, ToolPackageException> toolPackageExceptions =
new Dictionary <PackageId, ToolPackageException>();
List <string> errorMessages = new List <string>();
List <string> successMessages = new List <string>();
foreach (var package in packagesFromManifest)
{
string targetFramework = BundledTargetFramework.GetTargetFrameworkMoniker();
if (PackageHasBeenRestored(package, targetFramework))
{
successMessages.Add(string.Format(
LocalizableStrings.RestoreSuccessful, package.PackageId,
package.Version.ToNormalizedString(), string.Join(", ", package.CommandNames)));
continue;
}
try
{
IToolPackage toolPackage =
_toolPackageInstaller.InstallPackageToExternalManagedLocation(
new PackageLocation(
nugetConfig: configFile,
additionalFeeds: _sources,
rootConfigDirectory: package.FirstEffectDirectory),
package.PackageId, ToVersionRangeWithOnlyOneVersion(package.Version), targetFramework,
verbosity: _verbosity);
if (!ManifestCommandMatchesActualInPackage(package.CommandNames, toolPackage.Commands))
{
errorMessages.Add(
string.Format(LocalizableStrings.CommandsMismatch,
JoinBySpaceWithQuote(package.CommandNames.Select(c => c.Value.ToString())),
package.PackageId,
JoinBySpaceWithQuote(toolPackage.Commands.Select(c => c.Name.ToString()))));
}
foreach (RestoredCommand command in toolPackage.Commands)
{
dictionary.Add(
new RestoredCommandIdentifier(
toolPackage.Id,
toolPackage.Version,
NuGetFramework.Parse(targetFramework),
Constants.AnyRid,
command.Name),
command);
}
successMessages.Add(string.Format(
LocalizableStrings.RestoreSuccessful, package.PackageId,
package.Version.ToNormalizedString(), string.Join(" ", package.CommandNames)));
}
catch (ToolPackageException e)
{
toolPackageExceptions.Add(package.PackageId, e);
}
}
EnsureNoCommandNameCollision(dictionary);
_localToolsResolverCache.Save(dictionary, _nugetGlobalPackagesFolder);
return(PrintConclusionAndReturn(dictionary.Count() > 0, toolPackageExceptions, errorMessages, successMessages));
}
public IToolPackage InstallPackage(
PackageLocation packageLocation,
PackageId packageId,
VersionRange versionRange = null,
string targetFramework = null,
string verbosity = null)
{
var packageRootDirectory = _store.GetRootPackageDirectory(packageId);
string rollbackDirectory = null;
return(TransactionalAction.Run <IToolPackage>(
action: () => {
try
{
var stageDirectory = _store.GetRandomStagingDirectory();
Directory.CreateDirectory(stageDirectory.Value);
rollbackDirectory = stageDirectory.Value;
var tempProject = CreateTempProject(
packageId: packageId,
versionRange: versionRange,
targetFramework: targetFramework ?? BundledTargetFramework.GetTargetFrameworkMoniker(),
restoreDirectory: stageDirectory,
assetJsonOutputDirectory: stageDirectory,
rootConfigDirectory: packageLocation.RootConfigDirectory,
additionalFeeds: packageLocation.AdditionalFeeds);
try
{
_projectRestorer.Restore(
tempProject,
packageLocation,
verbosity: verbosity);
}
finally
{
File.Delete(tempProject.Value);
}
var version = _store.GetStagedPackageVersion(stageDirectory, packageId);
var packageDirectory = _store.GetPackageDirectory(packageId, version);
if (Directory.Exists(packageDirectory.Value))
{
throw new ToolPackageException(
string.Format(
CommonLocalizableStrings.ToolPackageConflictPackageId,
packageId,
version.ToNormalizedString()));
}
Directory.CreateDirectory(packageRootDirectory.Value);
FileAccessRetrier.RetryOnMoveAccessFailure(() => Directory.Move(stageDirectory.Value, packageDirectory.Value));
rollbackDirectory = packageDirectory.Value;
return new ToolPackageInstance(packageId, version, packageDirectory);
}
catch (Exception ex) when(ex is UnauthorizedAccessException || ex is IOException)
{
throw new ToolPackageException(
string.Format(
CommonLocalizableStrings.FailedToInstallToolPackage,
packageId,
ex.Message),
ex);
}
},
rollback: () => {
if (!string.IsNullOrEmpty(rollbackDirectory) && Directory.Exists(rollbackDirectory))
{
Directory.Delete(rollbackDirectory, true);
}
// Delete the root if it is empty
if (Directory.Exists(packageRootDirectory.Value) &&
!Directory.EnumerateFileSystemEntries(packageRootDirectory.Value).Any())
{
Directory.Delete(packageRootDirectory.Value, false);
}
}));
}
public override int Execute()
{
FilePath?customManifestFileLocation = GetCustomManifestFileLocation();
FilePath?configFile = null;
if (_configFilePath != null)
{
configFile = new FilePath(_configFilePath);
}
IReadOnlyCollection <ToolManifestPackage> packagesFromManifest;
try
{
packagesFromManifest = _toolManifestFinder.Find(customManifestFileLocation);
}
catch (ToolManifestCannotFindException e)
{
_reporter.WriteLine(e.Message.Yellow());
return(0);
}
Dictionary <RestoredCommandIdentifier, RestoredCommand> dictionary =
new Dictionary <RestoredCommandIdentifier, RestoredCommand>();
Dictionary <PackageId, ToolPackageException> toolPackageExceptions =
new Dictionary <PackageId, ToolPackageException>();
List <string> errorMessages = new List <string>();
foreach (var package in packagesFromManifest)
{
string targetFramework = BundledTargetFramework.GetTargetFrameworkMoniker();
try
{
IToolPackage toolPackage =
_toolPackageInstaller.InstallPackageToExternalManagedLocation(
new PackageLocation(
nugetConfig: configFile,
additionalFeeds: _sources),
package.PackageId, ToVersionRangeWithOnlyOneVersion(package.Version), targetFramework,
verbosity: _verbosity);
if (!ManifestCommandMatchesActualInPackage(package.CommandNames, toolPackage.Commands))
{
errorMessages.Add(
string.Format(LocalizableStrings.CommandsMismatch,
package.PackageId,
JoinBySpaceWithQuote(toolPackage.Commands.Select(c => c.Name.ToString())),
JoinBySpaceWithQuote(package.CommandNames.Select(c => c.Value.ToString()))));
}
foreach (RestoredCommand command in toolPackage.Commands)
{
dictionary.Add(
new RestoredCommandIdentifier(
toolPackage.Id,
toolPackage.Version,
NuGetFramework.Parse(targetFramework),
"any",
command.Name),
command);
}
}
catch (ToolPackageException e)
{
toolPackageExceptions.Add(package.PackageId, e);
}
}
EnsureNoCommandNameCollision(dictionary);
_localToolsResolverCache.Save(dictionary, _nugetGlobalPackagesFolder);
if (toolPackageExceptions.Any() || errorMessages.Any())
{
var partialOrTotalFailed = dictionary.Count() > 0
? LocalizableStrings.RestorePartiallySuccessful
: LocalizableStrings.RestoreFailed;
_errorReporter.WriteLine(partialOrTotalFailed +
Environment.NewLine +
string.Join(
Environment.NewLine,
CreateErrorMessage(toolPackageExceptions).Concat(errorMessages)));
return(1);
}
return(0);
}
