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 != null &&
!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. If the live reference was replaced with a harvested reference you may need to set <Preserve>true</Preserve> on your reference assembly ProjectReference.");
}
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);
}
}
/// <summary>
/// Generates a table in markdown that lists the API version supported by
/// various packages at all levels of NETStandard.
/// </summary>
/// <returns></returns>
public override bool Execute()
{
if (Reports == null || Reports.Length == 0)
{
Log.LogError("Reports argument must be specified");
return(false);
}
if (String.IsNullOrEmpty(DocFilePath))
{
Log.LogError("DocFilePath argument must be specified");
return(false);
}
string docDir = Path.GetDirectoryName(DocFilePath);
if (!Directory.Exists(docDir))
{
Directory.CreateDirectory(docDir);
}
SortedSet <Version> knownNetStandardVersions = new SortedSet <Version>();
List <SupportRow> rows = new List <SupportRow>(Reports.Length);
foreach (var reportPath in Reports.Select(r => r.GetMetadata("FullPath")))
{
SupportRow row = new SupportRow();
row.Name = Path.GetFileNameWithoutExtension(reportPath);
row.SuportedVersions = new SortedSet <NETStandardApiVersion>();
var report = ValidationReport.Load(reportPath);
foreach (var supportedFramework in report.SupportedFrameworks)
{
var fx = NuGetFramework.Parse(supportedFramework.Key);
if (fx.Framework == FrameworkConstants.FrameworkIdentifiers.NetStandard)
{
row.SuportedVersions.Add(new NETStandardApiVersion(fx.Version, new Version(supportedFramework.Value.ToString())));
knownNetStandardVersions.Add(fx.Version);
}
}
rows.Add(row);
}
StringBuilder table = new StringBuilder();
table.AppendLine($"| Contract | {String.Join(" | ", knownNetStandardVersions.Select(v => v.ToString(2)))} |");
table.AppendLine($"| -------- | {String.Join(" | ", Enumerable.Repeat("---", knownNetStandardVersions.Count))}");
foreach (var row in rows.OrderBy(r => r.Name))
{
if (row.SuportedVersions.Count == 0)
{
Log.LogMessage($"Skipping {row.Name} since it has no supported NETStandard versions");
continue;
}
table.Append($"| {row.Name} |");
foreach (var netStandardVersion in knownNetStandardVersions)
{
var apiVersion = row.SuportedVersions.LastOrDefault(a => a.NETStandardVersion <= netStandardVersion);
table.Append(" ");
if (apiVersion != null)
{
table.Append(apiVersion.APIVersion.ToString(3));
}
table.Append(" |");
}
table.AppendLine();
}
if (!InsertIntoFile)
{
File.WriteAllText(DocFilePath, table.ToString());
}
else
{
if (!File.Exists(DocFilePath))
{
Log.LogError($"InsertIntoFile was specified as true but {DocFilePath} did not exist.");
return(false);
}
string originalText = File.ReadAllText(DocFilePath);
int startIndex = originalText.IndexOf(startMarker);
if (startIndex < 0)
{
Log.LogError($"InsertIntoFile was specified as true but could not locate insertion start text \"{startMarker}\".");
return(false);
}
startIndex += startMarker.Length;
// skip any white-space / new line
while (startIndex < originalText.Length && Char.IsWhiteSpace(originalText[startIndex]))
{
startIndex++;
}
int endIndex = originalText.IndexOf(endMarker, startIndex);
if (endIndex < 0)
{
Log.LogError($"InsertIntoFile was specified as true but could not locate insertion end text \"{endMarker}\".");
return(false);
}
var docText = new StringBuilder(originalText);
docText.Remove(startIndex, endIndex - startIndex);
docText.Insert(startIndex, table.ToString());
File.WriteAllText(DocFilePath, docText.ToString(), Encoding.UTF8);
}
return(!Log.HasLoggedErrors);
}
