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);
}
