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); } } } }