Switch to code to generate deps file for tools using the lock file.
This commit is contained in:
Livar Cunha
parent
05472919af
commit
b4b89c7849
6 changed files with 500 additions and 16 deletions
|
|
@ -181,42 +181,37 @@ namespace Microsoft.DotNet.Cli.Utils
|
|||
depsPathRoot,
|
||||
toolLibrary.Name + FileNameSuffixes.DepsJson);
|
||||
|
||||
EnsureToolJsonDepsFileExists(toolLockFile, depsJsonPath);
|
||||
EnsureToolJsonDepsFileExists(toolLockFile, depsJsonPath, toolLibrary);
|
||||
|
||||
return depsJsonPath;
|
||||
}
|
||||
|
||||
private void EnsureToolJsonDepsFileExists(
|
||||
LockFile toolLockFile,
|
||||
string depsPath)
|
||||
string depsPath,
|
||||
LockFileTargetLibrary toolLibrary)
|
||||
{
|
||||
if (!File.Exists(depsPath))
|
||||
{
|
||||
GenerateDepsJsonFile(toolLockFile, depsPath);
|
||||
GenerateDepsJsonFile(toolLockFile, depsPath, toolLibrary);
|
||||
}
|
||||
}
|
||||
|
||||
// Need to unit test this, so public
|
||||
public void GenerateDepsJsonFile(
|
||||
LockFile toolLockFile,
|
||||
string depsPath)
|
||||
string depsPath,
|
||||
LockFileTargetLibrary toolLibrary)
|
||||
{
|
||||
Reporter.Verbose.WriteLine($"Generating deps.json at: {depsPath}");
|
||||
|
||||
var projectContext = new ProjectContextBuilder()
|
||||
.WithLockFile(toolLockFile)
|
||||
.WithTargetFramework(s_toolPackageFramework.ToString())
|
||||
.Build();
|
||||
|
||||
var exporter = projectContext.CreateExporter(Constants.DefaultConfiguration);
|
||||
var singleProjectInfo = new SingleProjectInfo(
|
||||
toolLibrary.Name,
|
||||
toolLibrary.Version.ToFullString(),
|
||||
Enumerable.Empty<ResourceAssemblyInfo>());
|
||||
|
||||
var dependencyContext = new DependencyContextBuilder()
|
||||
.Build(null,
|
||||
null,
|
||||
exporter.GetAllExports(),
|
||||
true,
|
||||
s_toolPackageFramework,
|
||||
string.Empty);
|
||||
.Build(singleProjectInfo, null, toolLockFile, s_toolPackageFramework, null);
|
||||
|
||||
var tempDepsFile = Path.GetTempFileName();
|
||||
using (var fileStream = File.Open(tempDepsFile, FileMode.Open, FileAccess.Write))
|
||||
|
|
|
|||
|
|
@ -0,0 +1,315 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using Microsoft.Extensions.DependencyModel;
|
||||
using NuGet.Frameworks;
|
||||
using NuGet.Packaging;
|
||||
using NuGet.Packaging.Core;
|
||||
using NuGet.ProjectModel;
|
||||
|
||||
namespace Microsoft.DotNet.Cli.Utils
|
||||
{
|
||||
internal class DependencyContextBuilder
|
||||
{
|
||||
private readonly VersionFolderPathResolver _versionFolderPathResolver;
|
||||
|
||||
public DependencyContextBuilder()
|
||||
{
|
||||
// This resolver is only used for building file names, so that base path is not required.
|
||||
_versionFolderPathResolver = new VersionFolderPathResolver(path: null);
|
||||
}
|
||||
|
||||
public DependencyContext Build(
|
||||
SingleProjectInfo mainProjectInfo,
|
||||
CompilationOptions compilationOptions,
|
||||
LockFile lockFile,
|
||||
NuGetFramework framework,
|
||||
string runtime)
|
||||
{
|
||||
bool includeCompilationLibraries = compilationOptions != null;
|
||||
|
||||
LockFileTarget lockFileTarget = lockFile.GetTarget(framework, runtime);
|
||||
|
||||
IEnumerable<LockFileTargetLibrary> runtimeExports = lockFileTarget.GetRuntimeLibraries();
|
||||
IEnumerable<LockFileTargetLibrary> compilationExports =
|
||||
includeCompilationLibraries ?
|
||||
lockFileTarget.GetCompileLibraries() :
|
||||
Enumerable.Empty<LockFileTargetLibrary>();
|
||||
|
||||
var dependencyLookup = compilationExports
|
||||
.Concat(runtimeExports)
|
||||
.Distinct()
|
||||
.Select(library => new Dependency(library.Name, library.Version.ToString()))
|
||||
.ToDictionary(dependency => dependency.Name, StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
var libraryLookup = lockFile.Libraries.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
var runtimeSignature = GenerateRuntimeSignature(runtimeExports);
|
||||
|
||||
IEnumerable<RuntimeLibrary> runtimeLibraries =
|
||||
GetLibraries(runtimeExports, libraryLookup, dependencyLookup, runtime: true).Cast<RuntimeLibrary>();
|
||||
|
||||
IEnumerable<CompilationLibrary> compilationLibraries;
|
||||
if (includeCompilationLibraries)
|
||||
{
|
||||
CompilationLibrary projectCompilationLibrary = GetProjectCompilationLibrary(
|
||||
mainProjectInfo,
|
||||
lockFile,
|
||||
lockFileTarget,
|
||||
dependencyLookup);
|
||||
compilationLibraries = new[] { projectCompilationLibrary }
|
||||
.Concat(
|
||||
GetLibraries(compilationExports, libraryLookup, dependencyLookup, runtime: false)
|
||||
.Cast<CompilationLibrary>());
|
||||
}
|
||||
else
|
||||
{
|
||||
compilationLibraries = Enumerable.Empty<CompilationLibrary>();
|
||||
}
|
||||
|
||||
return new DependencyContext(
|
||||
new TargetInfo(framework.DotNetFrameworkName, runtime, runtimeSignature, lockFileTarget.IsPortable()),
|
||||
compilationOptions ?? CompilationOptions.Default,
|
||||
compilationLibraries,
|
||||
runtimeLibraries,
|
||||
new RuntimeFallbacks[] { });
|
||||
}
|
||||
|
||||
private static string GenerateRuntimeSignature(IEnumerable<LockFileTargetLibrary> runtimeExports)
|
||||
{
|
||||
var sha1 = SHA1.Create();
|
||||
var builder = new StringBuilder();
|
||||
var packages = runtimeExports
|
||||
.Where(libraryExport => libraryExport.Type == "package");
|
||||
var separator = "|";
|
||||
foreach (var libraryExport in packages)
|
||||
{
|
||||
builder.Append(libraryExport.Name);
|
||||
builder.Append(separator);
|
||||
builder.Append(libraryExport.Version.ToString());
|
||||
builder.Append(separator);
|
||||
}
|
||||
var hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(builder.ToString()));
|
||||
|
||||
builder.Clear();
|
||||
foreach (var hashByte in hash)
|
||||
{
|
||||
builder.AppendFormat("{0:x2}", hashByte);
|
||||
}
|
||||
return builder.ToString();
|
||||
}
|
||||
|
||||
private List<Dependency> GetProjectDependencies(
|
||||
LockFile lockFile,
|
||||
LockFileTarget lockFileTarget,
|
||||
Dictionary<string, Dependency> dependencyLookup)
|
||||
{
|
||||
|
||||
List<Dependency> dependencies = new List<Dependency>();
|
||||
|
||||
IEnumerable<ProjectFileDependencyGroup> projectFileDependencies = lockFile
|
||||
.ProjectFileDependencyGroups
|
||||
.Where(dg => dg.FrameworkName == string.Empty ||
|
||||
dg.FrameworkName == lockFileTarget.TargetFramework.DotNetFrameworkName);
|
||||
|
||||
foreach (string projectFileDependency in projectFileDependencies.SelectMany(dg => dg.Dependencies))
|
||||
{
|
||||
int separatorIndex = projectFileDependency.IndexOf(' ');
|
||||
string dependencyName = separatorIndex > 0 ?
|
||||
projectFileDependency.Substring(0, separatorIndex) :
|
||||
projectFileDependency;
|
||||
|
||||
Dependency dependency;
|
||||
if (dependencyLookup.TryGetValue(dependencyName, out dependency))
|
||||
{
|
||||
dependencies.Add(dependency);
|
||||
}
|
||||
}
|
||||
|
||||
return dependencies;
|
||||
}
|
||||
|
||||
private RuntimeLibrary GetProjectRuntimeLibrary(
|
||||
SingleProjectInfo projectInfo,
|
||||
LockFile lockFile,
|
||||
LockFileTarget lockFileTarget,
|
||||
Dictionary<string, Dependency> dependencyLookup)
|
||||
{
|
||||
|
||||
RuntimeAssetGroup[] runtimeAssemblyGroups = new[] { new RuntimeAssetGroup(string.Empty, projectInfo.GetOutputName()) };
|
||||
|
||||
List<Dependency> dependencies = GetProjectDependencies(lockFile, lockFileTarget, dependencyLookup);
|
||||
|
||||
ResourceAssembly[] resourceAssemblies = projectInfo
|
||||
.ResourceAssemblies
|
||||
.Select(r => new ResourceAssembly(r.RelativePath, r.Culture))
|
||||
.ToArray();
|
||||
|
||||
return new RuntimeLibrary(
|
||||
type: "project",
|
||||
name: projectInfo.Name,
|
||||
version: projectInfo.Version,
|
||||
hash: string.Empty,
|
||||
runtimeAssemblyGroups: runtimeAssemblyGroups,
|
||||
nativeLibraryGroups: new RuntimeAssetGroup[] { },
|
||||
resourceAssemblies: resourceAssemblies,
|
||||
dependencies: dependencies.ToArray(),
|
||||
serviceable: false);
|
||||
}
|
||||
|
||||
private CompilationLibrary GetProjectCompilationLibrary(
|
||||
SingleProjectInfo projectInfo,
|
||||
LockFile lockFile,
|
||||
LockFileTarget lockFileTarget,
|
||||
Dictionary<string, Dependency> dependencyLookup)
|
||||
{
|
||||
List<Dependency> dependencies = GetProjectDependencies(lockFile, lockFileTarget, dependencyLookup);
|
||||
|
||||
return new CompilationLibrary(
|
||||
type: "project",
|
||||
name: projectInfo.Name,
|
||||
version: projectInfo.Version,
|
||||
hash: string.Empty,
|
||||
assemblies: new[] { projectInfo.GetOutputName() },
|
||||
dependencies: dependencies.ToArray(),
|
||||
serviceable: false);
|
||||
}
|
||||
|
||||
private IEnumerable<Library> GetLibraries(
|
||||
IEnumerable<LockFileTargetLibrary> exports,
|
||||
IDictionary<string, LockFileLibrary> libraryLookup,
|
||||
IDictionary<string, Dependency> dependencyLookup,
|
||||
bool runtime)
|
||||
{
|
||||
return exports.Select(export => GetLibrary(export, libraryLookup, dependencyLookup, runtime));
|
||||
}
|
||||
|
||||
private Library GetLibrary(
|
||||
LockFileTargetLibrary export,
|
||||
IDictionary<string, LockFileLibrary> libraryLookup,
|
||||
IDictionary<string, Dependency> dependencyLookup,
|
||||
bool runtime)
|
||||
{
|
||||
var type = export.Type;
|
||||
|
||||
// TEMPORARY: All packages are serviceable in RC2
|
||||
// See https://github.com/dotnet/cli/issues/2569
|
||||
var serviceable = export.Type == "package";
|
||||
var libraryDependencies = new HashSet<Dependency>();
|
||||
|
||||
foreach (PackageDependency libraryDependency in export.Dependencies)
|
||||
{
|
||||
Dependency dependency;
|
||||
if (dependencyLookup.TryGetValue(libraryDependency.Id, out dependency))
|
||||
{
|
||||
libraryDependencies.Add(dependency);
|
||||
}
|
||||
}
|
||||
|
||||
string hash = string.Empty;
|
||||
string path = null;
|
||||
string hashPath = null;
|
||||
LockFileLibrary library;
|
||||
if (libraryLookup.TryGetValue(export.Name, out library))
|
||||
{
|
||||
if (!string.IsNullOrEmpty(library.Sha512))
|
||||
{
|
||||
hash = "sha512-" + library.Sha512;
|
||||
hashPath = _versionFolderPathResolver.GetHashFileName(export.Name, export.Version);
|
||||
}
|
||||
|
||||
path = library.Path;
|
||||
}
|
||||
|
||||
if (runtime)
|
||||
{
|
||||
return new RuntimeLibrary(
|
||||
type.ToLowerInvariant(),
|
||||
export.Name,
|
||||
export.Version.ToString(),
|
||||
hash,
|
||||
CreateRuntimeAssemblyGroups(export),
|
||||
CreateNativeLibraryGroups(export),
|
||||
export.ResourceAssemblies.FilterPlaceHolderFiles().Select(CreateResourceAssembly),
|
||||
libraryDependencies,
|
||||
serviceable,
|
||||
path,
|
||||
hashPath);
|
||||
}
|
||||
else
|
||||
{
|
||||
IEnumerable<string> assemblies = export
|
||||
.CompileTimeAssemblies
|
||||
.FilterPlaceHolderFiles()
|
||||
.Select(libraryAsset => libraryAsset.Path);
|
||||
|
||||
return new CompilationLibrary(
|
||||
type.ToString().ToLowerInvariant(),
|
||||
export.Name,
|
||||
export.Version.ToString(),
|
||||
hash,
|
||||
assemblies,
|
||||
libraryDependencies,
|
||||
serviceable,
|
||||
path,
|
||||
hashPath);
|
||||
}
|
||||
}
|
||||
|
||||
private IReadOnlyList<RuntimeAssetGroup> CreateRuntimeAssemblyGroups(LockFileTargetLibrary export)
|
||||
{
|
||||
List<RuntimeAssetGroup> assemblyGroups = new List<RuntimeAssetGroup>();
|
||||
|
||||
assemblyGroups.Add(
|
||||
new RuntimeAssetGroup(
|
||||
string.Empty,
|
||||
export.RuntimeAssemblies.FilterPlaceHolderFiles().Select(a => a.Path)));
|
||||
|
||||
foreach (var runtimeTargetsGroup in export.GetRuntimeTargetsGroups("runtime"))
|
||||
{
|
||||
assemblyGroups.Add(
|
||||
new RuntimeAssetGroup(
|
||||
runtimeTargetsGroup.Key,
|
||||
runtimeTargetsGroup.Select(t => t.Path)));
|
||||
}
|
||||
|
||||
return assemblyGroups;
|
||||
}
|
||||
|
||||
private IReadOnlyList<RuntimeAssetGroup> CreateNativeLibraryGroups(LockFileTargetLibrary export)
|
||||
{
|
||||
List<RuntimeAssetGroup> nativeGroups = new List<RuntimeAssetGroup>();
|
||||
|
||||
nativeGroups.Add(
|
||||
new RuntimeAssetGroup(
|
||||
string.Empty,
|
||||
export.NativeLibraries.FilterPlaceHolderFiles().Select(a => a.Path)));
|
||||
|
||||
foreach (var runtimeTargetsGroup in export.GetRuntimeTargetsGroups("native"))
|
||||
{
|
||||
nativeGroups.Add(
|
||||
new RuntimeAssetGroup(
|
||||
runtimeTargetsGroup.Key,
|
||||
runtimeTargetsGroup.Select(t => t.Path)));
|
||||
}
|
||||
|
||||
return nativeGroups;
|
||||
}
|
||||
|
||||
private ResourceAssembly CreateResourceAssembly(LockFileItem resourceAssembly)
|
||||
{
|
||||
string locale;
|
||||
if (!resourceAssembly.Properties.TryGetValue("locale", out locale))
|
||||
{
|
||||
locale = null;
|
||||
}
|
||||
|
||||
return new ResourceAssembly(resourceAssembly.Path, locale);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using NuGet.Packaging.Core;
|
||||
using NuGet.ProjectModel;
|
||||
|
||||
namespace Microsoft.DotNet.Cli.Utils
|
||||
{
|
||||
internal static class LockFileTargetExtensions
|
||||
{
|
||||
public static bool IsPortable(this LockFileTarget lockFileTarget)
|
||||
{
|
||||
return string.IsNullOrEmpty(lockFileTarget.RuntimeIdentifier) &&
|
||||
lockFileTarget.GetPlatformLibrary() != null;
|
||||
}
|
||||
|
||||
public static LockFileTargetLibrary GetPlatformLibrary(this LockFileTarget lockFileTarget)
|
||||
{
|
||||
// TODO: https://github.com/dotnet/sdk/issues/17 get this from the lock file
|
||||
var platformPackageName = "Microsoft.NETCore.App";
|
||||
var platformLibrary = lockFileTarget
|
||||
.Libraries
|
||||
.FirstOrDefault(e => e.Name.Equals(platformPackageName, StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
return platformLibrary;
|
||||
}
|
||||
|
||||
public static HashSet<string> GetPlatformExclusionList(
|
||||
this LockFileTarget lockFileTarget,
|
||||
IDictionary<string, LockFileTargetLibrary> libraryLookup)
|
||||
{
|
||||
var platformLibrary = lockFileTarget.GetPlatformLibrary();
|
||||
var exclusionList = new HashSet<string>();
|
||||
|
||||
exclusionList.Add(platformLibrary.Name);
|
||||
CollectDependencies(libraryLookup, platformLibrary.Dependencies, exclusionList);
|
||||
|
||||
return exclusionList;
|
||||
}
|
||||
|
||||
public static IEnumerable<LockFileTargetLibrary> GetRuntimeLibraries(this LockFileTarget lockFileTarget)
|
||||
{
|
||||
IEnumerable<LockFileTargetLibrary> runtimeLibraries = lockFileTarget.Libraries;
|
||||
Dictionary<string, LockFileTargetLibrary> libraryLookup =
|
||||
runtimeLibraries.ToDictionary(e => e.Name, StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
HashSet<string> allExclusionList = new HashSet<string>();
|
||||
|
||||
if (lockFileTarget.IsPortable())
|
||||
{
|
||||
allExclusionList.UnionWith(lockFileTarget.GetPlatformExclusionList(libraryLookup));
|
||||
}
|
||||
|
||||
// TODO: exclude "type: build" dependencies during publish - https://github.com/dotnet/sdk/issues/42
|
||||
|
||||
return runtimeLibraries.Filter(allExclusionList).ToArray();
|
||||
}
|
||||
|
||||
public static IEnumerable<LockFileTargetLibrary> GetCompileLibraries(this LockFileTarget lockFileTarget)
|
||||
{
|
||||
// TODO: exclude "type: build" dependencies during publish - https://github.com/dotnet/sdk/issues/42
|
||||
|
||||
return lockFileTarget.Libraries;
|
||||
}
|
||||
|
||||
public static IEnumerable<LockFileTargetLibrary> Filter(
|
||||
this IEnumerable<LockFileTargetLibrary> libraries,
|
||||
HashSet<string> exclusionList)
|
||||
{
|
||||
return libraries.Where(e => !exclusionList.Contains(e.Name));
|
||||
}
|
||||
|
||||
public static IEnumerable<IGrouping<string, LockFileRuntimeTarget>> GetRuntimeTargetsGroups(
|
||||
this LockFileTargetLibrary library,
|
||||
string assetType)
|
||||
{
|
||||
return library.RuntimeTargets
|
||||
.FilterPlaceHolderFiles()
|
||||
.Cast<LockFileRuntimeTarget>()
|
||||
.Where(t => string.Equals(t.AssetType, assetType, StringComparison.OrdinalIgnoreCase))
|
||||
.GroupBy(t => t.Runtime);
|
||||
}
|
||||
|
||||
private static void CollectDependencies(
|
||||
IDictionary<string, LockFileTargetLibrary> libraryLookup,
|
||||
IEnumerable<PackageDependency> dependencies,
|
||||
HashSet<string> exclusionList)
|
||||
{
|
||||
foreach (PackageDependency dependency in dependencies)
|
||||
{
|
||||
LockFileTargetLibrary library = libraryLookup[dependency.Id];
|
||||
if (library.Version.Equals(dependency.VersionRange.MinVersion))
|
||||
{
|
||||
if (exclusionList.Add(library.Name))
|
||||
{
|
||||
CollectDependencies(libraryLookup, library.Dependencies, exclusionList);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using NuGet.Packaging.Core;
|
||||
using NuGet.ProjectModel;
|
||||
|
||||
namespace Microsoft.DotNet.Cli.Utils
|
||||
{
|
||||
internal static class NuGetUtils
|
||||
{
|
||||
public static bool IsPlaceholderFile(string path)
|
||||
{
|
||||
return string.Equals(Path.GetFileName(path), PackagingCoreConstants.EmptyFolder, StringComparison.Ordinal);
|
||||
}
|
||||
|
||||
public static IEnumerable<LockFileItem> FilterPlaceHolderFiles(this IEnumerable<LockFileItem> files)
|
||||
{
|
||||
return files.Where(f => !IsPlaceholderFile(f.Path));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
namespace Microsoft.DotNet.Cli.Utils
|
||||
{
|
||||
internal class ResourceAssemblyInfo
|
||||
{
|
||||
public string Culture { get; }
|
||||
public string RelativePath { get; }
|
||||
|
||||
public ResourceAssemblyInfo(string culture, string relativePath)
|
||||
{
|
||||
Culture = culture;
|
||||
RelativePath = relativePath;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Microsoft.DotNet.Cli.Utils
|
||||
{
|
||||
internal class SingleProjectInfo
|
||||
{
|
||||
public string Name { get; }
|
||||
public string Version { get; }
|
||||
|
||||
public IEnumerable<ResourceAssemblyInfo> ResourceAssemblies { get; }
|
||||
|
||||
public SingleProjectInfo(string name, string version, IEnumerable<ResourceAssemblyInfo> resourceAssemblies)
|
||||
{
|
||||
Name = name;
|
||||
Version = version;
|
||||
ResourceAssemblies = resourceAssemblies;
|
||||
}
|
||||
|
||||
public string GetOutputName()
|
||||
{
|
||||
return $"{Name}.dll";
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue