private static async Task <RestoreTargetGraph> GetPlatformSpecificGraph(RestoreTargetGraph independentGraph,
string package, string version, NuGetFramework framework, string runtimeIdentifier,
RemoteWalkContext context, LocalPackageExtractor extractor)
{
var graphTask = independentGraph.Flattened
.Where(m => m.Data?.Match?.Library?.Type == LibraryType.Package)
.Select(GetRuntimeGraphTask);
var graphs = (await Task.WhenAll(graphTask))
.Where(i => i != null);
var runtimeGraph = graphs.Aggregate(RuntimeGraph.Empty, RuntimeGraph.Merge);
// This results in additional entries
var resultWin = await new RemoteDependencyWalker(context).WalkAsync(
new LibraryRange(package, VersionRange.Parse(version), LibraryDependencyTarget.All),
framework,
runtimeGraph: runtimeGraph,
recursive: true,
runtimeIdentifier: runtimeIdentifier);
return(RestoreTargetGraph.Create(runtimeGraph, new[]
{
resultWin
}, context, context.Logger, framework, runtimeIdentifier));
async Task <RuntimeGraph> GetRuntimeGraphTask(GraphItem <RemoteResolveResult> item)
{
var packageIdentity = ToPackageIdentity(item.Data.Match);
var localPackageSourceInfo = await extractor.EnsureLocalPackage(item.Data.Match.Provider, packageIdentity);
return(localPackageSourceInfo?.Package?.RuntimeGraph);
}
}
public static RestoreTargetGraph GetRestoreTargetGraph(
string source,
PackageIdentity identity,
FileInfo packagePath,
TestLogger logger)
{
var libraryRange = new LibraryRange {
Name = identity.Id
};
var libraryIdentity = new LibraryIdentity(identity.Id, identity.Version, LibraryType.Package);
var dependencyProvider = new Mock <IRemoteDependencyProvider>();
IPackageDownloader packageDependency = null;
dependencyProvider
.Setup(x => x.GetPackageDownloaderAsync(
It.IsAny <PackageIdentity>(),
It.IsAny <SourceCacheContext>(),
It.IsAny <ILogger>(),
It.IsAny <CancellationToken>()))
.Callback <PackageIdentity, SourceCacheContext, ILogger, CancellationToken>(
(callbackIdentity, sourceCacheContext, callbackLogger, cancellationToken) =>
{
packageDependency = new LocalPackageArchiveDownloader(
source,
packagePath.FullName,
callbackIdentity,
callbackLogger);
})
.Returns(() => Task.FromResult(packageDependency));
var graph = RestoreTargetGraph.Create(
new[]
{
new GraphNode <RemoteResolveResult>(libraryRange)
{
Item = new GraphItem <RemoteResolveResult>(libraryIdentity)
{
Data = new RemoteResolveResult
{
Match = new RemoteMatch
{
Library = libraryIdentity,
Provider = dependencyProvider.Object
}
}
}
}
},
new TestRemoteWalkContext(),
logger,
FrameworkConstants.CommonFrameworks.NetStandard16);
return(graph);
}
private async Task <RestoreTargetGraph> GenerateRestoreGraph(ILogger log, string projectName, string projectPath)
{
var dgFile = await VSProjectHelper.GenerateRestoreGraphFile(log, projectPath);
var dgProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dgFile);
using (var cacheContext = new SourceCacheContext())
{
var restoreContext = new RestoreArgs();
restoreContext.CacheContext = cacheContext;
restoreContext.Log = new NuGet.Common.NullLogger();
restoreContext.PreLoadedRequestProviders.Add(dgProvider);
var request = (await dgProvider.CreateRequests(restoreContext)).Single();
var restoreRequest = request.Request;
var collectorLogger = new RestoreCollectorLogger(restoreRequest.Log, false);
var contextForProject = CreateRemoteWalkContext(restoreRequest, collectorLogger);
// Get external project references
// If the top level project already exists, update the package spec provided
// with the RestoreRequest spec.
var updatedExternalProjects = GetProjectReferences(restoreRequest, contextForProject);
// Load repositories
// the external project provider is specific to the current restore project
contextForProject.ProjectLibraryProviders.Add(new PackageSpecReferenceDependencyProvider(updatedExternalProjects, restoreRequest.Log));
var walker = new RemoteDependencyWalker(contextForProject);
var requestProject = request.Request.Project;
var projectRange = new LibraryRange()
{
Name = projectName,
VersionRange = new NuGet.Versioning.VersionRange(requestProject.Version),
TypeConstraint = LibraryDependencyTarget.Project | LibraryDependencyTarget.ExternalProject
};
var framework = requestProject.TargetFrameworks.First();
var graphs = new List <GraphNode <RemoteResolveResult> >
{
await walker.WalkAsync(
projectRange,
framework.FrameworkName,
null,
RuntimeGraph.Empty,
recursive : true)
};
return(RestoreTargetGraph.Create(graphs, contextForProject, restoreRequest.Log, framework.FrameworkName));
}
}
private async Task <RestoreTargetGraph> GetIndependentGraph(string package, string version, NuGetFramework nuGetFramework, RemoteWalkContext context)
{
var result = await new RemoteDependencyWalker(context).WalkAsync(
new LibraryRange(package, VersionRange.Parse(version), LibraryDependencyTarget.All),
nuGetFramework,
runtimeGraph: RuntimeGraph.Empty,
recursive: true,
runtimeIdentifier: null);
return(RestoreTargetGraph.Create(RuntimeGraph.Empty, new[]
{
result
}, _context, _context.Logger, nuGetFramework, runtimeIdentifier: null));
}
private static RestoreTargetGraph GetRestoreTargetGraph(PackageIdentity identity, FileInfo packagePath, TestLogger logger)
{
var libraryRange = new LibraryRange {
Name = identity.Id
};
var libraryIdentity = new LibraryIdentity(identity.Id, identity.Version, LibraryType.Package);
var dependencyProvider = new Mock <IRemoteDependencyProvider>();
dependencyProvider
.Setup(x => x.CopyToAsync(
It.IsAny <LibraryIdentity>(),
It.IsAny <Stream>(),
It.IsAny <SourceCacheContext>(),
It.IsAny <ILogger>(),
It.IsAny <CancellationToken>()))
.Callback <LibraryIdentity, Stream, SourceCacheContext, ILogger, CancellationToken>(
(_, destination, __, ___, ____) =>
{
using (var package = File.OpenRead(packagePath.FullName))
{
package.CopyTo(destination);
}
})
.Returns(Task.CompletedTask);
var graph = RestoreTargetGraph.Create(
new[]
{
new GraphNode <RemoteResolveResult>(libraryRange)
{
Item = new GraphItem <RemoteResolveResult>(libraryIdentity)
{
Data = new RemoteResolveResult
{
Match = new RemoteMatch
{
Library = libraryIdentity,
Provider = dependencyProvider.Object
}
}
}
}
},
new TestRemoteWalkContext(),
logger,
FrameworkConstants.CommonFrameworks.NetStandard16);
return(graph);
}
public RestoreResult GetRestoreResult(IEnumerable <PackageIdentity> identities)
{
var node = new GraphNode <RemoteResolveResult>(new LibraryRange("project", LibraryDependencyTarget.All))
{
Item = new GraphItem <RemoteResolveResult>(
new LibraryIdentity(
"project",
new NuGetVersion("1.0.0"),
LibraryType.Project))
{
Data = new RemoteResolveResult
{
Match = new RemoteMatch
{
Provider = null
}
}
}
};
foreach (var identity in identities)
{
var dependencyNode = new GraphNode <RemoteResolveResult>(
new LibraryRange(
identity.Id,
new VersionRange(identity.Version),
LibraryDependencyTarget.All))
{
Item = new GraphItem <RemoteResolveResult>(
new LibraryIdentity(
identity.Id,
identity.Version,
LibraryType.Package))
{
Data = new RemoteResolveResult
{
Match = new RemoteMatch
{
Provider = null
}
}
}
};
dependencyNode.OuterNode = node;
node.InnerNodes.Add(dependencyNode);
}
var graph = RestoreTargetGraph.Create(
new[] { node },
new TestRemoteWalkContext(),
NullLogger.Instance,
FrameworkConstants.CommonFrameworks.NetStandard10);
return(new RestoreResult(
true,
new[] { graph },
null,
null,
null,
null,
null,
null,
null,
null,
null,
ProjectStyle.Unknown,
TimeSpan.MinValue));
}
