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); } }
public static async Task Main(string[] args) { var builder = WebAssemblyHostBuilder.CreateDefault(args); builder.RootComponents.Add <App>("app"); builder.Services.AddSingleton(serviceProvider => (IJSInProcessRuntime)serviceProvider.GetRequiredService <IJSRuntime>()); builder.Services.AddSingleton(serviceProvider => (IJSUnmarshalledRuntime)serviceProvider.GetRequiredService <IJSRuntime>()); builder.Services.AddSingleton(_ => new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) }); builder.Services.AddSingleton <SnippetsService>(); builder.Services.AddSingleton <CompilationService>(); builder.Services.AddSingleton <NuGetRemoteDependencyProvider>(); builder.Services.AddTransient <NuGetPackageManagementService>(); builder.Services.AddSingleton(serviceProvider => { var remoteWalkContext = new RemoteWalkContext(NullSourceCacheContext.Instance, NullLogger.Instance); var remoteDependencyProvider = serviceProvider.GetRequiredService <NuGetRemoteDependencyProvider>(); remoteWalkContext.RemoteLibraryProviders.Add(remoteDependencyProvider); return(new RemoteDependencyWalker(remoteWalkContext)); }); builder.Services .AddOptions <SnippetsOptions>() .Configure <IConfiguration>((options, configuration) => configuration.GetSection("Snippets").Bind(options)); builder.Logging.Services.AddSingleton <ILoggerProvider, HandleCriticalUserComponentExceptionsLoggerProvider>(); var jsRuntime = GetJsRuntime(); try { await LoadResourcesAsync(jsRuntime); if (TryExecuteUserDefinedConfiguration(builder)) { // If the user defined configuration code has executed, the user components DLL is now // loaded in the app domain so we reset the DLL in the storage for the next app load jsRuntime.InvokeUnmarshalled <string, object>( "App.CodeExecution.updateUserComponentsDll", CoreConstants.DefaultUserComponentsAssemblyBytes); } } catch (Exception ex) { // We shouldn't throw during app start so just give the user the info that an exception has been thrown, // update the user components DLL to make sure the app will run on reload and continue the app execution var actualException = ex is TargetInvocationException tie ? tie.InnerException : ex; Console.Error.WriteLine($"Error on app startup: {actualException}"); jsRuntime.InvokeUnmarshalled <string, object>( "App.CodeExecution.updateUserComponentsDll", CoreConstants.DefaultUserComponentsAssemblyBytes); } await builder.Build().RunAsync(); }
public async Task NearestWinsOverridesStrictDependencyButDowngradeWarns() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0") .DependsOn("B", "2.0") .DependsOn("C", "2.0") .DependsOn("D", "1.0"); provider.Package("B", "2.0") .DependsOn("D", "[2.0]"); provider.Package("C", "2.0") .DependsOn("D", "[1.0]"); provider.Package("D", "1.0"); provider.Package("D", "2.0"); provider.Package("D", "3.0"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var result = node.Analyze(); Assert.Equal(0, result.VersionConflicts.Count); Assert.Equal(1, result.Downgrades.Count); var downgraded = result.Downgrades[0].DowngradedFrom; var downgradedBy = result.Downgrades[0].DowngradedTo; AssertPath(downgraded, "A 1.0", "B 2.0", "D 2.0"); AssertPath(downgradedBy, "A 1.0", "D 1.0"); }
public async Task DowngradeThenUpgradeThenDowngrade() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0") .DependsOn("B", "1.0") .DependsOn("C", "1.0"); provider.Package("B", "1.0"); provider.Package("C", "1.0") .DependsOn("B", "2.0") .DependsOn("D", "1.0"); provider.Package("B", "2.0"); provider.Package("D", "1.0") .DependsOn("B", "1.0"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var result = node.Analyze(); Assert.Equal(1, result.Downgrades.Count); var downgraded = result.Downgrades[0].DowngradedFrom; var downgradedBy = result.Downgrades[0].DowngradedTo; AssertPath(downgraded, "A 1.0", "C 1.0", "B 2.0"); AssertPath(downgradedBy, "A 1.0", "B 1.0"); }
public async Task TryResolveConflicts_ThrowsIfPackageConstraintCannotBeResolved() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("Root", "1.0") .DependsOn("A", "1.0") .DependsOn("B", "2.0"); provider.Package("A", "1.0") .DependsOn("C", "(1.0, 1.4]"); provider.Package("B", "2.0") .DependsOn("C", "1.8"); provider.Package("C", "1.3.8"); provider.Package("C", "1.8"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "Root"); var result = node.Analyze(); Assert.Equal(1, result.VersionConflicts.Count); var conflict = result.VersionConflicts[0]; var c1 = conflict.Selected; var c2 = conflict.Conflicting; AssertPath(c1, "Root 1.0", "B 2.0", "C 1.8"); AssertPath(c2, "Root 1.0", "A 1.0", "C 1.3.8"); }
public async Task StrictDependenciesButNoConflict() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0") .DependsOn("B", "2.0") .DependsOn("C", "2.0"); provider.Package("B", "2.0") .DependsOn("D", "[2.0]"); provider.Package("C", "2.0") .DependsOn("D", "[1.0, 3.0]"); provider.Package("D", "1.0"); provider.Package("D", "2.0"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var result = node.Analyze(); Assert.Equal(0, result.VersionConflicts.Count); }
public async Task SingleConflictWhereConflictingDependenyIsUnresolved() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0") .DependsOn("B", "2.0") .DependsOn("C", "2.0"); provider.Package("B", "2.0") .DependsOn("D", "[2.0]"); provider.Package("C", "2.0") .DependsOn("D", "[1.0]"); provider.Package("D", "2.0"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var result = node.Analyze(); Assert.Equal(1, result.VersionConflicts.Count); var conflict = result.VersionConflicts[0]; var c1 = conflict.Selected; var c2 = conflict.Conflicting; AssertPath(c1, "A 1.0", "B 2.0", "D 2.0"); AssertPath(c2, "A 1.0", "C 2.0", "D 1.0"); }
public async Task UpgradeThenDowngradeThenEqual() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0") .DependsOn("B", "2.0") .DependsOn("C", "1.0"); provider.Package("B", "1.0"); provider.Package("C", "1.0") .DependsOn("B", "1.0") .DependsOn("D", "1.0"); provider.Package("B", "2.0"); provider.Package("D", "1.0") .DependsOn("B", "2.0"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var result = node.Analyze(); Assert.Equal(0, result.Downgrades.Count); }
public async Task GivenAMultipleSourcesVerifyInfosReturned() { var versions1 = new[] { NuGetVersion.Parse("1.0.0"), NuGetVersion.Parse("2.0.0"), NuGetVersion.Parse("3.0.0-beta"), }; var versions2 = new[] { NuGetVersion.Parse("1.0.0") }; var provider1 = GetProvider("http://nuget.org/a/", versions1); var provider2 = GetProvider("http://nuget.org/b/", versions2); var cacheContext = new Mock <SourceCacheContext>(); var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, NullLogger.Instance); remoteWalkContext.RemoteLibraryProviders.Add(provider1.Object); remoteWalkContext.RemoteLibraryProviders.Add(provider2.Object); var infos = await UnresolvedMessages.GetSourceInfosForIdAsync("a", VersionRange.Parse("1.0.0"), remoteWalkContext, NullLogger.Instance, CancellationToken.None); infos.Count.Should().Be(2); infos[0].Value.ShouldBeEquivalentTo(versions1); infos[1].Value.ShouldBeEquivalentTo(versions2); infos[0].Key.Source.Should().Be("http://nuget.org/a/"); infos[1].Key.Source.Should().Be("http://nuget.org/b/"); }
/// <summary> /// Log errors for missing dependencies. /// </summary> public static async Task LogAsync(IEnumerable <IRestoreTargetGraph> graphs, RemoteWalkContext context, ILogger logger, CancellationToken token) { var tasks = graphs.SelectMany(graph => graph.Unresolved.Select(e => GetMessageAsync(graph.TargetGraphName, e, context.RemoteLibraryProviders, context.CacheContext, logger, token))).ToArray(); var messages = await Task.WhenAll(tasks); await logger.LogMessagesAsync(DiagnosticUtility.MergeOnTargetGraph(messages)); }
private LockFile BuildLockFile( LockFile existingLockFile, PackageSpec project, IEnumerable <RestoreTargetGraph> graphs, NuGetv3LocalRepository localRepository, RemoteWalkContext contextForProject, IEnumerable <ToolRestoreResult> toolRestoreResults, bool relockFile) { // Build the lock file LockFile lockFile; if (existingLockFile != null && existingLockFile.IsLocked) { // No lock file to write! lockFile = existingLockFile; } else { lockFile = new LockFileBuilder(_request.LockFileVersion, _logger, _includeFlagGraphs) .CreateLockFile( existingLockFile, project, graphs, localRepository, contextForProject, toolRestoreResults); // If the lock file was locked originally but we are re-locking it, well... re-lock it :) lockFile.IsLocked = relockFile; } return(lockFile); }
private async Task <RestoreTargetGraph> WalkDependenciesAsync(LibraryRange projectRange, NuGetFramework framework, string runtimeIdentifier, RuntimeGraph runtimeGraph, RemoteDependencyWalker walker, RemoteWalkContext context, CancellationToken token) { var name = FrameworkRuntimePair.GetTargetGraphName(framework, runtimeIdentifier); var graphs = new List <GraphNode <RemoteResolveResult> > { await walker.WalkAsync( projectRange, framework, runtimeIdentifier, runtimeGraph, recursive : true) }; // Resolve conflicts await _logger.LogAsync(LogLevel.Verbose, string.Format(CultureInfo.CurrentCulture, Strings.Log_ResolvingConflicts, name)); // Flatten and create the RestoreTargetGraph to hold the packages return(RestoreTargetGraph.Create(runtimeGraph, graphs, context, _logger, framework, runtimeIdentifier)); }
public async Task DeepCycleCheck() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0") .DependsOn("B", "2.0"); provider.Package("B", "2.0") .DependsOn("C", "2.0"); provider.Package("C", "2.0") .DependsOn("D", "1.0") .DependsOn("E", "1.0"); provider.Package("D", "1.0"); provider.Package("E", "1.0") .DependsOn("A", "1.0"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var result = node.Analyze(); Assert.Equal(1, result.Cycles.Count); var cycle = result.Cycles[0]; AssertPath(cycle, "A 1.0", "B 2.0", "C 2.0", "E 1.0", "A 1.0"); }
private RemoteWalkContext CreateRemoteWalkContext(ISettings settings, SourceCacheContext cache, ILogger logger) { // nuget.org etc. var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings); var localRepository = Repository.Factory.GetCoreV3(globalPackagesFolder, FeedType.FileSystemV3); var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3()); var context = new RemoteWalkContext(cache, logger); context.LocalLibraryProviders.Add(new SourceRepositoryDependencyProvider(localRepository, logger, cache, ignoreFailedSources: true, fileCache: new LocalPackageFileCache(), ignoreWarning: true, isFallbackFolderSource: false)); foreach (var remoteRepository in sourceRepositoryProvider.GetRepositories()) { context.RemoteLibraryProviders.Add(new SourceRepositoryDependencyProvider(remoteRepository, logger, cache, ignoreFailedSources: cache.IgnoreFailedSources, fileCache: new LocalPackageFileCache(), ignoreWarning: false, isFallbackFolderSource: false)); } return(context); }
public async Task AllowPreleaseVersionNoConflict() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0-beta") .DependsOn("B", "1.0") .DependsOn("C", "1.0-beta") .DependsOn("E", "1.0"); provider.Package("B", "1.0") .DependsOn("D", "1.0"); provider.Package("C", "1.0-beta") .DependsOn("D", "1.1-beta"); provider.Package("E", "1.0") .DependsOn("D", "0.1"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var result = node.Analyze(); Assert.Equal(0, result.VersionConflicts.Count); }
private Task <RestoreTargetGraph[]> WalkRuntimeDependenciesAsync(LibraryRange projectRange, RestoreTargetGraph graph, IEnumerable <string> runtimeIds, RemoteDependencyWalker walker, RemoteWalkContext context, RuntimeGraph runtimes, CancellationToken token) { var resultGraphs = new List <Task <RestoreTargetGraph> >(); foreach (var runtimeName in runtimeIds) { _logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoringPackages, FrameworkRuntimePair.GetName(graph.Framework, runtimeName))); resultGraphs.Add(WalkDependenciesAsync(projectRange, graph.Framework, runtimeName, runtimes, walker, context, token)); } return(Task.WhenAll(resultGraphs)); }
public async Task GivenAnUnresolvedPackageWithNoVersionsAndMultipleSourcesVerifyMessage() { var range = new LibraryRange("x", LibraryDependencyTarget.Package); var versions = new List <NuGetVersion>(); var token = CancellationToken.None; var logger = new TestLogger(); var provider1 = GetProvider("http://nuget.org/a/", versions); var provider2 = GetProvider("http://nuget.org/b/", versions); var cacheContext = new Mock <SourceCacheContext>(); var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, NullLogger.Instance); remoteWalkContext.RemoteLibraryProviders.Add(provider1.Object); remoteWalkContext.RemoteLibraryProviders.Add(provider2.Object); var graph = new Mock <IRestoreTargetGraph>(); graph.SetupGet(e => e.TargetGraphName).Returns("abc"); var message = await UnresolvedMessages.GetMessageAsync(graph.Object, range, remoteWalkContext, logger, token); message.Code.Should().Be(NuGetLogCode.NU1101); message.LibraryId.Should().Be("x"); message.Message.Should().Be("Unable to find package x. No packages exist with this id in source(s): http://nuget.org/a/, http://nuget.org/b/"); message.TargetGraphs.ShouldBeEquivalentTo(new[] { "abc" }); message.Level.Should().Be(LogLevel.Error); }
private List <ExternalProjectReference> GetProjectReferences(RemoteWalkContext context) { // External references var updatedExternalProjects = new List <ExternalProjectReference>(); if (_request.ExternalProjects.Count == 0) { // If no projects exist add the current project.json file to the project // list so that it can be resolved. updatedExternalProjects.Add(ToExternalProjectReference(_request.Project)); } else if (_request.ExternalProjects.Count > 0) { // There should be at most one match in the external projects. var rootProjectMatches = _request.ExternalProjects.Where(proj => string.Equals( _request.Project.Name, proj.PackageSpecProjectName, StringComparison.OrdinalIgnoreCase)) .ToList(); if (rootProjectMatches.Count > 1) { throw new InvalidOperationException($"Ambiguous project name '{_request.Project.Name}'."); } var rootProject = rootProjectMatches.SingleOrDefault(); if (rootProject != null) { // Replace the project spec with the passed in package spec, // for installs which are done in memory first this will be // different from the one on disk updatedExternalProjects.AddRange(_request.ExternalProjects .Where(project => !project.UniqueName.Equals(rootProject.UniqueName, StringComparison.Ordinal))); var updatedReference = new ExternalProjectReference( rootProject.UniqueName, _request.Project, rootProject.MSBuildProjectPath, rootProject.ExternalProjectReferences); updatedExternalProjects.Add(updatedReference); } } else { // External references were passed, but the top level project wasn't found. // This is always due to an internal issue and typically caused by errors // building the project closure. Debug.Fail("RestoreRequest.ExternalProjects contains references, but does not contain the top level references. Add the project we are restoring for."); throw new InvalidOperationException($"Missing external reference metadata for {_request.Project.Name}"); } return(updatedExternalProjects); }
public async Task FindLibraryEntryAsync_LogsOnlyPackages(LibraryDependencyTarget libraryDependencyTarget) { // Arrange const string packageX = "x", version = "1.0.0-beta.1", source = "source"; var range = new LibraryRange(packageX, VersionRange.Parse(version), libraryDependencyTarget); var cacheContext = new SourceCacheContext(); var testLogger = new TestLogger(); var framework = NuGetFramework.Parse("net45"); var token = CancellationToken.None; var edge = new GraphEdge <RemoteResolveResult>(null, null, null); var actualIdentity = new LibraryIdentity(packageX, NuGetVersion.Parse(version), LibraryType.Package); var dependencies = new[] { new LibraryDependency() { LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package) } }; var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies); //package source mapping configuration Dictionary <string, IReadOnlyList <string> > patterns = new(); patterns.Add(source, new List <string>() { packageX }); PackageSourceMapping sourceMappingConfiguration = new(patterns); var context = new RemoteWalkContext(cacheContext, sourceMappingConfiguration, testLogger); var remoteProvider = new Mock <IRemoteDependencyProvider>(); remoteProvider.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(actualIdentity); remoteProvider.SetupGet(e => e.IsHttp).Returns(true); remoteProvider.SetupGet(e => e.Source).Returns(new PackageSource(source)); remoteProvider.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(dependencyInfo); context.RemoteLibraryProviders.Add(remoteProvider.Object); // Act var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, context, token); // Assert Assert.Equal(0, testLogger.Errors); testLogger.DebugMessages.TryPeek(out string message); if (libraryDependencyTarget == LibraryDependencyTarget.Package) { Assert.Equal($"Package source mapping matches found for package ID '{packageX}' are: '{source}'.", message); Assert.Equal(version, result.Key.Version.ToString()); Assert.Equal(source, result.Data.Match.Provider.Source.Name); } else { Assert.Equal(message, null); } }
public async Task FindPackage_VerifyFloatingPackageIsRequiredOnlyFromASingleSource() { // Arrange var range = new LibraryRange("x", VersionRange.Parse("1.0.0-*"), LibraryDependencyTarget.Package); var cacheContext = new SourceCacheContext(); var testLogger = new TestLogger(); var framework = NuGetFramework.Parse("net45"); var context = new RemoteWalkContext(cacheContext, testLogger); var token = CancellationToken.None; var edge = new GraphEdge <RemoteResolveResult>(null, null, null); var actualIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta.1"), LibraryType.Package); var higherIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta.2"), LibraryType.Package); var dependencies = new[] { new LibraryDependency() { LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package) } }; var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies); var dependencyInfo2 = LibraryDependencyInfo.Create(higherIdentity, framework, dependencies); var downloadCount = 0; // Source1 returns 1.0.0-beta.1 var remoteProvider = new Mock <IRemoteDependencyProvider>(); remoteProvider.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(actualIdentity); remoteProvider.SetupGet(e => e.IsHttp).Returns(true); remoteProvider.SetupGet(e => e.Source).Returns(new PackageSource("test")); remoteProvider.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(dependencyInfo) .Callback(() => ++ downloadCount); context.RemoteLibraryProviders.Add(remoteProvider.Object); // Source2 returns 1.0.0-beta.2 var remoteProvider2 = new Mock <IRemoteDependencyProvider>(); remoteProvider2.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(higherIdentity); remoteProvider2.SetupGet(e => e.IsHttp).Returns(true); remoteProvider2.SetupGet(e => e.Source).Returns(new PackageSource("test")); remoteProvider2.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(dependencyInfo2) .Callback(() => ++ downloadCount); context.RemoteLibraryProviders.Add(remoteProvider2.Object); // Act var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, edge, context, token); // Assert // Verify only one download happened Assert.Equal(1, downloadCount); Assert.Equal("1.0.0-beta.2", result.Key.Version.ToString()); }
public LockFile CreateLockFile(LockFile previousLockFile, PackageSpec project, IEnumerable <RestoreTargetGraph> targetGraphs, IReadOnlyList <NuGetv3LocalRepository> localRepositories, RemoteWalkContext context) { return(CreateLockFile(previousLockFile, project, targetGraphs, localRepositories, context, new LockFileBuilderCache())); }
private Task <RestoreTargetGraph> WalkDependenciesAsync(LibraryRange projectRange, NuGetFramework framework, RemoteDependencyWalker walker, RemoteWalkContext context, CancellationToken token) { return(WalkDependenciesAsync(projectRange, framework, runtimeIdentifier: null, runtimeGraph: RuntimeGraph.Empty, walker: walker, context: context, token: token)); }
public async Task DoubleDowngrade() { var context = new RemoteWalkContext(); var provider = new DependencyProvider(); provider.Package("A", "1.0") .DependsOn("B", "0.7") .DependsOn("C", "1.0"); provider.Package("B", "0.7"); provider.Package("C", "1.0") .DependsOn("B", "0.8") .DependsOn("D", "1.0"); provider.Package("B", "0.8"); provider.Package("D", "1.0") .DependsOn("B", "1.0"); provider.Package("B", "1.0"); context.LocalLibraryProviders.Add(provider); var walker = new RemoteDependencyWalker(context); var node = await DoWalkAsync(walker, "A"); var downgrades = new List <Tuple <GraphNode <RemoteResolveResult>, GraphNode <RemoteResolveResult> > >(); var cycles = new List <GraphNode <RemoteResolveResult> >(); var result = node.Analyze(); Assert.Equal(2, result.Downgrades.Count); var d0 = result.Downgrades[0]; var d0To = d0.DowngradedFrom; var d0By = d0.DowngradedTo; AssertPath(d0To, "A 1.0", "C 1.0", "B 0.8"); AssertPath(d0By, "A 1.0", "B 0.7"); var d1 = result.Downgrades[1]; var d1To = d1.DowngradedFrom; var d1By = d1.DowngradedTo; AssertPath(d1To, "A 1.0", "C 1.0", "D 1.0", "B 1.0"); AssertPath(d1By, "A 1.0", "B 0.7"); }
private static RemoteWalkContext CreateRemoteWalkContext(RestoreRequest request) { var context = new RemoteWalkContext(); foreach (var provider in request.DependencyProviders.LocalProviders) { context.LocalLibraryProviders.Add(provider); } foreach (var provider in request.DependencyProviders.RemoteProviders) { context.RemoteLibraryProviders.Add(provider); } return(context); }
private static async Task <RestoreLogMessage> GetMessage(LibraryRange range, List <NuGetVersion> versions) { var token = CancellationToken.None; var logger = new TestLogger(); var provider = GetProvider("http://nuget.org/a/", versions); var cacheContext = new Mock <SourceCacheContext>(); var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, NullLogger.Instance); remoteWalkContext.RemoteLibraryProviders.Add(provider.Object); var graph = new Mock <IRestoreTargetGraph>(); graph.SetupGet(e => e.TargetGraphName).Returns("abc"); var message = await UnresolvedMessages.GetMessageAsync(graph.Object, range, remoteWalkContext, logger, token); return(message); }
private static async Task <RestoreLogMessage> GetMessage(LibraryRange range, List <NuGetVersion> versions) { var token = CancellationToken.None; var logger = new TestLogger(); var provider = GetProvider("http://nuget.org/a/", versions); var cacheContext = new Mock <SourceCacheContext>(); var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, PackageSourceMapping.GetPackageSourceMapping(NullSettings.Instance), NullLogger.Instance); var remoteLibraryProviders = new List <IRemoteDependencyProvider>() { provider.Object }; var targetGraphName = "abc"; var message = await UnresolvedMessages.GetMessageAsync(targetGraphName, range, remoteLibraryProviders, cacheContext.Object, logger, token); return(message); }
private LockFile BuildAssetsFile( LockFile existingLockFile, PackageSpec project, IEnumerable <RestoreTargetGraph> graphs, IReadOnlyList <NuGetv3LocalRepository> localRepositories, RemoteWalkContext contextForProject) { // Build the lock file var lockFile = new LockFileBuilder(_request.LockFileVersion, _logger, _includeFlagGraphs) .CreateLockFile( existingLockFile, project, graphs, localRepositories, contextForProject); return(lockFile); }
private static RemoteWalkContext CreateRemoteWalkContext(RestoreRequest request, RestoreCollectorLogger logger) { var context = new RemoteWalkContext( request.CacheContext, logger); foreach (var provider in request.DependencyProviders.LocalProviders) { context.LocalLibraryProviders.Add(provider); } foreach (var provider in request.DependencyProviders.RemoteProviders) { context.RemoteLibraryProviders.Add(provider); } return context; }
public async Task FindPackage_VerifyMissingListedPackageSucceedsOnRetry() { // Arrange var range = new LibraryRange("x", VersionRange.Parse("1.0.0-beta"), LibraryDependencyTarget.Package); var cacheContext = new SourceCacheContext(); var testLogger = new TestLogger(); var framework = NuGetFramework.Parse("net45"); var context = new RemoteWalkContext(cacheContext, testLogger); var token = CancellationToken.None; var edge = new GraphEdge <RemoteResolveResult>(null, null, null); var actualIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta"), LibraryType.Package); var dependencies = new[] { new LibraryDependency() { LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package) } }; var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies); var remoteProvider = new Mock <IRemoteDependencyProvider>(); remoteProvider.Setup(e => e.FindLibraryAsync(range, framework, It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(actualIdentity); remoteProvider.SetupGet(e => e.IsHttp).Returns(true); remoteProvider.SetupGet(e => e.Source).Returns(new PackageSource("test")); var hitCount = 0; remoteProvider.Setup(e => e.GetDependenciesAsync(actualIdentity, framework, cacheContext, testLogger, token)) .ThrowsAsync(new PackageNotFoundProtocolException(new PackageIdentity(actualIdentity.Name, actualIdentity.Version))) .Callback(() => ++ hitCount); remoteProvider.Setup(e => e.GetDependenciesAsync(actualIdentity, framework, It.IsAny <SourceCacheContext>(), testLogger, token)) .ReturnsAsync(dependencyInfo) .Callback(() => ++ hitCount); context.RemoteLibraryProviders.Add(remoteProvider.Object); // Act var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, edge, context, token); // Assert Assert.Equal(1, hitCount); Assert.Equal("x", result.Key.Name); }
public async Task <GraphNode <RemoteResolveResult> > ResolvePackages(List <PackageId> packages) { var walkerContext = new RemoteWalkContext(_cache, _nuGetLogger); foreach (var sourceRepository in _repositoryProvider.Repositories) { var provider = new SourceRepositoryDependencyProvider(sourceRepository, _nuGetLogger, _cache, true, true); walkerContext.RemoteLibraryProviders.Add(provider); } walkerContext.ProjectLibraryProviders.Add(new ProjectLibraryProvider(packages)); var localProvider = new SourceRepositoryDependencyProvider(_localRepository, _nuGetLogger, _cache, true, true); walkerContext.LocalLibraryProviders.Add(localProvider); var fakeLib = new LibraryRange("Dropcraft", VersionRange.Parse("1.0.0"), LibraryDependencyTarget.Project); var walker = new RemoteDependencyWalker(walkerContext); return(await walker.WalkAsync(fakeLib, _framework, _framework.GetShortFolderName(), RuntimeGraph.Empty, true)); }
public async Task SlowerFeedWinsIfBetterMatchExists() { // A var slowProvider = new TestProvider(TimeSpan.FromSeconds(2)); slowProvider.AddLibrary(new LibraryIdentity { Name = "A", Version = new NuGetVersion("1.0.0") }); var fastProvider = new TestProvider(TimeSpan.Zero); fastProvider.AddLibrary(new LibraryIdentity { Name = "A", Version = new NuGetVersion("1.1.0") }); var context = new RemoteWalkContext(); context.RemoteLibraryProviders.Add(slowProvider); context.RemoteLibraryProviders.Add(fastProvider); var walker = new RemoteDependencyWalker(context); var result = await walker.WalkAsync(new LibraryRange { Name = "A", VersionRange = VersionRange.Parse("1.0.0"), }, NuGetFramework.Parse("net45"), runtimeIdentifier: null, runtimeGraph: null); Assert.NotNull(result.Item.Data.Match); Assert.NotNull(result.Item.Data.Match.Library); Assert.Equal("A", result.Item.Data.Match.Library.Name); Assert.Equal(new NuGetVersion("1.0.0"), result.Item.Data.Match.Library.Version); Assert.Equal(slowProvider, result.Item.Data.Match.Provider); }