private async Task <RestoreTargetGraph> WalkDependenciesAsync(LibraryRange projectRange,
NuGetFramework framework,
string runtimeIdentifier,
RuntimeGraph runtimeGraph,
RemoteDependencyWalker walker,
RemoteWalkContext context,
CancellationToken token)
{
var name = FrameworkRuntimePair.GetTargetGraphName(framework, runtimeIdentifier);
var graphs = new List <GraphNode <RemoteResolveResult> >
{
await walker.WalkAsync(
projectRange,
framework,
runtimeIdentifier,
runtimeGraph,
recursive : true)
};
// Resolve conflicts
await _logger.LogAsync(LogLevel.Verbose, string.Format(CultureInfo.CurrentCulture, Strings.Log_ResolvingConflicts, name));
// Flatten and create the RestoreTargetGraph to hold the packages
return(RestoreTargetGraph.Create(runtimeGraph, graphs, context, _logger, framework, runtimeIdentifier));
}
private void ReplayWarningsAndErrors()
{
var logMessages = _request.ExistingLockFile?.LogMessages ?? Enumerable.Empty <IAssetsLogMessage>();
foreach (var logMessage in logMessages)
{
var restoreLogMessage = new RestoreLogMessage(logMessage.Level, logMessage.Code, logMessage.Message)
{
ProjectPath = logMessage.ProjectPath,
WarningLevel = logMessage.WarningLevel,
FilePath = logMessage.FilePath,
LibraryId = logMessage.LibraryId,
TargetGraphs = logMessage.TargetGraphs,
StartLineNumber = logMessage.StartLineNumber,
StartColumnNumber = logMessage.StartColumnNumber,
EndLineNumber = logMessage.EndLineNumber,
EndColumnNumber = logMessage.EndColumnNumber
};
_logger.LogAsync(restoreLogMessage);
}
}
private async Task <IEnumerable <RestoreTargetGraph> > ExecuteRestoreAsync(
NuGetv3LocalRepository userPackageFolder,
IReadOnlyList <NuGetv3LocalRepository> fallbackPackageFolders,
RemoteWalkContext context,
CancellationToken token)
{
if (_request.Project.TargetFrameworks.Count == 0)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Log_ProjectDoesNotSpecifyTargetFrameworks, _request.Project.Name, _request.Project.FilePath);
await _logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1001, message));
_success = false;
return(Enumerable.Empty <RestoreTargetGraph>());
}
_logger.LogMinimal(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoringPackages, _request.Project.FilePath));
// Get external project references
// If the top level project already exists, update the package spec provided
// with the RestoreRequest spec.
var updatedExternalProjects = GetProjectReferences(context);
// Determine if the targets and props files should be written out.
context.IsMsBuildBased = _request.ProjectStyle != ProjectStyle.DotnetCliTool;
// Load repositories
// the external project provider is specific to the current restore project
context.ProjectLibraryProviders.Add(
new PackageSpecReferenceDependencyProvider(updatedExternalProjects, _logger));
var remoteWalker = new RemoteDependencyWalker(context);
var projectRange = new LibraryRange()
{
Name = _request.Project.Name,
VersionRange = new VersionRange(_request.Project.Version),
TypeConstraint = LibraryDependencyTarget.Project | LibraryDependencyTarget.ExternalProject
};
// Resolve dependency graphs
var allInstalledPackages = new HashSet <LibraryIdentity>();
var allGraphs = new List <RestoreTargetGraph>();
var runtimeIds = RequestRuntimeUtility.GetRestoreRuntimes(_request);
var projectFrameworkRuntimePairs = CreateFrameworkRuntimePairs(_request.Project, runtimeIds);
var hasSupports = _request.Project.RuntimeGraph.Supports.Count > 0;
var projectRestoreRequest = new ProjectRestoreRequest(
_request,
_request.Project,
_request.ExistingLockFile,
_runtimeGraphCache,
_runtimeGraphCacheByPackage,
_logger);
var projectRestoreCommand = new ProjectRestoreCommand(projectRestoreRequest);
var result = await projectRestoreCommand.TryRestore(
projectRange,
projectFrameworkRuntimePairs,
allInstalledPackages,
userPackageFolder,
fallbackPackageFolders,
remoteWalker,
context,
forceRuntimeGraphCreation : hasSupports,
token : token);
var success = result.Item1;
allGraphs.AddRange(result.Item2);
_success = success;
// Calculate compatibility profiles to check by merging those defined in the project with any from the command line
foreach (var profile in _request.Project.RuntimeGraph.Supports)
{
var runtimes = result.Item3;
CompatibilityProfile compatProfile;
if (profile.Value.RestoreContexts.Any())
{
// Just use the contexts from the project definition
compatProfile = profile.Value;
}
else if (!runtimes.Supports.TryGetValue(profile.Value.Name, out compatProfile))
{
// No definition of this profile found, so just continue to the next one
var message = string.Format(CultureInfo.CurrentCulture, Strings.Log_UnknownCompatibilityProfile, profile.Key);
await _logger.LogAsync(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1502, message));
continue;
}
foreach (var pair in compatProfile.RestoreContexts)
{
_logger.LogDebug($" {profile.Value.Name} -> +{pair}");
_request.CompatibilityProfiles.Add(pair);
}
}
// Walk additional runtime graphs for supports checks
if (_success && _request.CompatibilityProfiles.Any())
{
var compatibilityResult = await projectRestoreCommand.TryRestore(
projectRange,
_request.CompatibilityProfiles,
allInstalledPackages,
userPackageFolder,
fallbackPackageFolders,
remoteWalker,
context,
forceRuntimeGraphCreation : true,
token : token);
_success = compatibilityResult.Item1;
// TryRestore may contain graphs that are already in allGraphs if the
// supports section contains the same TxM as the project framework.
var currentGraphs = new HashSet <KeyValuePair <NuGetFramework, string> >(
allGraphs.Select(graph => new KeyValuePair <NuGetFramework, string>(
graph.Framework,
graph.RuntimeIdentifier))
);
foreach (var graph in compatibilityResult.Item2)
{
var key = new KeyValuePair <NuGetFramework, string>(
graph.Framework,
graph.RuntimeIdentifier);
if (currentGraphs.Add(key))
{
allGraphs.Add(graph);
}
}
}
return(allGraphs);
}
