public void GetFallbackPackageFolders_MultipleFoldersFromNuGetConfig() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""d"" value=""C:\Temp\d"" /> <add key=""b"" value=""C:\Temp\b"" /> <add key=""c"" value=""C:\Temp\c"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var mockBaseDirectory = TestDirectory.Create()) { ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config); Settings settings = new Settings(mockBaseDirectory); // Act var paths = SettingsUtility.GetFallbackPackageFolders(settings).ToArray(); // Assert Assert.Equal(3, paths.Length); Assert.Equal("d", GetFileName(paths[0])); Assert.Equal("b", GetFileName(paths[1])); Assert.Equal("c", GetFileName(paths[2])); } }
public void GetFallbackPackageFolders_RelativePathChild() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""shared"" value=""test"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var mockBaseDirectory = TestDirectory.Create()) { var testFolder = Path.Combine(mockBaseDirectory, "test"); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config); Settings settings = new Settings(mockBaseDirectory); // Act var paths = SettingsUtility.GetFallbackPackageFolders(settings); // Assert Assert.Equal(testFolder, paths.Single()); } }
private async Task <RestoreTargetGraph?> RestoreProjectAsync(IEnumerable <NuGetReference> packages, IEnumerable <TargetFrameworkMoniker> tfms, CancellationToken token) { var tfmInfo = tfms.Select(tfm => new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse(tfm.ToFullString()) }).ToList(); // Create a project in a unique and temporary directory var path = Path.Combine(Path.GetTempPath(), "dotnet-ua", "restores", Guid.NewGuid().ToString(), "project.txt"); var spec = new PackageSpec(tfmInfo) { Dependencies = packages.Select(i => new LibraryDependency { LibraryRange = new LibraryRange(i.Name, new VersionRange(i.GetNuGetVersion()), LibraryDependencyTarget.Package), }).ToList(), RestoreMetadata = new() { ProjectPath = path, ProjectName = Path.GetFileNameWithoutExtension(path), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = path, OutputPath = Path.GetTempPath(), OriginalTargetFrameworks = tfms.Select(tfm => tfm.ToFullString()).ToArray(), ConfigFilePaths = _settings.GetConfigFilePaths(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(_settings), Sources = _packageSources.ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(_settings).ToList(), }, FilePath = path, Name = Path.GetFileNameWithoutExtension(path), }; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(spec); dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName); var requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = _context, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(_settings)), Log = new NuGetLogger(_logger), }; // Create requests from the arguments var requests = await requestProvider.CreateRequests(restoreArgs).ConfigureAwait(false); // Restore the package without generating extra files var result = await RestoreRunner.RunWithoutCommit(requests, restoreArgs).ConfigureAwait(false); if (result.Count == 0) { return(null); } return(result[0].Result.RestoreGraphs.FirstOrDefault()); }
public void GetFallbackPackageFolders_WithNullSettings_Throws() { var ex = Record.Exception(() => SettingsUtility.GetFallbackPackageFolders(settings: null)); ex.Should().NotBeNull(); ex.Should().BeOfType <ArgumentNullException>(); }
public void GetFallbackPackageFolders_MultipleFoldersFromMultipleNuGetConfigs() { // Arrange var configA = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""a"" value=""C:\Temp\a"" /> <add key=""b"" value=""C:\Temp\b"" /> </fallbackPackageFolders> </configuration>"; var configB = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""c"" value=""C:\Temp\c"" /> <add key=""d"" value=""C:\Temp\d"" /> </fallbackPackageFolders> </configuration>"; var configC = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""x"" value=""C:\Temp\x"" /> <add key=""y"" value=""C:\Temp\y"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var machineWide = TestDirectory.Create()) using (var mockBaseDirectory = TestDirectory.Create()) { var subFolder = Path.Combine(mockBaseDirectory, "sub"); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, subFolder, configA); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, configB); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, machineWide, configC); var machineWiderFolderSettings = new Settings(machineWide); var machineWideSettings = new TestMachineWideSettings(machineWiderFolderSettings); var settings = Settings.LoadDefaultSettings( subFolder, configFileName: null, machineWideSettings: machineWideSettings); // Act var paths = SettingsUtility.GetFallbackPackageFolders(settings).ToArray(); // Assert Assert.Equal(6, paths.Length); Assert.Equal("a", GetFileName(paths[0])); Assert.Equal("b", GetFileName(paths[1])); Assert.Equal("c", GetFileName(paths[2])); Assert.Equal("d", GetFileName(paths[3])); Assert.Equal("x", GetFileName(paths[4])); Assert.Equal("y", GetFileName(paths[5])); } }
public void GetFallbackPackageFolders_DefaultHasNoFallbackFolders() { // Arrange & Act var paths = SettingsUtility.GetFallbackPackageFolders(new NullSettings()); // Assert Assert.Equal(0, paths.Count); }
public void GetFallbackPackageFolders_MultipleFoldersFromMultipleNuGetConfigs() { // Arrange var configA = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""a"" value=""C:\Temp\a"" /> <add key=""b"" value=""C:\Temp\b"" /> </fallbackPackageFolders> </configuration>"; var configB = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""c"" value=""C:\Temp\c"" /> <add key=""d"" value=""C:\Temp\d"" /> </fallbackPackageFolders> </configuration>"; var configC = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""x"" value=""C:\Temp\x"" /> <add key=""y"" value=""C:\Temp\y"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var machineWide = TestDirectory.Create()) using (var mockBaseDirectory = TestDirectory.Create()) { var subFolder = Path.Combine(mockBaseDirectory, "sub"); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, subFolder, configA); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, configB); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, machineWide, configC); var machineWiderFolderSettings = new Settings(machineWide); var machineWideSettings = new TestMachineWideSettings(machineWiderFolderSettings); var settings = Settings.LoadDefaultSettings( subFolder, configFileName: null, machineWideSettings: machineWideSettings); // Act var actual = SettingsUtility .GetFallbackPackageFolders(settings) .Select(GetFileName); var expected = new[] { "a", "b", "c", "d", "x", "y" }; // Ignore any extra folders on the machine var actualFiltered = Enumerable.Intersect(actual, expected); Assert.Equal(expected, actualFiltered); } }
public void GetFallbackPackageFolders_ClearTag() { // Arrange var configA = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <clear /> <add key=""a"" value=""C:\Temp\a"" /> <add key=""b"" value=""C:\Temp\b"" /> </fallbackPackageFolders> </configuration>"; var configB = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""c"" value=""C:\Temp\c"" /> <add key=""d"" value=""C:\Temp\d"" /> </fallbackPackageFolders> </configuration>"; var configC = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""x"" value=""C:\Temp\x"" /> <add key=""y"" value=""C:\Temp\y"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var machineWide = TestDirectory.Create()) using (var mockBaseDirectory = TestDirectory.Create()) { var subFolder = Path.Combine(mockBaseDirectory, "sub"); SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, subFolder, configA); SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, configB); SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, machineWide, configC); var settings = Settings.LoadSettingsGivenConfigPaths(new[] { Path.Combine(subFolder, nugetConfigPath), Path.Combine(mockBaseDirectory, nugetConfigPath), Path.Combine(machineWide, nugetConfigPath) }); // Act var paths = SettingsUtility.GetFallbackPackageFolders(settings).ToArray(); // Assert Assert.Equal(2, paths.Length); Assert.Equal("a", GetFileName(paths[0])); Assert.Equal("b", GetFileName(paths[1])); } }
/// <summary> /// Returns a PackageReference spec. /// </summary> /// <param name="settings">Settings to be used for the restore metadata.</param> /// <param name="projectName">Project name</param> /// <param name="rootPath">Root path, normally solution root. The project is gonna be "located" at rootPath/projectName/projectName.csproj </param> /// <param name="framework">framework</param> /// <returns>Returns a PackageReference spec with all details similar to what a spec after the post processing before restore would look like. /// The RestoreMetadata has the settings, sources etc set based on the ISettings provided. /// </returns> public static PackageSpec GetPackageSpec(ISettings settings, string projectName, string rootPath = @"C:\", string framework = "net5.0") { var packageSpec = GetPackageSpec(projectName, rootPath, framework); packageSpec.RestoreMetadata.ConfigFilePaths = settings.GetConfigFilePaths(); packageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).ToList(); packageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList(); packageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings); return(packageSpec); }
public static IList <string> GetFallbackFolders(string projectFullPath, ISettings settings, IEnumerable <string> fallbackFolders) { if (ShouldReadFromSettings(fallbackFolders)) { fallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings); } else { fallbackFolders = HandleClear(fallbackFolders); } return(fallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile(projectFullPath, e)).ToList()); }
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() }); }
/// <summary> /// Gets the package fallback folders for a project. /// </summary> /// <param name="startupDirectory">The start-up directory of the tool.</param> /// <param name="projectDirectory">The full path to the directory of the project.</param> /// <param name="fallbackFolders">A <see cref="T:string[]" /> containing the fallback folders for the project.</param> /// <param name="fallbackFoldersOverride">A <see cref="T:string[]" /> containing overrides for the fallback folders for the project.</param> /// <param name="additionalProjectFallbackFolders">An <see cref="IEnumerable{String}" /> containing additional fallback folders for the project.</param> /// <param name="additionalProjectFallbackFoldersExcludes">An <see cref="IEnumerable{String}" /> containing fallback folders to exclude.</param> /// <param name="settings">An <see cref="ISettings" /> object containing settings for the project.</param> /// <returns>A <see cref="T:string[]" /> containing the package fallback folders for the project.</returns> public static string[] GetFallbackFolders(string startupDirectory, string projectDirectory, string[] fallbackFolders, string[] fallbackFoldersOverride, IEnumerable <string> additionalProjectFallbackFolders, IEnumerable <string> additionalProjectFallbackFoldersExcludes, ISettings settings) { // Fallback folders var currentFallbackFolders = RestoreSettingsUtils.GetValue( () => fallbackFoldersOverride?.Select(e => UriUtility.GetAbsolutePath(startupDirectory, e)).ToArray(), () => MSBuildRestoreUtility.ContainsClearKeyword(fallbackFolders) ? Array.Empty <string>() : null, () => fallbackFolders?.Select(e => UriUtility.GetAbsolutePath(projectDirectory, e)).ToArray(), () => SettingsUtility.GetFallbackPackageFolders(settings).ToArray()); // Append additional fallback folders after removing excluded folders var filteredAdditionalProjectFallbackFolders = MSBuildRestoreUtility.AggregateSources( values: additionalProjectFallbackFolders, excludeValues: additionalProjectFallbackFoldersExcludes); return(AppendItems(projectDirectory, currentFallbackFolders, filteredAdditionalProjectFallbackFolders)); }
public static SimpleTestProjectContext CreateProject(string projectName, SimpleTestPathContext pathContext, string projectFrameworks) { var settings = Settings.LoadDefaultSettings(Path.GetDirectoryName(pathContext.NuGetConfig), Path.GetFileName(pathContext.NuGetConfig), null); var project = SimpleTestProjectContext.CreateNETCoreWithSDK( projectName: projectName, solutionRoot: pathContext.SolutionRoot, frameworks: MSBuildStringUtility.Split(projectFrameworks)); project.FallbackFolders = (IList <string>)SettingsUtility.GetFallbackPackageFolders(settings); project.GlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings); var packageSourceProvider = new PackageSourceProvider(settings); project.Sources = packageSourceProvider.LoadPackageSources(); project.Save(); return(project); }
static IList <string> GetFallbackPackageFolders(ISettings settings, IDotNetProject project) { var folders = new List <string> (); AddFolders(folders, project, "RestoreFallbackFolders"); if (folders.Any()) { HandleClear(folders); } else { folders = SettingsUtility.GetFallbackPackageFolders(settings).ToList(); } AddFolders(folders, project, "RestoreAdditionalProjectFallbackFolders"); return(folders); }
private static List <string> GetFallbackFolders(ISettings settings, PackageSpec project) { IEnumerable <string> fallbackFolders = project.RestoreMetadata.FallbackFolders; if (ShouldReadFromSettings(fallbackFolders)) { fallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings); } else { fallbackFolders = HandleClear(fallbackFolders); } // Resolve relative paths return(fallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile( sourceFile: project.RestoreMetadata.ProjectPath, path: e)) .ToList()); }
private IList <string> GetFallbackFolders(ISettings settings, bool shouldThrow = true) { ThreadHelper.ThrowIfNotOnUIThread(); var fallbackFolders = MSBuildStringUtility.Split(_vsProjectAdapter.RestoreFallbackFolders).AsEnumerable(); if (ShouldReadFromSettings(fallbackFolders)) { fallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings); } else { fallbackFolders = VSRestoreSettingsUtilities.HandleClear(fallbackFolders); } // Add additional fallback folders fallbackFolders = fallbackFolders.Concat(MSBuildStringUtility.Split(_vsProjectAdapter.RestoreAdditionalProjectFallbackFolders)); return(fallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile(_projectFullPath, e)).ToList()); }
public static IList <string> GetFallbackFolders(ISettings settings, PackageSpec project) { var results = ProcessEntriesWithAdditional(project.RestoreMetadata.FallbackFolders); var fallbackFolders = results.Item1; var additionalFallbackFolders = results.Item2; var processedFallbackFolders = ( ShouldReadFromSettings(fallbackFolders) ? SettingsUtility.GetFallbackPackageFolders(settings) : HandleClear(fallbackFolders)) .Concat(additionalFallbackFolders); // Resolve relative paths return(processedFallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile( sourceFile: project.RestoreMetadata.ProjectPath, path: e)) .ToList()); }
public void GetFallbackPackageFolders_SingleFolderFromNuGetConfig() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""shared"" value=""a"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var mockBaseDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config); Settings settings = new Settings(mockBaseDirectory); // Act var paths = SettingsUtility.GetFallbackPackageFolders(settings); // Assert Assert.Equal(Path.Combine(mockBaseDirectory, "a"), paths.Single()); } }
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 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 static (RestoreRequest, RestoreResult) Restore(ILogger logger, NuGetFramework nugetFramework, string runtimeIdentifier, string packageName, VersionRange versionRange, string settingsRoot = null) { var settings = NuGet.Configuration.Settings.LoadDefaultSettings(settingsRoot); var assemblies = new List <string>(); var projectPath = Path.Combine("StrideNugetResolver.json"); var spec = new PackageSpec() { // Make sure this package never collides with a dependency Name = Path.GetFileNameWithoutExtension(projectPath), FilePath = projectPath, Dependencies = new List <LibraryDependency>() { new LibraryDependency { LibraryRange = new LibraryRange(packageName, versionRange, LibraryDependencyTarget.Package), } }, TargetFrameworks = { new TargetFrameworkInformation { FrameworkName = nugetFramework, } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(projectPath), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectPath, OutputPath = Path.Combine(Path.GetTempPath(), $"StrideNugetResolver-{packageName}-{versionRange.MinVersion.ToString()}-{nugetFramework.GetShortFolderName()}-{runtimeIdentifier}"), OriginalTargetFrameworks = new[] { nugetFramework.GetShortFolderName() }, ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings), Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, RuntimeGraph = new RuntimeGraph(new[] { new RuntimeDescription(runtimeIdentifier) }) }; using (var context = new SourceCacheContext()) { context.IgnoreFailedSources = true; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(spec); dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = context, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)), Log = logger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the packages for (int tryCount = 0; tryCount < 2; ++tryCount) { try { var results = RestoreRunner.RunWithoutCommit(requests, restoreArgs).Result; // Commit results so that noop cache works next time foreach (var result in results) { result.Result.CommitAsync(logger, CancellationToken.None).Wait(); } var mainResult = results.First(); return(mainResult.SummaryRequest.Request, mainResult.Result); } catch (Exception e) when(e is UnauthorizedAccessException || e is IOException || ((e is AggregateException ae) && ae.InnerExceptions.Any(e2 => e2 is UnauthorizedAccessException || e2 is IOException))) { // If we have an unauthorized access exception, it means assemblies are locked by running Stride process // During first try, kill some known harmless processes, and try again if (tryCount == 1) { throw; } foreach (var process in new[] { "Stride.ConnectionRouter" }.SelectMany(Process.GetProcessesByName)) { try { if (process.Id != Process.GetCurrentProcess().Id) { process.Kill(); process.WaitForExit(); } } catch { } } } } Debug.Fail("Unreachable code"); return(default);
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 async Task GetPackageSpecsAsync_ReadSettingsWithFullPaths(string restorePackagesPath, string sources, string fallbackFolders) { // Arrange using (var testDirectory = TestDirectory.Create()) { var projectAdapter = CreateProjectAdapter(testDirectory); Mock.Get(projectAdapter) .SetupGet(x => x.RestorePackagesPath) .Returns(restorePackagesPath); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreSources) .Returns(sources); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreFallbackFolders) .Returns(fallbackFolders); var projectServices = new TestProjectSystemServices(); var testProject = new LegacyPackageReferenceProject( projectAdapter, Guid.NewGuid().ToString(), projectServices, _threadingService); var settings = NullSettings.Instance; var testDependencyGraphCacheContext = new DependencyGraphCacheContext(NullLogger.Instance, settings); await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync(); // Act var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext); // Assert Assert.NotNull(packageSpecs); var actualRestoreSpec = packageSpecs.Single(); SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec); // Assert packagespath Assert.Equal(restorePackagesPath != null ? restorePackagesPath : SettingsUtility.GetGlobalPackagesFolder(settings), actualRestoreSpec.RestoreMetadata.PackagesPath); // assert sources var specSources = actualRestoreSpec.RestoreMetadata.Sources.Select(e => e.Source); var expectedSources = sources != null?MSBuildStringUtility.Split(sources) : SettingsUtility.GetEnabledSources(settings).Select(e => e.Source); Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t))); // assert fallbackfolders var specFallback = actualRestoreSpec.RestoreMetadata.FallbackFolders; var expectedFolders = fallbackFolders != null?MSBuildStringUtility.Split(fallbackFolders) : SettingsUtility.GetFallbackPackageFolders(settings); Assert.True(Enumerable.SequenceEqual(expectedFolders.OrderBy(t => t), specFallback.OrderBy(t => t))); // Verify Mock.Get(projectAdapter) .Verify(x => x.RestorePackagesPath, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreSources, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreFallbackFolders, Times.Once); } }
public NuGetSourceRepositoryProvider(ISettings settings, ICakeConfiguration config, PackageReference package, string packagesRoot) { if (settings is null) { throw new ArgumentNullException(nameof(settings)); } if (config is null) { throw new ArgumentNullException(nameof(config)); } if (package is null) { throw new ArgumentNullException(nameof(package)); } // Create the default v3 resource provider _resourceProviders = new List <Lazy <INuGetResourceProvider> >(); _resourceProviders.AddRange(Repository.Provider.GetCoreV3()); // Add repositories var sourceComparer = new NuGetSourceRepositoryComparer(); _repositories = new HashSet <SourceRepository>(sourceComparer); _primaryRepositories = new HashSet <SourceRepository>(sourceComparer); _localRepositories = new HashSet <SourceRepository>(sourceComparer); _localRepositories.Add(CreateRepository(packagesRoot)); _localRepositories.Add(CreateRepository(SettingsUtility.GetGlobalPackagesFolder(settings))); _localRepositories.AddRange(SettingsUtility.GetFallbackPackageFolders(settings).Select(CreateRepository)); var packageSources = new PackageSourceProvider(settings).LoadPackageSources().ToList(); if (package.Address != null) { var repository = GetOrCreateRepository(package.Address.AbsoluteUri); // Sources specified in directive is always primary. _repositories.Add(repository); _primaryRepositories.Add(repository); } var nugetSources = config.GetValue(Constants.NuGet.Source); if (!string.IsNullOrEmpty(nugetSources)) { foreach (var nugetSource in nugetSources.Split(';')) { if (!string.IsNullOrWhiteSpace(nugetSource)) { var repository = GetOrCreateRepository(nugetSource); _repositories.Add(repository); // If source is not specified in directive, add it as primary source. if (package.Address == null) { _primaryRepositories.Add(repository); } } } } else { // Only add sources added via NuGet.config if nuget_source configuration value is not specified. foreach (var source in packageSources) { if (source.IsEnabled) { var repository = CreateRepository(source); _repositories.Add(repository); // If source is not specified in directive, add it as primary source. if (package.Address == null) { _primaryRepositories.Add(repository); } } } } SourceRepository GetOrCreateRepository(string source) { var packageSource = packageSources .Where(p => p.IsEnabled) .FirstOrDefault(p => p.Source.Equals(source, StringComparison.OrdinalIgnoreCase)); return(packageSource == null? CreateRepository(source) : CreateRepository(packageSource)); } }
/// <summary> /// Fetch, if not already downloaded, and install the package represented by /// (<paramref name="packageId"/>, <paramref name="version"/>). /// </summary> /// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks> /// <param name="packageId">Name of package to install.</param> /// <param name="version">Version of package to install.</param> public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, IEnumerable <string> targetFrameworks, ProgressReport progress) { using (GetLocalRepositoryLock()) { currentProgressReport = progress; try { var identity = new PackageIdentity(packageId, version.ToNuGetVersion()); var resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, true, true, VersionConstraints.None); var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray(); var projectContext = new EmptyNuGetProjectContext() { ActionType = NuGetActionType.Install, PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.Skip, null, NativeLogger), }; ActivityCorrelationId.StartNew(); { var installPath = SettingsUtility.GetGlobalPackagesFolder(settings); // In case it's a package without any TFM (i.e. Visual Studio plugin), we still need to specify one if (!targetFrameworks.Any()) { targetFrameworks = new string[] { "net6.0" } } ; // Old version expects to be installed in GamePackages if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0) && oldRootDirectory != null) { installPath = oldRootDirectory; } var projectPath = Path.Combine("StrideLauncher.json"); var spec = new PackageSpec() { Name = Path.GetFileNameWithoutExtension(projectPath), // make sure this package never collides with a dependency FilePath = projectPath, Dependencies = new List <LibraryDependency>() { new LibraryDependency { LibraryRange = new LibraryRange(packageId, new VersionRange(version.ToNuGetVersion()), LibraryDependencyTarget.Package), } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(projectPath), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectPath, OutputPath = Path.Combine(Path.GetTempPath(), $"StrideLauncher-{packageId}-{version.ToString()}"), OriginalTargetFrameworks = targetFrameworks.ToList(), ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = installPath, Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, }; foreach (var targetFramework in targetFrameworks) { spec.TargetFrameworks.Add(new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse(targetFramework) }); } using (var context = new SourceCacheContext { MaxAge = DateTimeOffset.UtcNow }) { context.IgnoreFailedSources = true; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(spec); dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = context, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)), Log = NativeLogger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; foreach (var request in requests) { // Limit concurrency to avoid timeout request.Request.MaxDegreeOfConcurrency = 4; var command = new RestoreCommand(request.Request); // Act var result = await command.ExecuteAsync(); if (!result.Success) { throw new InvalidOperationException($"Could not restore package {packageId}"); } foreach (var install in result.RestoreGraphs.Last().Install) { var package = result.LockFile.Libraries.FirstOrDefault(x => x.Name == install.Library.Name && x.Version == install.Library.Version); if (package != null) { var packagePath = Path.Combine(installPath, package.Path); OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(install.Library.Name, install.Library.Version.ToPackageVersion()), packagePath)); } } } } if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0)) { UpdateTargetsHelper(); } } // Load the recently installed package var installedPackages = GetPackagesInstalled(new[] { packageId }); return(installedPackages.FirstOrDefault(p => p.Version == version)); } finally { currentProgressReport = null; } } }
public static async Task <(RestoreRequest, RestoreResult)> Restore(ILogger logger, string packageName, VersionRange versionRange) { var settings = NuGet.Configuration.Settings.LoadDefaultSettings(null); var packageSourceProvider = new PackageSourceProvider(settings); var installPath = SettingsUtility.GetGlobalPackagesFolder(settings); var assemblies = new List <string>(); var projectPath = Path.Combine("XenkoNugetResolver.json"); var spec = new PackageSpec() { Name = Path.GetFileNameWithoutExtension(projectPath), // make sure this package never collides with a dependency FilePath = projectPath, Dependencies = new List <LibraryDependency>() { new LibraryDependency { LibraryRange = new LibraryRange(packageName, versionRange, LibraryDependencyTarget.Package), } }, TargetFrameworks = { new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse("net48"), } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(projectPath), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectPath, OutputPath = Path.Combine(Path.GetTempPath(), $"XenkoNugetResolver-{packageName}-{versionRange.MinVersion.ToString()}"), OriginalTargetFrameworks = new[] { "net48" }, ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings), Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, }; // remove all remote sources, so we don't have to worry about connectivity issues // we are only restoring local dev packages anyway for (int i = 0; i < spec.RestoreMetadata.Sources.Count; i++) { var s = spec.RestoreMetadata.Sources[i]; if (s.IsLocal == false) { spec.RestoreMetadata.Sources.RemoveAt(i); i--; } } using (var context = new SourceCacheContext()) { context.IgnoreFailedSources = true; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(spec); dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = context, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)), Log = logger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the packages for (int tryCount = 0; tryCount < 2; ++tryCount) { try { var results = await RestoreRunner.RunWithoutCommit(requests, restoreArgs); // Commit results so that noop cache works next time foreach (var result in results) { await result.Result.CommitAsync(logger, CancellationToken.None); } var mainResult = results.First(); return(mainResult.SummaryRequest.Request, mainResult.Result); } catch (Exception e) when(e is UnauthorizedAccessException || e is IOException) { // If we have an unauthorized access exception, it means assemblies are locked by running Xenko process // During first try, kill some known harmless processes, and try again if (tryCount == 1) { throw; } foreach (var process in new[] { "Xenko.ConnectionRouter" }.SelectMany(Process.GetProcessesByName)) { try { if (process.Id != Process.GetCurrentProcess().Id) { process.Kill(); process.WaitForExit(); } } catch (Exception) { } } } } throw new InvalidOperationException("Unreachable code"); } }
public IReadOnlyList <string> GetEffectiveFallbackPackageFolders(ISettings settings) { return(SettingsUtility.GetFallbackPackageFolders(settings)); }
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)); } }
/// <summary> /// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json). /// </summary> /// <param name="libraryIdentity">The <see cref="LibraryIdentity"/> 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(LibraryIdentity libraryIdentity, ISettings settings, ILogger logger) { using (var sourceCacheContext = new SourceCacheContext { IgnoreFailedSources = true, }) { var projectDirectory = Path.Combine(NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), Guid.NewGuid().ToString("N")); var projectName = Guid.NewGuid().ToString("N"); var projectFullPath = Path.Combine(projectDirectory, $"{projectName}.proj"); // Iterate through TargetFrameworks to generate Lists required for packageSpec var frameworks = new List <TargetFrameworkInformation>(TargetFrameworks.Count); var originalTargetFrameworks = new List <string>(TargetFrameworks.Count); foreach (var tf in TargetFrameworks) { frameworks.Add(new TargetFrameworkInformation { FrameworkName = tf }); originalTargetFrameworks.Add(tf.ToString()); } // The package spec details what packages to restore var packageSpec = new PackageSpec(frameworks) { Dependencies = new List <LibraryDependency> { new LibraryDependency { LibraryRange = new LibraryRange( libraryIdentity.Name, new VersionRange( minVersion: libraryIdentity.Version, includeMinVersion: true, maxVersion: libraryIdentity.Version, includeMaxVersion: true), LibraryDependencyTarget.Package), SuppressParent = LibraryIncludeFlags.All, AutoReferenced = true, IncludeType = LibraryIncludeFlags.None, } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectFullPath, ProjectName = projectName, ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectFullPath, OutputPath = projectDirectory, OriginalTargetFrameworks = originalTargetFrameworks, ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings), Sources = SettingsUtility.GetEnabledSources(settings).AsList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, FilePath = projectFullPath, Name = projectName, }; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(packageSpec); dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = false, CacheContext = sourceCacheContext, #pragma warning disable CS0618 // Type or member is obsolete CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false)), #pragma warning restore CS0618 // Type or member is obsolete Log = logger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the package without generating extra files return(RestoreRunner.RunWithoutCommit(requests, restoreArgs)); } }