public ConsolidatePackageFeed(
IEnumerable <PackageCollectionItem> installedPackages,
IPackageMetadataProvider metadataProvider,
Common.ILogger logger)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
PageSize = 25;
}
private async Task ApplyPackageAsync()
{
try
{
//select identity version
var selectedVersion = Package?.Identity?.Version;
VersionsCollection = new ObservableCollection <NuGetVersion>()
{
selectedVersion
};
SelectedVersion = selectedVersion;
PackageMetadataProvider = Providers.PackageMetadataProvider.CreateFromSourceContext(ServiceLocator.Default);
VersionData = await LoadSinglePackageMetadataAsync(Package.Identity, Package, _settingsProvider.Model.IsPreReleaseIncluded);
if (Package is not null)
{
ValidateCurrentPackage(Package);
}
}
catch (Exception ex)
{
Log.Error(ex, "Error ocurred during view model inititalization, probably package metadata is incorrect");
}
finally
{
IsPackageApplied = true;
}
}
protected override Task LoadPackageMetadataFromPackageDetailModelAsync(
IPackageMetadataProvider metadataProvider,
CancellationToken cancellationToken)
{
LoadPackageMetadataTask = base.LoadPackageMetadataFromPackageDetailModelAsync(metadataProvider, cancellationToken);
return(LoadPackageMetadataTask);
}
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 <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 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));
}
protected override Task LoadPackageMetadataFromPackageDetailModelAsync (
IPackageMetadataProvider metadataProvider,
CancellationToken cancellationToken)
{
LoadPackageMetadataTask = base.LoadPackageMetadataFromPackageDetailModelAsync (metadataProvider, cancellationToken);
return LoadPackageMetadataTask;
}
public UpdatePackageFeed(
IEnumerable <PackageIdentity> installedPackages,
IPackageMetadataProvider metadataProvider,
PackageSearchMetadataCache cachedUpdates,
Common.ILogger logger)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
_cachedUpdates = cachedUpdates;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
}
protected virtual Task LoadPackageMetadataFromPackageDetailModelAsync(
IPackageMetadataProvider metadataProvider,
CancellationToken cancellationToken)
{
return(packageDetailModel.LoadPackageMetadaAsync(metadataProvider, cancellationToken).ContinueWith(
task => OnPackageMetadataLoaded(task),
TaskScheduler.FromCurrentSynchronizationContext()));
}
public InstalledPackageFeed(
ManagePackagesLoadContext context,
IPackageMetadataProvider metadataProvider,
Common.ILogger logger)
: this(new PackageIdentity[0], metadataProvider, logger)
{
this._context = context;
}
public ConsolidatePackageFeed(
PackageLoadContext context,
IPackageMetadataProvider metadataProvider,
Common.ILogger logger)
: this(new PackageIdentity[0], metadataProvider, logger)
{
_context = context;
}
void LoadPackageMetadataFromPackageDetailModel(IPackageMetadataProvider metadataProvider, CancellationToken cancellationToken)
{
try {
LoadPackageMetadataFromPackageDetailModelAsync(metadataProvider, cancellationToken);
} catch (Exception ex) {
LoggingService.LogError("Error getting detailed package metadata.", ex);
}
}
public PackageSearchMetadataCacheItemEntry(IPackageSearchMetadata packageSearchMetadata, IPackageMetadataProvider packageMetadataProvider)
{
_packageSearchMetadata = packageSearchMetadata;
_packageMetadataProvider = packageMetadataProvider;
_detailedPackageSearchMetadata = AsyncLazy.New(() =>
{
return(_packageMetadataProvider.GetPackageMetadataAsync(_packageSearchMetadata.Identity, includePrerelease: true, CancellationToken.None));
});
}
public UpdatePackageFeed(
ManagePackagesLoadContext context,
IPackageMetadataProvider metadataProvider,
PackageSearchMetadataCache cachedUpdates,
Common.ILogger logger)
: this(new PackageIdentity[0], metadataProvider, cachedUpdates, logger)
{
_context = context;
}
public PackageQueryService(ISourceRepositoryProvider repositoryProvider, IPackageMetadataProvider packageMetadataProvider, ILogger logger)
{
Argument.IsNotNull(() => repositoryProvider);
Argument.IsNotNull(() => packageMetadataProvider);
Argument.IsNotNull(() => logger);
_repositoryProvider = repositoryProvider;
_packageMetadataProvider = packageMetadataProvider;
_logger = logger;
}
public PackageSearchMetadataCacheItem(IPackageSearchMetadata packageSearchMetadata, IPackageMetadataProvider packageMetadataProvider)
{
Assumes.NotNull(packageSearchMetadata);
Assumes.NotNull(packageMetadataProvider);
_cachedItemEntries = new ConcurrentDictionary <NuGetVersion, PackageSearchMetadataCacheItemEntry>
{
[packageSearchMetadata.Identity.Version] = new PackageSearchMetadataCacheItemEntry(packageSearchMetadata, packageMetadataProvider)
};
_packageMetadataProvider = packageMetadataProvider;
_packageSearchMetadata = packageSearchMetadata;
AllVersionsContextInfo = GetVersionInfoContextInfoAsync();
}
public UpdatePackageFeed(
IServiceBroker serviceBroker,
IEnumerable <PackageCollectionItem> installedPackages,
IPackageMetadataProvider metadataProvider,
IProjectContextInfo[] projects,
PackageSearchMetadataCache optionalCachedUpdates,
Common.ILogger logger)
{
_installedPackages = installedPackages ?? throw new ArgumentNullException(nameof(installedPackages));
_metadataProvider = metadataProvider ?? throw new ArgumentNullException(nameof(metadataProvider));
_projects = projects ?? throw new ArgumentNullException(nameof(projects));
_cachedUpdates = optionalCachedUpdates;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_serviceBroker = serviceBroker ?? throw new ArgumentNullException(nameof(serviceBroker));
}
public UpdatePackageFeed(
IServiceBroker serviceBroker,
IEnumerable <PackageCollectionItem> installedPackages,
IPackageMetadataProvider metadataProvider,
IProjectContextInfo[] projects)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(installedPackages);
Assumes.NotNull(metadataProvider);
Assumes.NotNull(projects);
_serviceBroker = serviceBroker;
_installedPackages = installedPackages;
_metadataProvider = metadataProvider;
_projects = projects;
}
public InstalledPackageFeed(
IEnumerable <PackageCollectionItem> installedPackages,
IPackageMetadataProvider metadataProvider)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
}
public SearchObject(
IPackageFeed mainFeed,
IPackageFeed?recommenderFeed,
IPackageMetadataProvider packageMetadataProvider,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
MemoryCache?searchCache)
{
Assumes.NotNull(mainFeed);
Assumes.NotNull(packageMetadataProvider);
Assumes.NotNullOrEmpty(packageSources);
_mainFeed = mainFeed;
_recommenderFeed = recommenderFeed;
_packageSources = packageSources;
_packageMetadataProvider = packageMetadataProvider;
_inMemoryObjectCache = searchCache;
}
public InstalledAndTransitivePackageFeedTests(ITestOutputHelper testOutputHelper)
{
_logger = new TestLogger(testOutputHelper);
var _metadataResource = Mock.Of <PackageMetadataResource>();
var provider = Mock.Of <INuGetResourceProvider>();
Mock.Get(provider)
.Setup(x => x.TryCreate(It.IsAny <SourceRepository>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(Tuple.Create(true, (INuGetResource)_metadataResource)));
Mock.Get(provider)
.Setup(x => x.ResourceType)
.Returns(typeof(PackageMetadataResource));
var packageSource = new Configuration.PackageSource("http://fake-source");
var source = new SourceRepository(source: packageSource, providers: new[] { provider });
_packageMetadataProvider = new MultiSourcePackageMetadataProvider(sourceRepositories: new[] { source }, optionalLocalRepository: null, optionalGlobalLocalRepositories: null, logger: _logger);
}
public void LoadPackageMetadata(IPackageMetadataProvider metadataProvider, CancellationToken cancellationToken)
{
if (packageDetailModel != null)
{
return;
}
if (IsRecentPackage)
{
ReadVersions(cancellationToken).ContinueWith(
task => LoadPackageMetadataFromPackageDetailModel(metadataProvider, cancellationToken),
TaskScheduler.FromCurrentSynchronizationContext());
}
else
{
ReadVersions(cancellationToken);
LoadPackageMetadataFromPackageDetailModel(metadataProvider, cancellationToken);
}
}
public async ValueTask<IReadOnlyCollection<PackageSearchMetadataContextInfo>> GetPackageMetadataListAsync(
string id,
IReadOnlyCollection<PackageSourceContextInfo> packageSources,
bool includePrerelease,
bool includeUnlisted,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(id);
Assumes.NotNullOrEmpty(packageSources);
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IEnumerable<IPackageSearchMetadata> packageMetadata = await packageMetadataProvider.GetPackageMetadataListAsync(
id,
includePrerelease,
includeUnlisted,
cancellationToken);
return packageMetadata.Select(package => PackageSearchMetadataContextInfo.Create(package)).ToList();
}
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);
}
internal async Task LoadPackageMetadaAsync(IPackageMetadataProvider metadataProvider, CancellationToken token)
{
var versions = await _searchResultPackage.GetVersionsAsync();
var packages = Enumerable.Empty <IPackageSearchMetadata>();
try
{
// load up the full details for each version
if (metadataProvider != null)
{
packages = await metadataProvider.GetPackageMetadataListAsync(Id, true, false, token);
}
}
catch (InvalidOperationException)
{
// Ignore failures.
}
var uniquePackages = packages
.GroupBy(m => m.Identity.Version, (v, ms) => ms.First());
var s = uniquePackages
.GroupJoin(
versions,
m => m.Identity.Version,
d => d.Version,
(m, d) => new DetailedPackageMetadata(m, d.FirstOrDefault()?.DownloadCount));
_metadataDict = s.ToDictionary(m => m.Version);
DetailedPackageMetadata p;
if (SelectedVersion != null &&
_metadataDict.TryGetValue(SelectedVersion.Version, out p))
{
PackageMetadata = p;
}
}
public UpdatePackageFeed(
IEnumerable <PackageCollectionItem> installedPackages,
IPackageMetadataProvider metadataProvider,
NuGetProject[] projects,
PackageSearchMetadataCache optionalCachedUpdates,
Common.ILogger logger)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
if (projects == null)
{
throw new ArgumentNullException(nameof(projects));
}
_projects = projects;
_cachedUpdates = optionalCachedUpdates;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
}
public InstalledPackageFeed(
IEnumerable <PackageIdentity> installedPackages,
IPackageMetadataProvider metadataProvider,
Common.ILogger logger)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
PageSize = 25;
}
public InstalledAndTransitivePackageFeed(IEnumerable <PackageCollectionItem> installedPackages, IEnumerable <PackageCollectionItem> transitivePackages, IPackageMetadataProvider metadataProvider)
: base(installedPackages, metadataProvider)
{
_transitivePackages = transitivePackages ?? throw new ArgumentNullException(nameof(transitivePackages));
}
public void LoadPackageMetadata(ManagePackagesSearchResultViewModel packageViewModel)
{
IPackageMetadataProvider provider = CreatePackageMetadataProvider();
packageViewModel.LoadPackageMetadata(provider, cancellationTokenSource.Token);
}
public PackageSearchMetadataCacheItemEntry(IPackageSearchMetadata packageSearchMetadata, IPackageMetadataProvider packageMetadataProvider)
{
_packageSearchMetadata = packageSearchMetadata;
_packageMetadataProvider = packageMetadataProvider;
}
internal async Task LoadPackageMetadaAsync(IPackageMetadataProvider metadataProvider, CancellationToken token)
{
var versions = await _searchResultPackage.GetVersionsAsync();
// First try to load the metadata from the version info. This will happen if we already fetched metadata
// about each version at the same time as fetching the version list (that it, V2). This also acts as a
// means to cache version metadata.
_metadataDict = versions
.Where(v => v.PackageSearchMetadata != null)
.ToDictionary(
v => v.Version,
v => new DetailedPackageMetadata(v.PackageSearchMetadata, v.DownloadCount));
// If we are missing any metadata, go to the metadata provider and fetch all of the data again.
if (versions.Select(v => v.Version).Except(_metadataDict.Keys).Any())
{
try
{
// Load up the full details for each version.
var packages = await metadataProvider?.GetPackageMetadataListAsync(
Id,
includePrerelease : true,
includeUnlisted : false,
cancellationToken : token);
var uniquePackages = packages
.GroupBy(
m => m.Identity.Version,
(v, ms) => ms.First());
_metadataDict = uniquePackages
.GroupJoin(
versions,
m => m.Identity.Version,
d => d.Version,
(m, d) =>
{
var versionInfo = d.OrderByDescending(v => v.DownloadCount).FirstOrDefault();
if (versionInfo != null)
{
// Save the metadata about this version to the VersionInfo instance.
versionInfo.PackageSearchMetadata = m;
}
return(new DetailedPackageMetadata(m, versionInfo?.DownloadCount));
})
.ToDictionary(m => m.Version);
}
catch (InvalidOperationException)
{
// Ignore failures.
}
}
DetailedPackageMetadata p;
if (SelectedVersion != null &&
_metadataDict.TryGetValue(SelectedVersion.Version, out p))
{
PackageMetadata = p;
}
}
internal async Task LoadPackageMetadaAsync(IPackageMetadataProvider metadataProvider, CancellationToken token)
{
var versions = await _searchResultPackage.GetVersionsAsync();
var packages = Enumerable.Empty<IPackageSearchMetadata>();
try
{
// load up the full details for each version
if (metadataProvider != null)
packages = await metadataProvider.GetPackageMetadataListAsync(Id, true, false, token);
}
catch (InvalidOperationException)
{
// Ignore failures.
}
var uniquePackages = packages
.GroupBy(m => m.Identity.Version, (v, ms) => ms.First());
var s = uniquePackages
.GroupJoin(
versions,
m => m.Identity.Version,
d => d.Version,
(m, d) => new DetailedPackageMetadata(m, d.FirstOrDefault()?.DownloadCount));
_metadataDict = s.ToDictionary(m => m.Version);
DetailedPackageMetadata p;
if (SelectedVersion != null
&& _metadataDict.TryGetValue(SelectedVersion.Version, out p))
{
PackageMetadata = p;
}
}
