public async Task <string> InstallPackageAsync(PackageId packageId, NuGetVersion packageVersion)
{
var cancellationToken = CancellationToken.None;
var cache = new SourceCacheContext()
{
DirectDownload = true, NoCache = true
};
var source = Repository.Factory.GetCoreV3(sourceUrl);
var findPackageByIdResource = await source.GetResourceAsync <FindPackageByIdResource>();
var nupkgPath = Path.Combine(_packageInstallDir, packageId.ToString(), packageVersion.ToNormalizedString(), $"{packageId}.{packageVersion.ToNormalizedString()}.nupkg");
Directory.CreateDirectory(Path.GetDirectoryName(nupkgPath));
using var destinationStream = File.Create(nupkgPath);
var success = await findPackageByIdResource.CopyNupkgToStreamAsync(
id : packageId.ToString(),
version : packageVersion,
destination : destinationStream,
cacheContext : cache,
logger : _logger,
cancellationToken : cancellationToken);
if (!success)
{
throw new Exception($"Downloading {packageId} version {packageVersion.ToNormalizedString()} failed.");
}
return(nupkgPath);
}
private LoadedAssemblies LoadV3Assemblies(NuGetVersion version)
{
var versioningIdentity = new PackageIdentity(_versioningId, version);
_packageLoader.LoadPackageAssemblies(
version.ToNormalizedString(),
_framework,
versioningIdentity);
var frameworksIdentity = new PackageIdentity(_frameworksId, version);
var context = _packageLoader.LoadPackageAssemblies(
version.ToNormalizedString(),
_framework,
frameworksIdentity);
var versioningAssemblyName = context.LoadedAssemblies.GetByName(_versioningId);
var frameworksAssemblyName = context.LoadedAssemblies.GetByName(_frameworksId);
var loaded = new LoadedAssemblies
{
Context = context,
Framework = frameworksAssemblyName,
Version = versioningAssemblyName,
VersionRange = versioningAssemblyName,
};
return(loaded);
}
public async Task Install(IReadOnlyList <SourceRepository> remoteRepositories, InstalledPackagesCache installedPackages, NuGetPackageManager packageManager)
{
if (_versionMatch == null)
{
return;
}
IReadOnlyList <SourceRepository> sourceRepositories = GetSourceRepositories(remoteRepositories);
using (Trace.WithIndent().Verbose($"Installing package {_packageId} {_versionMatch.ToNormalizedString()}"))
{
// Check if this package was already installed in a previous run
PackageIdentity packageIdentity = new PackageIdentity(_packageId, _versionMatch);
if (installedPackages.VerifyPackage(packageIdentity, packageManager))
{
Trace.Verbose($"Package {_packageId} {_versionMatch.ToNormalizedString()} was already installed");
return;
}
// If not, go ahead and install it
using (installedPackages.AddPackage(packageIdentity, _currentFramework))
{
ResolutionContext resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest, _allowPrereleaseVersions, _allowUnlisted, VersionConstraints.None);
INuGetProjectContext projectContext = new NuGetProjectContext();
await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
packageIdentity, resolutionContext, projectContext,
sourceRepositories, Array.Empty <SourceRepository>(), CancellationToken.None);
Trace.Verbose($"Installed package {_packageId} {_versionMatch.ToNormalizedString()}");
}
}
}
public void WhenRunWithPackageIdItShouldUpdateFromManifestFile()
{
_toolRestoreCommand.Execute();
_mockFeed.Packages[0].Version = _packageNewVersionA.ToNormalizedString();
_defaultToolUpdateLocalCommand.Execute().Should().Be(0);
AssertUpdateSuccess();
}
public VersionForDisplay(
NuGetVersion version,
string additionalInfo)
{
Version = version;
_additionalInfo = additionalInfo;
_toString = string.IsNullOrEmpty(_additionalInfo) ?
Version.ToNormalizedString() :
_additionalInfo + " " + Version.ToNormalizedString();
}
public void WhenRunWithPackageIdItShouldShowSuccessMessage()
{
var toolInstallLocalCommand = GetDefaultTestToolInstallLocalCommand();
toolInstallLocalCommand.Execute().Should().Be(0);
_reporter.Lines[0].Should()
.Contain(
string.Format(LocalizableStrings.LocalToolInstallationSucceeded,
_toolCommandNameA.ToString(),
_packageIdA,
_packageVersionA.ToNormalizedString(),
_manifestFilePath).Green());
}
public void Add(
FilePath to,
PackageId packageId,
NuGetVersion nuGetVersion,
ToolCommandName[] toolCommandNames)
{
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(to);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(deserializedManifest, to, to.GetDirectoryPath());
var existing = toolManifestPackages.Where(t => t.PackageId.Equals(packageId)).ToArray();
if (existing.Any())
{
var existingPackage = existing.Single();
if (existingPackage.PackageId.Equals(packageId) &&
existingPackage.Version == nuGetVersion &&
CommandNamesEqual(existingPackage.CommandNames, toolCommandNames))
{
return;
}
throw new ToolManifestException(string.Format(
LocalizableStrings.ManifestPackageIdCollision,
existingPackage.Version.ToNormalizedString(),
existingPackage.PackageId.ToString(),
to.Value,
nuGetVersion.ToNormalizedString()));
}
if (deserializedManifest.Tools == null)
{
deserializedManifest.Tools = new Dictionary <string, SerializableLocalToolSinglePackage>();
}
deserializedManifest.Tools.Add(
packageId.ToString(),
new SerializableLocalToolSinglePackage
{
Version = nuGetVersion.ToNormalizedString(),
Commands = toolCommandNames.Select(c => c.Value).ToArray()
});
_fileSystem.File.WriteAllText(to.Value, deserializedManifest.ToJson());
}
public void VersionLength(string version)
{
// Arrange & Act
var semVer = new NuGetVersion(version);
Assert.Equal("2.0.0", semVer.ToNormalizedString());
}
private async Task <Stream> GetStreamAsync(
string id,
NuGetVersion version,
Func <string, string, string> pathFunc,
CancellationToken cancellationToken)
{
var lowercasedId = id.ToLowerInvariant();
var lowercasedNormalizedVersion = version.ToNormalizedString().ToLowerInvariant();
var path = pathFunc(lowercasedId, lowercasedNormalizedVersion);
try
{
return(await _storage.GetAsync(path, cancellationToken));
}
catch (DirectoryNotFoundException)
{
// The "packages" prefix was lowercased, which was a breaking change
// on filesystems that are case sensitive. Handle this case to help
// users migrate to the latest version of BaGet.
// See https://github.com/loic-sharma/BaGet/issues/298
_logger.LogError(
$"Unable to find the '{PackagesPathPrefix}' folder. " +
"If you've recently upgraded BaGet, please make sure this folder starts with a lowercased letter. " +
"For more information, please see https://github.com/loic-sharma/BaGet/issues/298");
throw;
}
}
public void TrackHandlerFailedToProcessPackage(IPackagesContainerHandler handler, string packageId, NuGetVersion packageVersion)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
if (string.IsNullOrEmpty(packageId))
{
throw new ArgumentException($"The package id parameter is required", nameof(packageId));
}
if (packageVersion == null)
{
throw new ArgumentNullException(nameof(packageVersion));
}
_telemetryClient.TrackMetric(
TelemetryConstants.HandlerFailedToProcessPackage,
1,
new Dictionary <string, string>
{
{ TelemetryConstants.Handler, handler.GetType().Name },
{ TelemetryConstants.Id, packageId },
{ TelemetryConstants.Version, packageVersion.ToNormalizedString() }
});
}
public void GivenManifestFileWhenAddingTheSamePackageIdToolItThrows()
{
string manifestFile = Path.Combine(_testDirectoryRoot, _manifestFilename);
_fileSystem.File.WriteAllText(manifestFile, _jsonContent);
var toolManifestFileEditor = new ToolManifestEditor(_fileSystem);
PackageId packageId = new PackageId("dotnetsay");
NuGetVersion nuGetVersion = NuGetVersion.Parse("3.0.0");
Action a = () => toolManifestFileEditor.Add(new FilePath(manifestFile),
packageId,
nuGetVersion,
new[] { new ToolCommandName("dotnetsay") });
var expectedString = string.Format(
LocalizableStrings.ManifestPackageIdCollision,
packageId.ToString(),
nuGetVersion.ToNormalizedString(),
manifestFile,
packageId.ToString(),
"2.1.4");
a.ShouldThrow <ToolManifestException>()
.And.Message.Should().Contain(expectedString);
_fileSystem.File.ReadAllText(manifestFile).Should().Be(_jsonContent);
}
protected override void ExecuteCore()
{
NuGetVersion currentPackageVersion = new NuGetVersion(PackageVersion);
NuGetVersion version = null;
foreach (string nugetFeed in NugetFeeds)
{
SourceRepository repository = Repository.Factory.GetCoreV3(nugetFeed);
FindPackageByIdResource resource = repository.GetResource <FindPackageByIdResource>();
SourceCacheContext cache = new SourceCacheContext();
IEnumerable <NuGetVersion> versions = resource.GetAllVersionsAsync(PackageId, cache, NullLogger.Instance, CancellationToken.None).Result;
NuGetVersion packageVersion = versions?.Where(t => !t.IsPrerelease && t != currentPackageVersion).OrderByDescending(t => t.Version).FirstOrDefault();
if (packageVersion != null)
{
if ((version == null || packageVersion > version) && packageVersion.Version < currentPackageVersion.Version)
{
version = packageVersion;
}
}
}
if (version == null)
{
throw new Exception(string.Format(Resources.BaselinePackageNotFound, PackageId, Environment.NewLine + string.Join(Environment.NewLine + " - ", NugetFeeds)));
}
LastStableVersion = version?.ToNormalizedString();
}
public void Edit(
FilePath manifest,
PackageId packageId,
NuGetVersion newNuGetVersion,
ToolCommandName[] newToolCommandNames)
{
SerializableLocalToolsManifest deserializedManifest =
DeserializeLocalToolsManifest(manifest);
List <ToolManifestPackage> toolManifestPackages =
GetToolManifestPackageFromOneManifestFile(deserializedManifest, manifest, manifest.GetDirectoryPath());
var existing = toolManifestPackages.Where(t => t.PackageId.Equals(packageId)).ToArray();
if (existing.Any())
{
var existingPackage = existing.Single();
if (existingPackage.PackageId.Equals(packageId))
{
var toEdit = deserializedManifest.Tools.Single(t => new PackageId(t.PackageId).Equals(packageId));
toEdit.Version = newNuGetVersion.ToNormalizedString();
toEdit.Commands = newToolCommandNames.Select(c => c.Value).ToArray();
}
}
else
{
throw new ArgumentException($"Manifest {manifest.Value} does not contain package id '{packageId}'.");
}
_fileSystem.File.WriteAllText(manifest.Value, deserializedManifest.ToJson());
}
public LocalPackageInfo FindPackage(string packageId, NuGetVersion version)
{
var package = FindPackagesById(packageId)
.FirstOrDefault(localPackage => localPackage.Version == version);
if (package == null)
{
return(null);
}
// Check for an exact match on casing
if (StringComparer.Ordinal.Equals(packageId, package.Id) &&
StringComparer.Ordinal.Equals(version.ToNormalizedString(), package.Version.ToNormalizedString()))
{
return(package);
}
// nuspec
var nuspec = _nuspecCache.GetOrAdd(package.ExpandedPath, new Lazy <NuspecReader>(() => GetNuspec(package.ManifestPath, package.ExpandedPath)));
// Create a new info to match the given id/version
return(new LocalPackageInfo(
packageId,
version,
package.ExpandedPath,
package.ManifestPath,
package.ZipPath,
nuspec));
}
/// <summary>
/// Process RegistrationIndex
/// </summary>
/// <param name="httpSource">Httpsource instance.</param>
/// <param name="rangeUri">Paged registration index url address.</param>
/// <param name="packageId">PackageId for package we're checking.</param>
/// <param name="lower">Lower bound of nuget package.</param>
/// <param name="upper">Upper bound of nuget package.</param>
/// <param name="httpSourceCacheContext">SourceCacheContext for cache.</param>
/// <param name="log">Logger Instance.</param>
/// <param name="token">Cancellation token.</param>
/// <returns></returns>
private Task <RegistrationPage> GetRegistratioIndexPageAsync(
HttpSource httpSource,
string rangeUri,
string packageId,
NuGetVersion lower,
NuGetVersion upper,
HttpSourceCacheContext httpSourceCacheContext,
ILogger log,
CancellationToken token)
{
var packageIdLowerCase = packageId.ToLowerInvariant();
var registrationPage = httpSource.GetAsync(
new HttpSourceCachedRequest(
rangeUri,
$"list_{packageIdLowerCase}_range_{lower.ToNormalizedString()}-{upper.ToNormalizedString()}",
httpSourceCacheContext)
{
IgnoreNotFounds = true,
},
httpSourceResult => DeserializeStreamDataAsync <RegistrationPage>(httpSourceResult.Stream, token),
log,
token);
return(registrationPage);
}
public string GetPackageManifestDownloadUrl(string id, NuGetVersion version)
{
var packageId = id.ToLowerInvariant();
var packageVersion = version.ToNormalizedString().ToLowerInvariant();
return($"https://api.nuget.org/v3-flatcontainer/{packageId}/{packageVersion}/{packageId}.{packageVersion}.nuspec");
}
public async Task <Package> FindOrNullAsync(
string id,
NuGetVersion version,
bool includeUnlisted,
CancellationToken cancellationToken)
{
var operation = TableOperation.Retrieve <PackageEntity>(
id.ToLowerInvariant(),
version.ToNormalizedString().ToLowerInvariant());
var result = await _table.ExecuteAsync(operation, cancellationToken);
var entity = result.Result as PackageEntity;
if (entity == null)
{
return(null);
}
// Filter out the package if it's unlisted.
if (!includeUnlisted && !entity.Listed)
{
return(null);
}
return(AsPackage(entity));
}
private string GetOutputPath(PackageBuilder builder, bool symbols = false, NuGetVersion nugetVersion = null)
{
string version;
if (nugetVersion != null)
{
version = nugetVersion.ToNormalizedString();
}
else
{
version = String.IsNullOrEmpty(_packArgs.Version) ? builder.Version.ToNormalizedString() : _packArgs.Version;
}
// Output file is {id}.{version}
string outputFile = builder.Id + "." + version;
// If this is a source package then add .symbols.nupkg to the package file name
if (symbols)
{
outputFile += SymbolsExtension;
}
else
{
outputFile += NuGetConstants.PackageExtension;
}
string outputDirectory = _packArgs.OutputDirectory ?? _packArgs.CurrentDirectory;
return(Path.Combine(outputDirectory, outputFile));
}
public void VersionLength(string version)
{
// Arrange & Act
var semVer = new NuGetVersion(version);
Assert.Equal("2.0.0", semVer.ToNormalizedString());
}
private Stream GetFileStream(string id, NuGetVersion version, Func <string, string, string> pathFunc)
{
var versionString = version.ToNormalizedString().ToLowerInvariant();
var path = pathFunc(id.ToLowerInvariant(), versionString);
return(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read));
}
public static string PackageRegistration(this IUrlHelper url, string id, NuGetVersion version)
=> url.AbsoluteRouteUrl(
Routes.RegistrationLeafRouteName,
new {
Id = id.ToLowerInvariant(),
Version = version.ToNormalizedString().ToLowerInvariant()
});
public ToolInstallLocalCommandTests()
{
_packageVersionA = NuGetVersion.Parse("1.0.4");
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
_nugetGlobalPackagesFolder = new DirectoryPath(NuGetGlobalPackagesFolder.GetLocation());
_temporaryDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
_pathToPlacePackages = Path.Combine(_temporaryDirectory, "pathToPlacePackage");
ToolPackageStoreMock toolPackageStoreMock =
new ToolPackageStoreMock(new DirectoryPath(_pathToPlacePackages), _fileSystem);
_toolPackageStore = toolPackageStoreMock;
_toolPackageInstallerMock = new ToolPackageInstallerMock(
_fileSystem,
_toolPackageStore,
new ProjectRestorerMock(
_fileSystem,
_reporter,
new[]
{
new MockFeed
{
Type = MockFeedType.ImplicitAdditionalFeed,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageIdA.ToString(),
Version = _packageVersionA.ToNormalizedString(),
ToolCommandName = _toolCommandNameA.ToString()
}
}
}
}));
_localToolsResolverCache
= new LocalToolsResolverCache(
_fileSystem,
new DirectoryPath(Path.Combine(_temporaryDirectory, "cache")),
1);
_manifestFilePath = Path.Combine(_temporaryDirectory, "dotnet-tools.json");
_fileSystem.File.WriteAllText(Path.Combine(_temporaryDirectory, _manifestFilePath), _jsonContent);
_toolManifestFinder = new ToolManifestFinder(new DirectoryPath(_temporaryDirectory), _fileSystem);
_toolManifestEditor = new ToolManifestEditor(_fileSystem);
ParseResult result = Parser.Instance.Parse($"dotnet tool install {_packageIdA.ToString()}");
_appliedCommand = result["dotnet"]["tool"]["install"];
Cli.CommandLine.Parser parser = Parser.Instance;
_parseResult = parser.ParseFrom("dotnet tool", new[] { "install", _packageIdA.ToString() });
_localToolsResolverCache
= new LocalToolsResolverCache(
_fileSystem,
new DirectoryPath(Path.Combine(_temporaryDirectory, "cache")),
1);
}
public ToolRestoreCommandTests()
{
_packageVersionA = NuGetVersion.Parse("1.0.4");
_packageVersionWithCommandNameCollisionWithA = NuGetVersion.Parse("1.0.9");
_packageVersionB = NuGetVersion.Parse("1.0.4");
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
_nugetGlobalPackagesFolder = new DirectoryPath(NuGetGlobalPackagesFolder.GetLocation());
_temporaryDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
_pathToPlacePackages = Path.Combine(_temporaryDirectory, "pathToPlacePackage");
ToolPackageStoreMock toolPackageStoreMock =
new ToolPackageStoreMock(new DirectoryPath(_pathToPlacePackages), _fileSystem);
_toolPackageStore = toolPackageStoreMock;
_toolPackageInstallerMock = new ToolPackageInstallerMock(
_fileSystem,
_toolPackageStore,
new ProjectRestorerMock(
_fileSystem,
_reporter,
new List <MockFeed>
{
new MockFeed
{
Type = MockFeedType.ImplicitAdditionalFeed,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageIdA.ToString(),
Version = _packageVersionA.ToNormalizedString(),
ToolCommandName = _toolCommandNameA.ToString()
},
new MockFeedPackage
{
PackageId = _packageIdB.ToString(),
Version = _packageVersionB.ToNormalizedString(),
ToolCommandName = _toolCommandNameB.ToString()
},
new MockFeedPackage
{
PackageId = _packageIdWithCommandNameCollisionWithA.ToString(),
Version = _packageVersionWithCommandNameCollisionWithA.ToNormalizedString(),
ToolCommandName = "A"
}
}
}
}),
installCallback: () => _installCalledCount++);
_parseResult = Parser.Instance.Parse("dotnet tool restore");
_localToolsResolverCache
= new LocalToolsResolverCache(
_fileSystem,
new DirectoryPath(Path.Combine(_temporaryDirectory, "cache")),
1);
}
public async Task <string> DownloadPackageAsync(PackageId packageId,
NuGetVersion packageVersion = null,
PackageSourceLocation packageSourceLocation = null,
bool includePreview = false,
DirectoryPath?downloadFolder = null)
{
CancellationToken cancellationToken = CancellationToken.None;
if (_restoreActionConfig.Interactive)
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(_verboseLogger,
_restoreActionConfig.Interactive);
}
(var source, var resolvedPackageVersion) = await GetPackageSourceAndVerion(packageId, packageVersion,
packageSourceLocation, includePreview);
FindPackageByIdResource resource = null;
SourceRepository repository = Repository.Factory.GetCoreV3(source);
resource = await repository.GetResourceAsync <FindPackageByIdResource>(cancellationToken)
.ConfigureAwait(false);
if (resource == null)
{
throw new NuGetPackageNotFoundException(
string.Format(LocalizableStrings.FailedToLoadNuGetSource, source.Source));
}
string nupkgPath = downloadFolder == null || !downloadFolder.HasValue
? Path.Combine(_packageInstallDir.Value, packageId.ToString(),
resolvedPackageVersion.ToNormalizedString(),
$"{packageId}.{resolvedPackageVersion.ToNormalizedString()}.nupkg")
: Path.Combine(downloadFolder.Value.Value,
$"{packageId}.{resolvedPackageVersion.ToNormalizedString()}.nupkg");
Directory.CreateDirectory(Path.GetDirectoryName(nupkgPath));
using FileStream destinationStream = File.Create(nupkgPath);
bool success = await resource.CopyNupkgToStreamAsync(
packageId.ToString(),
resolvedPackageVersion,
destinationStream,
_cacheSettings,
_verboseLogger,
cancellationToken);
destinationStream.Close();
if (!success)
{
throw new NuGetPackageInstallerException(
string.Format("Downloading {0} version {1} failed", packageId,
packageVersion.ToNormalizedString()));
}
VerifySigning(nupkgPath);
return(nupkgPath);
}
public string GetRegistrationLeafUrl(string id, NuGetVersion version)
{
var packageMetadataUrl = GetPackageMetadataResourceUrl();
var packageId = id.ToLowerInvariant();
var packageVersion = version.ToNormalizedString().ToLowerInvariant();
return($"{packageMetadataUrl}/{packageId}/{packageVersion}.json");
}
public static Uri GetPackageRegistrationUri(Uri registrationBaseUri, string id, NuGetVersion version)
{
var idFixed = id.ToLowerInvariant();
var versionFixed = version.ToNormalizedString().ToLowerInvariant();
var baseUrl = EnsureNoTrailingSlash(registrationBaseUri);
return(new Uri($"{baseUrl}/{idFixed}/{versionFixed}.json"));
}
public static Uri GetNupkgUri(Uri packageBaseAddress, string id, NuGetVersion version)
{
var idFixed = id.ToLowerInvariant();
var versionFixed = version.ToNormalizedString().ToLowerInvariant();
var baseUrl = EnsureNoTrailingSlash(packageBaseAddress);
return(new Uri($"{baseUrl}/{idFixed}/{versionFixed}/{idFixed}.{versionFixed}.nupkg"));
}
public string GetPackageManifestDownloadUrl(string id, NuGetVersion version)
{
var packageContentUrl = GetPackageContentResourceUrl();
var packageId = id.ToLowerInvariant();
var packageVersion = version.ToNormalizedString().ToLowerInvariant();
return($"{packageContentUrl}/{packageId}/{packageVersion}/{packageId}.nuspec");
}
public async Task <bool> ExistsAsync(string id, NuGetVersion version, CancellationToken cancellationToken)
{
return(await _context
.Packages
.Where(p => p.Id == id)
.Where(p => p.NormalizedVersionString == version.ToNormalizedString())
.AnyAsync(cancellationToken));
}
public override async Task <JObject> GetPackageMetadata(string id, NuGetVersion version)
{
var data = await GetPackageMetadataById(id);
return(data.FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(
p["version"].ToString(),
version.ToNormalizedString())));
}
/// <summary>
/// Gets a URL for reporting package abuse. The URL will not be verified to exist.
/// </summary>
/// <param name="id">The package id (natural casing)</param>
/// <param name="version">The package version</param>
/// <returns>The first URL from the resource, with the URI template applied.</returns>
public Uri GetReportAbuseUrl(string id, NuGetVersion version)
{
var uriString = _uriTemplate
.Replace("{id}", id)
.Replace("{version}", version.ToNormalizedString());
return(new Uri(uriString));
}