private static string GetEffectivePathForContentFile(NuGetFramework nuGetFramework, string zipArchiveEntryFullName)
{
// Always use Path.DirectorySeparatorChar
var effectivePathForContentFile = PathUtility.ReplaceAltDirSeparatorWithDirSeparator(zipArchiveEntryFullName);
if (effectivePathForContentFile.StartsWith(PackagingConstants.Folders.Content + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
{
effectivePathForContentFile = effectivePathForContentFile.Substring((PackagingConstants.Folders.Content + Path.DirectorySeparatorChar).Length);
if (!nuGetFramework.Equals(NuGetFramework.AnyFramework))
{
// Parsing out the framework name out of the effective path
var frameworkFolderEndIndex = effectivePathForContentFile.IndexOf(Path.DirectorySeparatorChar);
if (frameworkFolderEndIndex != -1)
{
if (effectivePathForContentFile.Length > frameworkFolderEndIndex + 1)
{
effectivePathForContentFile = effectivePathForContentFile.Substring(frameworkFolderEndIndex + 1);
}
}
return(effectivePathForContentFile);
}
}
// Return the effective path with Path.DirectorySeparatorChar
return(effectivePathForContentFile);
}
public static NuGetFramework ParseNormalized(string framework)
{
NuGetFramework fx = NuGetFramework.Parse(framework);
// remap win8 & win81 since they are synonymous with netcore45 and netcore451 respectively
if (fx.Equals(FrameworkConstants.CommonFrameworks.Win8))
{
fx = FrameworkConstants.CommonFrameworks.NetCore45;
}
else if (fx.Equals(FrameworkConstants.CommonFrameworks.Win81))
{
fx = FrameworkConstants.CommonFrameworks.NetCore451;
}
return(fx);
}
private IEnumerable <string> GetRuntimeAssetFoldersForPromotion(ContentItemGroup runtimeAssets, NuGetFramework targetFramework, string targetFrameworkName)
{
if (runtimeAssets == null || runtimeAssets.Items.Count == 0)
{
return(Enumerable.Empty <string>());
}
if (runtimeAssets.Items.All(ci => NuGetAssetResolver.IsPlaceholder(ci.Path)))
{
return(Enumerable.Empty <string>());
}
if (targetFrameworkName == null)
{
targetFrameworkName = targetFramework.GetShortFolderName();
}
var resolvedFramework = runtimeAssets.Properties["tfm"] as NuGetFramework;
if (targetFramework.Equals(resolvedFramework))
{
Log.LogMessage(LogImportance.Low, $"Not promoting explicit implementation for {targetFrameworkName}");
return(Enumerable.Empty <string>());
}
return(NuGetAssetResolver.GetPackageTargetDirectories(runtimeAssets));
}
private IEnumerable <string> GetObscuredAssetFolders(ContentItemGroup assets, ContentItemGroup obscuredAssets, NuGetFramework targetFramework, string targetFrameworkName, string expectedAssetFolder, string ignoredAssetFolder = null)
{
if (assets == null || assets.Items.Count == 0)
{
return(Enumerable.Empty <string>());
}
if (assets.Items.Any(ci => !NuGetAssetResolver.IsPlaceholder(ci.Path)))
{
return(Enumerable.Empty <string>());
}
if (targetFrameworkName == null)
{
targetFrameworkName = targetFramework.GetShortFolderName();
}
var resolvedFramework = assets.Properties["tfm"] as NuGetFramework;
if (targetFramework.Equals(resolvedFramework))
{
Log.LogMessage(LogImportance.Low, $"Not overriding explicit placeholder for {targetFrameworkName}");
return(Enumerable.Empty <string>());
}
var obscuredAssetPaths = NuGetAssetResolver.GetPackageTargetDirectories(obscuredAssets);
if (ignoredAssetFolder != null)
{
string ignoredFolder = ignoredAssetFolder + '/';
obscuredAssetPaths = obscuredAssetPaths.Where(i => - 1 == i.IndexOf(ignoredFolder, StringComparison.OrdinalIgnoreCase));
}
if (expectedAssetFolder != null)
{
var unexpectedAssetPaths = obscuredAssetPaths.Where(ri => !ri.StartsWith(expectedAssetFolder, StringComparison.OrdinalIgnoreCase));
foreach (var unexpectedAssetPath in unexpectedAssetPaths)
{
Log.LogWarning($"Unexpected targetPath {unexpectedAssetPath}. Expected only {expectedAssetFolder}.");
}
// filter after we've warned
obscuredAssetPaths = obscuredAssetPaths.Except(unexpectedAssetPaths);
}
if (!obscuredAssetPaths.Any())
{
// it's acceptable to have no override, this is the case for packages which
// carry implementation in a runtime-specific package
Log.LogMessage(LogImportance.Low, $"No {expectedAssetFolder} assets could be found to override inbox placeholder for {targetFrameworkName}.");
}
return(obscuredAssetPaths);
}
public bool IsTargetingFramework(NuGetFramework framework)
{
foreach (var tfm in GetTargetFrameworks())
{
if (framework.Equals(tfm))
{
return(true);
}
}
return(false);
}
public override bool Execute()
{
if (References == null || References.Length == 0)
{
return(true);
}
Dictionary <string, ITaskItem> packageReferences = new Dictionary <string, ITaskItem>();
Dictionary <string, ITaskItem> assemblyReferences = new Dictionary <string, ITaskItem>();
bool referencesMscorlib = false;
NuGetFramework targetFx = NuGetFramework.Parse(TargetFramework);
bool isOobFramework = targetFx.Equals(FrameworkConstants.CommonFrameworks.NetCore50) || targetFx.Framework == FrameworkConstants.FrameworkIdentifiers.UAP;
foreach (var reference in References)
{
string referenceName = reference.ItemSpec;
referencesMscorlib |= referenceName.Equals("mscorlib");
string referenceVersion = reference.GetMetadata("Version");
reference.SetMetadata("TargetFramework", TargetFramework);
if (!string.IsNullOrEmpty(TargetFramework) && !isOobFramework && Frameworks.IsInbox(FrameworkListsPath, TargetFramework, referenceName, referenceVersion))
{
AddReference(assemblyReferences, reference);
}
else
{
AddReference(packageReferences, reference);
}
}
if (referencesMscorlib)
{
// only add framework references for mscorlib-based assemblies.
FrameworkReferences = assemblyReferences.Values.ToArray();
}
if (packageReferences.Count == 0)
{
var emptyItem = new TaskItem("_._");
emptyItem.SetMetadata("TargetFramework", TargetFramework);
packageReferences.Add(emptyItem.ItemSpec, emptyItem);
}
PackageReferences = packageReferences.Values.ToArray();
return(true);
}
public static string GetShortFrameworkName(this NuGetFramework frameworkName)
{
if (frameworkName == null || frameworkName == NuGetFramework.AnyFramework)
{
return(null);
}
if (frameworkName.Equals(new NuGetFramework(FrameworkConstants.FrameworkIdentifiers.Portable, new Version(5, 0))))
{
// Avoid calling GetShortFrameworkName because NuGet throws ArgumentException
// in this case.
return("dotnet");
}
return(frameworkName.GetShortFolderName());
}
private static int Compare(NuGetFramework dependent, NuGetFramework dependency)
{
if (dependent.Equals(dependency))
{
return(0);
}
var dependentToDependency = DefaultCompatibilityProvider.Instance.IsCompatible(dependent, dependency);
var dependencyToDependent = DefaultCompatibilityProvider.Instance.IsCompatible(dependency, dependent);
return((dependentToDependency, dependencyToDependent) switch
{
(true, true) => 0,
(false, true) => - 1,
(true, false) => 1,
(false, false) => - 1,
});
/// <summary>
/// Return the matching framework/runtime ProjectContext.
/// If 'framework' or 'runtimeIdentifier' is null or empty then it matches with any.
/// </summary>
private static IEnumerable <ProjectContext> GetMatchingProjectContexts(IEnumerable <ProjectContext> contexts, NuGetFramework framework, string runtimeIdentifier)
{
foreach (var context in contexts)
{
if (context.TargetFramework == null || string.IsNullOrEmpty(context.RuntimeIdentifier))
{
continue;
}
if (string.IsNullOrEmpty(runtimeIdentifier) || string.Equals(runtimeIdentifier, context.RuntimeIdentifier, StringComparison.OrdinalIgnoreCase))
{
if (framework == null || framework.Equals(context.TargetFramework))
{
yield return(context);
}
}
}
}
private static HashSet <string> GetMatchingFrameworkStrings(PackageSpec spec, NuGetFramework framework)
{
// Ignore case since msbuild does
var matches = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
if (spec.RestoreMetadata != null)
{
matches.UnionWith(spec.RestoreMetadata.OriginalTargetFrameworks
.Where(s => framework.Equals(NuGetFramework.Parse(s))));
}
// If there were no matches, use the generated name
if (matches.Count < 1)
{
matches.Add(framework.GetShortFolderName());
}
return(matches);
}
// recursive
static void ReportProjectReferences(ProjectReferenceNode source, PackageSpec project, NuGetFramework rootNuGetFramework,
DependencyGraphSpec dependencyGraph, int indentLevel, HashSet <Node> vertices, HashSet <Edge> edges)
{
const int INDENT_SIZE = 2;
NuGetFramework nearest = project.GetNearestFrameworkMatching(rootNuGetFramework);
// TODO: This is done be caller....delete
//var projectReference = new ProjectReferenceNode(project.FilePath, project.Version.ToString(), nearest);
//projects.Add(projectReference);
// indent shows levels of the graph
Console.Write(new string(' ', indentLevel * INDENT_SIZE));
Console.WriteLine($"{project.RestoreMetadata.ProjectUniqueName}, v{project.Version}, ({nearest.GetShortFolderName()})");
ProjectRestoreMetadataFrameworkInfo resolvedTargetFramework =
project.RestoreMetadata.TargetFrameworks.Single(tf => nearest.Equals(tf.FrameworkName));
// project references of a targetFramework
foreach (ProjectRestoreReference projectRestoreReference in resolvedTargetFramework.ProjectReferences)
{
// TODO: PrivateAssets, ExcludeAssets, IncludeAssets
//dependency.ProjectPath
//dependency.ProjectUniqueName
PackageSpec projectDependency = dependencyGraph.GetProjectSpec(projectRestoreReference.ProjectUniqueName);
var projectDependencyReference = new ProjectReferenceNode(
projectDependency.FilePath,
projectDependency.Version.ToString(),
projectDependency.GetNearestFrameworkMatching(rootNuGetFramework));
vertices.Add(projectDependencyReference);
edges.Add(new Edge(source, projectDependencyReference));
//Console.WriteLine($"({projectDependency.Name}, {Path.GetFileName(projectDependency.FilePath)}) is a project reference of ({project.Name}, {Path.GetFileName(project.FilePath)}");
// recursive
ReportProjectReferences(projectDependencyReference, projectDependency, rootNuGetFramework,
dependencyGraph, indentLevel + 1, vertices, edges);
}
}
// TODO: Should we use framework here
//
// 1. Create dgspec.json via .NET Core CLI: GenerateRestoreGraphFile target
// 2. Load dgspec.json into DependencyGraphSpec instance/object
// For each SDK project (ProjectStyle.PackageReference) in the graph spec
// 3. Get assets file (project.assets.json) for the project
// 4. Construct LockFile from assets file for the project
static void AnalyzeProject(string projectPath, string framework)
{
// Graph input
var vertices = new HashSet <Node>();
var edges = new HashSet <Edge>();
var rootNuGetFramework = NuGetFramework.ParseFolder(framework); // TODO: optional filter
// TODO: HACK...kan fjernes
if (string.IsNullOrEmpty(projectPath))
{
var rootPath = GetRepoRootPath();
//projectPath = Path.Combine(rootPath, "DotnetDependencies.sln");
projectPath = Path.Combine(
Path.Combine(
Path.Combine(rootPath, "src"), "Deps.CLI"), "Deps.CLI.csproj");
}
// 'package graph' is a better word
// Load dependency graph via nuget client tools build into msbuild (.NET Core CLI, .NET Core SDK)
// TODO: opsatning af packageSources
var dependencyGraphService = new DependencyGraphService();
var dependencyGraph = dependencyGraphService.GenerateDependencyGraph(projectPath);
// We only support MSBuild style <PackageReference> SDK projects, where project.assets.json (lock file) is
// generated in the RestoreOutputPath folder
if (dependencyGraph.Projects.Any(p => p.RestoreMetadata.ProjectStyle != ProjectStyle.PackageReference))
{
throw new InvalidOperationException("Only SDK projects are supported.");
}
PackageSpec projectRoot = dependencyGraph.Projects.Single(p => Path.GetFileName(p.FilePath) == Path.GetFileName(projectPath));
var rootNode = new ProjectReferenceNode(projectPath, projectRoot.Version.ToString(), rootNuGetFramework);
vertices.Add(rootNode);
var projectRootTargetFramework = projectRoot.TargetFrameworks.FirstOrDefault(tf => rootNuGetFramework.Equals(tf.FrameworkName));
if (projectRootTargetFramework == null)
{
throw new InvalidOperationException(
$"The root project does not define the TargetFramework {rootNuGetFramework}");
}
//Console.WriteLine($"project: {Path.GetFileName(project.FilePath)}");
//Console.WriteLine($"project.BaseDirectory: {Path.GetFileName(project.BaseDirectory)}");
//Console.WriteLine($"project.Name: {project.Name}");
//Console.WriteLine($"project.TargetFrameworks: {string.Join(", ", project.TargetFrameworks.Select(tfm => tfm.FrameworkName.GetShortFolderName()))}");
//Console.WriteLine($"project.Version: {project.Version}");
//Console.WriteLine($"project.RestoreMetadata.ProjectName: {project.RestoreMetadata.ProjectName}");
//Console.WriteLine($"project.RestoreMetadata.Sources: {string.Join(", ", project.RestoreMetadata.Sources)}");
//Console.WriteLine($"project.Dependencies: {string.Join(", ", project.Dependencies)}");
// TODO: Path. Unique name etc...
Console.WriteLine($"Name: {projectRoot.Name}");
Console.WriteLine($"Version: {projectRoot.Version} ({rootNuGetFramework.GetShortFolderName()})");
Console.WriteLine($"Framework: {rootNuGetFramework.DotNetFrameworkName}");
Console.WriteLine($"Framework moniker: {rootNuGetFramework.GetShortFolderName()}");
Console.WriteLine();
Console.WriteLine("resolve project reference dependency graph");
Console.WriteLine();
// TODO: Path. Unique name etc...
Console.WriteLine($"{projectRoot.Name}, v{projectRoot.Version} ({rootNuGetFramework.GetShortFolderName()})");
//
// First resolve project reference dependency graph
//
foreach (ProjectRestoreMetadataFrameworkInfo targetFramework in projectRoot.RestoreMetadata.TargetFrameworks)
{
// only want project references defined for the TargetFramework
if (!rootNuGetFramework.Equals(targetFramework.FrameworkName))
{
continue;
}
// project references of a targetFramework
foreach (var projectRestoreReference in targetFramework.ProjectReferences)
{
// TODO: PrivateAssets, ExcludeAssets, IncludeAssets
//dependency.ProjectPath
//dependency.ProjectUniqueName
PackageSpec projectDependency = dependencyGraph.GetProjectSpec(projectRestoreReference.ProjectUniqueName);
//Console.WriteLine($"({project.Name}, {Path.GetFileName(project.FilePath)}) is a project reference of ({projectRoot.Name}, {Path.GetFileName(projectRoot.FilePath)}");
NuGetFramework nearest = projectDependency.GetNearestFrameworkMatching(rootNuGetFramework);
var projectReference = new ProjectReferenceNode(projectDependency.FilePath, projectDependency.Version.ToString(), nearest);
vertices.Add(projectReference);
edges.Add(new Edge(rootNode, projectReference));
ReportProjectReferences(rootNode, projectDependency, rootNuGetFramework, dependencyGraph, 1,
vertices, edges);
}
}
// TODO: What about ProjectReferences...are project references converted to package specs in dgspec file??? YES,
// and available via dependencyGraph.Projects and dependencyGraph.GetProjectSpec
// TODO: project Closure is part of graph all ready
// closure[0] is the root
// closure[1..m] contains project references
IReadOnlyList <PackageSpec> projectClosure = dependencyGraph.GetClosure(projectRoot.RestoreMetadata.ProjectUniqueName);
Debug.Assert(ReferenceEquals(projectRoot, projectClosure[0]));
//
// Second, resolve package reference dependency graph of each project
//
Console.WriteLine();
Console.WriteLine("resolve package reference dependency graph");
Console.WriteLine();
// for each csproj with PackageReference style (i.e. SDK csproj)
foreach (PackageSpec project in dependencyGraph.Projects)
{
// TODO: Maybe just use the project.assets.json created by .NET Core SDK tooling
// Generate lock file: A lock file has the package dependency graph for the project/solution/repo
// that includes both the direct as well as transitive dependencies.
var lockFileService = new LockFileService();
LockFile lockFile = lockFileService.GetLockFile(project.FilePath, project.RestoreMetadata.OutputPath);
// TODO: This could change our code...we can get at the project references inside one single loop
//{
// // TODO: For debugging
// var projectDirectory = Path.GetDirectoryName(lockFile.PackageSpec.RestoreMetadata.ProjectPath);
// // full path to the referenced msbuild files (csproj files)
// var projectReferences = lockFile.Libraries
// .Where(library => library.MSBuildProject != null)
// .Select(library => Path.GetFullPath(Path.Combine(projectDirectory, library.MSBuildProject)))
// .ToArray();
// if (projectReferences.Length > 0)
// {
// Console.WriteLine($"project references {string.Join(", ", projectReferences)}");
// }
//}
NuGetFramework nearest = project.GetNearestFrameworkMatching(rootNuGetFramework);
TargetFrameworkInformation resolvedTargetFramework =
project.TargetFrameworks.Single(tf => nearest.Equals(tf.FrameworkName));
// for the root should this resolve to the rootNuGetFramework
Console.WriteLine($"{project.Name}, v{project.Version}, ({resolvedTargetFramework.FrameworkName.GetShortFolderName()})");
// Find the transitive closure for this tfm
LockFileTarget lockFileTargetFramework =
lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(resolvedTargetFramework.FrameworkName));
if (lockFileTargetFramework != null)
{
// For each direct dependency
foreach (LibraryDependency directDependency in resolvedTargetFramework.Dependencies)
{
// Find the _resolved_ package reference
LockFileTargetLibrary resolvedPackageReference =
lockFileTargetFramework.Libraries.FirstOrDefault(library =>
library.Name == directDependency.Name);
// Show transitive dependencies of this direct dependency
ReportLockFilePackageDependencies(resolvedPackageReference, lockFileTargetFramework, 1);
}
}
}
}
