protected override void ExecuteCore()
{
// Get the list of runtime identifiers that we support and can target
ITaskItem frameworkRef = KnownFrameworkReferences.Where(item => String.Compare(item.ItemSpec, "Microsoft.NETCore.App", true) == 0).SingleOrDefault();
string supportedRuntimeIdentifiers = frameworkRef == null ? null : frameworkRef.GetMetadata("RuntimePackRuntimeIdentifiers");
// Get information on the runtime package used for the current target
ITaskItem frameworkPack = RuntimePacks.Where(pack =>
pack.GetMetadata(MetadataKeys.FrameworkName).Equals("Microsoft.NETCore.App", StringComparison.OrdinalIgnoreCase))
.SingleOrDefault();
_runtimeIdentifier = frameworkPack == null ? null : frameworkPack.GetMetadata(MetadataKeys.RuntimeIdentifier);
_packagePath = frameworkPack == null ? null : frameworkPack.GetMetadata(MetadataKeys.PackageDirectory);
var runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath);
var supportedRIDsList = supportedRuntimeIdentifiers == null?Array.Empty <string>() : supportedRuntimeIdentifiers.Split(';');
// Get the best RID for the host machine, which will be used to validate that we can run crossgen for the target platform and architecture
string hostRuntimeIdentifier = NuGetUtils.GetBestMatchingRid(
runtimeGraph,
NETCoreSdkRuntimeIdentifier,
supportedRIDsList,
out bool wasInGraph);
if (hostRuntimeIdentifier == null || _runtimeIdentifier == null || _packagePath == null)
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return;
}
if (!ExtractTargetPlatformAndArchitecture(_runtimeIdentifier, out string targetPlatform, out _targetArchitecture) ||
!ExtractTargetPlatformAndArchitecture(hostRuntimeIdentifier, out string hostPlatform, out Architecture hostArchitecture) ||
targetPlatform != hostPlatform)
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return;
}
if (!GetCrossgenComponentsPaths() || !File.Exists(_crossgenPath) || !File.Exists(_clrjitPath))
{
Log.LogError(Strings.ReadyToRunTargetNotSupportedError);
return;
}
// Create tool task item
CrossgenTool = new TaskItem(_crossgenPath);
CrossgenTool.SetMetadata("JitPath", _clrjitPath);
if (!String.IsNullOrEmpty(_diasymreaderPath))
{
CrossgenTool.SetMetadata("DiaSymReader", _diasymreaderPath);
}
// Process input lists of files
ProcessInputFileList(FilesToPublish, _compileList, _symbolsCompileList, _r2rFiles);
}
protected override void ExecuteCore()
{
var knownFrameworkReferences = KnownFrameworkReferences.Select(item => new KnownFrameworkReference(item))
.Where(kfr => kfr.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) &&
NormalizeVersion(kfr.TargetFramework.Version) == NormalizeVersion(new Version(TargetFrameworkVersion)))
.ToDictionary(kfr => kfr.Name);
List <ITaskItem> packageReferencesToAdd = new List <ITaskItem>();
List <ITaskItem> runtimeFrameworks = new List <ITaskItem>();
List <string> unresolvedFrameworkReferences = new List <string>();
foreach (var frameworkReference in FrameworkReferences)
{
KnownFrameworkReference knownFrameworkReference;
if (knownFrameworkReferences.TryGetValue(frameworkReference.ItemSpec, out knownFrameworkReference))
{
TaskItem packageReference = new TaskItem(knownFrameworkReference.TargetingPackName);
packageReference.SetMetadata(MetadataKeys.Version, knownFrameworkReference.TargetingPackVersion);
packageReference.SetMetadata(MetadataKeys.IsImplicitlyDefined, "true");
packageReference.SetMetadata("PrivateAssets", "all");
packageReference.SetMetadata("Publish", "true");
packageReferencesToAdd.Add(packageReference);
TaskItem runtimeFramework = new TaskItem(knownFrameworkReference.RuntimeFrameworkName);
// Use default (non roll-forward) version for now. Eventually we'll need to add support for rolling
// forward, and for publishing assets from a runtime pack for self-contained apps
runtimeFramework.SetMetadata(MetadataKeys.Version, knownFrameworkReference.DefaultRuntimeFrameworkVersion);
runtimeFrameworks.Add(runtimeFramework);
}
else
{
unresolvedFrameworkReferences.Add(frameworkReference.ItemSpec);
}
}
if (packageReferencesToAdd.Any())
{
PackageReferencesToAdd = packageReferencesToAdd.ToArray();
}
if (runtimeFrameworks.Any())
{
RuntimeFrameworks = runtimeFrameworks.ToArray();
}
if (unresolvedFrameworkReferences.Any())
{
UnresolvedFrameworkReferences = unresolvedFrameworkReferences.ToArray();
}
}
protected override void ExecuteCore()
{
// Perf optimization: If there are no FrameworkReference items, then don't do anything
// (This means that if you don't have any direct framework references, you won't get any transitive ones either
if (FrameworkReferences == null || FrameworkReferences.Length == 0)
{
return;
}
_normalizedTargetFrameworkVersion = NormalizeVersion(new Version(TargetFrameworkVersion));
var knownFrameworkReferencesForTargetFramework =
KnownFrameworkReferences
.Select(item => new KnownFrameworkReference(item))
.Where(KnownFrameworkReferenceAppliesToTargetFramework)
.ToList();
// Get known runtime packs from known framework references.
// Only use items where the framework reference name matches the RuntimeFrameworkName.
// This will filter out known framework references for "profiles", ie WindowsForms and WPF
var knownRuntimePacksForTargetFramework =
knownFrameworkReferencesForTargetFramework
.Where(kfr => kfr.Name.Equals(kfr.RuntimeFrameworkName, StringComparison.OrdinalIgnoreCase))
.Select(kfr => kfr.ToKnownRuntimePack())
.ToList();
// Add additional known runtime packs
knownRuntimePacksForTargetFramework.AddRange(
KnownRuntimePacks.Select(item => new KnownRuntimePack(item))
.Where(krp => krp.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) &&
NormalizeVersion(krp.TargetFramework.Version) == _normalizedTargetFrameworkVersion));
var frameworkReferenceMap = FrameworkReferences.ToDictionary(fr => fr.ItemSpec, StringComparer.OrdinalIgnoreCase);
List <ITaskItem> packagesToDownload = new List <ITaskItem>();
List <ITaskItem> runtimeFrameworks = new List <ITaskItem>();
List <ITaskItem> targetingPacks = new List <ITaskItem>();
List <ITaskItem> runtimePacks = new List <ITaskItem>();
List <ITaskItem> unavailableRuntimePacks = new List <ITaskItem>();
HashSet <string> unrecognizedRuntimeIdentifiers = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
bool windowsOnlyErrorLogged = false;
foreach (var knownFrameworkReference in knownFrameworkReferencesForTargetFramework)
{
frameworkReferenceMap.TryGetValue(knownFrameworkReference.Name, out ITaskItem frameworkReference);
// Handle Windows-only frameworks on non-Windows platforms
if (knownFrameworkReference.IsWindowsOnly &&
!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// It is an error to reference the framework from non-Windows
if (!windowsOnlyErrorLogged && frameworkReference != null)
{
Log.LogError(Strings.WindowsDesktopFrameworkRequiresWindows);
windowsOnlyErrorLogged = true;
}
// Ignore (and don't download) this known framework reference as it requires Windows
continue;
}
KnownRuntimePack?selectedRuntimePack = SelectRuntimePack(frameworkReference, knownFrameworkReference, knownRuntimePacksForTargetFramework);
// Add targeting pack and all known runtime packs to "preferred packages" list.
// These are packages that will win in conflict resolution for assets that have identical assembly and file versions
var preferredPackages = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase);
preferredPackages.Add(knownFrameworkReference.TargetingPackName);
if (selectedRuntimePack != null)
{
var knownFrameworkReferenceRuntimePackRuntimeIdentifiers = selectedRuntimePack?.RuntimePackRuntimeIdentifiers.Split(';');
foreach (var runtimeIdentifier in knownFrameworkReferenceRuntimePackRuntimeIdentifiers)
{
foreach (var runtimePackNamePattern in selectedRuntimePack?.RuntimePackNamePatterns.Split(';'))
{
string runtimePackName = runtimePackNamePattern.Replace("**RID**", runtimeIdentifier);
preferredPackages.Add(runtimePackName);
}
}
}
TaskItem targetingPack = new TaskItem(knownFrameworkReference.Name);
targetingPack.SetMetadata(MetadataKeys.NuGetPackageId, knownFrameworkReference.TargetingPackName);
targetingPack.SetMetadata(MetadataKeys.PackageConflictPreferredPackages, string.Join(";", preferredPackages));
string targetingPackVersion = null;
if (frameworkReference != null)
{
// Allow targeting pack version to be overridden via metadata on FrameworkReference
targetingPackVersion = frameworkReference.GetMetadata("TargetingPackVersion");
}
if (string.IsNullOrEmpty(targetingPackVersion))
{
targetingPackVersion = knownFrameworkReference.TargetingPackVersion;
}
targetingPack.SetMetadata(MetadataKeys.NuGetPackageVersion, targetingPackVersion);
targetingPack.SetMetadata("TargetingPackFormat", knownFrameworkReference.TargetingPackFormat);
targetingPack.SetMetadata("TargetFramework", knownFrameworkReference.TargetFramework.GetShortFolderName());
targetingPack.SetMetadata(MetadataKeys.RuntimeFrameworkName, knownFrameworkReference.RuntimeFrameworkName);
if (selectedRuntimePack != null)
{
targetingPack.SetMetadata(MetadataKeys.RuntimePackRuntimeIdentifiers, selectedRuntimePack?.RuntimePackRuntimeIdentifiers);
}
if (!string.IsNullOrEmpty(knownFrameworkReference.Profile))
{
targetingPack.SetMetadata("Profile", knownFrameworkReference.Profile);
}
// Get the path of the targeting pack in the targeting pack root (e.g. dotnet/packs)
string targetingPackPath = null;
if (!string.IsNullOrEmpty(TargetingPackRoot))
{
targetingPackPath = Path.Combine(TargetingPackRoot, knownFrameworkReference.TargetingPackName, targetingPackVersion);
}
if (targetingPackPath != null && Directory.Exists(targetingPackPath))
{
// Use targeting pack from packs folder
targetingPack.SetMetadata(MetadataKeys.PackageDirectory, targetingPackPath);
targetingPack.SetMetadata(MetadataKeys.Path, targetingPackPath);
}
else
{
if (EnableTargetingPackDownload)
{
// Download targeting pack
TaskItem packageToDownload = new TaskItem(knownFrameworkReference.TargetingPackName);
packageToDownload.SetMetadata(MetadataKeys.Version, targetingPackVersion);
packagesToDownload.Add(packageToDownload);
}
}
targetingPacks.Add(targetingPack);
var runtimeFrameworkVersion = GetRuntimeFrameworkVersion(
frameworkReference,
knownFrameworkReference,
selectedRuntimePack,
out string runtimePackVersion);
string isTrimmable = null;
if (frameworkReference != null)
{
// Allow IsTrimmable to be overridden via metadata on FrameworkReference
isTrimmable = frameworkReference.GetMetadata(MetadataKeys.IsTrimmable);
}
if (string.IsNullOrEmpty(isTrimmable))
{
isTrimmable = selectedRuntimePack?.IsTrimmable;
}
bool includeInPackageDownload;
KnownRuntimePack runtimePackForRuntimeIDProcessing;
if (knownFrameworkReference.Name.Equals(knownFrameworkReference.RuntimeFrameworkName, StringComparison.OrdinalIgnoreCase))
{
// Only add runtime packs where the framework reference name matches the RuntimeFrameworkName
// Framework references for "profiles" will use the runtime pack from the corresponding non-profile framework
runtimePackForRuntimeIDProcessing = selectedRuntimePack.Value;
includeInPackageDownload = true;
}
else if (!knownFrameworkReference.RuntimePackRuntimeIdentifiers.Equals(selectedRuntimePack?.RuntimePackRuntimeIdentifiers))
{
// If the profile has a different set of runtime identifiers than the runtime pack, use the profile.
runtimePackForRuntimeIDProcessing = knownFrameworkReference.ToKnownRuntimePack();
includeInPackageDownload = true;
}
else
{
// For the remaining profiles, don't include them in package download but add them to unavaliable if necessary.
runtimePackForRuntimeIDProcessing = knownFrameworkReference.ToKnownRuntimePack();
includeInPackageDownload = false;
}
bool processedPrimaryRuntimeIdentifier = false;
var hasRuntimePackAlwaysCopyLocal =
selectedRuntimePack != null && selectedRuntimePack.Value.RuntimePackAlwaysCopyLocal;
var runtimeRequiredByDeployment
= (SelfContained || ReadyToRunEnabled) &&
!string.IsNullOrEmpty(RuntimeIdentifier) &&
selectedRuntimePack != null &&
!string.IsNullOrEmpty(selectedRuntimePack.Value.RuntimePackNamePatterns);
if (hasRuntimePackAlwaysCopyLocal || runtimeRequiredByDeployment)
{
// Find other KnownFrameworkReferences that map to the same runtime pack, if any
List <string> additionalFrameworkReferencesForRuntimePack = null;
foreach (var additionalKnownFrameworkReference in knownFrameworkReferencesForTargetFramework)
{
if (additionalKnownFrameworkReference.RuntimeFrameworkName.Equals(knownFrameworkReference.RuntimeFrameworkName, StringComparison.OrdinalIgnoreCase) &&
!additionalKnownFrameworkReference.RuntimeFrameworkName.Equals(additionalKnownFrameworkReference.Name, StringComparison.OrdinalIgnoreCase))
{
if (additionalFrameworkReferencesForRuntimePack == null)
{
additionalFrameworkReferencesForRuntimePack = new List <string>();
}
additionalFrameworkReferencesForRuntimePack.Add(additionalKnownFrameworkReference.Name);
}
}
ProcessRuntimeIdentifier(hasRuntimePackAlwaysCopyLocal ? "any" : RuntimeIdentifier, runtimePackForRuntimeIDProcessing, runtimePackVersion, additionalFrameworkReferencesForRuntimePack,
unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks, packagesToDownload, isTrimmable, includeInPackageDownload);
processedPrimaryRuntimeIdentifier = true;
}
if (RuntimeIdentifiers != null)
{
foreach (var runtimeIdentifier in RuntimeIdentifiers)
{
if (processedPrimaryRuntimeIdentifier && runtimeIdentifier == this.RuntimeIdentifier)
{
// We've already processed this RID
continue;
}
// Pass in null for the runtimePacks list, as for these runtime identifiers we only want to
// download the runtime packs, but not use the assets from them
ProcessRuntimeIdentifier(runtimeIdentifier, runtimePackForRuntimeIDProcessing, runtimePackVersion, additionalFrameworkReferencesForRuntimePack: null,
unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks: null, packagesToDownload, isTrimmable, includeInPackageDownload);
}
}
if (!string.IsNullOrEmpty(knownFrameworkReference.RuntimeFrameworkName) && !knownFrameworkReference.RuntimePackAlwaysCopyLocal)
{
TaskItem runtimeFramework = new TaskItem(knownFrameworkReference.RuntimeFrameworkName);
runtimeFramework.SetMetadata(MetadataKeys.Version, runtimeFrameworkVersion);
runtimeFramework.SetMetadata(MetadataKeys.FrameworkName, knownFrameworkReference.Name);
runtimeFrameworks.Add(runtimeFramework);
}
}
if (ReadyToRunEnabled && ReadyToRunUseCrossgen2)
{
if (!SelfContained)
{
Log.LogError(Strings.Crossgen2RequiresSelfContained);
return;
}
if (!AddCrossgen2Package(_normalizedTargetFrameworkVersion, packagesToDownload))
{
Log.LogError(Strings.ReadyToRunNoValidRuntimePackageError);
return;
}
}
if (packagesToDownload.Any())
{
PackagesToDownload = packagesToDownload.Distinct(new PackageToDownloadComparer <ITaskItem>()).ToArray();
}
if (runtimeFrameworks.Any())
{
RuntimeFrameworks = runtimeFrameworks.ToArray();
}
if (targetingPacks.Any())
{
TargetingPacks = targetingPacks.ToArray();
}
if (runtimePacks.Any())
{
RuntimePacks = runtimePacks.ToArray();
}
if (unavailableRuntimePacks.Any())
{
UnavailableRuntimePacks = unavailableRuntimePacks.ToArray();
}
}
protected override void ExecuteCore()
{
// Perf optimization: If there are no FrameworkReference items, then don't do anything
// (This means that if you don't have any direct framework references, you won't get any transitive ones either
if (FrameworkReferences == null || FrameworkReferences.Length == 0)
{
return;
}
var normalizedTargetFrameworkVersion = NormalizeVersion(new Version(TargetFrameworkVersion));
var knownFrameworkReferencesForTargetFramework = KnownFrameworkReferences.Select(item => new KnownFrameworkReference(item))
.Where(kfr => kfr.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) &&
NormalizeVersion(kfr.TargetFramework.Version) == normalizedTargetFrameworkVersion)
.ToList();
var frameworkReferenceMap = FrameworkReferences.ToDictionary(fr => fr.ItemSpec, StringComparer.OrdinalIgnoreCase);
List <ITaskItem> packagesToDownload = new List <ITaskItem>();
List <ITaskItem> runtimeFrameworks = new List <ITaskItem>();
List <ITaskItem> targetingPacks = new List <ITaskItem>();
List <ITaskItem> runtimePacks = new List <ITaskItem>();
List <ITaskItem> unavailableRuntimePacks = new List <ITaskItem>();
HashSet <string> unrecognizedRuntimeIdentifiers = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
bool windowsOnlyErrorLogged = false;
foreach (var knownFrameworkReference in knownFrameworkReferencesForTargetFramework)
{
frameworkReferenceMap.TryGetValue(knownFrameworkReference.Name, out ITaskItem frameworkReference);
// Handle Windows-only frameworks on non-Windows platforms
if (knownFrameworkReference.IsWindowsOnly &&
!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// It is an error to reference the framework from non-Windows
if (!windowsOnlyErrorLogged && frameworkReference != null)
{
Log.LogError(Strings.WindowsDesktopFrameworkRequiresWindows);
windowsOnlyErrorLogged = true;
}
// Ignore (and don't download) this known framework reference as it requires Windows
continue;
}
List <string> preferredPackages = new List <string>();
preferredPackages.Add(knownFrameworkReference.TargetingPackName);
var knownFrameworkReferenceRuntimePackRuntimeIdentifiers = knownFrameworkReference.RuntimePackRuntimeIdentifiers.Split(';');
foreach (var runtimeIdentifier in knownFrameworkReferenceRuntimePackRuntimeIdentifiers)
{
foreach (var runtimePackNamePattern in knownFrameworkReference.RuntimePackNamePatterns.Split(';'))
{
string runtimePackName = runtimePackNamePattern.Replace("**RID**", runtimeIdentifier);
preferredPackages.Add(runtimePackName);
}
}
// Get the path of the targeting pack in the targeting pack root (e.g. dotnet/ref)
TaskItem targetingPack = new TaskItem(knownFrameworkReference.Name);
targetingPack.SetMetadata(MetadataKeys.PackageName, knownFrameworkReference.TargetingPackName);
targetingPack.SetMetadata(MetadataKeys.PackageConflictPreferredPackages, string.Join(";", preferredPackages));
string targetingPackVersion = null;
if (frameworkReference != null)
{
// Allow targeting pack version to be overridden via metadata on FrameworkReference
targetingPackVersion = frameworkReference.GetMetadata("TargetingPackVersion");
}
if (string.IsNullOrEmpty(targetingPackVersion))
{
targetingPackVersion = knownFrameworkReference.TargetingPackVersion;
}
targetingPack.SetMetadata(MetadataKeys.PackageVersion, targetingPackVersion);
targetingPack.SetMetadata("TargetingPackFormat", knownFrameworkReference.TargetingPackFormat);
targetingPack.SetMetadata("TargetFramework", knownFrameworkReference.TargetFramework.GetShortFolderName());
targetingPack.SetMetadata("RuntimeFrameworkName", knownFrameworkReference.RuntimeFrameworkName);
if (!string.IsNullOrEmpty(knownFrameworkReference.Profile))
{
targetingPack.SetMetadata("Profile", knownFrameworkReference.Profile);
}
string targetingPackPath = null;
if (!string.IsNullOrEmpty(TargetingPackRoot))
{
targetingPackPath = Path.Combine(TargetingPackRoot, knownFrameworkReference.TargetingPackName, targetingPackVersion);
}
if (targetingPackPath != null && Directory.Exists(targetingPackPath))
{
// Use targeting pack from packs folder
targetingPack.SetMetadata(MetadataKeys.PackageDirectory, targetingPackPath);
targetingPack.SetMetadata(MetadataKeys.Path, targetingPackPath);
}
else
{
if (EnableTargetingPackDownload)
{
// Download targeting pack
TaskItem packageToDownload = new TaskItem(knownFrameworkReference.TargetingPackName);
packageToDownload.SetMetadata(MetadataKeys.Version, targetingPackVersion);
packagesToDownload.Add(packageToDownload);
}
}
targetingPacks.Add(targetingPack);
var runtimeFrameworkVersion = GetRuntimeFrameworkVersion(frameworkReference, knownFrameworkReference);
string isTrimmable = null;
if (frameworkReference != null)
{
// Allow IsTrimmable to be overridden via metadata on FrameworkReference
isTrimmable = frameworkReference.GetMetadata(MetadataKeys.IsTrimmable);
}
if (string.IsNullOrEmpty(isTrimmable))
{
isTrimmable = knownFrameworkReference.IsTrimmable;
}
bool processedPrimaryRuntimeIdentifier = false;
if ((SelfContained || ReadyToRunEnabled) &&
!string.IsNullOrEmpty(RuntimeIdentifier) &&
!string.IsNullOrEmpty(knownFrameworkReference.RuntimePackNamePatterns))
{
ProcessRuntimeIdentifier(RuntimeIdentifier, knownFrameworkReference, runtimeFrameworkVersion,
unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks, packagesToDownload, isTrimmable);
processedPrimaryRuntimeIdentifier = true;
}
if (RuntimeIdentifiers != null)
{
foreach (var runtimeIdentifier in RuntimeIdentifiers)
{
if (processedPrimaryRuntimeIdentifier && runtimeIdentifier == this.RuntimeIdentifier)
{
// We've already processed this RID
continue;
}
// Pass in null for the runtimePacks list, as for these runtime identifiers we only want to
// download the runtime packs, but not use the assets from them
ProcessRuntimeIdentifier(runtimeIdentifier, knownFrameworkReference, runtimeFrameworkVersion,
unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks: null, packagesToDownload, isTrimmable);
}
}
if (!string.IsNullOrEmpty(knownFrameworkReference.RuntimeFrameworkName))
{
TaskItem runtimeFramework = new TaskItem(knownFrameworkReference.RuntimeFrameworkName);
runtimeFramework.SetMetadata(MetadataKeys.Version, runtimeFrameworkVersion);
runtimeFramework.SetMetadata(MetadataKeys.FrameworkName, knownFrameworkReference.Name);
runtimeFrameworks.Add(runtimeFramework);
}
}
if (packagesToDownload.Any())
{
PackagesToDownload = packagesToDownload.ToArray();
}
if (runtimeFrameworks.Any())
{
RuntimeFrameworks = runtimeFrameworks.ToArray();
}
if (targetingPacks.Any())
{
TargetingPacks = targetingPacks.ToArray();
}
if (runtimePacks.Any())
{
RuntimePacks = runtimePacks.ToArray();
}
if (unavailableRuntimePacks.Any())
{
UnavailableRuntimePacks = unavailableRuntimePacks.ToArray();
}
}
protected override void ExecuteCore()
{
var knownFrameworkReferences = KnownFrameworkReferences.Select(item => new KnownFrameworkReference(item))
.Where(kfr => kfr.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) &&
NormalizeVersion(kfr.TargetFramework.Version) == NormalizeVersion(new Version(TargetFrameworkVersion)))
.ToDictionary(kfr => kfr.Name);
List <ITaskItem> packagesToDownload = new List <ITaskItem>();
List <ITaskItem> runtimeFrameworks = new List <ITaskItem>();
List <ITaskItem> targetingPacks = new List <ITaskItem>();
List <ITaskItem> runtimePacks = new List <ITaskItem>();
List <string> unresolvedFrameworkReferences = new List <string>();
string appHostPackPattern = null;
string appHostPackVersion = null;
string appHostRuntimeIdentifiers = null;
foreach (var frameworkReference in FrameworkReferences)
{
KnownFrameworkReference knownFrameworkReference;
if (knownFrameworkReferences.TryGetValue(frameworkReference.ItemSpec, out knownFrameworkReference))
{
if (!string.IsNullOrEmpty(knownFrameworkReference.AppHostPackNamePattern))
{
if (appHostPackPattern == null)
{
appHostPackPattern = knownFrameworkReference.AppHostPackNamePattern;
appHostPackVersion = knownFrameworkReference.LatestRuntimeFrameworkVersion;
appHostRuntimeIdentifiers = knownFrameworkReference.AppHostRuntimeIdentifiers;
}
else
{
throw new InvalidOperationException("Multiple FrameworkReferences defined an AppHostPack, which is not supposed to happen");
}
}
// Get the path of the targeting pack in the targeting pack root (e.g. dotnet/ref)
TaskItem targetingPack = new TaskItem(knownFrameworkReference.Name);
targetingPack.SetMetadata(MetadataKeys.PackageName, knownFrameworkReference.TargetingPackName);
targetingPack.SetMetadata(MetadataKeys.PackageVersion, knownFrameworkReference.TargetingPackVersion);
targetingPack.SetMetadata(MetadataKeys.RelativePath, "");
string targetingPackPath = null;
if (!string.IsNullOrEmpty(TargetingPackRoot))
{
targetingPackPath = GetPackPath(knownFrameworkReference.TargetingPackName, knownFrameworkReference.TargetingPackVersion);
}
if (targetingPackPath != null && Directory.Exists(targetingPackPath))
{
targetingPack.SetMetadata(MetadataKeys.Path, targetingPackPath);
targetingPack.SetMetadata(MetadataKeys.PackageDirectory, targetingPackPath);
}
else
{
// Download targeting pack
TaskItem packageToDownload = new TaskItem(knownFrameworkReference.TargetingPackName);
packageToDownload.SetMetadata(MetadataKeys.Version, knownFrameworkReference.TargetingPackVersion);
packagesToDownload.Add(packageToDownload);
}
targetingPacks.Add(targetingPack);
if (SelfContained &&
!string.IsNullOrEmpty(RuntimeIdentifier) &&
!string.IsNullOrEmpty(knownFrameworkReference.RuntimePackNamePatterns))
{
foreach (var runtimePackNamePattern in knownFrameworkReference.RuntimePackNamePatterns.Split(';'))
{
string runtimePackRuntimeIdentifier = GetBestRuntimeIdentifier(RuntimeIdentifier, knownFrameworkReference.RuntimePackRuntimeIdentifiers,
out bool wasInGraph);
if (runtimePackRuntimeIdentifier == null)
{
if (wasInGraph)
{
// NETSDK1082: There was no runtime pack for {0} available for the specified RuntimeIdentifier '{1}'.
Log.LogError(Strings.NoRuntimePackAvailable, knownFrameworkReference.Name, RuntimeIdentifier);
}
else
{
// NETSDK1083: The specified RuntimeIdentifier '{0}' is not recognized.
Log.LogError(Strings.UnsupportedRuntimeIdentifier, RuntimeIdentifier);
}
}
else
{
string runtimePackName = runtimePackNamePattern.Replace("**RID**", runtimePackRuntimeIdentifier);
TaskItem runtimePackItem = new TaskItem(runtimePackName);
runtimePackItem.SetMetadata(MetadataKeys.PackageName, runtimePackName);
runtimePackItem.SetMetadata(MetadataKeys.PackageVersion, knownFrameworkReference.LatestRuntimeFrameworkVersion);
runtimePackItem.SetMetadata("FrameworkReference", knownFrameworkReference.Name);
runtimePackItem.SetMetadata(MetadataKeys.RuntimeIdentifier, runtimePackRuntimeIdentifier);
runtimePacks.Add(runtimePackItem);
TaskItem packageToDownload = new TaskItem(runtimePackName);
packageToDownload.SetMetadata(MetadataKeys.Version, knownFrameworkReference.LatestRuntimeFrameworkVersion);
packagesToDownload.Add(packageToDownload);
}
}
}
TaskItem runtimeFramework = new TaskItem(knownFrameworkReference.RuntimeFrameworkName);
// Use default (non roll-forward) version for now. Eventually we'll need to add support for rolling
// forward, and for publishing assets from a runtime pack for self-contained apps
runtimeFramework.SetMetadata(MetadataKeys.Version, knownFrameworkReference.DefaultRuntimeFrameworkVersion);
runtimeFrameworks.Add(runtimeFramework);
}
else
{
unresolvedFrameworkReferences.Add(frameworkReference.ItemSpec);
}
}
if (!string.IsNullOrEmpty(AppHostRuntimeIdentifier) && !string.IsNullOrEmpty(appHostPackPattern))
{
// Choose AppHost RID as best match of the specified RID
string bestAppHostRuntimeIdentifier = GetBestRuntimeIdentifier(AppHostRuntimeIdentifier, appHostRuntimeIdentifiers, out bool wasInGraph);
if (bestAppHostRuntimeIdentifier == null)
{
if (wasInGraph)
{
// NETSDK1084: There was no app host for available for the specified RuntimeIdentifier '{0}'.
Log.LogError(Strings.NoAppHostAvailable, AppHostRuntimeIdentifier);
}
else
{
// NETSDK1083: The specified RuntimeIdentifier '{0}' is not recognized.
Log.LogError(Strings.UnsupportedRuntimeIdentifier, AppHostRuntimeIdentifier);
}
}
else
{
string appHostPackName = appHostPackPattern.Replace("**RID**", bestAppHostRuntimeIdentifier);
string appHostRelativePathInPackage = Path.Combine("runtimes", bestAppHostRuntimeIdentifier, "native",
DotNetAppHostExecutableNameWithoutExtension + ExecutableExtension.ForRuntimeIdentifier(bestAppHostRuntimeIdentifier));
TaskItem appHostItem = new TaskItem("AppHost");
string appHostPackPath = null;
if (!string.IsNullOrEmpty(TargetingPackRoot))
{
appHostPackPath = GetPackPath(appHostPackName, appHostPackVersion);
}
if (appHostPackPath != null && Directory.Exists(appHostPackPath))
{
// Use AppHost from packs folder
appHostItem.SetMetadata(MetadataKeys.Path, Path.Combine(appHostPackPath, appHostRelativePathInPackage));
}
else
{
// Download apphost pack
TaskItem packageToDownload = new TaskItem(appHostPackName);
packageToDownload.SetMetadata(MetadataKeys.Version, appHostPackVersion);
packagesToDownload.Add(packageToDownload);
appHostItem.SetMetadata(MetadataKeys.PackageName, appHostPackName);
appHostItem.SetMetadata(MetadataKeys.PackageVersion, appHostPackVersion);
appHostItem.SetMetadata(MetadataKeys.RelativePath, appHostRelativePathInPackage);
}
AppHost = new ITaskItem[] { appHostItem };
}
}
if (packagesToDownload.Any())
{
PackagesToDownload = packagesToDownload.ToArray();
}
if (runtimeFrameworks.Any())
{
RuntimeFrameworks = runtimeFrameworks.ToArray();
}
if (targetingPacks.Any())
{
TargetingPacks = targetingPacks.ToArray();
}
if (runtimePacks.Any())
{
RuntimePacks = runtimePacks.ToArray();
}
if (unresolvedFrameworkReferences.Any())
{
UnresolvedFrameworkReferences = unresolvedFrameworkReferences.ToArray();
}
}
protected override void ExecuteCore()
{
// Perf optimization: If there are no FrameworkReference items, then don't do anything
// (This means that if you don't have any direct framework references, you won't get any transitive ones either
if (FrameworkReferences == null || FrameworkReferences.Length == 0)
{
return;
}
var normalizedTargetFrameworkVersion = NormalizeVersion(new Version(TargetFrameworkVersion));
var knownFrameworkReferencesForTargetFramework = KnownFrameworkReferences.Select(item => new KnownFrameworkReference(item))
.Where(kfr => kfr.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) &&
NormalizeVersion(kfr.TargetFramework.Version) == normalizedTargetFrameworkVersion)
.ToList();
var frameworkReferenceMap = FrameworkReferences.ToDictionary(fr => fr.ItemSpec, StringComparer.OrdinalIgnoreCase);
List <ITaskItem> packagesToDownload = new List <ITaskItem>();
List <ITaskItem> legacyFrameworkPackages = new List <ITaskItem>();
List <ITaskItem> runtimeFrameworks = new List <ITaskItem>();
List <ITaskItem> targetingPacks = new List <ITaskItem>();
List <ITaskItem> runtimePacks = new List <ITaskItem>();
List <ITaskItem> unavailableRuntimePacks = new List <ITaskItem>();
HashSet <string> unrecognizedRuntimeIdentifiers = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var knownFrameworkReference in knownFrameworkReferencesForTargetFramework)
{
frameworkReferenceMap.TryGetValue(knownFrameworkReference.Name, out ITaskItem frameworkReference);
if (frameworkReference != null && !string.IsNullOrEmpty(knownFrameworkReference.LegacyFrameworkPackages))
{
foreach (var packageAndVersion in knownFrameworkReference.LegacyFrameworkPackages.Split(';'))
{
var items = packageAndVersion.Split('/');
TaskItem packageToReference = new TaskItem(items[0]);
packageToReference.SetMetadata(MetadataKeys.Version, items[1]);
legacyFrameworkPackages.Add(packageToReference);
}
}
// Get the path of the targeting pack in the targeting pack root (e.g. dotnet/ref)
TaskItem targetingPack = new TaskItem(knownFrameworkReference.Name);
targetingPack.SetMetadata(MetadataKeys.PackageName, knownFrameworkReference.TargetingPackName);
string targetingPackVersion = null;
if (frameworkReference != null)
{
// Allow targeting pack version to be overridden via metadata on FrameworkReference
targetingPackVersion = frameworkReference.GetMetadata("TargetingPackVersion");
}
if (string.IsNullOrEmpty(targetingPackVersion))
{
targetingPackVersion = knownFrameworkReference.TargetingPackVersion;
}
targetingPack.SetMetadata(MetadataKeys.PackageVersion, targetingPackVersion);
targetingPack.SetMetadata("TargetingPackFormat", knownFrameworkReference.TargetingPackFormat);
targetingPack.SetMetadata("TargetFramework", knownFrameworkReference.TargetFramework.GetShortFolderName());
targetingPack.SetMetadata("RuntimeFrameworkName", knownFrameworkReference.RuntimeFrameworkName);
string targetingPackPath = null;
if (!string.IsNullOrEmpty(TargetingPackRoot))
{
targetingPackPath = Path.Combine(TargetingPackRoot, knownFrameworkReference.TargetingPackName, targetingPackVersion);
}
if (targetingPackPath != null && Directory.Exists(targetingPackPath))
{
// Use targeting pack from packs folder
targetingPack.SetMetadata(MetadataKeys.PackageDirectory, targetingPackPath);
targetingPack.SetMetadata(MetadataKeys.Path, targetingPackPath);
}
else
{
if (EnableTargetingPackDownload)
{
// Download targeting pack
TaskItem packageToDownload = new TaskItem(knownFrameworkReference.TargetingPackName);
packageToDownload.SetMetadata(MetadataKeys.Version, targetingPackVersion);
packagesToDownload.Add(packageToDownload);
}
}
targetingPacks.Add(targetingPack);
var runtimeFrameworkVersion = GetRuntimeFrameworkVersion(frameworkReference, knownFrameworkReference);
bool processedPrimaryRuntimeIdentifier = false;
if ((SelfContained || ReadyToRunEnabled) &&
!string.IsNullOrEmpty(RuntimeIdentifier) &&
!string.IsNullOrEmpty(knownFrameworkReference.RuntimePackNamePatterns))
{
ProcessRuntimeIdentifier(RuntimeIdentifier, knownFrameworkReference, runtimeFrameworkVersion,
unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks, packagesToDownload);
processedPrimaryRuntimeIdentifier = true;
}
if (RuntimeIdentifiers != null)
{
foreach (var runtimeIdentifier in RuntimeIdentifiers)
{
if (processedPrimaryRuntimeIdentifier && runtimeIdentifier == this.RuntimeIdentifier)
{
// We've already processed this RID
continue;
}
// Pass in null for the runtimePacks list, as for these runtime identifiers we only want to
// download the runtime packs, but not use the assets from them
ProcessRuntimeIdentifier(runtimeIdentifier, knownFrameworkReference, runtimeFrameworkVersion,
unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks: null, packagesToDownload);
}
}
if (!string.IsNullOrEmpty(knownFrameworkReference.RuntimeFrameworkName))
{
TaskItem runtimeFramework = new TaskItem(knownFrameworkReference.RuntimeFrameworkName);
runtimeFramework.SetMetadata(MetadataKeys.Version, runtimeFrameworkVersion);
runtimeFramework.SetMetadata(MetadataKeys.FrameworkName, knownFrameworkReference.Name);
runtimeFrameworks.Add(runtimeFramework);
}
}
if (packagesToDownload.Any())
{
PackagesToDownload = packagesToDownload.ToArray();
}
if (legacyFrameworkPackages.Any())
{
LegacyFrameworkPackages = legacyFrameworkPackages.ToArray();
}
if (runtimeFrameworks.Any())
{
RuntimeFrameworks = runtimeFrameworks.ToArray();
}
if (targetingPacks.Any())
{
TargetingPacks = targetingPacks.ToArray();
}
if (runtimePacks.Any())
{
RuntimePacks = runtimePacks.ToArray();
}
if (unavailableRuntimePacks.Any())
{
UnavailableRuntimePacks = unavailableRuntimePacks.ToArray();
}
}
protected override void ExecuteCore()
{
// Perf optimization: If there are no FrameworkReference items, then don't do anything
// (This means that if you don't have any direct framework references, you won't get any transitive ones either
if (FrameworkReferences == null || FrameworkReferences.Length == 0)
{
return;
}
var knownFrameworkReferencesForTargetFramework = KnownFrameworkReferences.Select(item => new KnownFrameworkReference(item))
.Where(kfr => kfr.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) &&
NormalizeVersion(kfr.TargetFramework.Version) == NormalizeVersion(new Version(TargetFrameworkVersion)))
.ToList();
var frameworkReferenceMap = FrameworkReferences.ToDictionary(fr => fr.ItemSpec);
List <ITaskItem> packagesToDownload = new List <ITaskItem>();
List <ITaskItem> runtimeFrameworks = new List <ITaskItem>();
List <ITaskItem> targetingPacks = new List <ITaskItem>();
List <ITaskItem> runtimePacks = new List <ITaskItem>();
List <ITaskItem> unavailableRuntimePacks = new List <ITaskItem>();
bool reportedUnrecognizedRuntimeIdentifier = false;
foreach (var knownFrameworkReference in knownFrameworkReferencesForTargetFramework)
{
frameworkReferenceMap.TryGetValue(knownFrameworkReference.Name, out ITaskItem frameworkReference);
// Get the path of the targeting pack in the targeting pack root (e.g. dotnet/ref)
TaskItem targetingPack = new TaskItem(knownFrameworkReference.Name);
targetingPack.SetMetadata(MetadataKeys.PackageName, knownFrameworkReference.TargetingPackName);
string targetingPackVersion = null;
if (frameworkReference != null)
{
// Allow targeting pack version to be overridden via metadata on FrameworkReference
targetingPackVersion = frameworkReference.GetMetadata("TargetingPackVersion");
}
if (string.IsNullOrEmpty(targetingPackVersion))
{
targetingPackVersion = knownFrameworkReference.TargetingPackVersion;
}
targetingPack.SetMetadata(MetadataKeys.PackageVersion, targetingPackVersion);
string targetingPackPath = null;
if (!string.IsNullOrEmpty(TargetingPackRoot))
{
targetingPackPath = Path.Combine(TargetingPackRoot, knownFrameworkReference.TargetingPackName, knownFrameworkReference.TargetingPackVersion);
}
if (targetingPackPath != null && Directory.Exists(targetingPackPath))
{
// Use targeting pack from packs folder
targetingPack.SetMetadata(MetadataKeys.PackageDirectory, targetingPackPath);
targetingPack.SetMetadata(MetadataKeys.Path, targetingPackPath);
}
else
{
if (EnableTargetingPackDownload)
{
// Download targeting pack
TaskItem packageToDownload = new TaskItem(knownFrameworkReference.TargetingPackName);
packageToDownload.SetMetadata(MetadataKeys.Version, targetingPackVersion);
packagesToDownload.Add(packageToDownload);
}
}
targetingPacks.Add(targetingPack);
var runtimeFrameworkVersion = GetRuntimeFrameworkVersion(frameworkReference, knownFrameworkReference);
if (SelfContained &&
!string.IsNullOrEmpty(RuntimeIdentifier) &&
!string.IsNullOrEmpty(knownFrameworkReference.RuntimePackNamePatterns))
{
foreach (var runtimePackNamePattern in knownFrameworkReference.RuntimePackNamePatterns.Split(';'))
{
string runtimePackRuntimeIdentifier = NuGetUtils.GetBestMatchingRid(
new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath),
RuntimeIdentifier,
knownFrameworkReference.RuntimePackRuntimeIdentifiers.Split(';'),
out bool wasInGraph);
if (runtimePackRuntimeIdentifier == null)
{
if (wasInGraph)
{
// Report this as an error later, if necessary. This is because we try to download
// all available runtime packs in case there is a transitive reference to a shared
// framework we don't directly reference. But we don't want to immediately error out
// here if a runtime pack that we might not need to reference isn't available for the
// targeted RID (e.g. Microsoft.WindowsDesktop.App for a linux RID).
var unavailableRuntimePack = new TaskItem(knownFrameworkReference.Name);
unavailableRuntimePack.SetMetadata(MetadataKeys.RuntimeIdentifier, RuntimeIdentifier);
unavailableRuntimePacks.Add(unavailableRuntimePack);
}
else if (!reportedUnrecognizedRuntimeIdentifier)
{
// NETSDK1083: The specified RuntimeIdentifier '{0}' is not recognized.
Log.LogError(Strings.RuntimeIdentifierNotRecognized, RuntimeIdentifier);
reportedUnrecognizedRuntimeIdentifier = true;
}
}
else
{
string runtimePackName = runtimePackNamePattern.Replace("**RID**", runtimePackRuntimeIdentifier);
TaskItem runtimePackItem = new TaskItem(runtimePackName);
runtimePackItem.SetMetadata(MetadataKeys.PackageName, runtimePackName);
runtimePackItem.SetMetadata(MetadataKeys.PackageVersion, runtimeFrameworkVersion);
runtimePackItem.SetMetadata(MetadataKeys.FrameworkName, knownFrameworkReference.Name);
runtimePackItem.SetMetadata(MetadataKeys.RuntimeIdentifier, runtimePackRuntimeIdentifier);
runtimePacks.Add(runtimePackItem);
TaskItem packageToDownload = new TaskItem(runtimePackName);
packageToDownload.SetMetadata(MetadataKeys.Version, runtimeFrameworkVersion);
packagesToDownload.Add(packageToDownload);
}
}
}
TaskItem runtimeFramework = new TaskItem(knownFrameworkReference.RuntimeFrameworkName);
runtimeFramework.SetMetadata(MetadataKeys.Version, runtimeFrameworkVersion);
runtimeFramework.SetMetadata(MetadataKeys.FrameworkName, knownFrameworkReference.Name);
runtimeFrameworks.Add(runtimeFramework);
}
if (packagesToDownload.Any())
{
PackagesToDownload = packagesToDownload.ToArray();
}
if (runtimeFrameworks.Any())
{
RuntimeFrameworks = runtimeFrameworks.ToArray();
}
if (targetingPacks.Any())
{
TargetingPacks = targetingPacks.ToArray();
}
if (runtimePacks.Any())
{
RuntimePacks = runtimePacks.ToArray();
}
if (unavailableRuntimePacks.Any())
{
UnavailableRuntimePacks = unavailableRuntimePacks.ToArray();
}
}
