private RestoreSummaryRequest Create(
string projectNameToRestore,
ExternalProjectReference project,
HashSet <ExternalProjectReference> projectReferenceClosure,
RestoreArgs restoreArgs,
DependencyGraphSpec projectDgSpec)
{
var projectPackageSpec = projectDgSpec.GetProjectSpec(projectNameToRestore);
//fallback paths, global packages path and sources need to all be passed in the dg spec
var fallbackPaths = projectPackageSpec.RestoreMetadata.FallbackFolders;
var globalPath = GetPackagesPath(restoreArgs, projectPackageSpec);
var settings = Settings.LoadSettingsGivenConfigPaths(projectPackageSpec.RestoreMetadata.ConfigFilePaths);
var sources = restoreArgs.GetEffectiveSources(settings, projectPackageSpec.RestoreMetadata.Sources);
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(settings, restoreArgs.Log);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
fallbackPaths.AsList(),
sources,
restoreArgs.CacheContext,
restoreArgs.Log);
var rootPath = Path.GetDirectoryName(project.PackageSpec.FilePath);
// Create request
var request = new RestoreRequest(
project.PackageSpec,
sharedCache,
restoreArgs.CacheContext,
clientPolicyContext,
restoreArgs.Log)
{
// Set properties from the restore metadata
ProjectStyle = project.PackageSpec.RestoreMetadata.ProjectStyle,
// Project.json is special cased to put assets file and generated .props and targets in the project folder
RestoreOutputPath = project.PackageSpec.RestoreMetadata.ProjectStyle == ProjectStyle.ProjectJson ? rootPath : project.PackageSpec.RestoreMetadata.OutputPath,
DependencyGraphSpec = projectDgSpec,
MSBuildProjectExtensionsPath = projectPackageSpec.RestoreMetadata.OutputPath
};
var restoreLegacyPackagesDirectory = project.PackageSpec?.RestoreMetadata?.LegacyPackagesDirectory
?? DefaultRestoreLegacyPackagesDirectory;
request.IsLowercasePackagesDirectory = !restoreLegacyPackagesDirectory;
// Standard properties
restoreArgs.ApplyStandardProperties(request);
// Add project references
request.ExternalProjects = projectReferenceClosure.ToList();
// The lock file is loaded later since this is an expensive operation
var summaryRequest = new RestoreSummaryRequest(
request,
project.MSBuildProjectPath,
settings.GetConfigFilePaths(),
sources);
return(summaryRequest);
}
private static async Task <RestoreResultPair> ExecuteAsync(RestoreSummaryRequest summaryRequest, CancellationToken token)
{
var log = summaryRequest.Request.Log;
log.LogVerbose(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_ReadingProject,
summaryRequest.InputPath));
// Run the restore
var request = summaryRequest.Request;
// Read the existing lock file, this is needed to support IsLocked=true
// This is done on the thread and not as part of creating the request due to
// how long it takes to load the lock file.
if (request.ExistingLockFile == null)
{
request.ExistingLockFile = LockFileUtilities.GetLockFile(request.LockFilePath, log);
}
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync(token);
return(new RestoreResultPair(summaryRequest, result));
}
private RestoreSummaryRequest Create(
string inputPath,
RestoreArgs restoreContext)
{
var file = new FileInfo(inputPath);
// Get settings relative to the input file
var settings = restoreContext.GetSettings(file.DirectoryName);
var sources = restoreContext.GetEffectiveSources(settings);
var globalPath = restoreContext.GetEffectiveGlobalPackagesFolder(file.DirectoryName, settings);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
sources,
restoreContext.CacheContext,
restoreContext.Log);
var project = JsonPackageSpecReader.GetPackageSpec(file.Directory.Name, file.FullName);
var request = new RestoreRequest(
project,
sharedCache,
restoreContext.Log,
disposeProviders: false);
restoreContext.ApplyStandardProperties(request);
var summaryRequest = new RestoreSummaryRequest(request, inputPath, settings, sources);
return(summaryRequest);
}
private static async Task <RestoreSummary> ExecuteAndCommitAsync(RestoreSummaryRequest summaryRequest, IRestoreProgressReporter progressReporter, CancellationToken token)
{
RestoreResultPair result = await ExecuteAsync(summaryRequest, token);
bool isNoOp = result.Result is NoOpRestoreResult;
IReadOnlyList <string> filesToBeUpdated = isNoOp ? null : GetFilesToBeUpdated(result);
RestoreSummary summary = null;
try
{
if (!isNoOp)
{
progressReporter?.StartProjectUpdate(summaryRequest.Request.Project.FilePath, filesToBeUpdated);
}
summary = await CommitAsync(result, token);
}
finally
{
if (!isNoOp)
{
progressReporter?.EndProjectUpdate(summaryRequest.Request.Project.FilePath, filesToBeUpdated);
}
}
return(summary);
protected virtual RestoreSummaryRequest Create(
ExternalProjectReference project,
MSBuildProjectReferenceProvider msbuildProvider,
RestoreArgs restoreContext,
ISettings settingsOverride)
{
// Get settings relative to the input file
var rootPath = Path.GetDirectoryName(project.PackageSpecPath);
var settings = settingsOverride;
if (settings == null)
{
settings = restoreContext.GetSettings(rootPath);
}
var globalPath = restoreContext.GetEffectiveGlobalPackagesFolder(rootPath, settings);
var fallbackPaths = restoreContext.GetEffectiveFallbackPackageFolders(settings);
var sources = restoreContext.GetEffectiveSources(settings);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
fallbackPaths,
sources,
restoreContext.CacheContext,
restoreContext.Log);
var request = new RestoreRequest(
project.PackageSpec,
sharedCache,
restoreContext.Log,
disposeProviders: false);
restoreContext.ApplyStandardProperties(request);
// Find all external references
var externalReferences = msbuildProvider.GetReferences(project.MSBuildProjectPath).ToList();
request.ExternalProjects = externalReferences;
// Determine if this needs to fall back to an older lock file format
// Skip this if the arguments override the lock file version
if (restoreContext.LockFileVersion == null)
{
request.LockFileVersion = LockFileUtilities.GetLockFileVersion(externalReferences);
}
// The lock file is loaded later since this is an expensive operation
var summaryRequest = new RestoreSummaryRequest(
request,
project.MSBuildProjectPath,
settings,
sources);
return(summaryRequest);
}
private static async Task <RestoreSummary> Execute(RestoreSummaryRequest summaryRequest)
{
var log = summaryRequest.Request.Log;
log.LogVerbose(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_ReadingProject,
summaryRequest.InputPath));
// Run the restore
var sw = Stopwatch.StartNew();
var request = summaryRequest.Request;
// Read the existing lock file, this is needed to support IsLocked=true
// This is done on the thread and not as part of creating the request due to
// how long it takes to load the lock file.
if (request.ExistingLockFile == null)
{
request.ExistingLockFile = LockFileUtilities.GetLockFile(request.LockFilePath, log);
}
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
// Commit the result
log.LogInformation(Strings.Log_Committing);
await result.CommitAsync(request.Log, CancellationToken.None);
sw.Stop();
if (result.Success)
{
log.LogMinimal(
summaryRequest.InputPath + Environment.NewLine +
string.Format(
CultureInfo.CurrentCulture,
Strings.Log_RestoreComplete,
sw.ElapsedMilliseconds));
}
else
{
log.LogMinimal(
summaryRequest.InputPath + Environment.NewLine +
string.Format(
CultureInfo.CurrentCulture,
Strings.Log_RestoreFailed,
sw.ElapsedMilliseconds));
}
// Build the summary
return(new RestoreSummary(
result,
summaryRequest.InputPath,
summaryRequest.Settings,
summaryRequest.Sources,
summaryRequest.CollectorLogger.Errors));
}
private RestoreSummaryRequest Create(
ExternalProjectReference project,
HashSet <ExternalProjectReference> projectReferenceClosure,
RestoreArgs restoreContext,
ISettings settingsOverride)
{
// Get settings relative to the input file
var rootPath = Path.GetDirectoryName(project.PackageSpec.FilePath);
var settings = settingsOverride;
if (settings == null)
{
settings = restoreContext.GetSettings(rootPath);
}
var globalPath = restoreContext.GetEffectiveGlobalPackagesFolder(rootPath, settings);
var fallbackPaths = restoreContext.GetEffectiveFallbackPackageFolders(settings);
var sources = restoreContext.GetEffectiveSources(settings);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
fallbackPaths,
sources,
restoreContext.CacheContext,
restoreContext.Log);
// Create request
var request = new RestoreRequest(
project.PackageSpec,
sharedCache,
restoreContext.CacheContext,
restoreContext.Log);
// Set properties from the restore metadata
request.ProjectStyle = project.PackageSpec?.RestoreMetadata?.ProjectStyle ?? ProjectStyle.Unknown;
request.RestoreOutputPath = project.PackageSpec?.RestoreMetadata?.OutputPath ?? rootPath;
var restoreLegacyPackagesDirectory = project.PackageSpec?.RestoreMetadata?.LegacyPackagesDirectory
?? DefaultRestoreLegacyPackagesDirectory;
request.IsLowercasePackagesDirectory = !restoreLegacyPackagesDirectory;
// Standard properties
restoreContext.ApplyStandardProperties(request);
// Add project references
request.ExternalProjects = projectReferenceClosure.ToList();
// The lock file is loaded later since this is an expensive operation
var summaryRequest = new RestoreSummaryRequest(
request,
project.MSBuildProjectPath,
settings,
sources);
return(summaryRequest);
}
private static async Task <RestoreResultPair> ExecuteAsync(RestoreSummaryRequest summaryRequest, CancellationToken token)
{
var log = summaryRequest.Request.Log;
log.LogVerbose(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_ReadingProject,
summaryRequest.InputPath));
// Run the restore
var request = summaryRequest.Request;
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync(token);
return(new RestoreResultPair(summaryRequest, result));
}
private IReadOnlyList <RestoreSummaryRequest> GetRequestsFromItems(RestoreArgs restoreContext, DependencyGraphSpec dgFile)
{
if (restoreContext == null)
{
throw new ArgumentNullException(nameof(restoreContext));
}
if (dgFile == null)
{
throw new ArgumentNullException(nameof(dgFile));
}
// Validate the dg file input, this throws if errors are found.
SpecValidationUtility.ValidateDependencySpec(dgFile);
// Create requests
var requests = new ConcurrentBag <RestoreSummaryRequest>();
var toolRequests = new ConcurrentBag <RestoreSummaryRequest>();
var parallelOptions = new ParallelOptions
{
// By default, max degree of parallelism is -1 which means no upper bound.
// Limiting to processor count reduces task context switching which is better
MaxDegreeOfParallelism = Environment.ProcessorCount
};
using (var settingsLoadingContext = new SettingsLoadingContext())
{
// Parallel.Foreach has an optimization for Arrays, so calling .ToArray() is better and adds almost no overhead
Parallel.ForEach(dgFile.Restore.ToArray(), parallelOptions, projectNameToRestore =>
{
IReadOnlyList <PackageSpec> closure = dgFile.GetClosure(projectNameToRestore);
DependencyGraphSpec projectDependencyGraphSpec = dgFile.CreateFromClosure(projectNameToRestore, closure);
var externalClosure = new HashSet <ExternalProjectReference>(closure.Select(GetExternalProject));
ExternalProjectReference rootProject = externalClosure.Single(p =>
StringComparer.Ordinal.Equals(projectNameToRestore, p.UniqueName));
RestoreSummaryRequest request = Create(
projectNameToRestore,
rootProject,
externalClosure,
restoreContext,
projectDependencyGraphSpec,
settingsLoadingContext);
if (request.Request.ProjectStyle == ProjectStyle.DotnetCliTool)
{
// Store tool requests to be filtered later
toolRequests.Add(request);
}
else
{
requests.Add(request);
}
});
}
// Filter out duplicate tool restore requests
foreach (RestoreSummaryRequest subSetRequest in ToolRestoreUtility.GetSubSetRequests(toolRequests))
{
requests.Add(subSetRequest);
}
return(requests.ToArray());
}
public RestoreResultPair(RestoreSummaryRequest request, RestoreResult result)
{
SummaryRequest = request;
Result = result;
}
private static async Task <RestoreSummary> ExecuteAndCommitAsync(RestoreSummaryRequest summaryRequest, CancellationToken token)
{
var result = await ExecuteAsync(summaryRequest, token);
return(await CommitAsync(result, token));
}