private async Task RestorePackageSpecProjectsAsync(
List <IDependencyGraphProject> projects,
bool forceRestore,
bool isSolutionAvailable,
IReadOnlyList <PackageSpec> packageSpecs,
CancellationToken token)
{
// Only continue if there are some build integrated type projects.
if (!(projects.Any(project => project is BuildIntegratedNuGetProject) ||
packageSpecs.Any(project => IsProjectBuildIntegrated(project))))
{
return;
}
if (IsConsentGranted(_settings))
{
if (!isSolutionAvailable)
{
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings);
if (!Path.IsPathRooted(globalPackagesFolder))
{
await _logger.DoAsync((l, _) =>
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.RelativeGlobalPackagesFolder,
globalPackagesFolder);
l.WriteLine(VerbosityLevel.Quiet, message);
});
// Cannot restore packages since globalPackagesFolder is a relative path
// and the solution is not available
return;
}
}
// Cache p2ps discovered from DTE
var cacheContext = new DependencyGraphCacheContext(_logger);
var pathContext = NuGetPathContext.Create(_settings);
// add deferred projects package spec in cacheContext packageSpecCache
cacheContext.DeferredPackageSpecs.AddRange(packageSpecs);
var isRestoreRequired = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync(
_solutionManager,
forceRestore,
pathContext,
cacheContext,
_dependencyGraphProjectCacheHash);
// No-op all project closures are up to date and all packages exist on disk.
if (isRestoreRequired)
{
// Save the project between operations.
_dependencyGraphProjectCacheHash = cacheContext.SolutionSpecHash;
// NOTE: During restore for build integrated projects,
// We might show the dialog even if there are no packages to restore
// When both currentStep and totalSteps are 0, we get a marquee on the dialog
await _logger.RunWithProgressAsync(
async (l, _, t) =>
{
// Display the restore opt out message if it has not been shown yet
await l.WriteHeaderAsync();
var sources = _sourceRepositoryProvider
.GetRepositories()
.ToList();
var providerCache = new RestoreCommandProvidersCache();
Action <SourceCacheContext> cacheModifier = (cache) => { };
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
_solutionManager,
cacheContext,
providerCache,
cacheModifier,
sources,
_settings,
l,
t);
_packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum();
var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false);
if (isRestoreFailed)
{
_status = NuGetOperationStatus.Failed;
}
},
token);
}
}
}
public async Task DependencyGraphRestoreUtility_NoopIsRestoreRequiredAsyncTest()
{
// Arrange
var projectName = "testproj";
var logger = new TestLogger();
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "testproj.project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework,
new TestNuGetProjectContext());
var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
var restoreContext = new DependencyGraphCacheContext(logger);
var projects = new List <IDependencyGraphProject>()
{
project
};
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var sources = new[] {
Repository.Factory.GetVisualStudio(new PackageSource("https://www.nuget.org/api/v2/"))
};
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
NullSettings.Instance,
logger,
CancellationToken.None);
var pathContext = NuGetPathContext.Create(NullSettings.Instance);
var oldHash = restoreContext.SolutionSpecHash;
var newContext = new DependencyGraphCacheContext(logger);
// Act
var result = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync(
solutionManager,
forceRestore : false,
pathContext : pathContext,
cacheContext : newContext,
oldDependencyGraphSpecHash : oldHash);
// Assert
Assert.Equal(false, result);
Assert.Equal(0, logger.Errors);
Assert.Equal(0, logger.Warnings);
Assert.Equal(3, logger.MinimalMessages.Count);
}
}
public async Task BuildIntegratedRestoreUtility_IsRestoreRequired_DeferredProjectLoad()
{
// Arrange
var projectName = "testproj";
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = Path.Combine(projectFolder.FullName, "project.json");
var projectPath = Path.Combine(projectFolder.FullName, $"{projectName}.csproj");
var packageSpec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", projectConfig);
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.ProjectPath = projectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = projectPath;
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
var solutionManager = new TestSolutionManager(false);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
restoreContext.DeferredPackageSpecs.Add(packageSpec);
var pathContext = NuGetPathContext.Create(NullSettings.Instance);
var oldHash = restoreContext.SolutionSpecHash;
// Act
var result = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync(
solutionManager,
forceRestore : false,
pathContext : pathContext,
cacheContext : restoreContext,
oldDependencyGraphSpecHash : oldHash);
// Assert
Assert.Equal(true, result);
Assert.Equal(0, testLogger.Errors);
Assert.Equal(0, testLogger.Warnings);
}
}