private void AddPackageSource(List <Lazy <INuGetResourceProvider> > providers, PackageSource packageSource)
{
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
try
{
PackageMetadataResource packageMetadataResource = sourceRepository.GetResource <PackageMetadataResource>();
MetadataResourceList.Add(packageMetadataResource);
}
catch (Exception e)
{
Console.WriteLine("Error loading NuGet Package Meta Data Resource resoure for url: " + packageSource.SourceUri);
if (e.InnerException != null)
{
Console.WriteLine(e.InnerException.Message);
}
}
try
{
DependencyInfoResource dependencyInfoResource = sourceRepository.GetResource <DependencyInfoResource>();
DependencyInfoResourceList.Add(dependencyInfoResource);
Console.WriteLine("Succesfully added dependency info resource: " + sourceRepository.PackageSource.SourceUri);
}
catch (Exception e)
{
Console.WriteLine("Error loading NuGet Dependency Resource resoure for url: " + packageSource.SourceUri);
if (e.InnerException != null)
{
Console.WriteLine(e.InnerException.Message);
}
}
}
private async Task GetPackageDependenciesAsync(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
ILogger logger,
IEnumerable <SourceRepository> repositories,
ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
foreach (SourceRepository sourceRepository in repositories)
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
SourcePackageDependencyInfo dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, framework, cacheContext, logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
foreach (PackageDependency dependency in dependencyInfo.Dependencies)
{
await GetPackageDependenciesAsync(
new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion),
framework, cacheContext, logger, repositories, availablePackages);
}
}
}
static async Task<IEnumerable<SourcePackageDependencyInfo>> GetDependencyInfoAsync(
DependencyInfoResource dependencyInfoResource,
IEnumerable<PackageIdentity> packages,
NuGetFramework projectFramework)
{
try
{
var result = new HashSet<SourcePackageDependencyInfo>(PackageIdentity.Comparer);
foreach (var package in packages)
{
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package,
projectFramework,
NullSourceCacheContext.Instance,
NullLogger.Instance,
CancellationToken.None);
if (dependencyInfo != null)
{
result.Add(dependencyInfo);
}
}
return result;
}
catch (NuGetProtocolException)
{
return null;
}
}
static IEnumerable <string> FindAssemblyReferences(
NuGetFramework projectFramework,
DependencyInfoResource dependencyResource,
FindLocalPackagesResource localPackageResource,
SourceCacheContext cacheContext,
string packageId)
{
var packageInfo = localPackageResource.FindPackagesById(packageId, NullLogger.Instance, CancellationToken.None).FirstOrDefault();
if (packageInfo == null)
{
yield break;
}
using (var reader = packageInfo.GetReader())
{
var nearestFramework = reader.GetReferenceItems().GetNearest(projectFramework);
if (nearestFramework != null)
{
foreach (var assembly in nearestFramework.Items)
{
yield return(Path.GetFileName(assembly));
}
}
}
var dependencyInfo = dependencyResource.ResolvePackage(packageInfo.Identity, projectFramework, cacheContext, NullLogger.Instance, CancellationToken.None).Result;
foreach (var dependency in dependencyInfo.Dependencies)
{
foreach (var reference in FindAssemblyReferences(projectFramework, dependencyResource, localPackageResource, cacheContext, dependency.Id))
{
yield return(reference);
}
}
}
GetDependencies
(
string id,
string version
)
{
DependencyInfoResource resource = await repository.GetResourceAsync <DependencyInfoResource>(CancellationToken.None);
SourcePackageDependencyInfo package = await resource.ResolvePackage
(
new PackageIdentity(id, new NuGetVersion(version)),
NuGetFramework.AnyFramework,
source_cache,
logger,
cancellationToken
);
if (package == null)
{
throw new InvalidOperationException("Could not locate dependency!");
}
//System.Collections.Concurrent.ConcurrentBag<string> dependency_collection;
//dependency_collection = new System.Collections.Concurrent.ConcurrentBag<string>();
Graph <string, string> dependency_graph = new Graph <string, string>();
foreach (var dependency in package.Dependencies)
{
Node <string> dependency_node = new Node <string>()
{
};
//dependency_collection.Add(dependency.Id + " " + dependency.VersionRange.MinVersion);
}
await Task.WhenAll
(
package.Dependencies.Select
(
async(d) =>
{
var rec = await GetDependencies
(
d.Id,
d.VersionRange.MinVersion.ToNormalizedString()
);
foreach (string s in rec)
{
dependency_collection.Add(s);
}
}
)
);
return(dependency_collection);
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
DependencyInfoResource DependencyInfoResourceV2 = null;
var v2repo = await GetRepository(source, token);
if (v2repo != null)
{
DependencyInfoResourceV2 = new DependencyInfoResourceV2(v2repo, source);
}
return(Tuple.Create <bool, INuGetResource>(DependencyInfoResourceV2 != null, DependencyInfoResourceV2));
}
public ProjectReaderNugetDependencyDecorator(IProjectReader @base,
PackageMetadataResource metadataProvider,
DependencyInfoResource dependencyResolver,
SourceCacheContext cacheContext,
ILogger logger)
{
_base = @base ?? throw new ArgumentNullException(nameof(@base));
_metadataProvider = metadataProvider ?? throw new ArgumentNullException(nameof(metadataProvider));
_dependencyResolver = dependencyResolver ?? throw new ArgumentNullException(nameof(dependencyResolver));
_cacheContext = cacheContext ?? throw new ArgumentNullException(nameof(cacheContext));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_cancellationToken = CancellationToken.None;
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
DependencyInfoResource curResource = null;
if (await source.GetResourceAsync<ServiceIndexResourceV3>(token) != null)
{
var httpSourceResource = await source.GetResourceAsync<HttpSourceResource>(token);
var regResource = await source.GetResourceAsync<RegistrationResourceV3>(token);
// construct a new resource
curResource = new DependencyInfoResourceV3(httpSourceResource.HttpSource, regResource, source);
}
return new Tuple<bool, INuGetResource>(curResource != null, curResource);
}
static IEnumerable<string> FindAssemblyReferences(
NuGetFramework projectFramework,
DependencyInfoResource dependencyResource,
FindLocalPackagesResource localPackageResource,
SourceCacheContext cacheContext,
string packageId)
{
var packageInfo = localPackageResource.FindPackagesById(packageId, NullLogger.Instance, CancellationToken.None).FirstOrDefault();
if (packageInfo == null) yield break;
using (var reader = packageInfo.GetReader())
{
var assemblyReferences = reader.GetReferenceItems().GetNearest(projectFramework);
if (assemblyReferences != null)
{
foreach (var assembly in assemblyReferences.Items)
{
yield return Path.GetFileName(assembly);
}
}
var buildReferences = reader.GetBuildItems().GetNearest(projectFramework);
if (buildReferences != null)
{
var buildProperties = buildReferences.Items.FirstOrDefault(item => Path.GetExtension(item) == PropertyExtension);
if (buildProperties != null)
{
using (var propertyStream = reader.GetStream(buildProperties))
using (var propertyReader = XmlReader.Create(propertyStream))
{
while (propertyReader.ReadToFollowing(ReferenceElement))
{
var assemblyName = propertyReader.GetAttribute(IncludeAttribute);
yield return Path.ChangeExtension(assemblyName, DllExtension);
}
}
}
}
}
var dependencyInfo = dependencyResource.ResolvePackage(packageInfo.Identity, projectFramework, cacheContext, NullLogger.Instance, CancellationToken.None).Result;
foreach (var dependency in dependencyInfo.Dependencies)
{
foreach (var reference in FindAssemblyReferences(projectFramework, dependencyResource, localPackageResource, cacheContext, dependency.Id))
{
yield return reference;
}
}
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
DependencyInfoResource DependencyInfoResourceV2 = null;
if (FeedTypeUtility.GetFeedType(source.PackageSource) == FeedType.FileSystem)
{
var v2repo = await GetRepository(source, token);
if (v2repo != null)
{
DependencyInfoResourceV2 = new DependencyInfoResourceV2(v2repo, source);
}
}
return(Tuple.Create <bool, INuGetResource>(DependencyInfoResourceV2 != null, DependencyInfoResourceV2));
}
public async Task <NuGetPackageFilterResult> FilterAsync(SourceRepository repository, IPackageSearchMetadata package, CancellationToken cancellationToken)
{
if (!dependencies.Any())
{
return(NuGetPackageFilterResult.Ok);
}
DependencyInfoResource resource = await repository.GetResourceAsync <DependencyInfoResource>();
if (resource == null)
{
return(NuGetPackageFilterResult.NotCompatible);
}
NuGetPackageFilterResult result = NuGetPackageFilterResult.Ok;
foreach (NuGetFramework framework in frameworks)
{
SourcePackageDependencyInfo dependencyInfo = await resource.ResolvePackage(package.Identity, framework, new SourceCacheContext(), nuGetLogger, cancellationToken);
if (dependencyInfo != null)
{
// Dependency filtering:
// - When incompatible dependency version is found there is a chance that previous version has the right one.
// - When all dependencies are missing, don't even try previous versions.
foreach (var dependency in dependencies)
{
PackageDependency packageDependency = dependencyInfo.Dependencies.FirstOrDefault(p => string.Equals(p.Id, dependency.Id, StringComparison.CurrentCultureIgnoreCase));
if (packageDependency == null)
{
log.Info($"Package '{package.Identity}' skipped: missing dependency '{dependency.Id}'.");
result = NuGetPackageFilterResult.NotCompatible;
}
if (dependency.Version != null && !packageDependency.VersionRange.Satisfies(new NuGetVersion(dependency.Version)))
{
log.Info($"Package '{package.Identity}' skipped: not compatible version '{dependency.Version}' on dependency '{dependency.Id}'.");
return(NuGetPackageFilterResult.NotCompatibleVersion);
}
}
return(result);
}
}
return(NuGetPackageFilterResult.NotCompatible);
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
DependencyInfoResource resource = null;
if (await source.GetFeedType(token) == FeedType.HttpV2)
{
var serviceDocument = await source.GetResourceAsync <ODataServiceDocumentResourceV2>(token);
var httpSource = await source.GetResourceAsync <HttpSourceResource>(token);
var parser = new V2FeedParser(httpSource.HttpSource, serviceDocument.BaseAddress, source.PackageSource.Source);
resource = new DependencyInfoResourceV2Feed(parser, source);
}
return(new Tuple <bool, INuGetResource>(resource != null, resource));
}
/// <summary>
/// Call the DependencyInfoResource safely
/// </summary>
private async Task <List <SourcePackageDependencyInfo> > GatherPackageFromSourceAsync(
string packageId,
NuGetVersion version,
DependencyInfoResource resource,
NuGetFramework targetFramework,
bool ignoreExceptions,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
var results = new List <SourcePackageDependencyInfo>();
try
{
// Call the dependecy info resource
if (version == null)
{
// find all versions of a package
var packages = await resource.ResolvePackages(packageId, targetFramework, _context.ResolutionContext.SourceCacheContext, _context.Log, token);
results.AddRange(packages);
}
else
{
// find a single package id and version
var identity = new PackageIdentity(packageId, version);
var package = await resource.ResolvePackage(identity, targetFramework, _context.ResolutionContext.SourceCacheContext, _context.Log, token);
if (package != null)
{
results.Add(package);
}
}
}
catch
{
// Secondary sources should not stop the gather process. They are often invalid
// such as scenarios where a UNC is offline.
if (!ignoreExceptions)
{
throw;
}
}
return(results);
}
private async Task EnsureDependencyProvider(CancellationToken cancellationToken)
{
if (_dependencyInfoResource == null)
{
try
{
await _dependencyInfoSemaphore.WaitAsync(cancellationToken);
if (_dependencyInfoResource == null)
{
_dependencyInfoResource = await SourceRepository.GetResourceAsync <DependencyInfoResource>();
}
}
finally
{
_dependencyInfoSemaphore.Release();
}
}
}
public async Task <string> GetLatestVersionAsync(string packageId)
{
using (SourceCacheContext cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = _sourceRepositoryProvider.GetRepositories();
foreach (var repo in repositories)
{
DependencyInfoResource dependencyInfoResource = repo.GetResource <DependencyInfoResource>();
IEnumerable <SourcePackageDependencyInfo> packages = await dependencyInfoResource.ResolvePackages(packageId, _nuGetFramework, cacheContext, _logger, CancellationToken.None);
if (packages != null && packages.Count() > 0)
{
SourcePackageDependencyInfo version = packages.Where(p => p.Listed && !p.Version.IsPrerelease).OrderByDescending(x => x.Version).First();
return(version.Version.ToNormalizedString());
}
}
return(null);
}
}
private static async Task <NuGetVersion> GetLatestMatchingVersion(string packageId, NuGetFramework currentFramework, VersionRange versionRange, SourceRepository sourceRepository, ILogger logger)
{
try
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackages(
packageId, NullSourceCacheContext.Instance, logger, CancellationToken.None);
return(dependencyInfo
.Select(x => x.Identity.Version)
.Where(x => x != null && (versionRange == null || versionRange.Satisfies(x)))
.DefaultIfEmpty()
.Max());
}
catch (Exception ex)
{
Trace.TraceWarning($"Could not get latest version for package {packageId} from source {sourceRepository}: {ex.Message}");
return(null);
}
}
private async Task <NuGetVersion> GetLatestMatchingVersion(SourceRepository sourceRepository, ILogger logger)
{
try
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages(
_packageId, _currentFramework, logger, CancellationToken.None);
return(dependencyInfo
.Select(x => x.Version)
.Where(x => x != null && (_versionRange == null || _versionRange.Satisfies(x)))
.DefaultIfEmpty()
.Max());
}
catch (Exception ex)
{
Trace.Warning($"Could not get latest version for package {_packageId} from source {sourceRepository}: {ex.Message}");
return(null);
}
}
private async Task GetPackageDependencies(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
SourceRepository repository,
DependencyInfoResource dependencyInfoResource,
ISet <SourcePackageDependencyInfo> availablePackages,
ILogger logger)
{
if (availablePackages.Contains(package))
{
return;
}
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package,
framework,
cacheContext,
logger,
CancellationToken.None);
if (dependencyInfo == null)
{
return;
}
availablePackages.Add(dependencyInfo);
foreach (var dependency in dependencyInfo.Dependencies)
{
await GetPackageDependencies(
new PackageIdentity(
dependency.Id,
dependency.VersionRange.MinVersion),
framework,
cacheContext,
repository,
dependencyInfoResource,
availablePackages, logger);
}
}
private async Task <TemplatePackage> GetLatestTemplatePackage(string packageId, string frameworkVersion, IAbsoluteDirectoryPath templateRepositoryPath)
{
ISettings settings = Settings.LoadSpecificSettings(root: null, this.appEnvironment.NuGetConfigFilePath.ToString());
var nugetFramework = NuGetFramework.ParseFolder(frameworkVersion);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
foreach (SourceRepository sourceRepository in repositories)
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>().ConfigureAwait(false);
IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages(
packageId,
nugetFramework,
cacheContext,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
if (dependencyInfo == null)
{
continue;
}
availablePackages.AddRange(dependencyInfo);
}
var resolverContext = new PackageResolverContext(
DependencyBehavior.Highest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
SourcePackageDependencyInfo packageToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)))
.FirstOrDefault();
var packagePathResolver = new PackagePathResolver(SettingsUtility.GetGlobalPackagesFolder(settings));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
PackageReaderBase packageReader;
if (installedPath == null && packageToInstall != null)
{
DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None).ConfigureAwait(false);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None).ConfigureAwait(false);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
PackageIdentity identity = await packageReader.GetIdentityAsync(CancellationToken.None).ConfigureAwait(false);
var templatePackageMetaData = new TemplatePackage
{
PackageId = identity.Id,
Version = identity.Version.OriginalVersion,
TemplateRepositoryPath = templateRepositoryPath.ToString(),
};
foreach (FrameworkSpecificGroup contentItem in packageReader.GetContentItems())
{
foreach (string item in contentItem.Items)
{
templatePackageMetaData.Templates.Add(new Template {
NestedFilePath = item
});
}
}
var packageFileExtractor = new PackageFileExtractor(
templatePackageMetaData.Templates.Select(template => template.NestedFilePath),
XmlDocFileSaveMode.None);
await packageReader.CopyFilesAsync(
templatePackageMetaData.InstalltionPath,
templatePackageMetaData.Templates.Select(template => template.NestedFilePath),
packageFileExtractor.ExtractPackageFile,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
return(templatePackageMetaData);
}
}
public SourceResource(SourceRepository source, DependencyInfoResource resource)
{
Source = source;
Resource = resource;
}
private async Task InitializeResourcesAsync(CancellationToken token)
{
var currentSource = string.Empty;
try
{
// get the dependency info resources for each repo
// primary and all may share the same resources
var getResourceTasks = new List <Task>();
var allSources = new List <SourceRepository>();
allSources.AddRange(_context.PrimarySources);
allSources.Add(_context.PackagesFolderSource);
allSources.AddRange(_context.AllSources);
var depResources = new Dictionary <SourceRepository, Task <DependencyInfoResource> >();
foreach (var source in allSources)
{
if (!depResources.ContainsKey(source))
{
var task = Task.Run(async() => await source.GetResourceAsync <DependencyInfoResource>(token));
depResources.Add(source, task);
// Limit the number of tasks to MaxThreads by awaiting each time we hit the limit
while (getResourceTasks.Count >= MaxDegreeOfParallelism)
{
var finishedTask = await Task.WhenAny(getResourceTasks);
getResourceTasks.Remove(finishedTask);
}
}
}
var uniquePrimarySources = new HashSet <Configuration.PackageSource>();
// a resource may be null, if it is exclude this source from the gather
foreach (var source in _context.PrimarySources)
{
if (uniquePrimarySources.Add(source.PackageSource))
{
var resource = await depResources[source];
if (source != null && !_primaryResources.Any(sourceResource => sourceResource.Source.PackageSource.Equals(source)))
{
_primaryResources.Add(new SourceResource(source, resource));
}
}
}
// All sources - for fallback
var uniqueAllSources = new HashSet <Configuration.PackageSource>();
foreach (var source in allSources)
{
if (uniqueAllSources.Add(source.PackageSource))
{
//var resource = await depResources[source];
var resource = depResources[source];
if (source != null && !_allResources.Any(sourceResource => sourceResource.Source.PackageSource.Equals(source)))
{
currentSource = source.PackageSource.Source;
_allResources.Add(new SourceResource(source, resource.Result));
}
}
}
// Installed packages resource
_packagesFolderResource = await _context.PackagesFolderSource.GetResourceAsync <DependencyInfoResource>(token);
}
catch (Exception ex) when(ex is System.Net.Http.HttpRequestException || ex is OperationCanceledException ||
ex is InvalidOperationException || ex is TaskCanceledException || ex is AggregateException)
{
string message = String.Format(Strings.ExceptionWhenTryingToAddSource, ex.GetType().ToString(), currentSource);
throw new InvalidOperationException(message, ex);
}
}
/// <summary>
/// Returns package dependency info for the given package identities in the given resource. It returns null if any protocol errors occur.
/// For example, the feed is not accessible.
/// </summary>
/// <param name="packageIdentities">A collection of <see cref="PackageIdentity"/> to get info for.</param>
/// <param name="nuGetFramework">Framework for determining the dependency groups of packages</param>
/// <param name="dependencyInfoResource">The resource to fetch dependency info from. Could be http/file feed/global packages folder/solution packages folder.</param>
/// <param name="sourceCacheContext">Caching context. Only really applicable when the dependency info resource is http based.</param>
/// <param name="includeUnresolved">Whether to include unresolved packages in the list. If true, the unresolved packages will have an empty dependencies collection.</param>
/// <param name="logger">logger</param>
/// <param name="cancellationToken">cancellation token</param>
/// <returns>A collection of <see cref="PackageDependencyInfo"/>, null if a protocol exception happens. </returns>
public static async Task <IEnumerable <PackageDependencyInfo> > GetDependencyInfoForPackageIdentitiesAsync(IEnumerable <PackageIdentity> packageIdentities,
NuGetFramework nuGetFramework,
DependencyInfoResource dependencyInfoResource,
SourceCacheContext sourceCacheContext,
bool includeUnresolved,
ILogger logger,
CancellationToken cancellationToken)
{
try
{
cancellationToken.ThrowIfCancellationRequested();
var results = new HashSet <PackageDependencyInfo>(PackageIdentity.Comparer);
foreach (var package in packageIdentities)
{
var packageDependencyInfo = await dependencyInfoResource.ResolvePackage(
package,
nuGetFramework,
sourceCacheContext,
logger,
cancellationToken);
if (packageDependencyInfo != null)
{
results.Add(packageDependencyInfo);
}
else if (includeUnresolved)
{
results.Add(new PackageDependencyInfo(package, null));
}
}
return(results);
}
catch (NuGetProtocolException e)
{
logger.LogWarning(e.ToString());
return(null);
}
}
private async Task <PluginPackage> GetLatestTemplatePackage(string packageId, string frameworkVersion, IAbsoluteDirectoryPath pluginRepositoryPath)
{
var nugetFramework = NuGetFramework.ParseFolder(frameworkVersion);
ISettings settings = Settings.LoadSpecificSettings(root: null, this.appEnvironment.NuGetConfigFilePath.ToString());
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var packageMetaDataList = new List <PluginPackage>();
using (var cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
foreach (SourceRepository sourceRepository in repositories)
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>().ConfigureAwait(false);
IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages(
packageId,
nugetFramework,
cacheContext,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
if (dependencyInfo == null)
{
continue;
}
availablePackages.AddRange(dependencyInfo);
}
var resolverContext = new PackageResolverContext(
DependencyBehavior.Highest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
try
{
SourcePackageDependencyInfo packageToInstall = resolver
.Resolve(resolverContext, CancellationToken.None).Select(p =>
availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)))
.FirstOrDefault();
var packagePathResolver = new PackagePathResolver(SettingsUtility.GetGlobalPackagesFolder(settings));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
PackageReaderBase packageReader;
if (installedPath == null && packageToInstall != null)
{
DownloadResource downloadResource = await packageToInstall.Source
.GetResourceAsync <DownloadResource>(CancellationToken.None).ConfigureAwait(false);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None).ConfigureAwait(false);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
PackageIdentity identity = await packageReader.GetIdentityAsync(CancellationToken.None).ConfigureAwait(false);
var packageMetaData = new PluginPackage
{
Name = identity.Id,
Version = identity.Version.OriginalVersion,
RepositoryPath = pluginRepositoryPath,
};
foreach (FrameworkSpecificGroup contentItem in await packageReader.GetContentItemsAsync(CancellationToken.None).ConfigureAwait(false))
{
packageMetaData.Plugins.AddRange(contentItem.Items);
}
var packageFileExtractor = new PackageFileExtractor(
packageMetaData.Plugins,
XmlDocFileSaveMode.None);
await packageReader.CopyFilesAsync(
packageMetaData.PluginPath.ToString(),
packageMetaData.Plugins,
packageFileExtractor.ExtractPackageFile,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
foreach (IAbsoluteFilePath file in packageMetaData.PluginPath.GetChildDirectoryWithName("content").ChildrenFilesPath)
{
File.Copy(file.ToString(), Path.Join(packageMetaData.PluginPath.ToString(), file.FileName), overwrite: true);
}
packageMetaData.Plugins.Clear();
foreach (IAbsoluteFilePath file in packageMetaData.PluginPath.ChildrenFilesPath)
{
packageMetaData.Plugins.Add(file.GetRelativePathFrom(packageMetaData.PluginPath).ToString());
}
Directory.Delete(packageMetaData.PluginPath.GetChildDirectoryWithName("content").ToString(), recursive: true);
packageMetaDataList.Add(packageMetaData);
}
catch (NuGetResolverConstraintException exception)
{
string foo = exception.Message;
}
}
return(packageMetaDataList.FirstOrDefault());
}
