public async ValueTask <IReadOnlyCollection <VersionInfoContextInfo> > GetPackageVersionsAsync(
PackageIdentity identity,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
bool includePrerelease,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
PackageSearchMetadataCacheItem?backgroundDataCache = PackageSearchMetadataMemoryCache.Get(cacheId) as PackageSearchMetadataCacheItem;
if (backgroundDataCache != null)
{
return(await backgroundDataCache.AllVersionsContextInfo);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
IEnumerable <VersionInfo> versions = await packageMetadata.GetVersionsAsync();
return(await Task.WhenAll(versions.Select(v => VersionInfoContextInfo.CreateAsync(v).AsTask())));
}
public async ValueTask <PackageDeprecationMetadataContextInfo?> GetDeprecationMetadataAsync(
PackageIdentity identity,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
bool includePrerelease,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
PackageSearchMetadataCacheItem?backgroundDataCache = PackageSearchMetadataMemoryCache.Get(cacheId) as PackageSearchMetadataCacheItem;
if (backgroundDataCache != null)
{
PackageSearchMetadataCacheItemEntry cacheItem = await backgroundDataCache.GetPackageSearchMetadataCacheVersionedItemAsync(identity, cancellationToken);
return(await cacheItem.PackageDeprecationMetadataContextInfo);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
PackageDeprecationMetadata deprecationMetadata = await packageMetadata.GetDeprecationMetadataAsync();
if (deprecationMetadata == null)
{
return(null);
}
return(PackageDeprecationMetadataContextInfo.Create(deprecationMetadata));
}
public async ValueTask <IReadOnlyCollection <VersionInfoContextInfo> > GetPackageVersionsAsync(
PackageIdentity identity,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
bool includePrerelease,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
PackageSearchMetadataCacheItem?backgroundDataCache = PackageSearchMetadataMemoryCache.Get(cacheId) as PackageSearchMetadataCacheItem;
if (backgroundDataCache != null)
{
return(await backgroundDataCache.AllVersionsContextInfo);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
// Update the cache
var cacheEntry = new PackageSearchMetadataCacheItem(packageMetadata, packageMetadataProvider);
cacheEntry.UpdateSearchMetadata(packageMetadata);
PackageSearchMetadataMemoryCache.AddOrGetExisting(cacheId, cacheEntry, CacheItemPolicy);
return(await cacheEntry.AllVersionsContextInfo);
}
public override async Task <SearchResult <IPackageSearchMetadata> > ContinueSearchAsync(ContinuationToken continuationToken, CancellationToken cancellationToken)
{
var searchToken = continuationToken as FeedSearchContinuationToken;
if (searchToken == null)
{
throw new InvalidOperationException("Invalid token");
}
var packagesNeedingConsolidation = _installedPackages
.GroupById()
.Where(g => g.Count() > 1)
.Select(g => new PackageIdentity(g.Key, g.Max()))
.ToArray();
var packages = packagesNeedingConsolidation
.Where(p => p.Id.IndexOf(searchToken.SearchString, StringComparison.OrdinalIgnoreCase) != -1)
.OrderBy(p => p.Id)
.Skip(searchToken.StartIndex)
.Take(PageSize + 1)
.ToArray();
var hasMoreItems = packages.Length > PageSize;
if (hasMoreItems)
{
packages = packages.Take(packages.Length - 1).ToArray();
}
var items = await TaskCombinators.ThrottledAsync(
packages,
(p, t) => _metadataProvider.GetPackageMetadataAsync(p, searchToken.SearchFilter.IncludePrerelease, t),
cancellationToken);
var result = SearchResult.FromItems(items.ToArray());
var loadingStatus = hasMoreItems
? LoadingStatus.Ready
: packages.Length == 0
? LoadingStatus.NoItemsFound
: LoadingStatus.NoMoreItems;
result.SourceSearchStatus = new Dictionary <string, LoadingStatus>
{
{ "Consolidate", loadingStatus }
};
if (hasMoreItems)
{
result.NextToken = new FeedSearchContinuationToken
{
SearchString = searchToken.SearchString,
SearchFilter = searchToken.SearchFilter,
StartIndex = searchToken.StartIndex + packages.Length
};
}
return(result);
}
public PackageSearchMetadataCacheItemEntry(IPackageSearchMetadata packageSearchMetadata, IPackageMetadataProvider packageMetadataProvider)
{
_packageSearchMetadata = packageSearchMetadata;
_packageMetadataProvider = packageMetadataProvider;
_detailedPackageSearchMetadata = AsyncLazy.New(() =>
{
return(_packageMetadataProvider.GetPackageMetadataAsync(_packageSearchMetadata.Identity, includePrerelease: true, CancellationToken.None));
});
}
private async Task <DeferToken> GetMetadataFromRemoteSourcesAsync(DeferToken token, CancellationToken cancellationToken)
{
bool prerelease = _settignsProvider.Model.IsPreReleaseIncluded;
var searchMetadata = await _packageMetadataProvider.GetPackageMetadataAsync(token.Package.Identity, prerelease, cancellationToken);
token.Result = searchMetadata;
return(token);
}
async Task <IPackageSearchMetadata> GetPackageMetadataAsync(PackageIdentity identity, bool includePrerelease, CancellationToken cancellationToken)
{
// first we try and load the metadata from a local package
var packageMetadata = await _metadataProvider.GetLocalPackageMetadataAsync(identity, includePrerelease, cancellationToken);
if (packageMetadata == null)
{
// and failing that we go to the network
packageMetadata = await _metadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
}
return(packageMetadata);
}
internal virtual async Task <IPackageSearchMetadata> GetPackageMetadataAsync <T>(T identity, bool includePrerelease, CancellationToken cancellationToken) where T : PackageIdentity
{
cancellationToken.ThrowIfCancellationRequested();
// first we try and load the metadata from a local package
var packageMetadata = await _metadataProvider.GetLocalPackageMetadataAsync(identity, includePrerelease, cancellationToken);
if (packageMetadata == null)
{
// and failing that we go to the network
packageMetadata = await _metadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
}
return(packageMetadata);
}
public async ValueTask <PackageSearchMetadataCacheItemEntry> GetPackageSearchMetadataCacheVersionedItemAsync(PackageIdentity packageIdentity, CancellationToken cancellationToken)
{
Assumes.NotNull(packageIdentity);
if (!_cachedItemEntries.TryGetValue(packageIdentity.Version, out PackageSearchMetadataCacheItemEntry cacheItemEntry))
{
IPackageSearchMetadata packageSearchMetadata = await _packageMetadataProvider.GetPackageMetadataAsync(packageIdentity, includePrerelease : true, cancellationToken);
cacheItemEntry = new PackageSearchMetadataCacheItemEntry(packageSearchMetadata, _packageMetadataProvider);
_cachedItemEntries[packageIdentity.Version] = cacheItemEntry;
}
return(cacheItemEntry);
}
protected static async Task <IPackageSearchMetadata> LoadSinglePackageMetadataAsync(PackageIdentity identity, NuGetPackage packageModel, bool isPreReleaseIncluded)
{
try
{
var versionMetadata = await PackageMetadataProvider?.GetPackageMetadataAsync(identity, isPreReleaseIncluded, CancellationToken.None);
if (versionMetadata?.Identity?.Version is not null)
{
packageModel.AddDependencyInfo(versionMetadata.Identity.Version, versionMetadata.DependencySets);
}
return(versionMetadata);
}
catch (Exception ex)
{
Log.Error(ex, "Metadata retrieve error");
return(null);
}
}
public async ValueTask <IReadOnlyCollection <VersionInfoContextInfo> > GetPackageVersionsAsync(
PackageIdentity identity,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
bool includePrerelease,
bool isTransitive,
IEnumerable <IProjectContextInfo>?projects,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
PackageSearchMetadataCacheItem?backgroundDataCache = PackageSearchMetadataMemoryCache.Get(cacheId) as PackageSearchMetadataCacheItem;
// Transitive packages will have only one version the first time they are loaded, when the package is selected we update the cache with all the versions
if (backgroundDataCache != null)
{
if (isTransitive &&
(backgroundDataCache.AllVersionsContextInfo.Result == null || backgroundDataCache.AllVersionsContextInfo.Result.Count <= 1))
{
IPackageMetadataProvider transitivePackageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, projects?.ToList().AsReadOnly(), cancellationToken);
IPackageSearchMetadata transitivePackageMetadata = await transitivePackageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
backgroundDataCache.UpdateSearchMetadata(transitivePackageMetadata);
}
return(await backgroundDataCache.AllVersionsContextInfo);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, projects?.ToList().AsReadOnly(), cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
// Update the cache
var cacheEntry = new PackageSearchMetadataCacheItem(packageMetadata, packageMetadataProvider);
cacheEntry.UpdateSearchMetadata(packageMetadata);
PackageSearchMetadataMemoryCache.AddOrGetExisting(cacheId, cacheEntry, CacheItemPolicy);
return(await cacheEntry.AllVersionsContextInfo);
}
private async ValueTask <PackageSearchMetadataContextInfo> GetDetailedPackageSearchMetadataContextInfoAsync()
{
IPackageSearchMetadata detailedMetadata = await _packageMetadataProvider.GetPackageMetadataAsync(_packageSearchMetadata.Identity, includePrerelease : true, CancellationToken.None);
return(PackageSearchMetadataContextInfo.Create(detailedMetadata));
}