private void ValidateGenerations()
{
// get the generation of all portable implementation dlls.
var allRuntimeGenerations = _resolver.GetAllRuntimeItems().Values
.SelectMany(groups => groups.Select(group => group.Properties[PropertyNames.TargetFrameworkMoniker] as NuGetFramework))
.Where(fx => fx != null && fx.Framework == _generationIdentifier)
.Select(fx => fx.Version);
// get the generation of all supported frameworks (some may have framework specific implementations
// or placeholders).
var allSupportedGenerations = _frameworks.Values.Where(vf => vf.SupportedVersion != null && FrameworkUtilities.IsGenerationMoniker(vf.Framework))
.Select(vf => vf.Framework.Version);
// find the minimum supported version as the minimum of any generation explicitly implemented
// with a portable implementation, or the generation of a framework with a platform specific
// implementation.
Version minSupportedGeneration = allRuntimeGenerations.Concat(allSupportedGenerations).Min();
// validate API version against generation for all files
foreach (var validateFile in _validateFiles.SelectMany(packageFileSet => packageFileSet.Value)
.Where(f => IsDll(f.SourcePath) && FrameworkUtilities.IsGenerationMoniker(f.TargetFramework)))
{
if (validateFile.TargetFramework.Version < minSupportedGeneration)
{
Log.LogError($"Invalid generation {validateFile.TargetFramework.Version} for {validateFile.SourcePath}, must be at least {minSupportedGeneration} based on the implementations in the package. If you meant to target the lower generation you may be missing an implementation for a framework on that lower generation. If not you should raise the generation of the reference assembly to match that of the lowest supported generation of all implementations/placeholders.");
}
}
}
private void ValidateGenerations()
{
// get the generation of all portable implementation dlls.
var allRuntimeGenerations = _report.Targets.Values.SelectMany(t => t.RuntimeAssets.NullAsEmpty())
.Select(r => r.TargetFramework)
.Where(fx => fx != null && fx.Framework == _generationIdentifier && fx.Version != null)
.Select(fx => fx.Version);
// get the generation of all supported frameworks (some may have framework specific implementations
// or placeholders).
var allSupportedGenerations = _frameworks.Values.Where(vf => vf.SupportedVersion != null && FrameworkUtilities.IsGenerationMoniker(vf.Framework) && vf.Framework.Version != null)
.Select(vf => vf.Framework.Version);
// find the minimum supported version as the minimum of any generation explicitly implemented
// with a portable implementation, or the generation of a framework with a platform specific
// implementation.
Version minSupportedGeneration = allRuntimeGenerations.Concat(allSupportedGenerations).Min();
// validate API version against generation for all files
foreach (var compileAsset in _report.Targets.Values.SelectMany(t => t.CompileAssets)
.Where(f => IsDll(f.LocalPath) && FrameworkUtilities.IsGenerationMoniker(f.TargetFramework)))
{
if (compileAsset.TargetFramework.Version < minSupportedGeneration)
{
Log.LogError($"Invalid generation {compileAsset.TargetFramework.Version} for {compileAsset.LocalPath}, must be at least {minSupportedGeneration} based on the implementations in the package. If you meant to target the lower generation you may be missing an implementation for a framework on that lower generation. If not you should raise the generation of the reference assembly to match that of the lowest supported generation of all implementations/placeholders.");
}
}
}
public static bool IsInbox(string frameworkListsPath, NuGetFramework framework, string assemblyName, string assemblyVersion)
{
if (framework.Framework == FrameworkConstants.FrameworkIdentifiers.UAP ||
(framework.Framework == FrameworkConstants.FrameworkIdentifiers.NetCore && framework.Version >= FrameworkConstants.CommonFrameworks.NetCore50.Version))
{
// UAP & netcore50 or higher are completely OOB, despite being compatible with netcore4x which has inbox assemblies
return(false);
}
// if no version is specified just use 0.0.0.0 to evaluate for any version of the contract
Version version = FrameworkUtilities.Ensure4PartVersion(assemblyVersion);
FrameworkSet fxs = GetInboxFrameworks(frameworkListsPath);
Version latestLegacyVersion = null;
fxs.LastNonSemanticVersions.TryGetValue(assemblyName, out latestLegacyVersion);
foreach (var fxVersions in fxs.Frameworks.Values)
{
// Get the nearest compatible framework from this set of frameworks.
var nearest = FrameworkUtilities.GetNearest(framework, fxVersions.Select(fx => NuGetFramework.Parse(fx.ShortName)).ToArray());
// If there are not compatible frameworks in the current framework set, there is not going to be a match.
if (nearest == null)
{
continue;
}
// don't allow PCL to specify inbox for non-PCL framework.
if (nearest.IsPCL != framework.IsPCL)
{
continue;
}
// find the first version (if any) that supports this contract
foreach (var fxVersion in fxVersions)
{
Version supportedVersion;
if (fxVersion.Assemblies.TryGetValue(assemblyName, out supportedVersion))
{
if (supportedVersion >= version)
{
return(true);
}
// new versions represent API surface via major.minor only, so consider
// a contract as supported so long as the latest legacy version is supported
// and this contract's major.minor match the latest legacy version.
if (supportedVersion == latestLegacyVersion &&
version.Major == latestLegacyVersion.Major && version.Minor == latestLegacyVersion.Minor)
{
return(true);
}
}
}
}
return(false);
}
public override bool Execute()
{
if (PackageIndexes == null && PackageIndexes.Length == 0)
{
Log.LogError("PackageIndexes argument must be specified");
return(false);
}
index = PackageIndex.Load(PackageIndexes.Select(pi => pi.GetMetadata("FullPath")));
List <ITaskItem> promotedDependencies = new List <ITaskItem>();
var dependencies = Dependencies.Select(d => new Dependency(d)).ToArray();
var refSets = dependencies.Where(d => d.Id != "_._").Where(d => d.IsReference).GroupBy(d => NuGetFramework.Parse(d.TargetFramework)).ToDictionary(g => g.Key, g => g.ToArray());
var refFxs = refSets.Keys.ToArray();
Log.LogMessage(LogImportance.Low, $"Ref frameworks {string.Join(";", refFxs.Select(f => f.ToString()))}");
var libSets = dependencies.Where(d => !d.IsReference).GroupBy(d => NuGetFramework.Parse(d.TargetFramework)).ToDictionary(g => g.Key, g => g.ToArray());
var libFxs = libSets.Keys.ToArray();
Log.LogMessage(LogImportance.Low, $"Lib frameworks {string.Join(";", libFxs.Select(f => f.ToString()))}");
if (libFxs.Length > 0)
{
foreach (var refFx in refFxs)
{
// find best lib (if any)
var nearestLibFx = FrameworkUtilities.GetNearest(refFx, libFxs);
if (nearestLibFx != null && !nearestLibFx.Equals(refFx))
{
promotedDependencies.AddRange(CopyDependencies(libSets[nearestLibFx], refFx));
}
}
}
if (refFxs.Length > 0)
{
foreach (var libFx in libFxs)
{
// find best lib (if any)
var nearestRefFx = FrameworkUtilities.GetNearest(libFx, refFxs);
if (nearestRefFx != null && !nearestRefFx.Equals(libFx))
{
promotedDependencies.AddRange(CopyDependencies(refSets[nearestRefFx], libFx));
}
}
}
PromotedDependencies = promotedDependencies.ToArray();
return(!Log.HasLoggedErrors);
}
private static Version GetAssemblyVersion(ITaskItem dependency)
{
// If we don't have the AssemblyVersion metadata (4 part version string), fall back and use Version (3 part version string)
string versionString = dependency.GetMetadata("AssemblyVersion");
if (string.IsNullOrEmpty(versionString))
{
versionString = dependency.GetMetadata("Version");
}
return(FrameworkUtilities.Ensure4PartVersion(versionString));
}
public override bool Execute()
{
List <ITaskItem> promotedDependencies = new List <ITaskItem>();
var dependencies = Dependencies.Select(d => new Dependency(d)).ToArray();
var refSets = dependencies.Where(d => d.Id != "_._").Where(d => d.IsReference).GroupBy(d => d.TargetFramework).ToDictionary(g => NuGetFramework.Parse(g.Key), g => g.ToArray());
var refFxs = refSets.Keys.ToArray();
var libSets = dependencies.Where(d => !d.IsReference).GroupBy(d => d.TargetFramework).ToDictionary(g => NuGetFramework.Parse(g.Key), g => g.ToArray());
var libFxs = libSets.Keys.ToArray();
if (libFxs.Length > 0)
{
foreach (var refFx in refFxs)
{
// find best lib (if any)
var nearestLibFx = FrameworkUtilities.GetNearest(refFx, libFxs);
if (nearestLibFx != null && !nearestLibFx.Equals(refFx))
{
promotedDependencies.AddRange(CopyDependencies(libSets[nearestLibFx], refFx));
}
}
}
if (refFxs.Length > 0)
{
foreach (var libFx in libFxs)
{
// find best lib (if any)
var nearestRefFx = FrameworkUtilities.GetNearest(libFx, refFxs);
if (nearestRefFx == null && !nearestRefFx.Equals(libFx))
{
// This should never happen and indicates a bug in the package. If a package contains references,
// all implementations should have an applicable reference assembly.
Log.LogError($"Could not find applicable reference assembly for implementation framework {libFx} from reference frameworks {string.Join(", ", refFxs.Select(f => f.GetShortFolderName()))}");
}
else
{
promotedDependencies.AddRange(CopyDependencies(refSets[nearestRefFx], libFx));
}
}
}
PromotedDependencies = promotedDependencies.ToArray();
return(!Log.HasLoggedErrors);
}
private static Generation ReadGeneration(KeyValuePair <string, JToken> json)
{
var generation = new Generation()
{
Version = FrameworkUtilities.Ensure4PartVersion(new Version(json.Key))
};
foreach (var assembly in EachProperty(json.Value["assemblies"]))
{
generation.Assemblies.Add(assembly.Key, new Version(assembly.Value.ToString()));
}
return(generation);
}
public static bool IsInbox(string frameworkListsPath, string framework, string assemblyName, string assemblyVersion)
{
// if no version is specified just use 0.0.0.0 to evaluate for any version of the contract
Version version = FrameworkUtilities.Ensure4PartVersion(String.IsNullOrEmpty(assemblyVersion) ? new Version(0, 0, 0, 0) : new Version(assemblyVersion));
FrameworkSet fxs = GetInboxFrameworks(frameworkListsPath);
Version latestLegacyVersion = null;
fxs.LastNonSemanticVersions.TryGetValue(assemblyName, out latestLegacyVersion);
foreach (var fxVersions in fxs.Frameworks.Values)
{
// Get the nearest compatible framework from this set of frameworks.
var nearest = FrameworkUtilities.GetNearest(NuGetFramework.Parse(framework), fxVersions.Select(fx => NuGetFramework.Parse(fx.ShortName)).ToArray());
// If there are not compatible frameworks in the current framework set, there is not going to be a match.
if (nearest == null)
{
continue;
}
var origFramework = NuGetFramework.Parse(framework);
// if the nearest compatible frameworks version is greater than the version of the framework we are looking for, this is not going to be a match.
if (nearest.Version > origFramework.Version)
{
continue;
}
// find the first version (if any) that supports this contract
foreach (var fxVersion in fxVersions)
{
Version supportedVersion;
if (fxVersion.Assemblies.TryGetValue(assemblyName, out supportedVersion))
{
if (supportedVersion >= version)
{
return(true);
}
// new versions represent API surface via major.minor only, so consider
// a contract as supported so long as the latest legacy version is supported
// and this contract's major.minor match the latest legacy version.
if (supportedVersion == latestLegacyVersion &&
version.Major == latestLegacyVersion.Major && version.Minor == latestLegacyVersion.Minor)
{
return(true);
}
}
}
}
return(false);
}
public override bool Execute()
{
List <ITaskItem> promotedDependencies = new List <ITaskItem>();
var implementationFxs = Dependencies.Select(d => d.GetMetadata("TargetFramework")).Distinct();
var actualDependencies = Dependencies.Where(d => d.ItemSpec != "_._").Select(d => new Dependency(d)).ToArray();
var referenceSets = actualDependencies.Where(d => d.IsReference).GroupBy(d => d.TargetFramework).ToDictionary(g => NuGetFramework.Parse(g.Key), g => g.ToArray());
var candidateFxs = referenceSets.Keys.ToArray();
if (candidateFxs.Length != 0)
{
foreach (var implementationFx in implementationFxs)
{
NuGetFramework fx = NuGetFramework.Parse(implementationFx);
if (referenceSets.ContainsKey(fx))
{
// if this implementation assembly fx has a matching reference fx skip promotion
continue;
}
var nearestReferenceFx = FrameworkUtilities.GetNearest(fx, candidateFxs);
if (nearestReferenceFx == null)
{
// This should never happen and indicates a bug in the package. If a package contains references,
// all implementations should have an applicable reference assembly.
Log.LogError($"Could not find applicable reference assembly for implementation framework {implementationFx} from reference frameworks {string.Join(", ", referenceSets.Keys)}");
}
foreach (var reference in referenceSets[nearestReferenceFx])
{
var promotedDependency = new TaskItem(reference.OriginalItem);
promotedDependency.SetMetadata(TargetFrameworkMetadataName, implementationFx);
if (!Frameworks.IsInbox(FrameworkListsPath, implementationFx, reference.Id, reference.Version))
{
promotedDependencies.Add(promotedDependency);
}
}
}
}
PromotedDependencies = promotedDependencies.ToArray();
return(!Log.HasLoggedErrors);
}
private static Version GetAssemblyVersion(ITaskItem dependency)
{
// If we don't have the AssemblyVersion metadata (4 part version string), fall back and use Version (3 part version string)
string versionString = dependency.GetMetadata("AssemblyVersion");
if (string.IsNullOrEmpty(versionString))
{
versionString = dependency.GetMetadata("Version");
int prereleaseIndex = versionString.IndexOf('-');
if (prereleaseIndex != -1)
{
versionString = versionString.Substring(0, prereleaseIndex);
}
}
Version assemblyVersion = FrameworkUtilities.Ensure4PartVersion(
String.IsNullOrEmpty(versionString) ?
new Version(0, 0, 0, 0) :
new Version(versionString));
return(assemblyVersion);
}
public override bool Execute()
{
LoadFiles();
LoadFrameworks();
var report = new PackageReport()
{
Id = PackageId,
Version = PackageVersion,
SupportedFrameworks = new Dictionary <string, string>()
};
string package = $"{PackageId}/{PackageVersion}";
foreach (var framework in _frameworks.OrderBy(f => f.Key.ToString()))
{
var fx = framework.Key;
var runtimeIds = framework.Value;
var compileAssets = _resolver.ResolveCompileAssets(fx, PackageId);
bool hasCompileAsset, hasCompilePlaceHolder;
NuGetAssetResolver.ExamineAssets(Log, "Compile", package, fx.ToString(), compileAssets, out hasCompileAsset, out hasCompilePlaceHolder);
MarkUsed(compileAssets);
// start by making sure it has some asset available for compile
var isSupported = hasCompileAsset || hasCompilePlaceHolder;
if (runtimeIds.All(rid => !String.IsNullOrEmpty(rid)))
{
// Add Framework only (compile) target if all RIDs are non-empty.
// This acts as a compile target for a framework that requires a RID for runtime.
var reportTarget = new Target()
{
Framework = fx.ToString(),
RuntimeID = null,
CompileAssets = compileAssets.Select(c => GetPackageAssetFromTargetPath(c)).ToArray()
};
report.Targets.Add(fx.ToString(), reportTarget);
}
foreach (var runtimeId in runtimeIds)
{
string target = String.IsNullOrEmpty(runtimeId) ? fx.ToString() : $"{fx}/{runtimeId}";
var runtimeAssets = _resolver.ResolveRuntimeAssets(fx, runtimeId);
bool hasRuntimeAsset, hasRuntimePlaceHolder;
NuGetAssetResolver.ExamineAssets(Log, "Runtime", package, target, runtimeAssets, out hasRuntimeAsset, out hasRuntimePlaceHolder);
MarkUsed(runtimeAssets);
if (!FrameworkUtilities.IsGenerationMoniker(fx) && !fx.IsPCL)
{
// only look at runtime assets for runnable frameworks.
isSupported &= (hasCompileAsset && hasRuntimeAsset) || // matching assets
(hasCompilePlaceHolder && hasRuntimeAsset) || // private runtime
(hasCompilePlaceHolder && hasRuntimePlaceHolder); // placeholders
}
var nativeAssets = _resolver.ResolveNativeAssets(fx, runtimeId);
MarkUsed(nativeAssets);
var reportTarget = new Target()
{
Framework = fx.ToString(),
RuntimeID = runtimeId,
CompileAssets = compileAssets.Select(c => GetPackageAssetFromTargetPath(c)).ToArray(),
RuntimeAssets = runtimeAssets.Select(r => GetPackageAssetFromTargetPath(r)).ToArray(),
NativeAssets = nativeAssets.Select(n => GetPackageAssetFromTargetPath(n)).ToArray()
};
report.Targets[target] = reportTarget;
}
if (isSupported)
{
// Find version
// first try the resolved compile asset for this package
var refAssm = compileAssets.FirstOrDefault(r => !NuGetAssetResolver.IsPlaceholder(r))?.Substring(PackageId.Length + 1);
if (refAssm == null)
{
// if we didn't have a compile asset it means this framework is supported inbox with a placeholder
// resolve the assets without placeholders to pick up the netstandard reference assembly.
compileAssets = _resolverWithoutPlaceholders.ResolveCompileAssets(fx);
refAssm = compileAssets.FirstOrDefault(r => !NuGetAssetResolver.IsPlaceholder(r));
}
var version = "unknown";
if (refAssm != null)
{
version = _targetPathToPackageItem[AggregateNuGetAssetResolver.AsPackageSpecificTargetPath(PackageId, refAssm)].Version?.ToString() ?? version;
}
report.SupportedFrameworks.Add(fx.ToString(), version);
}
}
report.UnusedAssets = _unusedTargetPaths.Select(tp => GetPackageAssetFromTargetPath(tp)).ToArray();
report.Save(ReportFile);
return(!Log.HasLoggedErrors);
}
/* Given a set of available frameworks ("InboxOnTargetFrameworks"), and a list of desired frameworks,
* reduce the set of frameworks to the minimum set of frameworks which is compatible (preferring inbox frameworks. */
public override bool Execute()
{
if (null == Dependencies)
{
Log.LogError("Dependencies argument must be specified");
return(false);
}
if (null == FrameworkListsPath)
{
Log.LogError("FrameworkListsPath argument must be specified");
return(false);
}
// Retrieve the list of generation dependency group TFM's
var dependencyGroups = Dependencies.GroupBy(d => d.GetMetadata("TargetFramework")).Select(dg => new
{
Framework = NuGetFramework.Parse(dg.Key),
Dependencies = dg.ToArray()
});
List <ITaskItem> addedDependencies = new List <ITaskItem>();
// Exclude any non-portable frameworks that already have specific dependency groups.
var frameworksToExclude = dependencyGroups.Select(dg => dg.Framework).Where(fx => !FrameworkUtilities.IsGenerationMoniker(fx));
// Prepare a resolver for evaluating if candidate frameworks are actually supported by the package
PackageItem[] packageItems = Files.Select(f => new PackageItem(f)).ToArray();
var packagePaths = packageItems.Select(pi => pi.TargetPath);
var targetFrameworksWithPlaceHolders = packageItems.Where(pi => NuGetAssetResolver.IsPlaceholder(pi.TargetPath)).Select(pi => pi.TargetFramework);
NuGetAssetResolver resolver = new NuGetAssetResolver(null, packagePaths);
foreach (var portableDependencyGroup in dependencyGroups.Where(dg => FrameworkUtilities.IsGenerationMoniker(dg.Framework)))
{
// Determine inbox frameworks for this generation that don't already have explicit groups
HashSet <NuGetFramework> inboxFrameworksList = new HashSet <NuGetFramework>(
Frameworks.GetAlllInboxFrameworks(FrameworkListsPath)
.Where(fx => !fx.IsPCL)
.Where(fx => Generations.DetermineGenerationForFramework(fx, UseNetPlatform) >= portableDependencyGroup.Framework.Version &&
!frameworksToExclude.Any(exFx => exFx.Framework == fx.Framework && exFx.Version <= fx.Version)));
// Check for assets which have a ref, but not a lib asset. If we have any of these, then they are actually not supported frameworks
// and we should not include them.
inboxFrameworksList.RemoveWhere(inboxFx => !IsSupported(inboxFx, resolver));
// Only add the lowest version for a particular inbox framework. EG if both net45 and net46 are supported by this generation,
// only add net45
inboxFrameworksList.RemoveWhere(fx => inboxFrameworksList.Any(otherFx => (otherFx.Framework.Equals(fx.Framework)) && (otherFx.Version < fx.Version)));
// Create dependency items for each inbox framework.
foreach (var framework in inboxFrameworksList)
{
bool addedDependencyToFramework = false;
foreach (ITaskItem dependency in portableDependencyGroup.Dependencies)
{
string version = GetVersion(dependency);
if (!Frameworks.IsInbox(FrameworkListsPath, framework, dependency.ItemSpec, version))
{
addedDependencyToFramework = true;
AddDependency(addedDependencies, new TaskItem(dependency), framework, portableDependencyGroup.Framework);
}
}
if (!addedDependencyToFramework)
{
AddDependency(addedDependencies, new TaskItem("_._"), framework, portableDependencyGroup.Framework);
}
}
}
// Collapse frameworks
// For any dependency with a targetframework, if there is another target framework which is compatible and older, remove this dependency.
// Get all Dependencies which are not in a portable dependency group so that we can collapse the frameworks. If we include
// the portable frameworks, then we'll end up collapsing to those.
List <NuGetFramework> allDependencyGroups = new List <NuGetFramework>();
allDependencyGroups.AddRange(Dependencies.Select(d => NuGetFramework.Parse(d.GetMetadata("TargetFramework"))).Where(a => !allDependencyGroups.Contains(a) &&
!FrameworkUtilities.IsGenerationMoniker(a) &&
!FrameworkUtilities.IsPortableMoniker(a)));
allDependencyGroups.AddRange(addedDependencies.Select(d => NuGetFramework.Parse(d.GetMetadata("TargetFramework"))).Where(a => !allDependencyGroups.Contains(a) &&
!FrameworkUtilities.IsGenerationMoniker(a) &&
!FrameworkUtilities.IsPortableMoniker(a)));
List <NuGetFramework> collapsedDependencyGroups = FrameworkUtilities.ReduceDownwards(allDependencyGroups).ToList <NuGetFramework>();
// Get the list of dependency groups that we collapsed down so that we can add them back if they contained different dependencies than what is present in the collapsed group.
/* TODO: Look into NuGet's sorting algorithm, they may have a bug (fixed in this line). They were not including version in the sort.
* See ReduceCore in https://github.com/NuGet/NuGet.Client/blob/23ea68b91a439fcfd7f94bcd01bcdee2e8adae92/src/NuGet.Core/NuGet.Frameworks/FrameworkReducer.cs */
IEnumerable <NuGetFramework> removedDependencyGroups = allDependencyGroups.Where(d => !collapsedDependencyGroups.Contains(d))?.OrderBy(f => f.Framework, StringComparer.OrdinalIgnoreCase).ThenBy(f => f.Version);
foreach (NuGetFramework removedDependencyGroup in removedDependencyGroups)
{
// always recalculate collapsedDependencyGroups in case we added an item in a previous iteration. Dependency groups are sorted, so this should be additive and we shouldn't need to restart the collapse / add back cycle
var nearest = FrameworkUtilities.GetNearest(removedDependencyGroup, collapsedDependencyGroups.ToArray());
// gather the dependencies for this dependency group and the calculated "nearest" dependency group
var nearestDependencies = addedDependencies.Where(d => nearest.Equals(NuGetFramework.Parse(d.GetMetadata("TargetFramework")))).OrderBy(f => f.ToString());
var currentDependencies = addedDependencies.Where(d => removedDependencyGroup.Equals(NuGetFramework.Parse(d.GetMetadata("TargetFramework")))).OrderBy(f => f.ToString());
// The nearest dependency group's dependencies are different than this dependency group's dependencies
if (nearestDependencies.Count() != currentDependencies.Count())
{
// ignore if dependency is a placeholder
if (currentDependencies.Count() > 0)
{
if (!NuGetAssetResolver.IsPlaceholder(currentDependencies.First().ToString()))
{
collapsedDependencyGroups.Add(removedDependencyGroup);
}
}
else
{
collapsedDependencyGroups.Add(removedDependencyGroup);
}
}
// identical dependency count between current and nearest, and the count is > 0
else if (nearestDependencies.Count() > 0)
{
if (!currentDependencies.SequenceEqual(nearestDependencies, new DependencyITaskItemComparer()))
{
collapsedDependencyGroups.Add(removedDependencyGroup);
}
}
}
List <ITaskItem> collapsedDependencies = new List <ITaskItem>();
foreach (ITaskItem dependency in addedDependencies)
{
if (collapsedDependencyGroups.Contains(NuGetFramework.Parse(dependency.GetMetadata("TargetFramework"))))
{
collapsedDependencies.Add(dependency);
}
}
TrimmedDependencies = collapsedDependencies.ToArray();
return(!Log.HasLoggedErrors);
}
private void HarvestSupportedFrameworks()
{
List <ITaskItem> supportedFrameworks = new List <ITaskItem>();
AggregateNuGetAssetResolver resolver = new AggregateNuGetAssetResolver(RuntimeFile);
string packagePath = Path.Combine(PackagesFolder, PackageId, PackageVersion);
// add the primary package
resolver.AddPackageItems(PackageId, GetPackageItems(packagePath));
if (RuntimePackages != null)
{
// add any split runtime packages
foreach (var runtimePackage in RuntimePackages)
{
var runtimePackageId = runtimePackage.ItemSpec;
var runtimePackageVersion = runtimePackage.GetMetadata("Version");
resolver.AddPackageItems(runtimePackageId, GetPackageItems(PackagesFolder, runtimePackageId, runtimePackageVersion));
}
}
// create a resolver that can be used to determine the API version for inbox assemblies
// since inbox assemblies are represented with placeholders we can remove the placeholders
// and use the netstandard reference assembly to determine the API version
var filesWithoutPlaceholders = GetPackageItems(packagePath)
.Where(f => !NuGetAssetResolver.IsPlaceholder(f));
NuGetAssetResolver resolverWithoutPlaceholders = new NuGetAssetResolver(RuntimeFile, filesWithoutPlaceholders);
string package = $"{PackageId}/{PackageVersion}";
foreach (var framework in Frameworks)
{
var runtimeIds = framework.GetMetadata("RuntimeIDs")?.Split(';');
NuGetFramework fx;
try
{
fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework.");
continue;
}
var compileAssets = resolver.ResolveCompileAssets(fx, PackageId);
bool hasCompileAsset, hasCompilePlaceHolder;
NuGetAssetResolver.ExamineAssets(Log, "Compile", package, fx.ToString(), compileAssets, out hasCompileAsset, out hasCompilePlaceHolder);
// start by making sure it has some asset available for compile
var isSupported = hasCompileAsset || hasCompilePlaceHolder;
if (!isSupported)
{
Log.LogMessage(LogImportance.Low, $"Skipping {fx} because it is not supported.");
continue;
}
foreach (var runtimeId in runtimeIds)
{
string target = String.IsNullOrEmpty(runtimeId) ? fx.ToString() : $"{fx}/{runtimeId}";
var runtimeAssets = resolver.ResolveRuntimeAssets(fx, runtimeId);
bool hasRuntimeAsset, hasRuntimePlaceHolder;
NuGetAssetResolver.ExamineAssets(Log, "Runtime", package, target, runtimeAssets, out hasRuntimeAsset, out hasRuntimePlaceHolder);
isSupported &= hasCompileAsset == hasRuntimeAsset;
isSupported &= hasCompilePlaceHolder == hasRuntimePlaceHolder;
if (!isSupported)
{
Log.LogMessage(LogImportance.Low, $"Skipping {fx} because it is not supported on {target}.");
break;
}
}
if (isSupported)
{
var supportedFramework = new TaskItem(framework.ItemSpec);
supportedFramework.SetMetadata("HarvestedFromPackage", package);
// set version
// first try the resolved compile asset for this package
var refAssm = compileAssets.FirstOrDefault(r => !NuGetAssetResolver.IsPlaceholder(r))?.Substring(PackageId.Length + 1);
if (refAssm == null)
{
// if we didn't have a compile asset it means this framework is supported inbox with a placeholder
// resolve the assets without placeholders to pick up the netstandard reference assembly.
compileAssets = resolverWithoutPlaceholders.ResolveCompileAssets(fx);
refAssm = compileAssets.FirstOrDefault(r => !NuGetAssetResolver.IsPlaceholder(r));
}
string version = "unknown";
if (refAssm != null)
{
version = VersionUtility.GetAssemblyVersion(Path.Combine(packagePath, refAssm))?.ToString() ?? version;
}
supportedFramework.SetMetadata("Version", version);
Log.LogMessage($"Validating version {version} for {supportedFramework.ItemSpec} because it was supported by {PackageId}/{PackageVersion}.");
supportedFrameworks.Add(supportedFramework);
}
}
SupportedFrameworks = supportedFrameworks.ToArray();
}
private void ValidateSupport()
{
// validate support for each TxM:RID
foreach (var validateFramework in _frameworks.Values)
{
NuGetFramework fx = validateFramework.Framework;
Version supportedVersion = validateFramework.SupportedVersion;
var compileAssetPaths = _resolver.ResolveCompileAssets(fx, PackageId);
bool hasCompileAsset, hasCompilePlaceHolder;
ExamineAssets("Compile", ContractName, fx.ToString(), compileAssetPaths, out hasCompileAsset, out hasCompilePlaceHolder);
// resolve/test for each RID associated with this framework.
foreach (string runtimeId in validateFramework.RuntimeIds)
{
string target = String.IsNullOrEmpty(runtimeId) ? fx.ToString() : $"{fx}/{runtimeId}";
var runtimeAssetPaths = _resolver.ResolveRuntimeAssets(fx, runtimeId);
bool hasRuntimeAsset, hasRuntimePlaceHolder;
ExamineAssets("Runtime", ContractName, target, runtimeAssetPaths, out hasRuntimeAsset, out hasRuntimePlaceHolder);
if (null == supportedVersion)
{
// Contract should not be supported on this platform.
bool permitImplementation = HasSuppression(Suppression.PermitImplementation, target);
if (hasCompileAsset && (hasRuntimeAsset & !permitImplementation))
{
Log.LogError($"{ContractName} should not be supported on {target} but has both compile and runtime assets.");
}
else if (hasRuntimeAsset & !permitImplementation)
{
Log.LogError($"{ContractName} should not be supported on {target} but has runtime assets.");
}
if (hasRuntimePlaceHolder && hasCompilePlaceHolder)
{
Log.LogError($"{ContractName} should not be supported on {target} but has placeholders for both compile and runtime which will permit the package to install.");
}
}
else
{
if (validateFramework.IsInbox)
{
if (!hasCompileAsset && !hasCompilePlaceHolder)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but was missing a placeholder for compile-time. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
else if (hasCompileAsset)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but contained a reference assemblies: {String.Join(", ", compileAssetPaths)}. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
if (!hasRuntimeAsset && !hasRuntimePlaceHolder)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but was missing a placeholder for run-time. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
else if (hasRuntimeAsset)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but contained a implementation assemblies: {String.Join(", ", runtimeAssetPaths)}. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
}
else
{
Version referenceAssemblyVersion = null;
if (!hasCompileAsset)
{
Log.LogError($"{ContractName} should be supported on {target} but has no compile assets.");
}
else
{
var referenceAssemblies = compileAssetPaths.Where(IsDll);
if (referenceAssemblies.Count() > 1)
{
Log.LogError($"{ContractName} should only contain a single compile asset for {target}.");
}
foreach (var referenceAssembly in referenceAssemblies)
{
referenceAssemblyVersion = _targetPathToPackageItem[referenceAssembly].Version;
if (!VersionUtility.IsCompatibleApiVersion(supportedVersion, referenceAssemblyVersion))
{
Log.LogError($"{ContractName} should support API version {supportedVersion} on {target} but {referenceAssembly} was found to support {referenceAssemblyVersion?.ToString() ?? "<unknown version>"}.");
}
}
}
if (!hasRuntimeAsset && !FrameworkUtilities.IsGenerationMoniker(validateFramework.Framework))
{
Log.LogError($"{ContractName} should be supported on {target} but has no runtime assets.");
}
else
{
var implementationAssemblies = runtimeAssetPaths.Where(IsDll);
Dictionary <string, string> implementationFiles = new Dictionary <string, string>();
foreach (var implementationAssembly in implementationAssemblies)
{
Version implementationVersion = _targetPathToPackageItem[implementationAssembly].Version;
if (!VersionUtility.IsCompatibleApiVersion(supportedVersion, implementationVersion))
{
Log.LogError($"{ContractName} should support API version {supportedVersion} on {target} but {implementationAssembly} was found to support {implementationVersion?.ToString() ?? "<unknown version>"}.");
}
if (referenceAssemblyVersion != null &&
HasSuppression(Suppression.PermitHigherCompatibleImplementationVersion) ?
!VersionUtility.IsCompatibleApiVersion(referenceAssemblyVersion, implementationVersion) :
(implementationVersion != referenceAssemblyVersion))
{
Log.LogError($"{ContractName} has mismatched compile ({referenceAssemblyVersion}) and runtime ({implementationVersion}) versions on {target}.");
}
string fileName = Path.GetFileName(implementationAssembly);
if (implementationFiles.ContainsKey(fileName))
{
Log.LogError($"{ContractName} includes both {implementationAssembly} and {implementationFiles[fileName]} an on {target} which have the same name and will clash when both packages are used.");
}
else
{
implementationFiles[fileName] = implementationAssembly;
}
}
}
}
}
}
}
// Set output items
AllSupportedFrameworks = _frameworks.Values.Where(fx => fx.SupportedVersion != null).Select(fx => fx.ToItem()).OrderBy(i => i.ItemSpec).ToArray();
if (!String.IsNullOrEmpty(ValidationReport))
{
WriteValidationReport(ValidationReport, _frameworks.Values);
}
}
private void LoadSupport()
{
_frameworks = new Dictionary <NuGetFramework, ValidationFramework>();
// determine which TxM:RIDs should be considered for support based on Frameworks item
foreach (var framework in Frameworks)
{
NuGetFramework fx;
try
{
fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework.");
continue;
}
string runtimeIdList = framework.GetMetadata("RuntimeIDs");
if (_frameworks.ContainsKey(fx))
{
Log.LogError($"Framework {fx} has been listed in Frameworks more than once.");
continue;
}
_frameworks[fx] = new ValidationFramework(fx);
if (!String.IsNullOrWhiteSpace(runtimeIdList))
{
_frameworks[fx].RuntimeIds = runtimeIdList.Split(';');
}
}
// keep a list of explicitly listed supported frameworks so that we can check for conflicts.
HashSet <NuGetFramework> explicitlySupportedFrameworks = new HashSet <NuGetFramework>();
// determine what version should be supported based on SupportedFramework items
foreach (var supportedFramework in SupportedFrameworks)
{
NuGetFramework fx;
string fxString = supportedFramework.ItemSpec;
bool isExclusiveVersion = fxString.Length > 1 && fxString[0] == '[' && fxString[fxString.Length - 1] == ']';
if (isExclusiveVersion)
{
fxString = fxString.Substring(1, fxString.Length - 2);
}
try
{
fx = FrameworkUtilities.ParseNormalized(fxString);
}
catch (Exception ex)
{
Log.LogError($"Could not parse TargetFramework {fxString} as a SupportedFramework. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize TargetFramework {fxString} as a SupportedFramework.");
continue;
}
Version supportedVersion;
string version = supportedFramework.GetMetadata("Version");
try
{
supportedVersion = Version.Parse(version);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Version {version} on SupportedFramework item {supportedFramework.ItemSpec}. {ex}");
continue;
}
ValidationFramework validationFramework = null;
if (!_frameworks.TryGetValue(fx, out validationFramework))
{
Log.LogError($"SupportedFramework {fx} was specified but is not part of the Framework list to use for validation.");
continue;
}
if (explicitlySupportedFrameworks.Contains(fx))
{
if (validationFramework.SupportedVersion != supportedVersion)
{
Log.LogError($"Framework {fx} has been listed in SupportedFrameworks more than once with different versions {validationFramework.SupportedVersion} and {supportedVersion}. Framework should only be listed once with the expected API version for that platform.");
}
continue;
}
explicitlySupportedFrameworks.Add(fx);
validationFramework.SupportedVersion = supportedVersion;
if (!isExclusiveVersion)
{
// find all frameworks of higher version, sorted by version ascending
var higherFrameworks = _frameworks.Values.Where(vf => vf.Framework.Framework == fx.Framework && vf.Framework.Version > fx.Version).OrderBy(vf => vf.Framework.Version);
foreach (var higherFramework in higherFrameworks)
{
if (higherFramework.SupportedVersion != null && higherFramework.SupportedVersion > supportedVersion)
{
// found an higher framework version a higher API version, stop applying this supported version
break;
}
higherFramework.SupportedVersion = supportedVersion;
}
}
}
// determine which Frameworks should support inbox
_frameworkSet = FrameworkSet.Load(FrameworkListsPath);
foreach (IEnumerable <Framework> inboxFxGroup in _frameworkSet.Frameworks.Values)
{
foreach (Framework inboxFx in inboxFxGroup)
{
// get currently supported version to see if we have OOB'ed it
Version inboxVersion = null;
inboxFx.Assemblies.TryGetValue(ContractName, out inboxVersion);
if (inboxVersion != null)
{
NuGetFramework fx = FrameworkUtilities.ParseNormalized(inboxFx.ShortName);
ValidationFramework validationFramework = null;
if (_frameworks.TryGetValue(fx, out validationFramework))
{
Version supportedVersion = validationFramework.SupportedVersion;
if (supportedVersion != null &&
(supportedVersion.Major > inboxVersion.Major ||
(supportedVersion.Major == inboxVersion.Major && supportedVersion.Minor > inboxVersion.Minor)))
{
// Higher major.minor
Log.LogMessage(LogImportance.Low, $"Framework {fx} supported {ContractName} as inbox but the current supported version {supportedVersion} is higher in major.minor than inbox version {inboxVersion}. Assuming out of box.");
continue;
}
else if (supportedVersion != null && supportedVersion < inboxVersion)
{
// Lower version
Log.LogError($"Framework {fx} supports {ContractName} as inbox but the current supported version {supportedVersion} is lower than the inbox version {inboxVersion}");
}
// equal major.minor, build.revision difference is permitted, prefer the version listed by ContractSupport item
}
if (validationFramework == null)
{
// we may not be explicitly validating for this framework so add it to validate inbox assets.
_frameworks[fx] = validationFramework = new ValidationFramework(fx)
{
SupportedVersion = inboxVersion
};
}
validationFramework.IsInbox = true;
}
}
}
// for every framework we know about, also validate it's generation to ensure it can
// be targeted by PCL. Even if a package only supports a single framework we still
// want to include a portable reference assembly. This allows 3rd parties to add
// their own implementation via a lineup/runtime.json.
// only consider frameworks that support the contract at a specific version
var portableFrameworks = _frameworks.Values.Where(fx => fx.SupportedVersion != null && fx.SupportedVersion != s_maxVersion).ToArray();
var genVersionSuppression = GetSuppressionValues(Suppression.PermitPortableVersionMismatch) ?? new HashSet <string>();
Dictionary <NuGetFramework, ValidationFramework> generationsToValidate = new Dictionary <NuGetFramework, ValidationFramework>();
foreach (var framework in portableFrameworks)
{
NuGetFramework generation = new NuGetFramework(_generationIdentifier, Generations.DetermineGenerationForFramework(framework.Framework, UseNetPlatform));
Log.LogMessage(LogImportance.Low, $"Validating {generation} for {ContractName}, {framework.SupportedVersion} since it is supported by {framework.Framework}");
ValidationFramework existingGeneration = null;
if (generationsToValidate.TryGetValue(generation, out existingGeneration))
{
if (!VersionUtility.IsCompatibleApiVersion(framework.SupportedVersion, existingGeneration.SupportedVersion) && !genVersionSuppression.Contains(framework.Framework.ToString()))
{
Log.LogError($"Framework {framework.Framework} supports {ContractName} at {framework.SupportedVersion} which is lower than {existingGeneration.SupportedVersion} supported by generation {generation.GetShortFolderName()}");
}
}
else
{
generationsToValidate.Add(generation, new ValidationFramework(generation)
{
SupportedVersion = framework.SupportedVersion
});
}
}
foreach (var generation in generationsToValidate)
{
_frameworks.Add(generation.Key, generation.Value);
}
// for every generation supported explcitly in implementation, ensure
// it can be targeted by PCL.
foreach (var packageGroup in _resolver.GetAllRuntimeItems())
{
var allGenerationalImplementations = packageGroup.Value
.Where(contentGroup => FrameworkUtilities.IsGenerationMoniker(contentGroup.Properties[PropertyNames.TargetFrameworkMoniker] as NuGetFramework))
.SelectMany(contentGroup => contentGroup.Items.Select(item => _targetPathToPackageItem[AggregateNuGetAssetResolver.AsPackageSpecificTargetPath(packageGroup.Key, item.Path)]));
foreach (var generationalImplementation in allGenerationalImplementations)
{
NuGetFramework generation = generationalImplementation.TargetFramework;
if (_frameworks.ContainsKey(generation))
{
continue;
}
Version supportedVersion = generationalImplementation.Version;
Log.LogMessage(LogImportance.Low, $"Validating {generation} for {ContractName}, {supportedVersion} since it is supported by {generationalImplementation.TargetPath}");
_frameworks.Add(generation, new ValidationFramework(generation)
{
SupportedVersion = supportedVersion
});
}
}
}
/* Given a set of available frameworks ("InboxOnTargetFrameworks"), and a list of desired frameworks,
* reduce the set of frameworks to the minimum set of frameworks which is compatible (preferring inbox frameworks. */
public override bool Execute()
{
if (null == Dependencies)
{
Log.LogError("Dependencies argument must be specified");
return(false);
}
if (PackageIndexes == null && PackageIndexes.Length == 0)
{
Log.LogError("PackageIndexes argument must be specified");
return(false);
}
var index = PackageIndex.Load(PackageIndexes.Select(pi => pi.GetMetadata("FullPath")));
// Retrieve the list of dependency group TFM's
var dependencyGroups = Dependencies
.Select(dependencyItem => new TaskItemPackageDependency(dependencyItem))
.GroupBy(dependency => dependency.TargetFramework)
.Select(dependencyGrouping => new TaskItemPackageDependencyGroup(dependencyGrouping.Key, dependencyGrouping))
.ToArray();
// Prepare a resolver for evaluating if candidate frameworks are actually supported by the package
PackageItem[] packageItems = Files.Select(f => new PackageItem(f)).ToArray();
var packagePaths = packageItems.Select(pi => pi.TargetPath);
NuGetAssetResolver resolver = new NuGetAssetResolver(null, packagePaths);
// Determine all inbox frameworks which are supported by this package
var supportedInboxFrameworks = index.GetAlllInboxFrameworks().Where(fx => IsSupported(fx, resolver));
var newDependencyGroups = new Queue <TaskItemPackageDependencyGroup>();
// For each inbox framework determine its best compatible dependency group and create an explicit group, trimming out any inbox dependencies
foreach (var supportedInboxFramework in supportedInboxFrameworks)
{
var nearestDependencyGroup = dependencyGroups.GetNearest(supportedInboxFramework);
// We found a compatible dependency group that is not the same as this framework
if (nearestDependencyGroup != null && nearestDependencyGroup.TargetFramework != supportedInboxFramework)
{
// remove all dependencies which are inbox on supportedInboxFramework
var filteredDependencies = nearestDependencyGroup.Packages.Where(d => !index.IsInbox(d.Id, supportedInboxFramework, d.AssemblyVersion)).ToArray();
newDependencyGroups.Enqueue(new TaskItemPackageDependencyGroup(supportedInboxFramework, filteredDependencies));
}
}
// Remove any redundant groups from the added set (EG: net45 and net46 with the same set of dependencies)
int groupsToCheck = newDependencyGroups.Count;
for (int i = 0; i < groupsToCheck; i++)
{
// to determine if this is a redundant group, we dequeue so that it won't be considered in the following check for nearest group.
var group = newDependencyGroups.Dequeue();
// of the remaining groups, find the most compatible one
var nearestGroup = newDependencyGroups.Concat(dependencyGroups).GetNearest(group.TargetFramework);
// either we found no compatible group,
// or the closest compatible group has different dependencies,
// or the closest compatible group is portable and this is not (Portable profiles have different framework precedence, https://github.com/NuGet/Home/issues/6483),
// keep it in the set of additions
if (nearestGroup == null ||
!group.Packages.SetEquals(nearestGroup.Packages) ||
FrameworkUtilities.IsPortableMoniker(group.TargetFramework) != FrameworkUtilities.IsPortableMoniker(nearestGroup.TargetFramework))
{
// not redundant, keep it in the queue
newDependencyGroups.Enqueue(group);
}
}
// Build the items representing added dependency groups.
List <ITaskItem> trimmedDependencies = new List <ITaskItem>();
foreach (var newDependencyGroup in newDependencyGroups)
{
if (newDependencyGroup.Packages.Count == 0)
{
// no dependencies (all inbox), use a placeholder dependency.
var item = new TaskItem(PlaceHolderDependency);
item.SetMetadata("TargetFramework", newDependencyGroup.TargetFramework.GetShortFolderName());
trimmedDependencies.Add(item);
}
else
{
foreach (var dependency in newDependencyGroup.Packages)
{
var item = new TaskItem(dependency.Item);
// emit CopiedFromTargetFramework to aide in debugging.
item.SetMetadata("CopiedFromTargetFramework", item.GetMetadata("TargetFramework"));
item.SetMetadata("TargetFramework", newDependencyGroup.TargetFramework.GetShortFolderName());
trimmedDependencies.Add(item);
}
}
}
TrimmedDependencies = trimmedDependencies.ToArray();
return(!Log.HasLoggedErrors);
}
public IEnumerable <NuGetFramework> GetInboxFrameworks(string assemblyName, string assemblyVersionString)
{
Version assemblyVersion = FrameworkUtilities.Ensure4PartVersion(assemblyVersionString);
return(GetInboxFrameworks(assemblyName, assemblyVersion));
}
private void LoadSupport()
{
_frameworks = new Dictionary <NuGetFramework, ValidationFramework>();
// determine which TxM:RIDs should be considered for support based on Frameworks item
foreach (var framework in Frameworks)
{
NuGetFramework fx;
try
{
fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework.");
continue;
}
string runtimeIdList = framework.GetMetadata("RuntimeIDs");
if (_frameworks.ContainsKey(fx))
{
Log.LogError($"Framework {fx} has been listed in Frameworks more than once.");
continue;
}
_frameworks[fx] = new ValidationFramework(fx);
if (!String.IsNullOrWhiteSpace(runtimeIdList))
{
_frameworks[fx].RuntimeIds = runtimeIdList.Split(';');
}
}
// keep a list of explicitly listed supported frameworks so that we can check for conflicts.
HashSet <NuGetFramework> explicitlySupportedFrameworks = new HashSet <NuGetFramework>(NuGetFramework.Comparer);
// determine what version should be supported based on SupportedFramework items
foreach (var supportedFramework in SupportedFrameworks)
{
NuGetFramework fx;
string fxString = supportedFramework.ItemSpec;
bool isExclusiveVersion = fxString.Length > 1 && fxString[0] == '[' && fxString[fxString.Length - 1] == ']';
if (isExclusiveVersion)
{
fxString = fxString.Substring(1, fxString.Length - 2);
}
try
{
fx = FrameworkUtilities.ParseNormalized(fxString);
}
catch (Exception ex)
{
Log.LogError($"Could not parse TargetFramework {fxString} as a SupportedFramework. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize TargetFramework {fxString} as a SupportedFramework.");
continue;
}
Version supportedVersion;
string version = supportedFramework.GetMetadata("Version");
try
{
supportedVersion = Version.Parse(version);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Version {version} on SupportedFramework item {supportedFramework.ItemSpec}. {ex}");
continue;
}
ValidationFramework validationFramework = null;
if (!_frameworks.TryGetValue(fx, out validationFramework))
{
Log.LogError($"SupportedFramework {fx} was specified but is not part of the Framework list to use for validation.");
continue;
}
if (explicitlySupportedFrameworks.Contains(fx))
{
if (supportedVersion <= validationFramework.SupportedVersion)
{
// if we've already picked up a higher/equal version, prefer it
continue;
}
}
else
{
explicitlySupportedFrameworks.Add(fx);
}
validationFramework.SupportedVersion = supportedVersion;
if (!isExclusiveVersion)
{
// find all frameworks of higher version, sorted by version ascending
IEnumerable <ValidationFramework> higherFrameworks = _frameworks.Values.Where(vf => vf.Framework.Framework == fx.Framework && vf.Framework.Version > fx.Version).OrderBy(vf => vf.Framework.Version);
// netcore50 is the last `netcore` framework, after that we use `uap`
if (fx.Framework == FrameworkConstants.FrameworkIdentifiers.NetCore)
{
var uapFrameworks = _frameworks.Values.Where(vf => vf.Framework.Framework == FrameworkConstants.FrameworkIdentifiers.UAP).OrderBy(vf => vf.Framework.Version);
higherFrameworks = higherFrameworks.Concat(uapFrameworks);
}
foreach (var higherFramework in higherFrameworks)
{
if (higherFramework.SupportedVersion != null && higherFramework.SupportedVersion > supportedVersion)
{
// found an higher framework version a higher API version, stop applying this supported version
break;
}
higherFramework.SupportedVersion = supportedVersion;
}
}
}
// determine which Frameworks should support inbox
PackageInfo packageInfo;
if (_index.Packages.TryGetValue(ContractName, out packageInfo))
{
foreach (var inboxPair in packageInfo.InboxOn.GetInboxVersions())
{
if (!_frameworks.ContainsKey(inboxPair.Key))
{
_frameworks[inboxPair.Key] = new ValidationFramework(inboxPair.Key)
{
SupportedVersion = inboxPair.Value,
IsInbox = true
};
}
}
foreach (var validationFramework in _frameworks.Values)
{
if (packageInfo.InboxOn.IsInbox(validationFramework.Framework,
validationFramework.SupportedVersion,
permitRevisions: HasSuppression(Suppression.PermitInboxRevsion)))
{
validationFramework.IsInbox = true;
}
}
}
// validate netstandard frameworks supported by references
foreach (var supportedFramework in _report.SupportedFrameworks)
{
var framework = NuGetFramework.Parse(supportedFramework.Key);
if (framework.Framework != _generationIdentifier)
{
continue;
}
Version supportedVersion;
if (!Version.TryParse(supportedFramework.Value, out supportedVersion))
{
continue;
}
if (!_frameworks.ContainsKey(framework))
{
_frameworks[framework] = new ValidationFramework(framework)
{
SupportedVersion = supportedVersion
};
}
}
}
private void LoadFrameworks()
{
_frameworks = new Dictionary <NuGetFramework, string[]>(NuGetFramework.Comparer);
// load the specified frameworks
foreach (var framework in Frameworks)
{
var runtimeIds = framework.GetMetadata("RuntimeIDs")?.Split(';');
NuGetFramework fx;
try
{
fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework.");
continue;
}
_frameworks.Add(fx, runtimeIds);
}
// inspect any TFMs explicitly targeted
var fileFrameworks = _targetPathToPackageItem.Values.Select(f => f.TargetFramework).Distinct(NuGetFramework.Comparer).Where(f => f != null);
foreach (var fileFramework in fileFrameworks)
{
if (!_frameworks.ContainsKey(fileFramework))
{
_frameworks.Add(fileFramework, s_noRids);
}
}
// inspect any TFMs inbox
var frameworkData = FrameworkSet.Load(FrameworkListsPath);
var inboxFrameworks = frameworkData.Frameworks.SelectMany(f => f.Value)
.Where(fx => fx.Assemblies.ContainsKey(PackageId))
.Select(fx => NuGetFramework.Parse(fx.FrameworkName.FullName));
foreach (var inboxFramework in inboxFrameworks)
{
if (!_frameworks.ContainsKey(inboxFramework))
{
_frameworks.Add(inboxFramework, s_noRids);
}
}
// inspect for derived TFMs
var expander = new FrameworkExpander();
foreach (var framework in _frameworks.Keys.ToArray())
{
var derivedFxs = expander.Expand(framework);
foreach (var derivedFx in derivedFxs)
{
if (!_frameworks.ContainsKey(derivedFx))
{
_frameworks.Add(derivedFx, s_noRids);
}
}
}
}
private void LoadFrameworks()
{
_frameworks = new Dictionary <NuGetFramework, string[]>(NuGetFramework.Comparer);
// load the specified frameworks
foreach (var framework in Frameworks)
{
var runtimeIds = framework.GetMetadata("RuntimeIDs")?.Split(';');
NuGetFramework fx;
try
{
fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework.");
continue;
}
_frameworks.Add(fx, runtimeIds);
}
// inspect any TFMs explicitly targeted
var fileFrameworks = _targetPathToPackageItem.Values.Select(f => f.TargetFramework).Distinct(NuGetFramework.Comparer).Where(f => f != null);
foreach (var fileFramework in fileFrameworks)
{
if (!_frameworks.ContainsKey(fileFramework))
{
_frameworks.Add(fileFramework, s_noRids);
}
}
// inspect any TFMs inbox
var index = PackageIndex.Load(PackageIndexes.Select(pi => pi.GetMetadata("FullPath")));
var inboxFrameworks = index.GetInboxFrameworks(PackageId).NullAsEmpty();
foreach (var inboxFramework in inboxFrameworks)
{
if (!_frameworks.ContainsKey(inboxFramework))
{
_frameworks.Add(inboxFramework, s_noRids);
}
}
// inspect for derived TFMs
var expander = new FrameworkExpander();
foreach (var framework in _frameworks.Keys.ToArray())
{
var derivedFxs = expander.Expand(framework);
foreach (var derivedFx in derivedFxs)
{
if (derivedFx.IsDesktop() && derivedFx.HasProfile)
{
// skip desktop profiles
continue;
}
if (derivedFx.Version.Major == 0 && derivedFx.Version.Minor == 0)
{
// skip unversioned frameworks
continue;
}
if (s_ignoredFrameworks.Contains(derivedFx.Framework))
{
continue;
}
if (!_frameworks.ContainsKey(derivedFx))
{
_frameworks.Add(derivedFx, s_noRids);
}
}
}
}
/* Given a set of available frameworks ("InboxOnTargetFrameworks"), and a list of desired frameworks,
* reduce the set of frameworks to the minimum set of frameworks which is compatible (preferring inbox frameworks. */
public override bool Execute()
{
if (null == Dependencies)
{
Log.LogError("Dependencies argument must be specified");
return(false);
}
if (null == FrameworkListsPath)
{
Log.LogError("FrameworkListsPath argument must be specified");
return(false);
}
// Retrieve the list of generation dependency group TFM's
Dictionary <string, IEnumerable <ITaskItem> > portableDependencyGroups = new Dictionary <string, IEnumerable <ITaskItem> >();
foreach (ITaskItem dependency in Dependencies)
{
string framework = dependency.GetMetadata("TargetFramework");
if (framework != null && FrameworkUtilities.IsGenerationMoniker(framework) && !portableDependencyGroups.ContainsKey(framework))
{
portableDependencyGroups.Add(framework, Dependencies.Where(d => d.GetMetadata("TargetFramework") == framework));
}
}
List <ITaskItem> addedDependencies = new List <ITaskItem>();
List <string> placeHolderFrameworks = new List <string>();
var frameworksToExclude = TrimFrameworks?.Select(fx => NuGetFramework.Parse(fx))?.ToArray() ?? new NuGetFramework[0];
// Prepare a resolver for evaluating if candidate frameworks are actually supported by the package
PackageItem[] packageItems = Files.Select(f => new PackageItem(f)).ToArray();
var packagePaths = packageItems.Select(pi => pi.TargetPath);
var targetFrameworksWithPlaceHolders = packageItems.Where(pi => NuGetAssetResolver.IsPlaceholder(pi.TargetPath)).Select(pi => pi.TargetFramework);
NuGetAssetResolver resolver = new NuGetAssetResolver(null, packagePaths);
foreach (string portableDependency in portableDependencyGroups.Keys)
{
NuGetFramework portableDependencyFramework = NuGetFramework.Parse(portableDependency);
// Determine inbox frameworks for this generations dependencies as a whole
HashSet <NuGetFramework> inboxFrameworksList = new HashSet <NuGetFramework>();
foreach (NuGetFramework inboxFramework in Frameworks.GetAlllInboxFrameworks(FrameworkListsPath))
{
if (Generations.DetermineGenerationForFramework(inboxFramework, UseNetPlatform) >= portableDependencyFramework.Version &&
!frameworksToExclude.Contains(inboxFramework))
{
inboxFrameworksList.Add(inboxFramework);
}
}
// Only add the lowest version for a particular inbox framework. EG if both net45 and net46 are supported by this generation,
// only add net45
inboxFrameworksList.RemoveWhere(fx => inboxFrameworksList.Any(otherFx => (otherFx.Framework.Equals(fx.Framework)) && (otherFx.Version < fx.Version)));
// Check for assets which have a ref, but not a lib asset. If we have any of these, then they are actually not supported frameworks
// and we should not include them.
inboxFrameworksList.RemoveWhere(inboxFx => !IsSupported(inboxFx, resolver));
// Remove the frameworks which have placeholders.
inboxFrameworksList.RemoveWhere(fx => targetFrameworksWithPlaceHolders.Any(tfx => tfx != null && fx.DotNetFrameworkName == tfx.DotNetFrameworkName));
// Create dependency items for each inbox framework.
foreach (string framework in inboxFrameworksList.Select(fx => fx.GetShortFolderName()))
{
bool addedDependencyToFramework = false;
foreach (ITaskItem dependency in portableDependencyGroups[portableDependency])
{
// If we don't have the AssemblyVersion metadata (4 part version string), fall back and use Version (3 part version string)
string version = dependency.GetMetadata("AssemblyVersion");
if (string.IsNullOrEmpty(version))
{
version = dependency.GetMetadata("Version");
int prereleaseIndex = version.IndexOf('-');
if (prereleaseIndex != -1)
{
version = version.Substring(0, prereleaseIndex);
}
}
if (!Frameworks.IsInbox(FrameworkListsPath, framework, dependency.ItemSpec, version))
{
addedDependencyToFramework = true;
TaskItem dependencyItem = new TaskItem(dependency);
dependencyItem.SetMetadata("TargetFramework", framework);
// "Generation" is not required metadata, we just include it because it can be useful for debugging.
dependencyItem.SetMetadata("Generation", portableDependency);
addedDependencies.Add(dependencyItem);
}
}
if (!addedDependencyToFramework)
{
TaskItem dependencyItem = new TaskItem("_._");
dependencyItem.SetMetadata("TargetFramework", framework);
// "Generation" is not required metadata, we just include it because it can be useful for debugging.
dependencyItem.SetMetadata("Generation", portableDependency);
addedDependencies.Add(dependencyItem);
placeHolderFrameworks.Add(framework);
}
}
}
// Collapse frameworks
// For any dependency with a targetframework, if there is another target framework which is compatible and older, remove this dependency.
// Get all Dependencies which are not in a portable dependency group so that we can collapse the frameworks. If we include
// the portable frameworks, then we'll end up collapsing to those.
List <NuGetFramework> allDependencyGroups = new List <NuGetFramework>();
allDependencyGroups.AddRange(Dependencies.Select(d => NuGetFramework.Parse(d.GetMetadata("TargetFramework"))).Where(a => !allDependencyGroups.Contains(a) &&
!FrameworkUtilities.IsGenerationMoniker(a) &&
!FrameworkUtilities.IsPortableMoniker(a)));
allDependencyGroups.AddRange(addedDependencies.Select(d => NuGetFramework.Parse(d.GetMetadata("TargetFramework"))).Where(a => !allDependencyGroups.Contains(a) &&
!FrameworkUtilities.IsGenerationMoniker(a) &&
!FrameworkUtilities.IsPortableMoniker(a)));
List <NuGetFramework> collapsedDependencyGroups = FrameworkUtilities.ReduceDownwards(allDependencyGroups).ToList <NuGetFramework>();
// Get the list of dependency groups that we collapsed down so that we can add them back if they contained different dependencies than what is present in the collapsed group.
/* TODO: Look into NuGet's sorting algorithm, they may have a bug (fixed in this line). They were not including version in the sort.
* See ReduceCore in https://github.com/NuGet/NuGet.Client/blob/23ea68b91a439fcfd7f94bcd01bcdee2e8adae92/src/NuGet.Core/NuGet.Frameworks/FrameworkReducer.cs */
IEnumerable <NuGetFramework> removedDependencyGroups = allDependencyGroups.Where(d => !collapsedDependencyGroups.Contains(d))?.OrderBy(f => f.Framework, StringComparer.OrdinalIgnoreCase).ThenBy(f => f.Version);
foreach (NuGetFramework removedDependencyGroup in removedDependencyGroups)
{
// always recalculate collapsedDependencyGroups in case we added an item in a previous iteration. Dependency groups are sorted, so this should be additive and we shouldn't need to restart the collapse / add back cycle
var nearest = FrameworkUtilities.GetNearest(removedDependencyGroup, collapsedDependencyGroups.ToArray());
// gather the dependencies for this dependency group and the calculated "nearest" dependency group
var nearestDependencies = addedDependencies.Where(d => nearest.Equals(NuGetFramework.Parse(d.GetMetadata("TargetFramework")))).OrderBy(f => f.ToString());
var currentDependencies = addedDependencies.Where(d => removedDependencyGroup.Equals(NuGetFramework.Parse(d.GetMetadata("TargetFramework")))).OrderBy(f => f.ToString());
// The nearest dependency group's dependencies are different than this dependency group's dependencies
if (nearestDependencies.Count() != currentDependencies.Count())
{
// ignore if dependency is a placeholder
if (currentDependencies.Count() > 0)
{
if (!NuGetAssetResolver.IsPlaceholder(currentDependencies.First().ToString()))
{
collapsedDependencyGroups.Add(removedDependencyGroup);
}
}
else
{
collapsedDependencyGroups.Add(removedDependencyGroup);
}
}
// identical dependency count between current and nearest, and the count is > 0
else if (nearestDependencies.Count() > 0)
{
if (!currentDependencies.SequenceEqual(nearestDependencies, new DependencyITaskItemComparer()))
{
collapsedDependencyGroups.Add(removedDependencyGroup);
}
}
}
List <ITaskItem> collapsedDependencies = new List <ITaskItem>();
foreach (ITaskItem dependency in addedDependencies)
{
if (collapsedDependencyGroups.Contains(NuGetFramework.Parse(dependency.GetMetadata("TargetFramework"))))
{
collapsedDependencies.Add(dependency);
}
}
TrimmedDependencies = collapsedDependencies.ToArray();
return(!Log.HasLoggedErrors);
}
private void ValidateSupport()
{
var runtimeFxSuppression = GetSuppressionValues(Suppression.PermitRuntimeTargetMonikerMismatch) ?? new HashSet <string>();
ValidationReport report = null;
if (ValidationReport != null)
{
report = CreateValidationReport();
}
// validate support for each TxM:RID
foreach (var validateFramework in _frameworks.Values)
{
NuGetFramework fx = validateFramework.Framework;
Version supportedVersion = validateFramework.SupportedVersion;
var compileAssetPaths = _resolver.ResolveCompileAssets(fx, PackageId);
bool hasCompileAsset, hasCompilePlaceHolder;
NuGetAssetResolver.ExamineAssets(Log, "Compile", ContractName, fx.ToString(), compileAssetPaths, out hasCompileAsset, out hasCompilePlaceHolder);
if (report != null && validateFramework.RuntimeIds.All(rid => !String.IsNullOrEmpty(rid)))
{
// Add Framework only (compile) target if all RIDs are non-empty.
// This acts as a compile target for a framework that requires a RID for runtime.
var reportTarget = new Target()
{
Framework = fx.ToString(),
RuntimeID = null,
CompileAssets = compileAssetPaths.Where(c => !NuGetAssetResolver.IsPlaceholder(c)).Select(c => GetPackageAssetFromTargetPath(c)).ToArray()
};
report.Targets.Add(fx.ToString(), reportTarget);
}
// resolve/test for each RID associated with this framework.
foreach (string runtimeId in validateFramework.RuntimeIds)
{
string target = String.IsNullOrEmpty(runtimeId) ? fx.ToString() : $"{fx}/{runtimeId}";
var runtimeAssetPaths = _resolver.ResolveRuntimeAssets(fx, runtimeId);
bool hasRuntimeAsset, hasRuntimePlaceHolder;
NuGetAssetResolver.ExamineAssets(Log, "Runtime", ContractName, target, runtimeAssetPaths, out hasRuntimeAsset, out hasRuntimePlaceHolder);
if (null == supportedVersion)
{
// Contract should not be supported on this platform.
bool permitImplementation = HasSuppression(Suppression.PermitImplementation, target);
if (hasCompileAsset && (hasRuntimeAsset & !permitImplementation))
{
Log.LogError($"{ContractName} should not be supported on {target} but has both compile and runtime assets.");
}
else if (hasRuntimeAsset & !permitImplementation)
{
Log.LogError($"{ContractName} should not be supported on {target} but has runtime assets.");
}
if (hasRuntimePlaceHolder && hasCompilePlaceHolder)
{
Log.LogError($"{ContractName} should not be supported on {target} but has placeholders for both compile and runtime which will permit the package to install.");
}
}
else
{
if (report != null)
{
var reportTarget = new Target()
{
Framework = fx.ToString(),
RuntimeID = runtimeId,
CompileAssets = compileAssetPaths.Where(c => !NuGetAssetResolver.IsPlaceholder(c)).Select(c => GetPackageAssetFromTargetPath(c)).ToArray(),
RuntimeAssets = runtimeAssetPaths.Where(r => !NuGetAssetResolver.IsPlaceholder(r)).Select(r => GetPackageAssetFromTargetPath(r)).ToArray()
};
report.Targets.Add(target, reportTarget);
}
if (validateFramework.IsInbox)
{
if (!hasCompileAsset && !hasCompilePlaceHolder)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but was missing a placeholder for compile-time. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
else if (hasCompileAsset)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but contained a reference assemblies: {String.Join(", ", compileAssetPaths)}. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
if (!hasRuntimeAsset && !hasRuntimePlaceHolder)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but was missing a placeholder for run-time. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
else if (hasRuntimeAsset)
{
Log.LogError($"Framework {fx} should support {ContractName} inbox but contained a implementation assemblies: {String.Join(", ", runtimeAssetPaths)}. You may need to add <InboxOnTargetFramework Include=\"{fx.GetShortFolderName()}\" /> to your project.");
}
}
else
{
Version referenceAssemblyVersion = null;
if (!hasCompileAsset)
{
Log.LogError($"{ContractName} should be supported on {target} but has no compile assets.");
}
else
{
var referenceAssemblies = compileAssetPaths.Where(IsDll);
if (referenceAssemblies.Count() > 1)
{
Log.LogError($"{ContractName} should only contain a single compile asset for {target}.");
}
foreach (var referenceAssembly in referenceAssemblies)
{
referenceAssemblyVersion = _targetPathToPackageItem[referenceAssembly].Version;
if (!VersionUtility.IsCompatibleApiVersion(supportedVersion, referenceAssemblyVersion))
{
Log.LogError($"{ContractName} should support API version {supportedVersion} on {target} but {referenceAssembly} was found to support {referenceAssemblyVersion?.ToString() ?? "<unknown version>"}.");
}
}
}
if (!hasRuntimeAsset && !FrameworkUtilities.IsGenerationMoniker(validateFramework.Framework))
{
Log.LogError($"{ContractName} should be supported on {target} but has no runtime assets.");
}
else
{
var implementationAssemblies = runtimeAssetPaths.Where(IsDll);
Dictionary <string, string> implementationFiles = new Dictionary <string, string>();
foreach (var implementationAssembly in implementationAssemblies)
{
var packageItem = _targetPathToPackageItem[implementationAssembly];
Version implementationVersion = packageItem.Version;
if (!VersionUtility.IsCompatibleApiVersion(supportedVersion, implementationVersion))
{
Log.LogError($"{ContractName} should support API version {supportedVersion} on {target} but {implementationAssembly} was found to support {implementationVersion?.ToString() ?? "<unknown version>"}.");
}
// Previously we only permitted compatible mismatch if Suppression.PermitHigherCompatibleImplementationVersion was specified
// this is a permitted thing on every framework but desktop (which requires exact match to ensure bindingRedirects exist)
// Now make this the default, we'll check desktop, where it matters, more strictly
if (referenceAssemblyVersion != null &&
!VersionUtility.IsCompatibleApiVersion(referenceAssemblyVersion, implementationVersion))
{
Log.LogError($"{ContractName} has mismatched compile ({referenceAssemblyVersion}) and runtime ({implementationVersion}) versions on {target}.");
}
if (fx.Framework == FrameworkConstants.FrameworkIdentifiers.Net &&
!referenceAssemblyVersion.Equals(implementationVersion))
{
Log.LogError($"{ContractName} has a higher runtime version ({implementationVersion}) than compile version ({referenceAssemblyVersion}) on .NET Desktop framework {target}. This will break bindingRedirects.");
}
string fileName = Path.GetFileName(implementationAssembly);
if (implementationFiles.ContainsKey(fileName))
{
Log.LogError($"{ContractName} includes both {implementationAssembly} and {implementationFiles[fileName]} an on {target} which have the same name and will clash when both packages are used.");
}
else
{
implementationFiles[fileName] = implementationAssembly;
}
if (packageItem.TargetFramework != fx && !runtimeFxSuppression.Contains(fx.ToString()))
{
// the selected asset wasn't an exact framework match, let's see if we have an exact match in any other runtime asset.
var matchingFxAssets = _targetPathToPackageItem.Values.Where(i => i.TargetFramework == fx && // exact framework
// Same file
Path.GetFileName(i.TargetPath).Equals(fileName, StringComparison.OrdinalIgnoreCase) &&
// Is implementation
(i.TargetPath.StartsWith("lib") || i.TargetPath.StartsWith("runtimes")) &&
// is not the same source file as was already selected
i.SourcePath != packageItem.SourcePath);
if (matchingFxAssets.Any())
{
Log.LogError($"When targeting {target} {ContractName} will use {implementationAssembly} which targets {packageItem.TargetFramework.GetShortFolderName()} but {String.Join(";", matchingFxAssets.Select(i => i.TargetPath))} targets {fx.GetShortFolderName()} specifically.");
}
}
}
}
}
}
}
}
// Set output items
AllSupportedFrameworks = _frameworks.Values.Where(fx => fx.SupportedVersion != null).Select(fx => fx.ToItem()).OrderBy(i => i.ItemSpec).ToArray();
if (!String.IsNullOrEmpty(ValidationReport))
{
report.Save(ValidationReport);
}
}
public bool IsInbox(string assemblyName, NuGetFramework framework, string assemblyVersionString)
{
Version assemblyVersion = FrameworkUtilities.Ensure4PartVersion(assemblyVersionString);
return(IsInbox(assemblyName, framework, assemblyVersion));
}
private void LoadSupport()
{
_frameworks = new Dictionary <NuGetFramework, ValidationFramework>();
// determine which TxM:RIDs should be considered for support based on Frameworks item
foreach (var framework in Frameworks)
{
NuGetFramework fx;
try
{
fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework.");
continue;
}
string runtimeIdList = framework.GetMetadata("RuntimeIDs");
if (_frameworks.ContainsKey(fx))
{
Log.LogError($"Framework {fx} has been listed in Frameworks more than once.");
continue;
}
_frameworks[fx] = new ValidationFramework(fx);
if (!String.IsNullOrWhiteSpace(runtimeIdList))
{
_frameworks[fx].RuntimeIds = runtimeIdList.Split(';');
}
}
// keep a list of explicitly listed supported frameworks so that we can check for conflicts.
HashSet <NuGetFramework> explicitlySupportedFrameworks = new HashSet <NuGetFramework>();
// determine what version should be supported based on SupportedFramework items
foreach (var supportedFramework in SupportedFrameworks)
{
NuGetFramework fx;
string fxString = supportedFramework.ItemSpec;
bool isExclusiveVersion = fxString.Length > 1 && fxString[0] == '[' && fxString[fxString.Length - 1] == ']';
if (isExclusiveVersion)
{
fxString = fxString.Substring(1, fxString.Length - 2);
}
try
{
fx = FrameworkUtilities.ParseNormalized(fxString);
}
catch (Exception ex)
{
Log.LogError($"Could not parse TargetFramework {fxString} as a SupportedFramework. {ex}");
continue;
}
if (fx.Equals(NuGetFramework.UnsupportedFramework))
{
Log.LogError($"Did not recognize TargetFramework {fxString} as a SupportedFramework.");
continue;
}
Version supportedVersion;
string version = supportedFramework.GetMetadata("Version");
try
{
supportedVersion = Version.Parse(version);
}
catch (Exception ex)
{
Log.LogError($"Could not parse Version {version} on SupportedFramework item {supportedFramework.ItemSpec}. {ex}");
continue;
}
ValidationFramework validationFramework = null;
if (!_frameworks.TryGetValue(fx, out validationFramework))
{
Log.LogError($"SupportedFramework {fx} was specified but is not part of the Framework list to use for validation.");
continue;
}
if (explicitlySupportedFrameworks.Contains(fx))
{
if (supportedVersion <= validationFramework.SupportedVersion)
{
// if we've already picked up a higher/equal version, prefer it
continue;
}
}
else
{
explicitlySupportedFrameworks.Add(fx);
}
validationFramework.SupportedVersion = supportedVersion;
if (!isExclusiveVersion)
{
// find all frameworks of higher version, sorted by version ascending
IEnumerable <ValidationFramework> higherFrameworks = _frameworks.Values.Where(vf => vf.Framework.Framework == fx.Framework && vf.Framework.Version > fx.Version).OrderBy(vf => vf.Framework.Version);
// netcore50 is the last `netcore` framework, after that we use `uap`
if (fx.Framework == FrameworkConstants.FrameworkIdentifiers.NetCore)
{
var uapFrameworks = _frameworks.Values.Where(vf => vf.Framework.Framework == FrameworkConstants.FrameworkIdentifiers.UAP).OrderBy(vf => vf.Framework.Version);
higherFrameworks = higherFrameworks.Concat(uapFrameworks);
}
foreach (var higherFramework in higherFrameworks)
{
if (higherFramework.SupportedVersion != null && higherFramework.SupportedVersion > supportedVersion)
{
// found an higher framework version a higher API version, stop applying this supported version
break;
}
higherFramework.SupportedVersion = supportedVersion;
}
}
}
// determine which Frameworks should support inbox
_frameworkSet = FrameworkSet.Load(FrameworkListsPath);
foreach (IEnumerable <Framework> inboxFxGroup in _frameworkSet.Frameworks.Values)
{
foreach (Framework inboxFx in inboxFxGroup)
{
// get currently supported version to see if we have OOB'ed it
Version inboxVersion = null;
inboxFx.Assemblies.TryGetValue(ContractName, out inboxVersion);
if (inboxVersion != null)
{
NuGetFramework fx = FrameworkUtilities.ParseNormalized(inboxFx.ShortName);
ValidationFramework validationFramework = null;
if (_frameworks.TryGetValue(fx, out validationFramework))
{
Version supportedVersion = validationFramework.SupportedVersion;
if (supportedVersion != null &&
(supportedVersion.Major > inboxVersion.Major ||
(supportedVersion.Major == inboxVersion.Major && supportedVersion.Minor > inboxVersion.Minor)))
{
// Higher major.minor
Log.LogMessage(LogImportance.Low, $"Framework {fx} supported {ContractName} as inbox but the current supported version {supportedVersion} is higher in major.minor than inbox version {inboxVersion}. Assuming out of box.");
continue;
}
else if (supportedVersion != null && supportedVersion < inboxVersion && inboxVersion != s_maxVersion)
{
// Lower version
Log.LogError($"Framework {fx} supports {ContractName} as inbox but the current supported version {supportedVersion} is lower than the inbox version {inboxVersion}");
}
// equal major.minor, build.revision difference is permitted, prefer the version listed by ContractSupport item
}
if (validationFramework == null)
{
// we may not be explicitly validating for this framework so add it to validate inbox assets.
_frameworks[fx] = validationFramework = new ValidationFramework(fx)
{
SupportedVersion = inboxVersion
};
}
validationFramework.IsInbox = true;
}
}
}
// for every framework we know about, also infer it's netstandard version to ensure it can
// be targeted by PCL. Even if a package only supports a single framework we still
// want to include a portable reference assembly. This allows 3rd parties to add
// their own implementation via a lineup/runtime.json.
// only consider frameworks that support the contract at a specific version
var inferFrameworks = _frameworks.Values.Where(fx => fx.SupportedVersion != null && fx.SupportedVersion != s_maxVersion).ToArray();
var genVersionSuppression = GetSuppressionValues(Suppression.PermitPortableVersionMismatch) ?? new HashSet <string>();
var inferNETStandardSuppression = GetSuppressionValues(Suppression.SuppressNETStandardInference) ?? new HashSet <string>();
Dictionary <NuGetFramework, ValidationFramework> generationsToValidate = new Dictionary <NuGetFramework, ValidationFramework>();
foreach (var inferFramework in inferFrameworks)
{
var inferFrameworkMoniker = inferFramework.Framework.ToString();
if (inferNETStandardSuppression.Contains(inferFrameworkMoniker))
{
continue;
}
NuGetFramework generation = new NuGetFramework(_generationIdentifier, Generations.DetermineGenerationForFramework(inferFramework.Framework, UseNetPlatform));
Log.LogMessage(LogImportance.Low, $"Validating {generation} for {ContractName}, {inferFramework.SupportedVersion} since it is supported by {inferFrameworkMoniker}");
ValidationFramework existingGeneration = null;
if (generationsToValidate.TryGetValue(generation, out existingGeneration))
{
// the netstandard version should be the minimum version supported by all platforms that support that netstandard version.
if (inferFramework.SupportedVersion < existingGeneration.SupportedVersion)
{
Log.LogMessage($"Framework {inferFramework.Framework} supports {ContractName} at {inferFramework.SupportedVersion} which is lower than {existingGeneration.SupportedVersion} supported by generation {generation.GetShortFolderName()}. Lowering the version supported by {generation.GetShortFolderName()}.");
existingGeneration.SupportedVersion = inferFramework.SupportedVersion;
}
}
else
{
generationsToValidate.Add(generation, new ValidationFramework(generation)
{
SupportedVersion = inferFramework.SupportedVersion
});
}
}
foreach (var generation in generationsToValidate)
{
_frameworks.Add(generation.Key, generation.Value);
}
}
public IEnumerable <NuGetFramework> GetInboxFrameworks(string assemblyName, string assemblyVersionString)
{
Version assemblyVersion = FrameworkUtilities.Ensure4PartVersion(String.IsNullOrEmpty(assemblyVersionString) ? new Version(0, 0, 0, 0) : new Version(assemblyVersionString));
return(GetInboxFrameworks(assemblyName, assemblyVersion));
}
public bool IsInbox(string assemblyName, NuGetFramework framework, string assemblyVersionString)
{
Version assemblyVersion = FrameworkUtilities.Ensure4PartVersion(String.IsNullOrEmpty(assemblyVersionString) ? new Version(0, 0, 0, 0) : new Version(assemblyVersionString));
return(IsInbox(assemblyName, framework, assemblyVersion));
}
