public void GetRestoreSettingsTask_FindConfigInProjectFolder()
{
// Verifies that we include any config file found in the project folder
using (var machineWide = TestDirectory.CreateInTemp())
using (var workingDir = TestDirectory.CreateInTemp())
{
// Arrange
ConfigurationFileTestUtility.CreateConfigurationFile(Settings.DefaultSettingsFileName, machineWide, MachineWideSettingsConfig);
var machineWideSettings = new Lazy <IMachineWideSettings>(() => new TestMachineWideSettings(new Settings(machineWide, Settings.DefaultSettingsFileName, isMachineWide: true)));
var innerConfigFile = Path.Combine(workingDir, "sub", Settings.DefaultSettingsFileName);
var outerConfigFile = Path.Combine(workingDir, Settings.DefaultSettingsFileName);
var projectDirectory = Path.GetDirectoryName(innerConfigFile);
Directory.CreateDirectory(projectDirectory);
File.WriteAllText(innerConfigFile, InnerConfig);
File.WriteAllText(outerConfigFile, OuterConfig);
var settings = RestoreSettingsUtils.ReadSettings(null, projectDirectory, null, machineWideSettings);
var innerValue = SettingsUtility.GetValueForAddItem(settings, "SectionName", "inner-key");
var outerValue = SettingsUtility.GetValueForAddItem(settings, "SectionName", "outer-key");
// Assert
Assert.Equal("inner-value", innerValue);
Assert.Equal("outer-value", outerValue);
Assert.True(SettingsUtility.GetConfigFilePaths(settings).Contains(innerConfigFile));
Assert.True(SettingsUtility.GetConfigFilePaths(settings).Contains(outerConfigFile));
}
}
public void GetConfigFilePaths_WithNullSettings_Throws()
{
var ex = Record.Exception(() => SettingsUtility.GetConfigFilePaths(settings: null));
ex.Should().NotBeNull();
ex.Should().BeOfType <ArgumentNullException>();
}
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, null);
var FallbackPackageFolders = restoreContext.GetEffectiveFallbackPackageFolders(settings);
var globalPath = restoreContext.GetEffectiveGlobalPackagesFolder(file.DirectoryName, settings);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
FallbackPackageFolders,
sources,
restoreContext.CacheContext,
restoreContext.Log);
var project = JsonPackageSpecReader.GetPackageSpec(file.Directory.Name, file.FullName);
var request = new RestoreRequest(
project,
sharedCache,
restoreContext.CacheContext,
restoreContext.Log);
restoreContext.ApplyStandardProperties(request);
var summaryRequest = new RestoreSummaryRequest(request, inputPath, SettingsUtility.GetConfigFilePaths(settings), sources);
return(summaryRequest);
}
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 extractionContext = restoreArgs.GetPackageExtractionContext(settings);
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,
extractionContext,
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,
SettingsUtility.GetConfigFilePaths(settings),
sources);
return(summaryRequest);
}
public void TestConfigFileProbingDirectory()
{
// Arrange
var parentConfig = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<fallbackPackageFolders>
<add key=""a"" value=""C:\Temp\a"" />
</fallbackPackageFolders>
</configuration>";
var unreachableConfig = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<fallbackPackageFolders>
<add key=""b"" value=""C:\Temp\b"" />
</fallbackPackageFolders>
</configuration>";
var baseConfig = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<packageSources>
<add key=""c"" value=""C:\Temp\c"" />
</packageSources>
</configuration>";
var configName = "NuGet.Config";
using (var machineWide = TestDirectory.CreateInTemp())
using (var mockParentDirectory = TestDirectory.CreateInTemp())
{
// Parent
// Base
// Probe Path
// Unreachable
var basePath = Path.Combine(mockParentDirectory, "base");
var unreachablePath = Path.Combine(mockParentDirectory, "unreachable");
var probePath = Path.Combine(basePath, "probe");
Directory.CreateDirectory(basePath);
Directory.CreateDirectory(unreachablePath);
Directory.CreateDirectory(probePath);
ConfigurationFileTestUtility.CreateConfigurationFile(configName, mockParentDirectory, parentConfig);
ConfigurationFileTestUtility.CreateConfigurationFile(configName, basePath, baseConfig);
ConfigurationFileTestUtility.CreateConfigurationFile(configName, unreachablePath, unreachableConfig);
ConfigurationFileTestUtility.CreateConfigurationFile(configName, machineWide, MachineWideSettingsConfig);
var machineWideSettings = new Lazy <IMachineWideSettings>(() => new TestMachineWideSettings(new Settings(machineWide, configName, isMachineWide: true)));
// Test
var settings = RestoreSettingsUtils.ReadSettings(null, probePath, null, machineWideSettings);
var filePaths = SettingsUtility.GetConfigFilePaths(settings);
Assert.Equal(4, filePaths.Count()); // base, parent, app data + machine wide
Assert.Contains(Path.Combine(basePath, configName), filePaths);
Assert.Contains(Path.Combine(mockParentDirectory, configName), filePaths);
Assert.DoesNotContain(Path.Combine(unreachablePath, configName), filePaths);
}
}
public void TestSolutionSettings()
{
// Arrange
var subFolderConfig = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<fallbackPackageFolders>
<add key=""a"" value=""C:\Temp\a"" />
</fallbackPackageFolders>
</configuration>";
var baseConfig = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<fallbackPackageFolders>
<add key=""b"" value=""C:\Temp\b"" />
</fallbackPackageFolders>
<packageSources>
<add key=""c"" value=""C:\Temp\c"" />
</packageSources>
</configuration>";
var baseConfigPath = "NuGet.Config";
using (var machineWide = TestDirectory.CreateInTemp())
using (var mockBaseDirectory = TestDirectory.CreateInTemp())
{
var subFolder = Path.Combine(mockBaseDirectory, "sub");
var solutionDirectoryConfig = Path.Combine(mockBaseDirectory, NuGetConstants.NuGetSolutionSettingsFolder);
ConfigurationFileTestUtility.CreateConfigurationFile(baseConfigPath, solutionDirectoryConfig, baseConfig);
ConfigurationFileTestUtility.CreateConfigurationFile(baseConfigPath, subFolder, subFolderConfig);
ConfigurationFileTestUtility.CreateConfigurationFile(baseConfigPath, machineWide, MachineWideSettingsConfig);
var machineWideSettings = new Lazy <IMachineWideSettings>(() => new TestMachineWideSettings(new Settings(machineWide, baseConfigPath, isMachineWide: true)));
// Test
var settings = RestoreSettingsUtils.ReadSettings(mockBaseDirectory, mockBaseDirectory, null, machineWideSettings);
var filePaths = SettingsUtility.GetConfigFilePaths(settings);
Assert.Equal(3, filePaths.Count()); // Solution, app data + machine wide
Assert.True(filePaths.Contains(Path.Combine(solutionDirectoryConfig, baseConfigPath)));
Assert.True(filePaths.Contains(Path.Combine(machineWide, baseConfigPath)));
// Test
settings = RestoreSettingsUtils.ReadSettings(mockBaseDirectory, mockBaseDirectory, Path.Combine(subFolder, baseConfigPath), machineWideSettings);
filePaths = SettingsUtility.GetConfigFilePaths(settings);
Assert.Equal(1, filePaths.Count());
Assert.True(filePaths.Contains(Path.Combine(subFolder, baseConfigPath)));
}
}
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);
// BUGFIX
// The null here causes an exception downstream. Instead, inline the important code.
//var sources = restoreContext.GetEffectiveSources(settings, null);
var packageSourceProvider = new PackageSourceProvider(settings);
CachingSourceProvider cachingSourceProvider = new CachingSourceProvider(packageSourceProvider);
var sources = packageSourceProvider
.LoadPackageSources()
.Select(cachingSourceProvider.CreateRepository)
.ToList();
// END BUGFIX
var FallbackPackageFolders = restoreContext.GetEffectiveFallbackPackageFolders(settings);
var globalPath = restoreContext.GetEffectiveGlobalPackagesFolder(file.DirectoryName, settings);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
FallbackPackageFolders,
sources,
restoreContext.CacheContext,
restoreContext.Log);
var project = JsonPackageSpecReader.GetPackageSpec(file.Directory.Name, file.FullName);
// BUGFIX
// ApplyStandardProperties tries to access RestoreMetadata with no null check. Add
// a default value.
project.RestoreMetadata = new ProjectRestoreMetadata();
// END BUGFIX
var request = new RestoreRequest(
project,
sharedCache,
restoreContext.CacheContext,
restoreContext.Log);
restoreContext.ApplyStandardProperties(request);
IEnumerable <string> configFiles = SettingsUtility.GetConfigFilePaths(settings);
var summaryRequest = new RestoreSummaryRequest(request, inputPath, configFiles, sources);
return(summaryRequest);
}
static ProjectRestoreMetadata CreateRestoreMetadata(PackageSpec packageSpec, IDotNetProject project, ISettings settings)
{
return(new ProjectRestoreMetadata {
ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
ProjectStyle = ProjectStyle.PackageReference,
ProjectPath = project.FileName,
ProjectName = packageSpec.Name,
ProjectUniqueName = project.FileName,
ProjectWideWarningProperties = GetWarningProperties(project),
OutputPath = project.BaseIntermediateOutputPath,
OriginalTargetFrameworks = GetOriginalTargetFrameworks(project).ToList(),
Sources = SettingsUtility.GetEnabledSources(settings).ToList()
});
}
public NuGetViewModel()
{
try
{
var settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = SettingsUtility.GetConfigFilePaths(settings);
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
_sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider);
}
catch (Exception e)
{
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public NuGetViewModel(ITelemetryProvider telemetryProvider)
#pragma warning restore CS8618 // Non-nullable field is uninitialized.
{
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException ex)
{
telemetryProvider.ReportError(ex);
// create default settings using a non-existent config file
settings = new Settings(nameof(RoslynPad));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = SettingsUtility.GetConfigFilePaths(settings);
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
_sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider);
}
catch (Exception e)
{
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
private IList <string> GetConfigFilePaths(ISettings settings)
{
return(SettingsUtility.GetConfigFilePaths(settings).ToList());
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
// Log Inputs
BuildTasksUtility.LogInputParam(log, nameof(ProjectUniqueName), ProjectUniqueName);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSources), RestoreSources);
BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPath), RestorePackagesPath);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFolders), RestoreFallbackFolders);
BuildTasksUtility.LogInputParam(log, nameof(RestoreConfigFile), RestoreConfigFile);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSolutionDirectory), RestoreSolutionDirectory);
BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPathOverride), RestorePackagesPathOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSourcesOverride), RestoreSourcesOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFoldersOverride), RestoreFallbackFoldersOverride);
BuildTasksUtility.LogInputParam(log, nameof(MSBuildStartupDirectory), MSBuildStartupDirectory);
try
{
// Validate inputs
if (RestoreSourcesOverride == null &&
MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreSources, ProjectUniqueName, log))
{
// Fail due to invalid source combination
return(false);
}
if (RestoreFallbackFoldersOverride == null &&
MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreFallbackFolders, ProjectUniqueName, log))
{
// Fail due to invalid fallback combination
return(false);
}
// Settings
// Find the absolute path of nuget.config, this should only be set on the command line. Setting the path in project files
// is something that could happen, but it is not supported.
var absoluteConfigFilePath = GetGlobalAbsolutePath(RestoreConfigFile);
var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, Path.GetDirectoryName(ProjectUniqueName), absoluteConfigFilePath, _machineWideSettings);
OutputConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToArray();
// PackagesPath
OutputPackagesPath = RestoreSettingsUtils.GetValue(
() => GetGlobalAbsolutePath(RestorePackagesPathOverride),
() => string.IsNullOrEmpty(RestorePackagesPath) ? null : UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, RestorePackagesPath),
() => SettingsUtility.GetGlobalPackagesFolder(settings));
// Sources
var currentSources = RestoreSettingsUtils.GetValue(
() => RestoreSourcesOverride?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => GetGlobalAbsolutePath(e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(RestoreSources) ? new string[0] : null,
() => RestoreSources?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(),
() => (new PackageSourceProvider(settings)).LoadPackageSources().Where(e => e.IsEnabled).Select(e => e.Source).ToArray());
// Append additional sources
// Escape strings to avoid xplat path issues with msbuild.
var additionalProjectSources = MSBuildRestoreUtility.AggregateSources(
values: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectSources"),
excludeValues: Enumerable.Empty <string>())
.Select(MSBuildRestoreUtility.FixSourcePath)
.ToArray();
OutputSources = AppendItems(currentSources, additionalProjectSources);
// Fallback folders
var currentFallbackFolders = RestoreSettingsUtils.GetValue(
() => RestoreFallbackFoldersOverride?.Select(e => GetGlobalAbsolutePath(e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(RestoreFallbackFolders) ? new string[0] : null,
() => RestoreFallbackFolders?.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(),
() => SettingsUtility.GetFallbackPackageFolders(settings).ToArray());
// Append additional fallback folders after removing excluded folders
var additionalProjectFallbackFolders = MSBuildRestoreUtility.AggregateSources(
values: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFolders"),
excludeValues: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFoldersExcludes"))
.ToArray();
OutputFallbackFolders = AppendItems(currentFallbackFolders, additionalProjectFallbackFolders);
}
catch (Exception ex)
{
// Log exceptions with error codes if they exist.
ExceptionUtilities.LogException(ex, log);
return(false);
}
// Log Outputs
BuildTasksUtility.LogOutputParam(log, nameof(OutputPackagesPath), OutputPackagesPath);
BuildTasksUtility.LogOutputParam(log, nameof(OutputSources), OutputSources);
BuildTasksUtility.LogOutputParam(log, nameof(OutputFallbackFolders), OutputFallbackFolders);
BuildTasksUtility.LogOutputParam(log, nameof(OutputConfigFilePaths), OutputConfigFilePaths);
return(true);
}
/// <summary>
/// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json).
/// </summary>
/// <param name="projectPath">The full path to the project.</param>
/// <param name="id">The ID of the package.</param>
/// <param name="version">The version of the package.</param>
/// <param name="settings">The NuGet settings to use.</param>
/// <param name="logger">An <see cref="ILogger"/> to use for logging.</param>
/// <returns></returns>
public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(string projectPath, string id, string version, ISettings settings, ILogger logger)
{
using (SourceCacheContext sourceCacheContext = new SourceCacheContext
{
IgnoreFailedSources = true,
})
{
// The package spec details what packages to restore
PackageSpec packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation
{
FrameworkName = i,
}).ToList())
{
Dependencies = new List <LibraryDependency>
{
new LibraryDependency
{
LibraryRange = new LibraryRange(id, new VersionRange(NuGetVersion.Parse(version)), LibraryDependencyTarget.Package),
SuppressParent = LibraryIncludeFlags.All,
AutoReferenced = true,
IncludeType = LibraryIncludeFlags.None,
Type = LibraryDependencyType.Build
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(),
ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToList(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
FilePath = projectPath,
Name = Path.GetFileNameWithoutExtension(projectPath),
};
DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
RestoreArgs restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = sourceCacheContext,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)),
Log = logger,
};
// Create requests from the arguments
IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
return(RestoreRunner.RunWithoutCommit(requests, restoreArgs));
}
}
private RestoreTargetGraph GetRestoreTargetGraph(List <PackageReference> packages, string projectPath, List <NuGetFramework> targetFrameworks, SourceCacheContext sourceCacheContext)
{
// The package spec details what packages to restore
PackageSpec packageSpec = new PackageSpec(targetFrameworks.Select(i => new TargetFrameworkInformation
{
FrameworkName = i
}).ToList())
{
//Dependencies = new List<LibraryDependency>
//{
// new LibraryDependency
// {
// LibraryRange = new LibraryRange(id, new VersionRange(NuGetVersion.Parse(version)), LibraryDependencyTarget.Package),
// SuppressParent = LibraryIncludeFlags.All,
// AutoReferenced = true,
// IncludeType = LibraryIncludeFlags.None,
// Type = LibraryDependencyType.Build
// }
//},
Dependencies = packages.Select(i => new LibraryDependency
{
LibraryRange = new LibraryRange(i.PackageId, new VersionRange(i.PackageVersion), LibraryDependencyTarget.Package),
//SuppressParent = LibraryIncludeFlags.All,
//AutoReferenced = true,
//IncludeType = LibraryIncludeFlags.None,
//Type = LibraryDependencyType.
}).ToList(),
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = targetFrameworks.Select(i => i.ToString()).ToList(),
ConfigFilePaths = SettingsUtility.GetConfigFilePaths(_nugetSettings).ToList(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
Sources = SettingsUtility.GetEnabledSources(_nugetSettings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(_nugetSettings).ToList()
},
FilePath = projectPath,
Name = Path.GetFileNameWithoutExtension(projectPath),
};
DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
RestoreArgs restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = sourceCacheContext,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(_nugetSettings)),
Log = NullLogger.Instance,
};
// Create requests from the arguments
IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
RestoreResultPair restoreResult = RestoreRunner.RunWithoutCommit(requests, restoreArgs).Result.FirstOrDefault();
RestoreTargetGraph restoreTargetGraph = restoreResult?.Result.RestoreGraphs.FirstOrDefault();
return(restoreTargetGraph);
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
// Log Inputs
BuildTasksUtility.LogInputParam(log, nameof(ProjectUniqueName), ProjectUniqueName);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSources), RestoreSources);
BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPath), RestorePackagesPath);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFolders), RestoreFallbackFolders);
BuildTasksUtility.LogInputParam(log, nameof(RestoreConfigFile), RestoreConfigFile);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSolutionDirectory), RestoreSolutionDirectory);
BuildTasksUtility.LogInputParam(log, nameof(RestoreAdditionalProjectSources), RestoreAdditionalProjectSources);
BuildTasksUtility.LogInputParam(log, nameof(RestoreAdditionalProjectFallbackFolders), RestoreAdditionalProjectFallbackFolders);
BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPathOverride), RestorePackagesPathOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSourcesOverride), RestoreSourcesOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFoldersOverride), RestoreFallbackFoldersOverride);
try
{
// Validate inputs
if (RestoreSourcesOverride == null &&
MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreSources, ProjectUniqueName, log))
{
// Fail due to invalid source combination
return(false);
}
if (RestoreFallbackFoldersOverride == null &&
MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreFallbackFolders, ProjectUniqueName, log))
{
// Fail due to invalid fallback combination
return(false);
}
// Settings
var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, Path.GetDirectoryName(ProjectUniqueName), RestoreConfigFile, _machineWideSettings);
OutputConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToArray();
// PackagesPath
OutputPackagesPath = RestoreSettingsUtils.GetValue(
() => string.IsNullOrEmpty(RestorePackagesPathOverride) ? null : UriUtility.GetAbsolutePath(MSBuildStartupDirectory, RestorePackagesPathOverride),
() => string.IsNullOrEmpty(RestorePackagesPath) ? null : UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, RestorePackagesPath),
() => SettingsUtility.GetGlobalPackagesFolder(settings));
// Sources
var currentSources = RestoreSettingsUtils.GetValue(
() => RestoreSourcesOverride?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePath(MSBuildStartupDirectory, e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(RestoreSources) ? new string[0] : null,
() => RestoreSources?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(),
() => (new PackageSourceProvider(settings)).LoadPackageSources().Select(e => e.Source).ToArray());
// Append additional sources
// Escape strings to avoid xplat path issues with msbuild.
OutputSources = AppendItems(currentSources, RestoreAdditionalProjectSources?.Select(MSBuildRestoreUtility.FixSourcePath).ToArray());
// Fallback folders
var currentFallbackFolders = RestoreSettingsUtils.GetValue(
() => RestoreFallbackFoldersOverride?.Select(e => UriUtility.GetAbsolutePath(MSBuildStartupDirectory, e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(RestoreFallbackFolders) ? new string[0] : null,
() => RestoreFallbackFolders?.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(),
() => SettingsUtility.GetFallbackPackageFolders(settings).ToArray());
// Append additional fallback folders
OutputFallbackFolders = AppendItems(currentFallbackFolders, RestoreAdditionalProjectFallbackFolders);
}
catch (Exception ex)
{
// Log exceptions with error codes if they exist.
ExceptionUtilities.LogException(ex, log);
return(false);
}
// Log Outputs
BuildTasksUtility.LogOutputParam(log, nameof(OutputPackagesPath), OutputPackagesPath);
BuildTasksUtility.LogOutputParam(log, nameof(OutputSources), OutputSources);
BuildTasksUtility.LogOutputParam(log, nameof(OutputFallbackFolders), OutputFallbackFolders);
BuildTasksUtility.LogOutputParam(log, nameof(OutputConfigFilePaths), OutputConfigFilePaths);
return(true);
}
public override bool Execute()
{
// Log Inputs
var log = new MSBuildLogger(Log);
log.LogDebug($"(in) ProjectUniqueName '{ProjectUniqueName}'");
if (RestoreSources != null)
{
log.LogDebug($"(in) RestoreSources '{string.Join(";", RestoreSources.Select(p => p))}'");
}
if (RestorePackagesPath != null)
{
log.LogDebug($"(in) RestorePackagesPath '{RestorePackagesPath}'");
}
if (RestoreFallbackFolders != null)
{
log.LogDebug($"(in) RestoreFallbackFolders '{string.Join(";", RestoreFallbackFolders.Select(p => p))}'");
}
if (RestoreConfigFile != null)
{
log.LogDebug($"(in) RestoreConfigFile '{RestoreConfigFile}'");
}
if (RestoreSolutionDirectory != null)
{
log.LogDebug($"(in) RestoreSolutionDirectory '{RestoreSolutionDirectory}'");
}
if (RestoreAdditionalProjectSources != null)
{
log.LogDebug($"(in) RestoreAdditionalProjectSources '{RestoreAdditionalProjectSources}'");
}
if (RestoreAdditionalProjectFallbackFolders != null)
{
log.LogDebug($"(in) RestoreAdditionalProjectFallbackFolders '{RestoreAdditionalProjectFallbackFolders}'");
}
try
{
var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, Path.GetDirectoryName(ProjectUniqueName), RestoreConfigFile, _machineWideSettings);
OutputPackagesPath = RestoreSettingsUtils.GetPackagesPath(ProjectUniqueName, settings, RestorePackagesPath);
if (RestoreSources == null)
{
var packageSourceProvider = new PackageSourceProvider(settings);
var packageSourcesFromProvider = packageSourceProvider.LoadPackageSources();
OutputSources = packageSourcesFromProvider.Select(e => e.Source).ToArray();
}
else if (MSBuildRestoreUtility.ContainsClearKeyword(RestoreSources))
{
if (MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreSources, ProjectUniqueName, log))
{
// Fail due to invalid combination
return(false);
}
OutputSources = new string[] { };
}
else
{
// Relative -> Absolute paths
OutputSources = RestoreSources.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray();
}
// Append additional sources
OutputSources = AppendItems(OutputSources, RestoreAdditionalProjectSources);
if (RestoreFallbackFolders == null)
{
OutputFallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToArray();
}
else if (MSBuildRestoreUtility.ContainsClearKeyword(RestoreFallbackFolders))
{
if (MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreFallbackFolders, ProjectUniqueName, log))
{
// Fail due to invalid combination
return(false);
}
OutputFallbackFolders = new string[] { };
}
else
{
// Relative -> Absolute paths
OutputFallbackFolders = RestoreFallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray();
}
// Append additional fallback folders
OutputFallbackFolders = AppendItems(OutputFallbackFolders, RestoreAdditionalProjectFallbackFolders);
OutputConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToArray();
}
catch (Exception ex)
{
// Log exceptions with error codes if they exist.
ExceptionUtilities.LogException(ex, log);
return(false);
}
// Log Outputs
log.LogDebug($"(out) OutputPackagesPath '{OutputPackagesPath}'");
log.LogDebug($"(out) OutputSources '{string.Join(";", OutputSources.Select(p => p))}'");
log.LogDebug($"(out) OutputFallbackFolders '{string.Join(";", OutputFallbackFolders.Select(p => p))}'");
log.LogDebug($"(out) OutputConfigFilePaths '{string.Join(";", OutputConfigFilePaths.Select(p => p))}'");
return(true);
}
public override async Task <IReadOnlyList <PackageSpec> > GetPackageSpecsAsync(DependencyGraphCacheContext context)
{
PackageSpec packageSpec = null;
if (context == null || !context.PackageSpecCache.TryGetValue(MSBuildProjectPath, out packageSpec))
{
packageSpec = JsonPackageSpecReader.GetPackageSpec(ProjectName, JsonConfigPath);
if (packageSpec == null)
{
throw new InvalidOperationException(
string.Format(Strings.ProjectNotLoaded_RestoreFailed, ProjectName));
}
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.OutputPath = await GetBaseIntermediatePathAsync();
metadata.ProjectPath = MSBuildProjectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = MSBuildProjectPath;
// Reload the target framework from csproj and update the target framework in packageSpec for restore
await UpdateInternalTargetFrameworkAsync();
if (TryGetInternalFramework(out var internalTargetFramework))
{
// Ensure the project json has only one target framework
if (packageSpec.TargetFrameworks != null && packageSpec.TargetFrameworks.Count == 1)
{
var replaceTargetFramework = new TargetFrameworkInformation();
replaceTargetFramework.FrameworkName = internalTargetFramework as NuGetFramework;
packageSpec.TargetFrameworks[0] = replaceTargetFramework;
}
}
var references = (await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(context.Logger, CancellationToken.None))
.ToList();
if (references != null && references.Count > 0)
{
// Add msbuild reference groups for each TFM in the project
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
foreach (var reference in references)
{
// This reference applies to all frameworks
// Include/exclude flags may be applied later when merged with project.json
// Add the reference for all TFM groups, there are no conditional project
// references in UWP. There should also be just one TFM.
foreach (var frameworkInfo in metadata.TargetFrameworks)
{
frameworkInfo.ProjectReferences.Add(reference);
}
}
}
// Write restore settings to the package spec.
// For project.json these properties may not come from the project file.
var settings = context?.Settings ?? NullSettings.Instance;
packageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings);
packageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).AsList();
packageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).AsList();
packageSpec.RestoreMetadata.ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).AsList();
context?.PackageSpecCache.Add(MSBuildProjectPath, packageSpec);
}
return(new[] { packageSpec });
}
private async Task <RestoreSummary> PerformNuGetV2RestoreAsync(PackageRestoreInputs packageRestoreInputs)
{
ReadSettings(packageRestoreInputs);
var packagesFolderPath = GetPackagesFolder(packageRestoreInputs);
var sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(SourceProvider);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, packagesFolderPath);
var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer());
if (packageRestoreInputs.RestoringWithSolutionFile)
{
installedPackageReferences.AddRange(packageRestoreInputs
.PackagesConfigFiles
.SelectMany(file => GetInstalledPackageReferences(file, allowDuplicatePackageIds: true)));
}
else if (packageRestoreInputs.PackagesConfigFiles.Count > 0)
{
// By default the PackageReferenceFile does not throw
// if the file does not exist at the specified path.
// So we'll need to verify that the file exists.
Debug.Assert(packageRestoreInputs.PackagesConfigFiles.Count == 1,
"Only one packages.config file is allowed to be specified " +
"at a time when not performing solution restore.");
var packageReferenceFile = packageRestoreInputs.PackagesConfigFiles[0];
if (!File.Exists(packageReferenceFile))
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandFileNotFound"),
packageReferenceFile);
throw new InvalidOperationException(message);
}
installedPackageReferences.AddRange(
GetInstalledPackageReferences(packageReferenceFile, allowDuplicatePackageIds: true));
}
// EffectivePackageSaveMode is None when -PackageSaveMode is not provided by the user. None is treated as
// Defaultv3 for V3 restore and should be treated as Defaultv2 for V2 restore. This is the case in the
// actual V2 restore flow and should match in this preliminary missing packages check.
var packageSaveMode = EffectivePackageSaveMode == Packaging.PackageSaveMode.None ?
Packaging.PackageSaveMode.Defaultv2 :
EffectivePackageSaveMode;
var missingPackageReferences = installedPackageReferences.Where(reference =>
!nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity, packageSaveMode)).ToArray();
if (missingPackageReferences.Length == 0)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallCommandNothingToInstall"),
"packages.config");
Console.LogMinimal(message);
return(new RestoreSummary(true));
}
var packageRestoreData = missingPackageReferences.Select(reference =>
new PackageRestoreData(
reference,
new[] { packageRestoreInputs.RestoringWithSolutionFile
? packageRestoreInputs.DirectoryOfSolutionFile
: packageRestoreInputs.PackagesConfigFiles[0] },
isMissing: true));
var packageSources = GetPackageSources(Settings);
var repositories = packageSources
.Select(sourceRepositoryProvider.CreateRepository)
.ToArray();
var installCount = 0;
var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>();
var collectorLogger = new RestoreCollectorLogger(Console);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packageRestoreData,
CancellationToken.None,
packageRestoredEvent: (sender, args) => { Interlocked.Add(ref installCount, args.Restored ? 1 : 0); },
packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); },
sourceRepositories: repositories,
maxNumberOfParallelTasks: DisableParallelProcessing
? 1
: PackageManagementConstants.DefaultMaxDegreeOfParallelism,
logger: collectorLogger);
CheckRequireConsent();
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(Settings, collectorLogger);
var projectContext = new ConsoleProjectContext(collectorLogger)
{
PackageExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext,
collectorLogger)
};
if (EffectivePackageSaveMode != Packaging.PackageSaveMode.None)
{
projectContext.PackageExtractionContext.PackageSaveMode = EffectivePackageSaveMode;
}
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = NoCache;
cacheContext.DirectDownload = DirectDownload;
var downloadContext = new PackageDownloadContext(cacheContext, packagesFolderPath, DirectDownload)
{
ExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext,
collectorLogger)
};
var result = await PackageRestoreManager.RestoreMissingPackagesAsync(
packageRestoreContext,
projectContext,
downloadContext);
if (downloadContext.DirectDownload)
{
GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext);
}
return(new RestoreSummary(
result.Restored,
"packages.config projects",
SettingsUtility.GetConfigFilePaths(Settings),
packageSources.Select(x => x.Source),
installCount,
collectorLogger.Errors.Concat(ProcessFailedEventsIntoRestoreLogs(failedEvents))));
}
}
