/// <summary> /// Create a restore context. /// </summary> private static RestoreArgs GetRestoreContext( DependencyGraphCacheContext context, RestoreCommandProvidersCache providerCache, SourceCacheContext sourceCacheContext, IEnumerable <SourceRepository> sources, DependencyGraphSpec dgFile, bool forceRestore) { var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings)); foreach (var source in sources) { caching.AddSourceRepository(source); } var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile); var restoreContext = new RestoreArgs() { CacheContext = sourceCacheContext, PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>() { dgProvider }, Log = context.Logger, AllowNoOp = !forceRestore, CachingSourceProvider = caching }; return(restoreContext); }
/// <summary> /// Create a restore context. /// </summary> private static RestoreArgs GetRestoreContext( DependencyGraphCacheContext context, RestoreCommandProvidersCache providerCache, ISettings settings, SourceCacheContext sourceCacheContext, IEnumerable <SourceRepository> sources, DependencyGraphSpec dgFile, string userPackagesPath) { var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile, settings); var restoreContext = new RestoreArgs() { CacheContext = sourceCacheContext, PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>() { dgProvider }, Log = context.Logger, SourceRepositories = sources.ToList(), GlobalPackagesFolder = userPackagesPath // Optional, this will load from settings if null }; return(restoreContext); }
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 GetMessagesForProject_WithMultipleMessages_SelectedMessagesForCorrectProject() { // Arrange var project1 = @"z:\src\solution\project1\project1.csproj"; var project2 = @"z:\src\solution\project2\project2.csproj"; var project1Error = RestoreLogMessage.CreateError(NuGetLogCode.NU1001, "project1 error"); project1Error.ProjectPath = project1; var project2Error = RestoreLogMessage.CreateError(NuGetLogCode.NU1002, "project2 error"); project2Error.ProjectPath = project2; var solutionMessages = new List <IAssetsLogMessage>() { AssetsLogMessage.Create(project1Error), AssetsLogMessage.Create(project2Error) }; // Act IReadOnlyList <IAssetsLogMessage> actual = DependencyGraphSpecRequestProvider.GetMessagesForProject(solutionMessages, project1); // Assert var actualError = Assert.Single(actual); Assert.Equal(NuGetLogCode.NU1001, actualError.Code); }
private async Task <RestoreTargetGraph> GenerateRestoreGraph(ILogger log, string projectName, string projectPath) { var dgFile = await VSProjectHelper.GenerateRestoreGraphFile(log, projectPath); var dgProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dgFile); using (var cacheContext = new SourceCacheContext()) { var restoreContext = new RestoreArgs(); restoreContext.CacheContext = cacheContext; restoreContext.Log = new NuGet.Common.NullLogger(); restoreContext.PreLoadedRequestProviders.Add(dgProvider); var request = (await dgProvider.CreateRequests(restoreContext)).Single(); var restoreRequest = request.Request; var collectorLogger = new RestoreCollectorLogger(restoreRequest.Log, false); var contextForProject = CreateRemoteWalkContext(restoreRequest, collectorLogger); // Get external project references // If the top level project already exists, update the package spec provided // with the RestoreRequest spec. var updatedExternalProjects = GetProjectReferences(restoreRequest, contextForProject); // Load repositories // the external project provider is specific to the current restore project contextForProject.ProjectLibraryProviders.Add(new PackageSpecReferenceDependencyProvider(updatedExternalProjects, restoreRequest.Log)); var walker = new RemoteDependencyWalker(contextForProject); var requestProject = request.Request.Project; var projectRange = new LibraryRange() { Name = projectName, VersionRange = new NuGet.Versioning.VersionRange(requestProject.Version), TypeConstraint = LibraryDependencyTarget.Project | LibraryDependencyTarget.ExternalProject }; var framework = requestProject.TargetFrameworks.First(); var graphs = new List <GraphNode <RemoteResolveResult> > { await walker.WalkAsync( projectRange, framework.FrameworkName, null, RuntimeGraph.Empty, recursive : true) }; return(RestoreTargetGraph.Create(graphs, contextForProject, restoreRequest.Log, framework.FrameworkName)); } }
/// <summary> /// Create a restore request for the specs. Restore only the first one. /// </summary> public static async Task <RestoreRequest> GetRequestAsync( RestoreArgs restoreContext, params PackageSpec[] projects) { var dgSpec = GetDGSpec(projects); var dgProvider = new DependencyGraphSpecRequestProvider( new RestoreCommandProvidersCache(), dgSpec); var requests = await dgProvider.CreateRequests(restoreContext); return(requests.Single().Request); }
/// <summary> /// Create a restore args. /// </summary> private static RestoreArgs GetRestoreArgs( DependencyGraphCacheContext context, RestoreCommandProvidersCache providerCache, SourceCacheContext sourceCacheContext, IEnumerable <SourceRepository> sources, DependencyGraphSpec dgFile, Guid parentId, bool forceRestore, bool isRestoreOriginalAction, bool restoreForceEvaluate, IReadOnlyList <IAssetsLogMessage> additionalMessasges, IRestoreProgressReporter progressReporter) { #pragma warning disable CS0618 // Type or member is obsolete var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings, enablePackageSourcesChangedEvent: false)); #pragma warning restore CS0618 // Type or member is obsolete foreach (var source in sources) { caching.AddSourceRepository(source); } var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile); var restoreContext = new RestoreArgs() { CacheContext = sourceCacheContext, PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>() { dgProvider }, Log = context.Logger, AllowNoOp = !forceRestore, CachingSourceProvider = caching, ParentId = parentId, IsRestoreOriginalAction = isRestoreOriginalAction, RestoreForceEvaluate = restoreForceEvaluate, AdditionalMessages = additionalMessasges, ProgressReporter = progressReporter, }; return(restoreContext); }
public static TestRestoreRequest CreateRestoreRequest(PackageSpec projectToRestore, IEnumerable <PackageSpec> packageSpecsClosure, SimpleTestPathContext pathContext, ILogger logger) { var sources = new List <PackageSource> { new PackageSource(pathContext.PackageSource) }; var dgSpec = new DependencyGraphSpec(); dgSpec.AddProject(projectToRestore); dgSpec.AddRestore(projectToRestore.RestoreMetadata.ProjectUniqueName); foreach (var spec in packageSpecsClosure) { dgSpec.AddProject(spec); } var externalClosure = DependencyGraphSpecRequestProvider.GetExternalClosure(dgSpec, projectToRestore.RestoreMetadata.ProjectUniqueName).ToList(); return(new TestRestoreRequest(projectToRestore, sources, pathContext.UserPackagesFolder, logger) { LockFilePath = Path.Combine(projectToRestore.FilePath, LockFileFormat.AssetsFileName), DependencyGraphSpec = dgSpec, ExternalProjects = externalClosure, }); }
/// <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"); } }
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);