private bool IsPackageCompatible(CompatibilityData compatibilityData)
{
// A package is compatible if it has...
return
(HasCompatibleAssets(compatibilityData.TargetLibrary) ||
!compatibilityData.Files.Any(p =>
p.StartsWith("ref/", StringComparison.OrdinalIgnoreCase) ||
p.StartsWith("lib/", StringComparison.OrdinalIgnoreCase))); // No assemblies at all (for any TxM)
}
private bool IsCompatible(CompatibilityData compatibilityData)
{
// A package is compatible if it has...
return
(compatibilityData.TargetLibrary.RuntimeAssemblies.Count > 0 || // Runtime Assemblies, or
compatibilityData.TargetLibrary.CompileTimeAssemblies.Count > 0 || // Compile-time Assemblies, or
compatibilityData.TargetLibrary.FrameworkAssemblies.Count > 0 || // Framework Assemblies, or
compatibilityData.TargetLibrary.ContentFiles.Count > 0 || // Shared content
compatibilityData.TargetLibrary.ResourceAssemblies.Count > 0 || // Resources (satellite package)
!compatibilityData.Files.Any(p =>
p.StartsWith("ref/", StringComparison.OrdinalIgnoreCase) ||
p.StartsWith("lib/", StringComparison.OrdinalIgnoreCase))); // No assemblies at all (for any TxM)
}
private static IEnumerable <NuGetFramework> GetPackageFrameworks(
CompatibilityData compatibilityData,
RestoreTargetGraph graph)
{
var available = new HashSet <NuGetFramework>();
var contentItems = new ContentItemCollection();
contentItems.Load(compatibilityData.Files);
var patterns = new[]
{
graph.Conventions.Patterns.ResourceAssemblies,
graph.Conventions.Patterns.CompileRefAssemblies,
graph.Conventions.Patterns.RuntimeAssemblies,
graph.Conventions.Patterns.EmbedAssemblies,
graph.Conventions.Patterns.ContentFiles
};
List <ContentItemGroup> itemGroups = new();
foreach (var pattern in patterns)
{
itemGroups.Clear();
contentItems.PopulateItemGroups(pattern, itemGroups);
foreach (var group in itemGroups)
{
// lib/net45/subfolder/a.dll will be returned as a group with zero items since sub
// folders are not allowed. Completely empty groups are not compatible, a group with
// _._ would contain _._ as an item.
if (group.Items.Count > 0)
{
group.Properties.TryGetValue(ManagedCodeConventions.PropertyNames.RuntimeIdentifier, out var ridObj);
group.Properties.TryGetValue(ManagedCodeConventions.PropertyNames.TargetFrameworkMoniker, out var tfmObj);
var tfm = tfmObj as NuGetFramework;
// RID specific items should be ignored here since they are only used in the runtime assembly check
if (ridObj == null && tfm?.IsSpecificFramework == true)
{
available.Add(tfm);
}
}
}
}
return(available);
}
private async Task VerifyDotnetToolCompatibilityChecks(CompatibilityData compatibilityData, GraphItem <RemoteResolveResult> node, RestoreTargetGraph graph, List <CompatibilityIssue> issues)
{
var containsDotnetToolPackageType = compatibilityData.TargetLibrary.PackageType.Contains(PackageType.DotnetTool);
if (compatibilityData.TargetLibrary.PackageType.Count != 1 && containsDotnetToolPackageType)
{
var issue = CompatibilityIssue.ToolsPackageWithExtraPackageTypes(
new PackageIdentity(node.Key.Name, node.Key.Version));
issues.Add(issue);
await _log.LogAsync(GetErrorMessage(NuGetLogCode.NU1204, issue, graph));
}
if (containsDotnetToolPackageType &&
!(HasCompatibleToolsAssets(compatibilityData.TargetLibrary) || !compatibilityData.Files.Any(p => p.StartsWith("tools/", StringComparison.OrdinalIgnoreCase))))
{
var available = GetAvailableFrameworkRuntimePairs(compatibilityData, graph);
var issue = CompatibilityIssue.IncompatibleToolsPackage(
new PackageIdentity(node.Key.Name, node.Key.Version),
graph.Framework,
graph.RuntimeIdentifier,
available);
issues.Add(issue);
await _log.LogAsync(GetErrorMessage(NuGetLogCode.NU1202, issue, graph));
}
if (ProjectStyle.DotnetToolReference == compatibilityData.PackageSpec.RestoreMetadata?.ProjectStyle)
{
// If the package is not autoreferenced or a tool package
if (!containsDotnetToolPackageType && compatibilityData.PackageSpec.GetAllPackageDependencies().Where(e => !e.AutoReferenced).Any(e => e.Name.Equals(compatibilityData.TargetLibrary.Name, StringComparison.OrdinalIgnoreCase)))
{
var issue = CompatibilityIssue.IncompatiblePackageWithDotnetTool(new PackageIdentity(node.Key.Name, node.Key.Version));
issues.Add(issue);
await _log.LogAsync(GetErrorMessage(NuGetLogCode.NU1212, issue, graph));
}
}
else
{
if (containsDotnetToolPackageType)
{
var issue = CompatibilityIssue.IncompatiblePackageWithDotnetTool(new PackageIdentity(node.Key.Name, node.Key.Version));
issues.Add(issue);
await _log.LogAsync(GetErrorMessage(NuGetLogCode.NU1212, issue, graph));
}
}
}
private static List <NuGetFramework> GetPackageFrameworks(
CompatibilityData compatibilityData,
RestoreTargetGraph graph)
{
var available = new HashSet <NuGetFramework>();
var contentItems = new ContentItemCollection();
contentItems.Load(compatibilityData.Files);
var patterns = new[]
{
graph.Conventions.Patterns.ResourceAssemblies,
graph.Conventions.Patterns.CompileRefAssemblies,
graph.Conventions.Patterns.RuntimeAssemblies,
graph.Conventions.Patterns.ContentFiles
};
foreach (var pattern in patterns)
{
foreach (var group in contentItems.FindItemGroups(pattern))
{
object tfmObj = null;
object ridObj = null;
group.Properties.TryGetValue(ManagedCodeConventions.PropertyNames.RuntimeIdentifier, out ridObj);
group.Properties.TryGetValue(ManagedCodeConventions.PropertyNames.TargetFrameworkMoniker, out tfmObj);
NuGetFramework tfm = tfmObj as NuGetFramework;
// RID specific items should be ignored here since they are only used in the runtime assem check
if (ridObj == null && tfm?.IsSpecificFramework == true)
{
available.Add(tfm);
}
}
}
return(available.ToList());
}
private static HashSet <FrameworkRuntimePair> GetAvailableFrameworkRuntimePairs(CompatibilityData compatibilityData, RestoreTargetGraph graph)
{
var available = new HashSet <FrameworkRuntimePair>();
var contentItems = new ContentItemCollection();
contentItems.Load(compatibilityData.Files);
if (compatibilityData.TargetLibrary.PackageType.Contains(PackageType.DotnetTool))
{
foreach (var group in contentItems.FindItemGroups(graph.Conventions.Patterns.ToolsAssemblies))
{
group.Properties.TryGetValue(ManagedCodeConventions.PropertyNames.RuntimeIdentifier, out var ridObj);
group.Properties.TryGetValue(ManagedCodeConventions.PropertyNames.TargetFrameworkMoniker, out var tfmObj);
var tfm = tfmObj as NuGetFramework;
var rid = ridObj as string;
if (tfm?.IsSpecificFramework == true)
{
available.Add(new FrameworkRuntimePair(tfm, rid));
}
}
}
return(available);
}
/// <summary>
/// Whether a package has an incompatible package type. Currently, only 1 package type is incompatible in every project graph and that's DotnetPlatform.
/// </summary>
/// <param name="compatibilityData"></param>
private bool IsPackageTypeCompatible(CompatibilityData compatibilityData)
{
// A package is compatible if it is not DotnetPlatform package type
return(!compatibilityData.TargetLibrary.PackageType.Contains(PackageType.DotnetPlatform));
}
