private static async Task <RestoreTargetGraph> GetPlatformSpecificGraph(RestoreTargetGraph independentGraph, string package, string version, NuGetFramework framework, string runtimeIdentifier, RemoteWalkContext context, LocalPackageExtractor extractor) { var graphTask = independentGraph.Flattened .Where(m => m.Data?.Match?.Library?.Type == LibraryType.Package) .Select(GetRuntimeGraphTask); var graphs = (await Task.WhenAll(graphTask)) .Where(i => i != null); var runtimeGraph = graphs.Aggregate(RuntimeGraph.Empty, RuntimeGraph.Merge); // This results in additional entries var resultWin = await new RemoteDependencyWalker(context).WalkAsync( new LibraryRange(package, VersionRange.Parse(version), LibraryDependencyTarget.All), framework, runtimeGraph: runtimeGraph, recursive: true, runtimeIdentifier: runtimeIdentifier); return(RestoreTargetGraph.Create(runtimeGraph, new[] { resultWin }, context, context.Logger, framework, runtimeIdentifier)); async Task <RuntimeGraph> GetRuntimeGraphTask(GraphItem <RemoteResolveResult> item) { var packageIdentity = ToPackageIdentity(item.Data.Match); var localPackageSourceInfo = await extractor.EnsureLocalPackage(item.Data.Match.Provider, packageIdentity); return(localPackageSourceInfo?.Package?.RuntimeGraph); } }
private void DetectMissingTransitiveDependencies(List <PackageReference> packages, string projectPath) { List <NuGetFramework> targetFrameworks = new List <NuGetFramework> { FrameworkConstants.CommonFrameworks.Net45 }; using (SourceCacheContext sourceCacheContext = new SourceCacheContext { IgnoreFailedSources = true, }) { RestoreTargetGraph restoreTargetGraph = GetRestoreTargetGraph(packages, projectPath, targetFrameworks, sourceCacheContext); if (restoreTargetGraph != null) { var flatPackageDependencies = restoreTargetGraph.Flattened.Where(i => i.Key.Type == LibraryType.Package); foreach (var packageDependency in flatPackageDependencies) { var(library, metadata) = (packageDependency.Key, packageDependency.Data); PackageReference packageReference = packages.FirstOrDefault(i => i.PackageId.Equals(library.Name, StringComparison.OrdinalIgnoreCase)); if (packageReference == null) { Log.Warn($"{projectPath}: The transitive package dependency \"{library.Name} {library.Version}\" was not in the packages.config. After converting to PackageReference, new dependencies will be pulled in transitively which could lead to restore or build errors"); packages.Add(new PackageReference(new PackageIdentity(library.Name, library.Version), NuGetFramework.AnyFramework, true, false, true, new VersionRange(library.Version), PackagePathResolver, VersionFolderPathResolver) { IsMissingTransitiveDependency = true }); } } } } }
public static RestoreTargetGraph GetRestoreTargetGraph( string source, PackageIdentity identity, FileInfo packagePath, TestLogger logger) { var libraryRange = new LibraryRange { Name = identity.Id }; var libraryIdentity = new LibraryIdentity(identity.Id, identity.Version, LibraryType.Package); var dependencyProvider = new Mock <IRemoteDependencyProvider>(); IPackageDownloader packageDependency = null; dependencyProvider .Setup(x => x.GetPackageDownloaderAsync( It.IsAny <PackageIdentity>(), It.IsAny <SourceCacheContext>(), It.IsAny <ILogger>(), It.IsAny <CancellationToken>())) .Callback <PackageIdentity, SourceCacheContext, ILogger, CancellationToken>( (callbackIdentity, sourceCacheContext, callbackLogger, cancellationToken) => { packageDependency = new LocalPackageArchiveDownloader( source, packagePath.FullName, callbackIdentity, callbackLogger); }) .Returns(() => Task.FromResult(packageDependency)); var graph = RestoreTargetGraph.Create( new[] { new GraphNode <RemoteResolveResult>(libraryRange) { Item = new GraphItem <RemoteResolveResult>(libraryIdentity) { Data = new RemoteResolveResult { Match = new RemoteMatch { Library = libraryIdentity, Provider = dependencyProvider.Object } } } } }, new TestRemoteWalkContext(), logger, FrameworkConstants.CommonFrameworks.NetStandard16); return(graph); }
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)); } }
private async Task <RestoreTargetGraph> GetIndependentGraph(string package, string version, NuGetFramework nuGetFramework, RemoteWalkContext context) { var result = await new RemoteDependencyWalker(context).WalkAsync( new LibraryRange(package, VersionRange.Parse(version), LibraryDependencyTarget.All), nuGetFramework, runtimeGraph: RuntimeGraph.Empty, recursive: true, runtimeIdentifier: null); return(RestoreTargetGraph.Create(RuntimeGraph.Empty, new[] { result }, _context, _context.Logger, nuGetFramework, runtimeIdentifier: null)); }
private static RestoreTargetGraph GetRestoreTargetGraph(PackageIdentity identity, FileInfo packagePath, TestLogger logger) { var libraryRange = new LibraryRange { Name = identity.Id }; var libraryIdentity = new LibraryIdentity(identity.Id, identity.Version, LibraryType.Package); var dependencyProvider = new Mock <IRemoteDependencyProvider>(); dependencyProvider .Setup(x => x.CopyToAsync( It.IsAny <LibraryIdentity>(), It.IsAny <Stream>(), It.IsAny <SourceCacheContext>(), It.IsAny <ILogger>(), It.IsAny <CancellationToken>())) .Callback <LibraryIdentity, Stream, SourceCacheContext, ILogger, CancellationToken>( (_, destination, __, ___, ____) => { using (var package = File.OpenRead(packagePath.FullName)) { package.CopyTo(destination); } }) .Returns(Task.CompletedTask); var graph = RestoreTargetGraph.Create( new[] { new GraphNode <RemoteResolveResult>(libraryRange) { Item = new GraphItem <RemoteResolveResult>(libraryIdentity) { Data = new RemoteResolveResult { Match = new RemoteMatch { Library = libraryIdentity, Provider = dependencyProvider.Object } } } } }, new TestRemoteWalkContext(), logger, FrameworkConstants.CommonFrameworks.NetStandard16); return(graph); }
public async Task <IReadOnlyCollection <LocalPackageSourceInfo> > DownloadPackages(RestoreTargetGraph dependencyGraph) { return(await Task.WhenAll(dependencyGraph.Flattened .Where(i => !string.Equals(i.Key.Name, _rootProjectName, StringComparison.OrdinalIgnoreCase)) .Select(DownloadPackage))); }
public RestoreResult GetRestoreResult(IEnumerable <PackageIdentity> identities) { var node = new GraphNode <RemoteResolveResult>(new LibraryRange("project", LibraryDependencyTarget.All)) { Item = new GraphItem <RemoteResolveResult>( new LibraryIdentity( "project", new NuGetVersion("1.0.0"), LibraryType.Project)) { Data = new RemoteResolveResult { Match = new RemoteMatch { Provider = null } } } }; foreach (var identity in identities) { var dependencyNode = new GraphNode <RemoteResolveResult>( new LibraryRange( identity.Id, new VersionRange(identity.Version), LibraryDependencyTarget.All)) { Item = new GraphItem <RemoteResolveResult>( new LibraryIdentity( identity.Id, identity.Version, LibraryType.Package)) { Data = new RemoteResolveResult { Match = new RemoteMatch { Provider = null } } } }; dependencyNode.OuterNode = node; node.InnerNodes.Add(dependencyNode); } var graph = RestoreTargetGraph.Create( new[] { node }, new TestRemoteWalkContext(), NullLogger.Instance, FrameworkConstants.CommonFrameworks.NetStandard10); return(new RestoreResult( true, new[] { graph }, null, null, null, null, null, null, null, null, null, ProjectStyle.Unknown, TimeSpan.MinValue)); }
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 TargetGraphLookup(RestoreTargetGraph graph) { _graph = graph; }