private SelectionCriteria GetSelectionCriteria()
{
var criteria = new SelectionCriteria();
criteria.Entries.Add(new SelectionCriteriaEntry
{
Properties = new Dictionary <string, object>
{
{ "tpm", NuGetFramework.Parse(TargetPlatformMonikers.First()) },
{ "tfm", NuGetFramework.Parse(TargetFrameworkMonikers.First()) },
{ "arch", Architecture }
}
});
criteria.Entries.Add(new SelectionCriteriaEntry
{
Properties = new Dictionary <string, object>
{
{ "tfm", NuGetFramework.Parse(TargetFrameworkMonikers.First()) }
}
});
return(criteria);
}
/// <summary>
/// Performs the NuGet package resolution.
/// </summary>
public override bool Execute()
{
var analyzers = new List <ITaskItem>();
var copyLocalItems = new List <ITaskItem>();
var references = new List <ITaskItem>();
var providers = new List <IDependencyProvider>();
if (!String.IsNullOrEmpty(PackageRoot))
{
providers.Add(new NuGetDependencyResolver(PackageRoot));
}
else
{
// Find and add all our package folders
var parentDirectory = new DirectoryInfo(Environment.CurrentDirectory);
while (parentDirectory != null)
{
if (parentDirectory.GetDirectories("packages").Any())
{
providers.Add(new NuGetDependencyResolver(Path.Combine(parentDirectory.FullName, "packages")));
}
parentDirectory = parentDirectory.Parent;
}
providers.Add(new NuGetDependencyResolver(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".dnx", "packages")));
}
providers.Add(new MSBuildDependencyProvider(ProjectFile, NuGetPackageReferences));
var walker = new DependencyWalker(providers);
var root = walker.Walk(ProjectFile, new NuGetVersion(new Version()), NuGetFramework.Parse(TargetFrameworkMonikers.First()));
root.TryResolveConflicts();
var resolvedItems = new Dictionary <string, Library>();
// Pick the relevant versions of the package after conflict
// resolution
root.ForEach(true, (node, state) =>
{
if (node.Disposition != Disposition.Accepted ||
node.Item == null)
{
return(false);
}
if (!resolvedItems.ContainsKey(node.Key.Name))
{
resolvedItems[node.Key.Name] = node.Item.Data;
}
return(true);
});
var patternDefinitions = new PatternDefinitions();
if (UseDotNetNativeToolchain)
{
var directoriesToPrep = new[] { IlcTargetFrameworkPath, IlcTargetFrameworkFacadesPath };
foreach (var directoryToPrep in directoriesToPrep)
{
var directoryInfoToPrep = new DirectoryInfo(directoryToPrep);
directoryInfoToPrep.Create();
foreach (var file in directoryInfoToPrep.GetFiles())
{
file.Delete();
}
}
}
foreach (var library in resolvedItems.Values)
{
if (library.Identity.Type != LibraryTypes.Package)
{
continue;
}
Log.LogMessage(MessageImportance.Low, "Resolved references from {0}:", library.Identity.ToString());
LoadContents(library);
var compileTimeReferences = TryGetTaskItemsFromLibrary(library, patternDefinitions.CompileTimeAssemblies);
var copyLocalReferences = TryGetTaskItemsFromLibrary(library, patternDefinitions.ManagedAssemblies) ?? Enumerable.Empty <ITaskItem>();
var copyLocalNativeReferences = TryGetTaskItemsFromLibrary(library, patternDefinitions.NativeLibraries) ?? Enumerable.Empty <ITaskItem>();
var itemsInAot = TryGetTaskItemsFromLibrary(library, patternDefinitions.AheadOfTimeAssemblies) ?? Enumerable.Empty <ITaskItem>();
if (compileTimeReferences == null)
{
// Then the "copy local" references are actually our compile-time references
compileTimeReferences = copyLocalReferences;
}
if (compileTimeReferences != null)
{
ApplyCompileTimeReferenceMetadata(compileTimeReferences, library);
foreach (var compileTimeReference in compileTimeReferences)
{
Log.LogMessage(MessageImportance.Low, " Build time reference: {0}", compileTimeReference.ItemSpec);
references.Add(compileTimeReference);
}
}
if (UseDotNetNativeToolchain)
{
var frameworkAotItems = itemsInAot.Any() ? itemsInAot : copyLocalReferences;
foreach (var frameworkAotItem in frameworkAotItems)
{
File.Copy(frameworkAotItem.ItemSpec, Path.Combine(IlcTargetFrameworkFacadesPath, Path.GetFileName(frameworkAotItem.ItemSpec)), overwrite: true);
}
foreach (var referenceItem in compileTimeReferences)
{
File.Copy(referenceItem.ItemSpec, Path.Combine(IlcTargetFrameworkPath, Path.GetFileName(referenceItem.ItemSpec)), overwrite: true);
}
}
else
{
foreach (var copyLocalReference in copyLocalReferences.Concat(copyLocalNativeReferences))
{
Log.LogMessage(MessageImportance.Low, " Copy local reference: {0}", copyLocalReference.ItemSpec);
copyLocalItems.Add(copyLocalReference);
}
}
}
ResolvedAnalyzers = analyzers.ToArray();
ResolvedCopyLocalItems = copyLocalItems.ToArray();
ResolvedReferences = references.ToArray();
return(true);
}
/// <summary>
/// Performs the NuGet package resolution.
/// </summary>
public override bool Execute()
{
JObject lockFile;
using (var streamReader = new StreamReader(ProjectLockFile))
{
lockFile = JObject.Load(new JsonTextReader(streamReader));
}
var targets = (JObject)lockFile["targets"];
string tfm = TargetFrameworkMonikers.First().Replace(" ", "");
string rid = "win7";
if (!String.IsNullOrEmpty(Architecture))
{
rid += "-" + Architecture;
}
if (UseDotNetNativeToolchain)
{
rid += "-aot";
}
var target = (JObject)targets[tfm + "/" + rid];
if (target == null)
{
// we don't yet have proper portable support, so fake it for now.
target = (JObject)targets[tfm];
}
if (target == null)
{
Log.LogError("Couldn't find the required information in the lock file. Make sure you have {0} in your frameworks list and {1} in your runtimes list.", tfm, rid);
return(false);
}
foreach (var package in target)
{
var packageNameParts = package.Key.Split('/');
var packageName = packageNameParts[0];
var packageVersion = packageNameParts[1];
Log.LogMessage(MessageImportance.Low, "Resolved references from {0}:", packageName);
foreach (var referenceItem in CreateItems(packageName, packageVersion, package.Value, "compile"))
{
Log.LogMessage(MessageImportance.Low, " Build time reference: {0}", referenceItem.ItemSpec);
_references.Add(referenceItem);
}
foreach (var copyLocalItem in CreateItems(packageName, packageVersion, package.Value, "runtime"))
{
Log.LogMessage(MessageImportance.Low, " Copy local reference: {0}", copyLocalItem.ItemSpec);
_copyLocalItems.Add(copyLocalItem);
}
foreach (var copyLocalItem in CreateItems(packageName, packageVersion, package.Value, "native"))
{
Log.LogMessage(MessageImportance.Low, " Copy local reference: {0}", copyLocalItem.ItemSpec);
_copyLocalItems.Add(copyLocalItem);
}
}
return(true);
}
