private FrameworkName GetNearestImpl(FrameworkName targetFramework, IEnumerable <FrameworkName> fallbackTargetFrameworks, IEnumerable <FrameworkName> frameworks) { if (targetFramework == null) { throw new ArgumentNullException(nameof(targetFramework)); } if (fallbackTargetFrameworks == null) { throw new ArgumentNullException(nameof(fallbackTargetFrameworks)); } if (frameworks == null) { throw new ArgumentNullException(nameof(frameworks)); } IEnumerable <NuGetFramework> ParseAllFrameworks(IEnumerable <FrameworkName> frameworks) { foreach (FrameworkName frameworkName in frameworks) { if (frameworkName == null) { throw new ArgumentException(message: VsResourcesFormat.PropertyCannotBeNull(nameof(FrameworkName)), paramName: nameof(frameworks)); } NuGetFramework nugetFramework = NuGetFramework.ParseFrameworkName(frameworkName.ToString(), DefaultFrameworkNameProvider.Instance); yield return(nugetFramework); } } var nuGetTargetFramework = NuGetFramework.ParseFrameworkName(targetFramework.ToString(), DefaultFrameworkNameProvider.Instance); var nuGetFallbackTargetFrameworks = ParseAllFrameworks(fallbackTargetFrameworks).ToList(); var nuGetFrameworks = ParseAllFrameworks(frameworks).ToList(); try { if (nuGetFallbackTargetFrameworks.Any()) { nuGetTargetFramework = new FallbackFramework(nuGetTargetFramework, nuGetFallbackTargetFrameworks); } var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(nuGetTargetFramework, nuGetFrameworks); if (nearest == null) { return(null); } return(new FrameworkName(nearest.DotNetFrameworkName)); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsFrameworkCompatibility).FullName); throw; } }
public void FallbackFramework_ReferenceEquals() { // Arrange var a = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("dnxcore50") }); // Act & Assert Assert.Equal(a, a); }
private static bool BuildTargetFrameworkNode(PackageSpec packageSpec, KeyValuePair <string, JToken> targetFramework, string filePath) { var frameworkName = GetFramework(targetFramework.Key); var properties = targetFramework.Value.Value <JObject>(); var assetTargetFallback = GetBoolOrFalse(properties, "assetTargetFallback", filePath); var importFrameworks = GetImports(properties, packageSpec); // If a fallback framework exists, update the framework to contain both. var updatedFramework = frameworkName; if (importFrameworks.Count != 0) { if (assetTargetFallback) { updatedFramework = new AssetTargetFallbackFramework(frameworkName, importFrameworks); } else { updatedFramework = new FallbackFramework(frameworkName, importFrameworks); } } var targetFrameworkInformation = new TargetFrameworkInformation { FrameworkName = updatedFramework, Dependencies = new List <LibraryDependency>(), Imports = importFrameworks, Warn = GetWarnSetting(properties), AssetTargetFallback = assetTargetFallback }; PopulateDependencies( packageSpec.FilePath, targetFrameworkInformation.Dependencies, properties, "dependencies", isGacOrFrameworkReference: false); var frameworkAssemblies = new List <LibraryDependency>(); PopulateDependencies( packageSpec.FilePath, frameworkAssemblies, properties, "frameworkAssemblies", isGacOrFrameworkReference: true); frameworkAssemblies.ForEach(d => targetFrameworkInformation.Dependencies.Add(d)); packageSpec.TargetFrameworks.Add(targetFrameworkInformation); return(true); }
public void FallbackFramework_DifferentFallbacks() { // Arrange var a = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("netstandard1.2") }); var b = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("win8") }); // Act & Assert Assert.NotEqual(a, b); Assert.NotEqual(b, a); }
public void FallbackFramework_DifferentFallbackOrder() { // Arrange var a = new FallbackFramework( NuGetFramework.Parse("netstandardapp1.5"), new[] { NuGetFramework.Parse("net40"), NuGetFramework.Parse("net45") }); var b = new FallbackFramework( NuGetFramework.Parse("netstandardapp1.5"), new[] { NuGetFramework.Parse("net40"), NuGetFramework.Parse("net46") }); // Act & Assert Assert.NotEqual(a, b); Assert.NotEqual(b, a); }
public void FallbackFramework_SubsetFallbacks() { // Arrange var a = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("dnxcore50") }); var b = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("dnxcore50"), NuGetFramework.Parse("netstandard1.1") }); // Act & Assert Assert.NotEqual(a, b); Assert.NotEqual(b, a); }
public void FallbackFramework_DifferentPrimary() { // Arrange var a = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("dnxcore50") }); var b = new FallbackFramework( NuGetFramework.Parse("net46"), new[] { NuGetFramework.Parse("dnxcore50") }); // Act & Assert Assert.NotEqual(a, b); Assert.NotEqual(b, a); }
public void FallbackFramework_CompareAsNuGetFramework() { // Arrange NuGetFramework a = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("netstandard1.2") }); var b = new FallbackFramework( NuGetFramework.Parse("net45"), new[] { NuGetFramework.Parse("win8") }); // Act & Assert Assert.Equal(a, (NuGetFramework)b); Assert.Equal(b, (NuGetFramework)a); Assert.Equal((NuGetFramework)a, b); Assert.Equal((NuGetFramework)b, a); }
public void AsFallbackFramework_WhenCalledMultipleTimes_CachesFallbackObjectReference() { var nugetFramework = CommonFrameworks.Net50; var dualCompatibilityFramework = new DualCompatibilityFramework(nugetFramework, secondaryFramework: NuGetFramework.AnyFramework); FallbackFramework fallbackFramework = dualCompatibilityFramework.AsFallbackFramework(); var comparer = new NuGetFrameworkFullComparer(); Assert.True(comparer.Equals(fallbackFramework, nugetFramework)); fallbackFramework.Fallback.Should().HaveCount(1); fallbackFramework.Fallback.Single().Should().Be(NuGetFramework.AnyFramework); FallbackFramework fallbackFramework2 = dualCompatibilityFramework.AsFallbackFramework(); fallbackFramework.Should().BeSameAs(fallbackFramework2); }
public void WarningPropertiesCollection_PackagePropertiesWithPTFFrameworkAndWarningWithFramework(string frameworkString) { // Arrange var libraryId = "test_library"; var targetFramework = new FallbackFramework(NuGetFramework.Parse(frameworkString), new List <NuGetFramework>() { NuGetFramework.AnyFramework }); var packageSpecificWarningProperties = new PackageSpecificWarningProperties(); packageSpecificWarningProperties.Add(NuGetLogCode.NU1500, libraryId, targetFramework); var warningPropertiesCollection = new WarningPropertiesCollection(null, packageSpecificWarningProperties, null); var suppressedMessage = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1500, "Warning", libraryId, frameworkString); // Act && Assert Assert.True(warningPropertiesCollection.ApplyWarningProperties(suppressedMessage)); }
public FrameworkName GetNearest(FrameworkName targetFramework, IEnumerable <FrameworkName> fallbackTargetFrameworks, IEnumerable <FrameworkName> frameworks) { if (targetFramework == null) { throw new ArgumentNullException(nameof(targetFramework)); } if (fallbackTargetFrameworks == null) { throw new ArgumentNullException(nameof(fallbackTargetFrameworks)); } if (frameworks == null) { throw new ArgumentNullException(nameof(frameworks)); } var nuGetTargetFramework = NuGetFramework.ParseFrameworkName(targetFramework.ToString(), DefaultFrameworkNameProvider.Instance); var nuGetFallbackTargetFrameworks = fallbackTargetFrameworks .Select(framework => NuGetFramework.ParseFrameworkName(framework.ToString(), DefaultFrameworkNameProvider.Instance)) .ToList(); if (nuGetFallbackTargetFrameworks.Any()) { nuGetTargetFramework = new FallbackFramework(nuGetTargetFramework, nuGetFallbackTargetFrameworks); } var nuGetFrameworks = frameworks .Select(framework => NuGetFramework.ParseFrameworkName(framework.ToString(), DefaultFrameworkNameProvider.Instance)); var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(nuGetTargetFramework, nuGetFrameworks); if (nearest == null) { return(null); } return(new FrameworkName(nearest.DotNetFrameworkName)); }
public IVsNuGetFramework GetNearestImpl(IVsNuGetFramework targetFramework, IEnumerable <IVsNuGetFramework> fallbackTargetFrameworks, IEnumerable <IVsNuGetFramework> frameworks) { if (targetFramework == null) { throw new ArgumentNullException(nameof(targetFramework)); } if (fallbackTargetFrameworks == null) { throw new ArgumentNullException(nameof(fallbackTargetFrameworks)); } if (frameworks == null) { throw new ArgumentNullException(nameof(frameworks)); } var inputFrameworks = new Dictionary <NuGetFramework, IVsNuGetFramework>(); NuGetFramework ToNuGetFramework(IVsNuGetFramework framework, string paramName) { NuGetFramework nugetFramework = MSBuildProjectFrameworkUtility.GetProjectFramework( projectFilePath: null, targetFrameworkMoniker: framework.TargetFrameworkMoniker, targetPlatformMoniker: framework.TargetPlatformMoniker, targetPlatformMinVersion: framework.TargetPlatformMinVersion); if (!nugetFramework.IsSpecificFramework) { throw new ArgumentException($"Framework '{framework}' could not be parsed", paramName); } inputFrameworks[nugetFramework] = framework; return(nugetFramework); } List <NuGetFramework> ToNuGetFrameworks(IEnumerable <IVsNuGetFramework> enumerable, string paramName) { var list = new List <NuGetFramework>(); foreach (var framework in enumerable) { if (framework == null) { throw new ArgumentException("Enumeration contains a null value", paramName); } NuGetFramework nugetFramework = ToNuGetFramework(framework, paramName); list.Add(nugetFramework); } return(list); } NuGetFramework targetNuGetFramework = ToNuGetFramework(targetFramework, nameof(targetFramework)); List <NuGetFramework> nugetFallbackTargetFrameworks = ToNuGetFrameworks(fallbackTargetFrameworks, nameof(fallbackTargetFrameworks)); List <NuGetFramework> nugetFrameworks = ToNuGetFrameworks(frameworks, nameof(frameworks)); try { if (nugetFallbackTargetFrameworks.Count > 0) { targetNuGetFramework = new FallbackFramework(targetNuGetFramework, nugetFallbackTargetFrameworks); } var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(targetNuGetFramework, nugetFrameworks); if (nearest == null) { return(null); } var originalFrameworkString = inputFrameworks[nearest]; return(originalFrameworkString); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsFrameworkCompatibility).FullName); throw; } }
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 GetMSBuildProjectExtensionsPathAsync(); metadata.ProjectPath = MSBuildProjectPath; metadata.ProjectJsonPath = packageSpec.FilePath; metadata.ProjectName = packageSpec.Name; metadata.ProjectUniqueName = MSBuildProjectPath; metadata.CacheFilePath = await GetCacheFilePathAsync(); // Reload the target framework from csproj and update the target framework in packageSpec for restore await UpdateInternalTargetFrameworkAsync(); if (TryGetInternalFramework(out var targetFramework)) { var nuGetFramework = targetFramework as NuGetFramework; if (IsUAPFramework(nuGetFramework)) { // Ensure the project json has only one target framework if (packageSpec.TargetFrameworks != null && packageSpec.TargetFrameworks.Count == 1) { var tfi = packageSpec.TargetFrameworks.First(); if (tfi.Imports.Count > 0) { if (tfi.AssetTargetFallback) { nuGetFramework = new AssetTargetFallbackFramework(nuGetFramework, tfi.Imports.AsList()); } else { nuGetFramework = new FallbackFramework(nuGetFramework, tfi.Imports.AsList()); } } tfi.FrameworkName = nuGetFramework; } } } var references = (await ProjectServices .ReferencesReader .GetProjectReferencesAsync(context.Logger, CancellationToken.None)) .ToList(); if (references != null && references.Count > 0) { // Add msbuild reference groups for each TFM in the project foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName)) { metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework)); } foreach (var reference in references) { // This reference applies to all frameworks // Include/exclude flags may be applied later when merged with project.json // Add the reference for all TFM groups, there are no conditional project // references in UWP. There should also be just one TFM. foreach (var frameworkInfo in metadata.TargetFrameworks) { frameworkInfo.ProjectReferences.Add(reference); } } } // Write restore settings to the package spec. // For project.json these properties may not come from the project file. var settings = context?.Settings ?? NullSettings.Instance; packageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings); packageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).AsList(); packageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).AsList(); packageSpec.RestoreMetadata.ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).AsList(); context?.PackageSpecCache.Add(MSBuildProjectPath, packageSpec); } return(new[] { packageSpec }); }
private async Task <IEnumerable <ToolRestoreResult> > ExecuteToolRestoresAsync( NuGetv3LocalRepository localRepository, CancellationToken token) { var toolPathResolver = new ToolPathResolver(_request.PackagesDirectory); var results = new List <ToolRestoreResult>(); foreach (var tool in _request.Project.Tools) { _logger.LogMinimal(string.Format( CultureInfo.CurrentCulture, Strings.Log_RestoringToolPackages, tool.LibraryRange.Name, _request.Project.FilePath)); // Build the fallback framework (which uses the "imports"). var framework = LockFile.ToolFramework; if (tool.Imports.Any()) { framework = new FallbackFramework(framework, tool.Imports); } // Build a package spec in memory to execute the tool restore as if it were // its own project. For now, we always restore for a null runtime and a single // constant framework. var toolPackageSpec = new PackageSpec(new JObject()) { Name = Guid.NewGuid().ToString(), // make sure this package never collides with a dependency Dependencies = new List <LibraryDependency>(), Tools = new List <ToolDependency>(), TargetFrameworks = { new TargetFrameworkInformation { FrameworkName = framework, Dependencies = new List <LibraryDependency> { new LibraryDependency { LibraryRange = tool.LibraryRange } } } } }; // Try to find the existing lock file. Since the existing lock file is pathed under // a folder that includes the resolved tool's version, this is a bit of a chicken // and egg problem. That is, we need to run the restore operation in order to resolve // a tool version, but we need the tool version to find the existing project.lock.json // file which is required before executing the restore! Fortunately, this is solved by // looking at the tool's consuming project's lock file to see if the tool has been // restored before. LockFile existingToolLockFile = null; if (_request.ExistingLockFile != null) { var existingTarget = _request .ExistingLockFile .Tools .Where(t => t.RuntimeIdentifier == null) .Where(t => t.TargetFramework.Equals(LockFile.ToolFramework)) .FirstOrDefault(); var existingLibrary = existingTarget?.Libraries .Where(l => StringComparer.OrdinalIgnoreCase.Equals(l.Name, tool.LibraryRange.Name)) .Where(l => tool.LibraryRange.VersionRange.Satisfies(l.Version)) .FirstOrDefault(); if (existingLibrary != null) { var existingLockFilePath = toolPathResolver.GetLockFilePath( existingLibrary.Name, existingLibrary.Version, existingTarget.TargetFramework); existingToolLockFile = LockFileUtilities.GetLockFile(existingLockFilePath, _logger); } } // Execute the restore. var toolSuccess = true; // success for this individual tool restore var runtimeIds = new HashSet <string>(); var projectFrameworkRuntimePairs = CreateFrameworkRuntimePairs(toolPackageSpec, runtimeIds); var allInstalledPackages = new HashSet <LibraryIdentity>(); var contextForTool = CreateRemoteWalkContext(_request); var walker = new RemoteDependencyWalker(contextForTool); var projectRestoreRequest = new ProjectRestoreRequest( _request, toolPackageSpec, existingToolLockFile, new Dictionary <NuGetFramework, RuntimeGraph>(), _runtimeGraphCacheByPackage); var projectRestoreCommand = new ProjectRestoreCommand(_logger, projectRestoreRequest); var result = await projectRestoreCommand.TryRestore( tool.LibraryRange, projectFrameworkRuntimePairs, allInstalledPackages, localRepository, walker, contextForTool, writeToLockFile : true, token : token); var graphs = result.Item2; if (!result.Item1) { toolSuccess = false; _success = false; } // Create the lock file (in memory). var toolLockFile = BuildLockFile( existingToolLockFile, toolPackageSpec, graphs, localRepository, contextForTool, Enumerable.Empty <ToolRestoreResult>(), false); // Build the path based off of the resolved tool. For now, we assume there is only // ever one target. var target = toolLockFile.Targets.Single(); var fileTargetLibrary = target .Libraries .FirstOrDefault(l => StringComparer.OrdinalIgnoreCase.Equals(tool.LibraryRange.Name, l.Name)); string toolLockFilePath = null; if (fileTargetLibrary != null) { toolLockFilePath = toolPathResolver.GetLockFilePath( fileTargetLibrary.Name, fileTargetLibrary.Version, target.TargetFramework); } // Validate the results. if (!ValidateRestoreGraphs(graphs, _logger)) { toolSuccess = false; _success = false; } var checkResults = VerifyCompatibility( toolPackageSpec, new Dictionary <RestoreTargetGraph, Dictionary <string, LibraryIncludeFlags> >(), localRepository, toolLockFile, graphs, _logger); if (checkResults.Any(r => !r.Success)) { toolSuccess = false; _success = false; } results.Add(new ToolRestoreResult( tool.LibraryRange.Name, toolSuccess, target, fileTargetLibrary, toolLockFilePath, toolLockFile, existingToolLockFile)); } return(results); }