private int LibraryDetail(PackageSpec project, LockFile lockfile, string targetName, string library)
{
var lib = lockfile.Libraries.FirstOrDefault(l => l.Name.Equals(library, StringComparison.OrdinalIgnoreCase));
if (lib == null)
{
_log.LogError($"Library not found: {library}");
return -1;
}
_log.LogInformation($"{lib.Name} {lib.Version}");
_log.LogInformation($"Servicable: {lib.IsServiceable}");
_log.LogInformation($"SHA512 Hash: {lib.Sha512}");
_log.LogInformation($"Files:");
foreach (var file in lib.Files)
{
_log.LogInformation($" * {file}");
}
IEnumerable<LockFileTarget> targets = lockfile.Targets;
if (!string.IsNullOrEmpty(targetName))
{
var parts = targetName.Split('/');
var tfm = NuGetFramework.Parse(parts[0]);
var rid = parts[1];
targets = targets.Where(t => string.Equals(rid, t.RuntimeIdentifier, StringComparison.Ordinal) && tfm.Equals(t.TargetFramework));
}
var libraryTargets = targets.Select(t => new { Target = t, Library = t.Libraries.FirstOrDefault(l => string.Equals(l.Name, library, StringComparison.OrdinalIgnoreCase)) });
foreach (var libraryTarget in libraryTargets)
{
_log.LogInformation($"Target: {libraryTarget.Target.TargetFramework}/{libraryTarget.Target.RuntimeIdentifier}");
if (libraryTarget.Library == null)
{
_log.LogInformation(" Not supported");
}
else
{
WriteList(Compile, libraryTarget.Library.CompileTimeAssemblies.Select(f => f.Path));
WriteList(Runtime, libraryTarget.Library.RuntimeAssemblies.Select(f => f.Path));
WriteList(Native, libraryTarget.Library.NativeLibraries.Select(f => f.Path));
WriteList(Framework, libraryTarget.Library.FrameworkAssemblies);
}
}
return 0;
}
public LockFileDependencyProvider(LockFile lockFile)
{
// List of all the libraries in the lock file, there can be multiple versions per id
_libraries = lockFile.Libraries.ToDictionary(l => Tuple.Create(l.Name, l.Version));
// Dependencies can only vary by target framework so only look at that target
_targetLibraries = new Dictionary<Tuple<NuGetFramework, string>, LockFileTargetLibrary>();
foreach (var target in lockFile.Targets)
{
if (!string.IsNullOrEmpty(target.RuntimeIdentifier))
{
continue;
}
foreach (var library in target.Libraries)
{
_targetLibraries[Tuple.Create(target.TargetFramework, library.Name)] = library;
}
}
}
/// <summary>
/// Get the library from each target graph it exists in.
/// </summary>
public static IEnumerable <LockFileTargetLibrary> GetTargetLibraries(this IAssetsLogMessage message, LockFile assetsFile)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (assetsFile == null)
{
throw new ArgumentNullException(nameof(assetsFile));
}
return(message.GetTargetGraphs(assetsFile).Select(target => target.GetTargetLibrary(message.LibraryId)));
}
/// <summary>
/// Get target graphs for the current log message.
/// </summary>
public static IEnumerable <LockFileTarget> GetTargetGraphs(this IAssetsLogMessage message, LockFile assetsFile)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (assetsFile == null)
{
throw new ArgumentNullException(nameof(assetsFile));
}
return(assetsFile.Targets.Where(target => message.TargetGraphs.Contains(target.Name, StringComparer.OrdinalIgnoreCase)));
}
/// <summary>
/// Get target graphs for the current log message.
/// </summary>
/// <remarks>If the message does not contain target graphs all graphs in the file
/// will be returned.</remarks>
public static IEnumerable <LockFileTarget> GetTargetGraphs(this IAssetsLogMessage message, LockFile assetsFile)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (assetsFile == null)
{
throw new ArgumentNullException(nameof(assetsFile));
}
// If the message does not contain any target graph it should apply to all graphs.
if (message.TargetGraphs == null || message.TargetGraphs.Count == 0)
{
return(assetsFile.Targets);
}
return(assetsFile.Targets.Where(target => message.TargetGraphs.Contains(target.Name, StringComparer.OrdinalIgnoreCase)));
}
private LockFile CreateLockFile(PackageSpec project, List<RestoreTargetGraph> targetGraphs, NuGetv3LocalRepository repository)
{
var lockFile = new LockFile();
using (var sha512 = SHA512.Create())
{
foreach (var item in targetGraphs.SelectMany(g => g.Flattened).Distinct().OrderBy(x => x.Data.Match.Library))
{
var library = item.Data.Match.Library;
var packageInfo = repository.FindPackagesById(library.Name)
.FirstOrDefault(p => p.Version == library.Version);
if (packageInfo == null)
{
continue;
}
var lockFileLib = CreateLockFileLibrary(
packageInfo,
sha512,
correctedPackageName: library.Name);
lockFile.Libraries.Add(lockFileLib);
}
}
// Use empty string as the key of dependencies shared by all frameworks
lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup(
string.Empty,
project.Dependencies.Select(x => x.LibraryRange.ToString())));
foreach (var frameworkInfo in project.TargetFrameworks)
{
lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup(
frameworkInfo.FrameworkName.ToString(),
frameworkInfo.Dependencies.Select(x => x.LibraryRange.ToString())));
}
// Add the targets
foreach (var targetGraph in targetGraphs)
{
var target = new LockFileTarget();
target.TargetFramework = targetGraph.Framework;
target.RuntimeIdentifier = targetGraph.RuntimeIdentifier;
foreach (var library in targetGraph.Flattened.Select(g => g.Key).OrderBy(x => x))
{
var packageInfo = repository.FindPackagesById(library.Name)
.FirstOrDefault(p => p.Version == library.Version);
if (packageInfo == null)
{
continue;
}
var targetLibrary = CreateLockFileTargetLibrary(
packageInfo,
targetGraph,
new DefaultPackagePathResolver(repository.RepositoryRoot),
correctedPackageName: library.Name);
target.Libraries.Add(targetLibrary);
}
lockFile.Targets.Add(target);
}
return lockFile;
}
private int SummarizeLockfile(PackageSpec project, LockFile lockfile, string targetName)
{
_log.LogInformation($"Locked: {lockfile.IsLocked}");
if (project == null)
{
_log.LogInformation($"Up-to-date: Unknown");
}
else
{
_log.LogInformation($"Up-to-date: {lockfile.IsValidForPackageSpec(project)}");
}
_log.LogInformation("Project Dependencies:");
foreach (var group in lockfile.ProjectFileDependencyGroups)
{
var fxName = string.IsNullOrEmpty(group.FrameworkName) ? "All Frameworks" : group.FrameworkName;
if (group.Dependencies.Any())
{
_log.LogInformation($" {fxName}");
foreach (var dep in group.Dependencies)
{
_log.LogInformation($" * {dep}");
}
}
else
{
_log.LogInformation($" {fxName}: none");
}
}
_log.LogInformation("All Libraries:");
foreach (var lib in lockfile.Libraries)
{
_log.LogInformation($"* {lib.Name} {lib.Version}");
}
IEnumerable<LockFileTarget> targets = lockfile.Targets;
if (!string.IsNullOrEmpty(targetName))
{
var parts = targetName.Split('/');
var tfm = NuGetFramework.Parse(parts[0]);
var rid = parts[1];
targets = targets.Where(t => string.Equals(rid, t.RuntimeIdentifier, StringComparison.Ordinal) && tfm.Equals(t.TargetFramework));
}
foreach (var target in targets)
{
_log.LogInformation($"Target: {target.TargetFramework} {target.RuntimeIdentifier}");
foreach (var lib in target.Libraries)
{
var provides = string.Empty;
if (lib.NativeLibraries.Any())
{
provides += Native + ",";
}
if (lib.RuntimeAssemblies.Any())
{
provides += Runtime + ",";
}
if (lib.CompileTimeAssemblies.Any())
{
provides += Compile + ",";
}
if (lib.FrameworkAssemblies.Any())
{
provides += Framework + ",";
}
provides = provides.TrimEnd(',');
if (string.IsNullOrEmpty(provides))
{
provides = Nothing;
}
_log.LogInformation($" * [{provides}] {lib.Name} {lib.Version}");
}
}
return 0;
}
private static void WriteLockFile(JsonWriter writer, IObjectWriter jsonObjectWriter, LockFile lockFile)
{
writer.WriteStartObject();
writer.WritePropertyName(VersionProperty);
writer.WriteValue(lockFile.Version);
writer.WritePropertyName(TargetsProperty);
JsonUtility.WriteObject(writer, lockFile.Targets, WriteTarget);
writer.WritePropertyName(LibrariesProperty);
JsonUtility.WriteObject(writer, lockFile.Libraries, WriteLibrary);
writer.WritePropertyName(ProjectFileDependencyGroupsProperty);
JsonUtility.WriteObject(writer, lockFile.ProjectFileDependencyGroups, WriteProjectFileDependencyGroup);
if (lockFile.PackageFolders?.Any() == true)
{
writer.WritePropertyName(PackageFoldersProperty);
JsonUtility.WriteObject(writer, lockFile.PackageFolders, WriteFileItem);
}
if (lockFile.Version >= 2)
{
if (lockFile.PackageSpec != null)
{
writer.WritePropertyName(PackageSpecProperty);
jsonObjectWriter.WriteObjectStart();
PackageSpecWriter.Write(lockFile.PackageSpec, jsonObjectWriter);
jsonObjectWriter.WriteObjectEnd();
}
}
if (lockFile.Version >= 3)
{
if (lockFile.LogMessages.Count > 0)
{
var projectPath = lockFile.PackageSpec?.RestoreMetadata?.ProjectPath;
writer.WritePropertyName(LogsProperty);
WriteLogMessages(writer, lockFile.LogMessages, projectPath);
}
}
if (lockFile.CentralTransitiveDependencyGroups.Any())
{
writer.WritePropertyName(CentralTransitiveDependencyGroupsProperty);
WriteCentralTransitiveDependencyGroup(jsonObjectWriter, lockFile.CentralTransitiveDependencyGroups);
}
writer.WriteEndObject();
}
public RestoreResult(bool success, IEnumerable<RestoreTargetGraph> restoreGraphs, LockFile lockfile)
{
Success = success;
RestoreGraphs = restoreGraphs;
LockFile = lockfile;
}
private static bool TryReadLockFile(string directory, out LockFile lockFile)
{
lockFile = null;
string file = Path.Combine(directory, LockFileFormat.LockFileName);
if (File.Exists(file))
{
using (var stream = File.OpenRead(file))
{
lockFile = LockFileFormat.Read(stream);
}
return true;
}
return false;
}