private static List <VersionInfo> GetVersions(
FindLocalPackagesResource localResource,
LocalPackageInfo package,
SearchFilter filter,
ILogger log,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
// apply the filters to the version list returned
var versions = localResource.FindPackagesById(package.Identity.Id, log, token)
.Where(v => filter.IncludePrerelease || !v.Identity.Version.IsPrerelease)
.Select(p => new VersionInfo(p.Identity.Version, downloadCount: 0))
.OrderByDescending(v => v.Version, VersionComparer.Default)
.ToList();
// Add in the current package if it does not already exist
if (!versions.Any(v => v.Version == package.Identity.Version))
{
var packageVersionInfo = new VersionInfo(package.Identity.Version, downloadCount: 0)
{
PackageSearchMetadata = new LocalPackageSearchMetadata(package)
};
versions.Add(packageVersionInfo);
}
return(versions);
}
public override Task <DownloadResourceResult> GetDownloadResourceResultAsync(
PackageIdentity identity,
ISettings settings,
ILogger logger,
CancellationToken token)
{
// Find the package from the local folder
LocalPackageInfo packageInfo = null;
var sourcePackage = identity as SourcePackageDependencyInfo;
if (sourcePackage?.DownloadUri != null)
{
// Get the package directly if the full path is known
packageInfo = _localResource.GetPackage(sourcePackage.DownloadUri, logger, token);
}
else
{
// Search for the local package
packageInfo = _localResource.GetPackage(identity, logger, token);
}
if (packageInfo != null)
{
var stream = File.OpenRead(packageInfo.Path);
return(Task.FromResult(new DownloadResourceResult(stream, packageInfo.GetReader())));
}
else
{
return(Task.FromResult(new DownloadResourceResult(DownloadResourceResultStatus.NotFound)));
}
}
/// <summary>
/// Retrieve all packages of an id from a v2 folder.
/// </summary>
/// <param name="root">Nupkg folder directory path.</param>
/// <param name="identity">Package id and version.</param>
public static LocalPackageInfo GetPackageV2(string root, PackageIdentity identity, ILogger log)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
// Verify the root path is a valid path.
var rootDirInfo = GetAndVerifyRootDirectory(root);
// Search directories starting with the top directory for any package matching the identity
// If multiple packages are found in the same directory that match (ex: 1.0, 1.0.0.0)
// then favor the exact non-normalized match. If no exact match is found take the first
// using the file system sort order. This is to match the legacy nuget 2.8.x behavior.
foreach (var directoryList in GetNupkgsFromFlatFolderChunked(rootDirInfo, log))
{
LocalPackageInfo fallbackMatch = null;
// Check for any files that are in the form packageId.version.nupkg
foreach (var file in directoryList.Where(file => IsPossiblePackageMatch(file, identity)))
{
var package = GetPackageFromNupkg(file);
if (identity.Equals(package.Identity))
{
if (StringComparer.OrdinalIgnoreCase.Equals(
identity.Version.ToString(),
package.Identity.Version.ToString()))
{
// Take an exact match immediately
return(package);
}
else if (fallbackMatch == null)
{
// This matches the identity, but there may be an exact match still
fallbackMatch = package;
}
}
}
if (fallbackMatch != null)
{
// Use the fallback match if an exact match was not found
return(fallbackMatch);
}
}
// Not found
return(null);
}
public override Task <DownloadResourceResult> GetDownloadResourceResultAsync(
PackageIdentity identity,
PackageDownloadContext downloadContext,
string globalPackagesFolder,
ILogger logger,
CancellationToken token)
{
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
var stopwatch = Stopwatch.StartNew();
try
{
// Find the package from the local folder
LocalPackageInfo packageInfo = null;
var sourcePackage = identity as SourcePackageDependencyInfo;
if (sourcePackage?.DownloadUri != null)
{
// Get the package directly if the full path is known
packageInfo = _localResource.GetPackage(sourcePackage.DownloadUri, logger, token);
}
else
{
// Search for the local package
packageInfo = _localResource.GetPackage(identity, logger, token);
}
if (packageInfo != null)
{
var stream = File.OpenRead(packageInfo.Path);
return(Task.FromResult(new DownloadResourceResult(stream, packageInfo.GetReader(), _localResource.Root)));
}
else
{
return(Task.FromResult(new DownloadResourceResult(DownloadResourceResultStatus.NotFound)));
}
}
finally
{
ProtocolDiagnostics.RaiseEvent(new ProtocolDiagnosticResourceEvent(
_source,
resourceType: nameof(DownloadResource),
type: nameof(LocalDownloadResource),
method: nameof(GetDownloadResourceResultAsync),
stopwatch.Elapsed));
}
}
public LocalPackageSearchMetadata(LocalPackageInfo package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
_package = package;
_nuspec = package.Nuspec;
}
private IPackageSearchMetadata CreatePackageSearchResult(
LocalPackageInfo package,
SearchFilter filter,
ILogger log,
CancellationToken cancellationToken)
{
var metadata = new LocalPackageSearchMetadata(package);
return(metadata
.WithVersions(() => GetVersions(_localResource, package, filter, log, CancellationToken.None)));
}
private IReadOnlyList <LocalPackageInfo> GetPackageInfosCore(string id, ILogger logger)
{
var result = new List <LocalPackageInfo>();
// packages\{packageId}.{version}.nupkg
var nupkgFiles = LocalFolderUtility.GetNupkgsFromFlatFolder(_source, logger)
.Where(path => LocalFolderUtility.IsPossiblePackageMatch(path, id));
foreach (var nupkgInfo in nupkgFiles)
{
using (var stream = nupkgInfo.OpenRead())
using (var packageReader = new PackageArchiveReader(stream))
{
NuspecReader reader;
try
{
reader = new NuspecReader(packageReader.GetNuspec());
}
catch (XmlException ex)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Protocol_PackageMetadataError, nupkgInfo.Name, _source);
throw new FatalProtocolException(message, ex);
}
catch (PackagingException ex)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Protocol_PackageMetadataError, nupkgInfo.Name, _source);
throw new FatalProtocolException(message, ex);
}
var identity = reader.GetIdentity();
if (string.Equals(identity.Id, id, StringComparison.OrdinalIgnoreCase))
{
var cachePackage = new LocalPackageInfo(
identity,
nupkgInfo.FullName,
nupkgInfo.LastWriteTimeUtc,
new Lazy <NuspecReader>(() => reader),
new Func <PackageReaderBase>(() => new PackageArchiveReader(nupkgInfo.FullName))
);
result.Add(cachePackage);
}
}
}
return(result);
}
/// <summary>
/// Convert a package into a PackageDependencyInfo
/// </summary>
private SourcePackageDependencyInfo CreateDependencyInfo(LocalPackageInfo package, NuGetFramework projectFramework)
{
// Take only the dependency group valid for the project TFM
var group = NuGetFrameworkUtility.GetNearest <PackageDependencyGroup>(package.Nuspec.GetDependencyGroups(), projectFramework);
var dependencies = group?.Packages ?? Enumerable.Empty <PackageDependency>();
var result = new SourcePackageDependencyInfo(
package.Identity,
dependencies,
listed: true,
source: _source,
downloadUri: UriUtility.CreateSourceUri(package.Path, UriKind.Absolute),
packageHash: null);
return(result);
}
/// <summary>
/// Return the package nupkg from a packages.config folder sub directory.
/// </summary>
/// <param name="dir">Package directory in the format id.version</param>
private static LocalPackageInfo GetPackagesConfigFolderPackage(DirectoryInfo dir)
{
LocalPackageInfo result = null;
var nupkgPath = Path.Combine(
dir.FullName,
$"{dir.Name}{PackagingCoreConstants.NupkgExtension}");
var nupkgFile = new FileInfo(nupkgPath);
if (nupkgFile.Exists)
{
result = GetPackageFromNupkg(nupkgFile);
}
return(result);
}
/// <summary>
/// Return the package nupkg from a packages.config folder sub directory.
/// </summary>
/// <param name="dir">Package directory in the format id.version</param>
private static LocalPackageInfo GetPackagesConfigFolderPackage(DirectoryInfo dir, ILogger log)
{
LocalPackageInfo result = null;
var nupkgPath = Path.Combine(
dir.FullName,
$"{dir.Name}{PackagingCoreConstants.NupkgExtension}");
var nupkgFile = CreateFileInfoIfValidOrNull(nupkgPath, log);
if (nupkgFile != null && nupkgFile.Exists)
{
result = GetPackageFromNupkg(nupkgFile);
}
return(result);
}
/// <summary>
/// Search Id, Tags, and Description to match the legacy local search behavior.
/// </summary>
private static bool ContainsAnyTerm(string[] terms, LocalPackageInfo package)
{
var id = package.Identity.Id;
var tags = package.Nuspec.GetTags();
var description = package.Nuspec.GetDescription();
foreach (var term in terms)
{
if (ContainsTerm(term, id) ||
ContainsTerm(term, tags) ||
ContainsTerm(term, description))
{
return(true);
}
}
return(false);
}
public override Task <DownloadResourceResult> GetDownloadResourceResultAsync(
PackageIdentity identity,
PackageDownloadContext downloadContext,
string globalPackagesFolder,
ILogger logger,
CancellationToken token)
{
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
// Find the package from the local folder
LocalPackageInfo packageInfo = null;
var sourcePackage = identity as SourcePackageDependencyInfo;
if (sourcePackage?.DownloadUri != null)
{
// Get the package directly if the full path is known
packageInfo = _localResource.GetPackage(sourcePackage.DownloadUri, logger, token);
}
else
{
// Search for the local package
packageInfo = _localResource.GetPackage(identity, logger, token);
}
if (packageInfo != null)
{
var stream = File.OpenRead(packageInfo.Path);
return(Task.FromResult(new DownloadResourceResult(stream, packageInfo.GetReader(), _localResource.Root)));
}
else
{
return(Task.FromResult(new DownloadResourceResult(DownloadResourceResultStatus.NotFound)));
}
}
/// <summary>
/// Returns a distinct set of elements using the comparer specified. This implementation will pick the last occurrence
/// of each element instead of picking the first. This method assumes that similar items occur in order.
/// </summary>
private static IEnumerable <LocalPackageInfo> CollapseToHighestVersion(IEnumerable <LocalPackageInfo> source)
{
bool first = true;
bool maxElementHasValue = false;
LocalPackageInfo previousElement = null;
LocalPackageInfo maxElement = null;
foreach (LocalPackageInfo element in source)
{
// If we're starting a new group then return the max element from the last group
if (!first && !StringComparer.OrdinalIgnoreCase.Equals(element.Identity.Id, previousElement.Identity.Id))
{
yield return(maxElement);
// Reset the max element
maxElementHasValue = false;
}
// If the current max element has a value and is bigger or doesn't have a value then update the max
if (!maxElementHasValue ||
(maxElementHasValue &&
VersionComparer.VersionRelease.Compare(maxElement.Identity.Version, element.Identity.Version) < 0))
{
maxElement = element;
maxElementHasValue = true;
}
previousElement = element;
first = false;
}
if (!first)
{
yield return(maxElement);
}
yield break;
}
private static IReadOnlyList <LocalPackageInfo> GetPackagesCore(string root)
{
var rootDirInfo = LocalFolderUtility.GetAndVerifyRootDirectory(root);
if (!rootDirInfo.Exists)
{
return(new List <LocalPackageInfo>());
}
var files = rootDirInfo.GetFiles("*" + PackagingCoreConstants.NupkgExtension, SearchOption.TopDirectoryOnly);
var directories = rootDirInfo.GetDirectories("*", SearchOption.TopDirectoryOnly);
// Find all packages that have both a nupkg and a directory
var validSet = new HashSet <string>(directories.Select(dir => dir.Name), StringComparer.OrdinalIgnoreCase);
validSet.IntersectWith(files.Select(file => Path.GetFileNameWithoutExtension(file.Name)));
var result = new List <LocalPackageInfo>(validSet.Count);
foreach (var name in validSet)
{
var nuspec = GetNuspec(rootDirInfo, name);
var nupkgPath = Path.Combine(rootDirInfo.FullName, $"{name}{PackagingCoreConstants.NupkgExtension}");
var localPackage = new LocalPackageInfo(
nuspec.GetIdentity(),
nupkgPath,
DateTime.UtcNow,
new Lazy <NuspecReader>(() => nuspec),
useFolder: true
);
result.Add(localPackage);
}
return(result);
}
private static IPackageSearchMetadata GetPackageMetadata(LocalPackageInfo package) => new LocalPackageSearchMetadata(package);