public async ValueTask <Stream?> GetPackageIconAsync(PackageIdentity packageIdentity, CancellationToken cancellationToken)
{
Assumes.NotNull(packageIdentity);
string key = NuGetPackageFileService.IconPrefix + packageIdentity.ToString();
Uri? uri = IdentityToUriCache.Get(key) as Uri;
if (uri == null)
{
var exception = new CacheMissException();
await _nuGetTelemetryProvider.PostFaultAsync(exception, typeof(NuGetPackageFileService).FullName, nameof(NuGetPackageFileService.GetPackageIconAsync));
return(null);
}
Stream?stream;
if (IsEmbeddedUri(uri))
{
stream = await GetEmbeddedFileAsync(uri, cancellationToken);
}
else
{
stream = await GetStream(uri);
}
return(stream);
}
public static void AddLicenseToCache(PackageIdentity packageIdentity, Uri embeddedLicenseUri)
{
Assumes.NotNull(embeddedLicenseUri);
string key = NuGetPackageFileService.LicensePrefix + packageIdentity.ToString();
IdentityToUriCache.Set(key, embeddedLicenseUri, CacheItemPolicy);
}
public void TestToString()
{
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
Assert.Equal("packageA.1.0.0", packageIdentity.ToString());
var formattedString = string.Format("This is package '{0}'", packageIdentity);
Assert.Equal("This is package 'packageA.1.0.0'", formattedString);
}
public static void AddIconToCache(PackageIdentity packageIdentity, Uri iconUri)
{
string key = NuGetPackageFileService.IconPrefix + packageIdentity.ToString();
if (iconUri != null)
{
IdentityToUriCache.Set(key, iconUri, CacheItemPolicy);
}
}
private async Task <PackageHierarchy> GetPackageHierarchyInternalAsync(
PackageIdentity package,
NuGetFramework targetFramework,
IEnumerable <Regex> dependencyExclusionFilters,
IEnumerable <Regex> expansionExclusionFilters,
string currentPath,
CancellationToken cancellationToken)
{
if (expansionExclusionFilters.Any(f => f.IsMatch(package.Id)))
{
return(new PackageHierarchy(package));
}
currentPath = ConcatenatePath(currentPath, package.ToString());
var dependencies = default(IEnumerable <PackageIdentity>);
try
{
dependencies = await this.GetPackageDependenciesInternalAsync(
package,
targetFramework,
dependencyExclusionFilters,
cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
ex.Data["Path"] = currentPath;
throw;
}
var dependencyHierarchiesTasks = dependencies
.Select(
p => this.GetPackageHierarchyInternalAsync(
p,
targetFramework,
dependencyExclusionFilters,
expansionExclusionFilters,
currentPath,
cancellationToken));
var children = await Task.WhenAll(dependencyHierarchiesTasks).ConfigureAwait(false);
return(new PackageHierarchy(package, children));
}
private async Task<SourcePackageDependencyInfo> CacheResolvePackage(NuGetFactory factory, PackageIdentity package, NuGetFramework fx)
{
string key = String.Format(@"{0}-{1}", package.ToString(), fx.ToString());
if (base.IsInCache<SourcePackageDependencyInfo>("CacheResolvePackage", key))
{
return Get<SourcePackageDependencyInfo>("CacheResolvePackage", key);
}
else
{
var depResource = await factory.GetDependency();
var output = await depResource.ResolvePackage(package, fx, CancellationToken.None);
return Get<SourcePackageDependencyInfo>("CacheResolvePackage", key, () => { return output; });
}
}
private async Task<NuGetPackageVersion> CacheGetVersionMeta(UIMetadataResource metaResource, PackageIdentity versionIdentity, bool showDependencies)
{
string key = String.Format(@"{0}-{1}", versionIdentity.ToString(), showDependencies);
if (base.IsInCache<NuGetPackageVersion>("GetVersionMeta", key))
{
return Get<NuGetPackageVersion>("GetVersionMeta", key);
}
else
{
var meta = await metaResource.GetMetadata(versionIdentity, CancellationToken.None);
var output = await GetVersionMeta(versionIdentity, metaResource, showDependencies);
return Get<NuGetPackageVersion>("GetVersionMeta", key, () => { return output; });
}
}