private LockFileTarget ReadTarget(string property, JToken json)
{
var target = new LockFileTarget();
var parts = property.Split(new[] { '/' }, 2);
target.TargetFramework = new FrameworkName(parts[0]);
if (parts.Length == 2)
{
target.RuntimeIdentifier = parts[1];
}
target.Libraries = ReadObject(json as JObject, ReadTargetLibrary);
return(target);
}
public void GivenATargetGraphVerifyLibraryReturned()
{
var graph = new LockFileTarget()
{
TargetFramework = NuGetFramework.Parse("net45"),
};
graph.Libraries.Add(new LockFileTargetLibrary()
{
Name = "x",
Version = NuGetVersion.Parse("1.0.0")
});
graph.GetTargetLibrary("x").Version.ToNormalizedString().Should().Be("1.0.0");
}
public ProjectContext(LockFile lockFile, LockFileTarget lockFileTarget, LockFileTargetLibrary platformLibrary, bool isFrameworkDependent)
{
Debug.Assert(lockFile != null);
Debug.Assert(lockFileTarget != null);
if (isFrameworkDependent)
{
Debug.Assert(platformLibrary != null);
}
_lockFile = lockFile;
_lockFileTarget = lockFileTarget;
PlatformLibrary = platformLibrary;
IsFrameworkDependent = isFrameworkDependent;
}
private static void ReportDependency(LockFileTargetLibrary projectLibrary, LockFileTarget lockFileTargetFramework, int indentLevel)
{
// First indent
Console.Write(String.Concat(Enumerable.Repeat("| ", (indentLevel - 1) * 2)));
// Then use the last two character to make the heriarchy identifier
Console.Write("|-");
Console.WriteLine($"{projectLibrary.Name}, v{projectLibrary.Version}{(projectLibrary.Framework != string.Empty ? COMMA_SEPARATOR + projectLibrary.Framework : string.Empty)}");
foreach (var childDependency in projectLibrary.Dependencies)
{
var childLibrary = lockFileTargetFramework.Libraries.FirstOrDefault(library => library.Name == childDependency.Id);
ReportDependency(childLibrary, lockFileTargetFramework, indentLevel + 1);
}
}
private void ScanLibraries(LockFileTarget target,
LockFileLookup lockFileLookup,
Dictionary <LibraryKey, LibraryDescription> libraries,
MSBuildDependencyProvider msbuildResolver,
PackageDependencyProvider packageResolver,
ProjectDependencyProvider projectResolver)
{
foreach (var library in target.Libraries)
{
LibraryDescription description = null;
var type = LibraryType.Unspecified;
if (string.Equals(library.Type, "project"))
{
var projectLibrary = lockFileLookup.GetProject(library.Name);
if (projectLibrary != null)
{
if (MSBuildDependencyProvider.IsMSBuildProjectLibrary(projectLibrary))
{
description = msbuildResolver.GetDescription(TargetFramework, projectLibrary, library, IsDesignTime);
type = LibraryType.MSBuildProject;
}
else
{
var path = Path.GetFullPath(Path.Combine(ProjectDirectory, projectLibrary.Path));
description = projectResolver.GetDescription(library.Name, path, library, ProjectResolver);
type = LibraryType.Project;
}
}
}
else
{
var packageEntry = lockFileLookup.GetPackage(library.Name, library.Version);
if (packageEntry != null)
{
description = packageResolver.GetDescription(TargetFramework, packageEntry, library);
}
type = LibraryType.Package;
}
description = description ?? UnresolvedDependencyProvider.GetDescription(new LibraryRange(library.Name, type), target.TargetFramework);
libraries.Add(new LibraryKey(library.Name), description);
}
}
public void BuildIntegratedNuGetProject_SortDependenciesWithProjects()
{
// Arrange
var lockFile = new LockFile();
var target = new LockFileTarget();
lockFile.Targets.Add(target);
var targetA = new LockFileTargetLibrary()
{
Name = "a",
Version = NuGetVersion.Parse("1.0.0"),
Type = "package"
};
targetA.Dependencies.Add(new PackageDependency("b"));
var targetB = new LockFileTargetLibrary()
{
Name = "b",
Version = NuGetVersion.Parse("1.0.0"),
Type = "project"
};
targetA.Dependencies.Add(new PackageDependency("c"));
var targetC = new LockFileTargetLibrary()
{
Name = "c",
Version = NuGetVersion.Parse("1.0.0"),
Type = "package"
};
target.Libraries.Add(targetA);
target.Libraries.Add(targetC);
target.Libraries.Add(targetB);
// Act
var ordered = BuildIntegratedProjectUtility.GetOrderedLockFileDependencies(lockFile)
.OrderBy(lib => lib.Name, StringComparer.Ordinal)
.ToList();
// Assert
Assert.Equal(3, ordered.Count);
Assert.Equal("a", ordered[0].Name);
Assert.Equal("b", ordered[1].Name);
Assert.Equal("c", ordered[2].Name);
}
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));
}
public CacheWriter(ResolvePackageAssets task)
{
var targetFramework = NuGetUtils.ParseFrameworkName(task.TargetFrameworkMoniker);
_task = task;
_lockFile = new LockFileCache(task).GetLockFile(task.ProjectAssetsFile);
_packageResolver = NuGetPackageResolver.CreateResolver(_lockFile, _task.ProjectPath);
_compileTimeTarget = _lockFile.GetTargetAndThrowIfNotFound(targetFramework, runtime: null);
_runtimeTarget = _lockFile.GetTargetAndThrowIfNotFound(targetFramework, _task.RuntimeIdentifier);
_stringTable = new Dictionary <string, int>(InitialStringTableCapacity, StringComparer.Ordinal);
_metadataStrings = new List <string>(InitialStringTableCapacity);
_bufferedMetadata = new List <int>();
var stream = File.Open(task.ProjectAssetsCacheFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
_writer = new BinaryWriter(stream, TextEncoding, leaveOpen: false);
}
public ToolRestoreResult(
string toolName,
bool success,
LockFileTarget lockFileTarget,
LockFileTargetLibrary fileTargetLibrary,
string lockFilePath,
LockFile lockFile,
LockFile previousLockFile)
{
ToolName = toolName;
Success = success;
LockFileTarget = lockFileTarget;
FileTargetLibrary = fileTargetLibrary;
LockFilePath = lockFilePath;
LockFile = lockFile;
PreviousLockFile = previousLockFile;
}
public ProjectReferenceModel Analyze(PackageSpec project)
{
var frameworkModels = new List <ProjectReferenceModel>();
LockFile lockFile = GetLockFile(project.FilePath, project.RestoreMetadata.OutputPath);
foreach (TargetFrameworkInformation targetFramework in project.TargetFrameworks)
{
LockFileTarget lockFileTargetFramework = lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(targetFramework.FrameworkName));
if (lockFileTargetFramework != null)
{
var framework = frameworkTargetAnalyzer.Analyze(targetFramework, lockFileTargetFramework);
frameworkModels.Add(framework);
}
}
return(new ProjectReferenceModel(project.Name, project.Version.ToString(), frameworkModels));
}
private static ITaskItem[] RaiseFrameworkAssemblies(LockFileTarget target, Action <string, ITaskItem> setup)
{
var items = new List <ITaskItem>();
foreach (var library in target.Libraries)
{
if (library.IsPackage())
{
foreach (string frameworkAssembly in library.FrameworkAssemblies)
{
var item = CreatePackageAssetItem(library, frameworkAssembly);
items.Add(item);
setup?.Invoke(frameworkAssembly, item);
}
}
}
return(items.ToArray());
}
public ToolRestoreResult(
string toolName,
bool success,
LockFileTarget lockFileTarget,
LockFileTargetLibrary fileTargetLibrary,
string lockFilePath,
LockFile lockFile,
LockFile previousLockFile)
{
ToolName = toolName;
Success = success;
LockFileTarget = lockFileTarget;
FileTargetLibrary = fileTargetLibrary;
LockFilePath = lockFilePath;
LockFile = lockFile;
PreviousLockFile = previousLockFile;
// "locked" property is not supported on tools
RelockFile = false;
}
private IEnumerable <string> ExtractDependencies(LockFile lockFile)
{
// Get the libraries to import for targeting netstandard2.0
LockFileTarget netstandardTarget = lockFile.Targets
.First(p => p.TargetFramework.Framework == NetStandardFramework &&
p.TargetFramework.Version == NetStandard20);
// Collect all DLL files from CompileTimeAssemblies from that target
// Note that we apply File.Exists since there may be muliple paths we're searching for each file listed
List <string> dependencies = netstandardTarget.Libraries
.SelectMany(p => p.CompileTimeAssemblies.Select(q => new
{
Library = p,
Path = q.Path.Replace('/', Path.DirectorySeparatorChar)
}))
.Where(p => Path.GetExtension(p.Path) == ".dll")
.SelectMany(
_ => lockFile.PackageFolders.Select(p => p.Path),
(dependency, folder) =>
Path.Combine(folder, dependency.Library.Name, dependency.Library.Version.ToString(), dependency.Path)
)
.Where(File.Exists)
.ToList();
// NETStandard.Library is a bit different, it has reference assemblies in the build/netstandard2.0/ref directory
// which are imported via a MSBuild target file in the package. So we need to emulate that behavior here.
LockFileTargetLibrary netstandardLibrary = netstandardTarget.Libraries.First(p => p.Name == NetStandardLibrary);
string refDirectory = lockFile.PackageFolders.Select(p => p.Path)
.Select(p => Path.Combine(p, netstandardLibrary.Name, netstandardLibrary.Version.ToString()))
.First(Directory.Exists);
refDirectory = Path.Combine(refDirectory, @"build\netstandard2.0\ref");
dependencies.AddRange(Directory.EnumerateFiles(refDirectory, "*.dll"));
return(dependencies);
}
public ProjectContext(LockFile lockFile, LockFileTarget lockFileTarget,
// Trimmed from publish output, and if there are no runtimeFrameworks, written to runtimeconfig.json
LockFileTargetLibrary platformLibrary,
// Written to runtimeconfig.json
RuntimeFramework[] runtimeFrameworks,
bool isFrameworkDependent)
{
Debug.Assert(lockFile != null);
Debug.Assert(lockFileTarget != null);
if (isFrameworkDependent)
{
Debug.Assert(platformLibrary != null ||
(runtimeFrameworks != null && runtimeFrameworks.Any()));
}
_lockFile = lockFile;
_lockFileTarget = lockFileTarget;
PlatformLibrary = platformLibrary;
RuntimeFrameworks = runtimeFrameworks;
IsFrameworkDependent = isFrameworkDependent;
}
public void Equals_WithTargetFramework(string left, string right, bool expected)
{
var leftSide = new LockFileTarget()
{
TargetFramework = NuGetFramework.Parse(left)
};
var rightSide = new LockFileTarget()
{
TargetFramework = NuGetFramework.Parse(right)
};
// Act & Assert
if (expected)
{
leftSide.Should().Be(rightSide);
}
else
{
leftSide.Should().NotBe(rightSide);
}
}
public void Equals_WithRuntimeIdentifier(string left, string right, bool expected)
{
var leftSide = new LockFileTarget()
{
RuntimeIdentifier = left
};
var rightSide = new LockFileTarget()
{
RuntimeIdentifier = right
};
// Act & Assert
if (expected)
{
leftSide.Should().Be(rightSide);
}
else
{
leftSide.Should().NotBe(rightSide);
}
}
private static IReadOnlyList <PackageDependency> GetTransitivePackagesForLibrary(LockFileTargetLibrary library, NuGetFramework targetFramework, IReadOnlyList <LockFileTarget> targets)
{
// PERF: Intentionally avoiding LINQ and foreach to avoid allocating capture classes and enumerators
if (targets != null)
{
LockFileTarget target = default;
for (int i = 0; i < targets.Count; ++i)
{
LockFileTarget t = targets[i];
if (t.TargetFramework.Equals(targetFramework) && string.IsNullOrEmpty(t.RuntimeIdentifier))
{
target = t;
break;
}
}
if (target != null && target.Libraries != null)
{
var packageDependencies = new List <PackageDependency>();
for (int i = 0; i < target.Libraries.Count; ++i)
{
LockFileTargetLibrary lib = target.Libraries[i];
if (lib.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase))
{
if (lib.Dependencies != null)
{
packageDependencies.AddRange(lib.Dependencies);
}
}
}
return(packageDependencies);
}
}
return(null);
}
// Collect C# source generators from the direct NuGet dependencies (ignores transitive dependencies)
public List <ISourceGenerator> GetSourceGenerators(RestoreCommandProviders dependencyProviders, RestoreResult result,
NuGetFramework targetFramework, AssemblyLoadContext assemblyLoadContext)
{
var generators = new List <ISourceGenerator>();
LockFileTarget lockFileTarget = result.LockFile.Targets
.First(p => p.TargetFramework == targetFramework);
foreach (var directDependency in _packageSpec.Dependencies
.Concat(_packageSpec.TargetFrameworks
.Where(p => p.FrameworkName == targetFramework)
.SelectMany(framework => framework.Dependencies)))
{
// Get the exact version we restored
var version = lockFileTarget.Libraries
.FirstOrDefault(p => string.Equals(p.Name, directDependency.Name, StringComparison.OrdinalIgnoreCase))?
.Version;
if (version is not null)
{
NuGet.Repositories.LocalPackageInfo localPackageInfo =
dependencyProviders.GlobalPackages.FindPackage(directDependency.Name, version);
// For now, we explicitly only handle Roslyn 4.0 analyzers or unversioned analyzers
// The regex also excludes resource assemblies in nested directories
foreach (Match file in localPackageInfo.Files
.Select(p => Regex.Match(p, @"^(analyzers/dotnet/(?:roslyn4\.0/)?cs/[^/]+\.dll$)"))
.Where(p => p.Success))
{
generators.AddRange(GetSourceGenerators(
Path.Join(localPackageInfo.ExpandedPath, file.Groups[1].Value),
assemblyLoadContext));
}
}
}
return(generators);
}
private void GetPackageAndFileDependencies(LockFileTarget target)
{
var resolvedPackageVersions = target.Libraries
.ToDictionary(pkg => pkg.Name, pkg => pkg.Version.ToNormalizedString(), StringComparer.OrdinalIgnoreCase);
string frameworkAlias = _targetNameToAliasMap[target.Name];
var transitiveProjectRefs = new HashSet <string>(
target.Libraries
.Where(lib => lib.IsTransitiveProjectReference(LockFile, ref _projectFileDependencies, frameworkAlias))
.Select(pkg => pkg.Name),
StringComparer.OrdinalIgnoreCase);
foreach (var package in target.Libraries)
{
string packageId = $"{package.Name}/{package.Version.ToNormalizedString()}";
if (_projectFileDependencies.Contains(package.Name))
{
TaskItem item = new TaskItem(packageId);
item.SetMetadata(MetadataKeys.ParentTarget, frameworkAlias); // Foreign Key
item.SetMetadata(MetadataKeys.ParentPackage, string.Empty); // Foreign Key
_packageDependencies.Add(item);
}
// get sub package dependencies
GetPackageDependencies(package, target.Name, resolvedPackageVersions, transitiveProjectRefs);
if (EmitLegacyAssetsFileItems)
{
// get file dependencies on this package
GetFileDependencies(package, target.Name);
}
}
}
protected IEnumerable <RuntimeLibrary> GetNugetReferences(string projectFilePath, Project project)
{
Logger.WriteInfo("Adding nuget references.");
ICollection <RuntimeLibrary> runtimeLibraries = new List <RuntimeLibrary>();
LockFileFormat lockFileFormat = new LockFileFormat();
string lockFileFilePath = Path.Combine(Path.GetDirectoryName(projectFilePath),
project.GetPropertyValue(PropertyNames.ProjectAssetsFile));
if (!File.Exists(lockFileFilePath))
{
Logger.WriteError($"Lock file {lockFileFilePath} not found. Run dotnet restore before executing Automaty.");
throw new AutomatyException();
}
LockFile lockFile = lockFileFormat.Read(lockFileFilePath);
string targetFramework = project.GetPropertyValue(PropertyNames.TargetFramework);
if (string.IsNullOrEmpty(targetFramework))
{
Logger.WriteDebug("Multi targeting project assembly detected.");
targetFramework = GetSuitableTargetFramework(project.GetPropertyValue(PropertyNames.TargetFrameworks));
Logger.WriteDebug($"Using target framework {targetFramework}.");
}
LockFileTarget lockFileTarget = lockFile.GetTarget(NuGetUtils.ParseFrameworkName(targetFramework), string.Empty);
NuGetPackageResolver nuGetPackageResolver =
NuGetPackageResolver.CreateResolver(lockFile, Path.GetDirectoryName(projectFilePath));
// Add nuget references
foreach (LockFileTargetLibrary library in lockFileTarget.Libraries)
{
if (library.Type != LibraryType.Package)
{
continue;
}
string packageDirectory = nuGetPackageResolver.GetPackageDirectory(library.Name, library.Version);
foreach (LockFileItem file in library.RuntimeAssemblies.Where(file => !NuGetUtils.IsPlaceholderFile(file.Path)))
{
string filePath = Path.GetFullPath(Path.Combine(packageDirectory, file.Path));
Logger.WriteDebug($"Adding \"{filePath}\".");
runtimeLibraries.Add(new RuntimeLibrary
{
Name = library.Name,
DirectoryName = Path.GetDirectoryName(filePath),
FileName = Path.GetFileName(filePath)
});
}
}
return(runtimeLibraries);
}
public LockFile CreateLockFile(LockFile previousLockFile,
PackageSpec project,
IEnumerable <RestoreTargetGraph> targetGraphs,
IReadOnlyList <NuGetv3LocalRepository> localRepositories,
RemoteWalkContext context)
{
var lockFile = new LockFile()
{
Version = _lockFileVersion
};
var previousLibraries = previousLockFile?.Libraries.ToDictionary(l => Tuple.Create(l.Name, l.Version));
if (project.RestoreMetadata?.ProjectStyle == ProjectStyle.PackageReference ||
project.RestoreMetadata?.ProjectStyle == ProjectStyle.DotnetToolReference)
{
AddProjectFileDependenciesForPackageReference(project, lockFile, targetGraphs);
}
else
{
AddProjectFileDependenciesForSpec(project, lockFile);
}
// Record all libraries used
foreach (var item in targetGraphs.SelectMany(g => g.Flattened).Distinct()
.OrderBy(x => x.Data.Match.Library))
{
var library = item.Data.Match.Library;
if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase))
{
// Do not include the project itself as a library.
continue;
}
if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject)
{
// Project
var localMatch = (LocalMatch)item.Data.Match;
var projectLib = new LockFileLibrary()
{
Name = library.Name,
Version = library.Version,
Type = LibraryType.Project,
};
// Set the relative path if a path exists
// For projects without project.json this will be empty
if (!string.IsNullOrEmpty(localMatch.LocalLibrary.Path))
{
projectLib.Path = PathUtility.GetRelativePath(
project.FilePath,
localMatch.LocalLibrary.Path,
'/');
}
// The msbuild project path if it exists
object msbuildPath;
if (localMatch.LocalLibrary.Items.TryGetValue(KnownLibraryProperties.MSBuildProjectPath, out msbuildPath))
{
var msbuildRelativePath = PathUtility.GetRelativePath(
project.FilePath,
(string)msbuildPath,
'/');
projectLib.MSBuildProject = msbuildRelativePath;
}
lockFile.Libraries.Add(projectLib);
}
else if (library.Type == LibraryType.Package)
{
// Packages
var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version);
// Add the library if it was resolved, unresolved packages are not added to the assets file.
if (packageInfo != null)
{
var package = packageInfo.Package;
var resolver = packageInfo.Repository.PathResolver;
var sha512 = package.Sha512;
var path = PathUtility.GetPathWithForwardSlashes(resolver.GetPackageDirectory(package.Id, package.Version));
LockFileLibrary lockFileLib = null;
LockFileLibrary previousLibrary = null;
if (previousLibraries?.TryGetValue(Tuple.Create(package.Id, package.Version), out previousLibrary) == true)
{
// Check that the previous library is still valid
if (previousLibrary != null &&
StringComparer.Ordinal.Equals(path, previousLibrary.Path) &&
StringComparer.Ordinal.Equals(sha512, previousLibrary.Sha512))
{
// We mutate this previous library so we must take a clone of it. This is
// important because later, when deciding whether the lock file has changed,
// we compare the new lock file to the previous (in-memory) lock file.
lockFileLib = previousLibrary.Clone();
}
}
// Create a new lock file library if one doesn't exist already.
if (lockFileLib == null)
{
lockFileLib = CreateLockFileLibrary(package, sha512, path);
}
// Create a new lock file library
lockFile.Libraries.Add(lockFileLib);
}
}
}
var libraries = lockFile.Libraries.ToDictionary(lib => Tuple.Create(lib.Name, lib.Version));
var librariesWithWarnings = new HashSet <LibraryIdentity>();
var rootProjectStyle = project.RestoreMetadata?.ProjectStyle ?? ProjectStyle.Unknown;
// Cache package data and selection criteria across graphs.
var builderCache = new LockFileBuilderCache();
// Add the targets
foreach (var targetGraph in targetGraphs
.OrderBy(graph => graph.Framework.ToString(), StringComparer.Ordinal)
.ThenBy(graph => graph.RuntimeIdentifier, StringComparer.Ordinal))
{
var target = new LockFileTarget
{
TargetFramework = targetGraph.Framework,
RuntimeIdentifier = targetGraph.RuntimeIdentifier
};
var flattenedFlags = IncludeFlagUtils.FlattenDependencyTypes(_includeFlagGraphs, project, targetGraph);
// Check if warnings should be displayed for the current framework.
var tfi = project.GetTargetFramework(targetGraph.Framework);
bool warnForImportsOnGraph = tfi.Warn &&
(target.TargetFramework is FallbackFramework ||
target.TargetFramework is AssetTargetFallbackFramework);
foreach (var graphItem in targetGraph.Flattened.OrderBy(x => x.Key))
{
var library = graphItem.Key;
// include flags
LibraryIncludeFlags includeFlags;
if (!flattenedFlags.TryGetValue(library.Name, out includeFlags))
{
includeFlags = ~LibraryIncludeFlags.ContentFiles;
}
if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject)
{
if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase))
{
// Do not include the project itself as a library.
continue;
}
var projectLib = LockFileUtils.CreateLockFileTargetProject(
graphItem,
library,
includeFlags,
targetGraph,
rootProjectStyle);
target.Libraries.Add(projectLib);
continue;
}
else if (library.Type == LibraryType.Package)
{
var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version);
if (packageInfo == null)
{
continue;
}
var package = packageInfo.Package;
var targetLibrary = LockFileUtils.CreateLockFileTargetLibrary(
libraries[Tuple.Create(library.Name, library.Version)],
package,
targetGraph,
dependencyType: includeFlags,
targetFrameworkOverride: null,
dependencies: graphItem.Data.Dependencies,
cache: builderCache);
target.Libraries.Add(targetLibrary);
// Log warnings if the target library used the fallback framework
if (warnForImportsOnGraph && !librariesWithWarnings.Contains(library))
{
var nonFallbackFramework = new NuGetFramework(target.TargetFramework);
var targetLibraryWithoutFallback = LockFileUtils.CreateLockFileTargetLibrary(
libraries[Tuple.Create(library.Name, library.Version)],
package,
targetGraph,
targetFrameworkOverride: nonFallbackFramework,
dependencyType: includeFlags,
dependencies: graphItem.Data.Dependencies,
cache: builderCache);
if (!targetLibrary.Equals(targetLibraryWithoutFallback))
{
var libraryName = DiagnosticUtility.FormatIdentity(library);
var message = string.Format(CultureInfo.CurrentCulture,
Strings.Log_ImportsFallbackWarning,
libraryName,
GetFallbackFrameworkString(target.TargetFramework),
nonFallbackFramework);
var logMessage = RestoreLogMessage.CreateWarning(
NuGetLogCode.NU1701,
message,
library.Name,
targetGraph.TargetGraphName);
_logger.Log(logMessage);
// only log the warning once per library
librariesWithWarnings.Add(library);
}
}
}
}
lockFile.Targets.Add(target);
}
PopulatePackageFolders(localRepositories.Select(repo => repo.RepositoryRoot).Distinct(), lockFile);
AddCentralTransitiveDependencyGroupsForPackageReference(project, lockFile, targetGraphs);
// Add the original package spec to the lock file.
lockFile.PackageSpec = project;
return(lockFile);
}
public ProjectContext Build()
{
ProjectDirectory = Project?.ProjectDirectory ?? ProjectDirectory;
if (GlobalSettings == null)
{
RootDirectory = ProjectRootResolver.ResolveRootDirectory(ProjectDirectory);
GlobalSettings globalSettings;
if (GlobalSettings.TryGetGlobalSettings(RootDirectory, out globalSettings))
{
GlobalSettings = globalSettings;
}
}
RootDirectory = GlobalSettings?.DirectoryPath ?? RootDirectory;
PackagesDirectory = PackagesDirectory ?? PackageDependencyProvider.ResolvePackagesPath(RootDirectory, GlobalSettings);
ReferenceAssembliesPath = ReferenceAssembliesPath ?? GetDefaultReferenceAssembliesPath();
LockFileLookup lockFileLookup = null;
EnsureProjectLoaded();
LockFile = LockFile ?? LockFileResolver(ProjectDirectory);
var validLockFile = true;
string lockFileValidationMessage = null;
if (LockFile != null)
{
validLockFile = LockFile.IsValidForProject(Project, out lockFileValidationMessage);
lockFileLookup = new LockFileLookup(LockFile);
}
var libraries = new Dictionary <LibraryKey, LibraryDescription>();
var projectResolver = new ProjectDependencyProvider(Settings);
var mainProject = projectResolver.GetDescription(TargetFramework, Project);
// Add the main project
libraries.Add(new LibraryKey(mainProject.Identity.Name), mainProject);
LockFileTarget target = null;
if (lockFileLookup != null)
{
target = SelectTarget(LockFile);
if (target != null)
{
var packageResolver = new PackageDependencyProvider(PackagesDirectory);
ScanLibraries(target, lockFileLookup, libraries, packageResolver, projectResolver);
}
}
var frameworkReferenceResolver = new FrameworkReferenceResolver(ReferenceAssembliesPath);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver);
bool requiresFrameworkAssemblies;
// Resolve the dependencies
ResolveDependencies(libraries, referenceAssemblyDependencyResolver, out requiresFrameworkAssemblies);
var diagnostics = new List <DiagnosticMessage>();
// REVIEW: Should this be in NuGet (possibly stored in the lock file?)
if (LockFile == null)
{
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.NU1009,
$"The expected lock file doesn't exist. Please run \"dotnet restore\" to generate a new lock file.",
Path.Combine(Project.ProjectDirectory, LockFile.FileName),
DiagnosticMessageSeverity.Error));
}
if (!validLockFile)
{
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.NU1006,
$"{lockFileValidationMessage}. Please run \"dotnet restore\" to generate a new lock file.",
Path.Combine(Project.ProjectDirectory, LockFile.FileName),
DiagnosticMessageSeverity.Warning));
}
if (requiresFrameworkAssemblies)
{
var frameworkInfo = Project.GetTargetFramework(TargetFramework);
if (string.IsNullOrEmpty(ReferenceAssembliesPath))
{
// If there was an attempt to use reference assemblies but they were not installed
// report an error
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.DOTNET1012,
$"The reference assemblies directory was not specified. You can set the location using the DOTNET_REFERENCE_ASSEMBLIES_PATH environment variable.",
filePath: Project.ProjectFilePath,
severity: DiagnosticMessageSeverity.Error,
startLine: frameworkInfo.Line,
startColumn: frameworkInfo.Column
));
}
else if (!frameworkReferenceResolver.IsInstalled(TargetFramework))
{
// If there was an attempt to use reference assemblies but they were not installed
// report an error
diagnostics.Add(new DiagnosticMessage(
ErrorCodes.DOTNET1011,
$"Framework not installed: {TargetFramework.DotNetFrameworkName} in {ReferenceAssembliesPath}",
filePath: Project.ProjectFilePath,
severity: DiagnosticMessageSeverity.Error,
startLine: frameworkInfo.Line,
startColumn: frameworkInfo.Column
));
}
}
// Create a library manager
var libraryManager = new LibraryManager(libraries.Values.ToList(), diagnostics, Project.ProjectFilePath);
return(new ProjectContext(
GlobalSettings,
mainProject,
TargetFramework,
target?.RuntimeIdentifier,
PackagesDirectory,
libraryManager));
}
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved)
{
var net45Target = new LockFileTarget
{
TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"),
Libraries = new List <LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List <LockFileItem> {
Path.Combine("ref", "net45", "_._")
},
RuntimeAssemblies = new List <LockFileItem> {
Path.Combine("lib", "net45", "_._")
}
}
}
};
var dnx451Target = new LockFileTarget
{
TargetFramework = new FrameworkName("DNX,Version=v4.5.1"),
Libraries = new List <LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List <LockFileItem> {
Path.Combine("lib", "net451", "Net451LibPackage.dll")
},
RuntimeAssemblies = new List <LockFileItem> {
Path.Combine("lib", "net451", "Net451LibPackage.dll")
}
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List <LockFileItem> {
Path.Combine("ref", "net451", "Net451LibPackage.dll")
}
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0")
}
}
};
var metaPackageLibrary = new LockFilePackageLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
};
var net451LibPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List <string>
{
Path.Combine("lib", "net451", "Net451LibPackage.dll"),
Path.Combine("lib", "net451", "Net451LibPackage.xml")
}
};
var net451RefPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List <string>
{
Path.Combine("ref", "net451", "Net451LibPackage.dll")
}
};
var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List <string>
{
Path.Combine("lib", "net45", "_._"),
Path.Combine("ref", "net45", "_._"),
}
};
var lockFile = new LockFile()
{
Targets = new List <LockFileTarget> {
net45Target, dnx451Target
},
PackageLibraries = new List <LockFilePackageLibrary>
{
metaPackageLibrary,
net451LibPackageLibrary,
net451RefPackageLibrary,
assemblyPlaceholderPackageLibrary
}
};
var resolver = new PackageDependencyProvider("/path/to/packages");
var lockFileLookup = new LockFileLookup(lockFile);
var targetFramework = new FrameworkName(framework);
var libToLookup = lockFile.Targets.First(t => t.TargetFramework == targetFramework)
.Libraries
.First(l => l.Name == packageName);
var description = resolver.GetDescription(lockFileLookup.GetPackage(libToLookup.Name, libToLookup.Version), libToLookup);
Assert.Equal(resolved, description.Compatible);
Assert.NotNull(description);
}
private static void ReportDependency(List <Dependency> dependencies, LockFileTargetLibrary projectLibrary, LockFileTarget lockFileTargetFramework, bool AutoReferenced, List <string> packageCollection)
{
Dependency targetDependency = new Dependency();
dependencies.Add(targetDependency);
targetDependency.name = projectLibrary.Name;
targetDependency.key = $"netcore:{projectLibrary.Name}";
targetDependency.versions.Add(projectLibrary.Version.ToNormalizedString());
//targetDependency.checksum = "";
//targetDependency.homepageUrl = "";
//targetDependency.repoUrl = "";
//targetDependency.description = projectLibrary.Version.ToFullString();
//targetDependency.licences.Add(new licence() { name = projectLibrary.Version.ToFullString(), url = "" });
if (!AutoReferenced)
{
packageCollection.Add(projectLibrary.Name);
foreach (var childDependency in projectLibrary.Dependencies)
{
var childLibrary = lockFileTargetFramework.Libraries.FirstOrDefault(library => library.Name == childDependency.Id);
bool SystemReferenced = MetaPackagesSkipper.MetaPackages.Any(x => x == childLibrary.Name) || packageCollection.Any(x => x == childLibrary.Name);
ReportDependency(targetDependency.dependencies, childLibrary, lockFileTargetFramework, SystemReferenced, packageCollection);
}
}
}
private void AddDependencies(TargetFramework targetFramework, LockFileTargetLibrary parentLibrary, LockFileTarget target, int level, int transitiveDepth)
{
if (parentLibrary?.Dependencies != null)
{
foreach (var packageDependency in parentLibrary.Dependencies)
{
var childLibrary = target.Libraries.FirstOrDefault(library => library.Name == packageDependency.Id);
// Only add library and process child dependencies if we have not come across this dependency before
if (!targetFramework.Dependencies.Any(dependency => dependency.Name == packageDependency.Id))
{
var childDependency = new Dependency(packageDependency.Id, packageDependency.VersionRange, childLibrary?.Version, false, true, false);
targetFramework.Dependencies.Add(childDependency);
// Process the dependency for this project depency
if (level < transitiveDepth)
{
AddDependencies(targetFramework, childLibrary, target, level + 1, transitiveDepth);
}
}
}
}
}
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved)
{
var net45Target = new LockFileTarget
{
TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"),
Libraries = new List<LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net45", "_._") },
RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net45", "_._") }
}
}
};
var dnx451Target = new LockFileTarget
{
TargetFramework = new FrameworkName("DNX,Version=v4.5.1"),
Libraries = new List<LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") },
RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") }
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0")
}
}
};
var metaPackageLibrary = new LockFilePackageLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
};
var net451LibPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("lib", "net451", "Net451LibPackage.dll"),
Path.Combine("lib", "net451", "Net451LibPackage.xml")
}
};
var net451RefPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("ref", "net451", "Net451LibPackage.dll")
}
};
var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("lib", "net45", "_._"),
Path.Combine("ref", "net45", "_._"),
}
};
var lockFile = new LockFile()
{
Targets = new List<LockFileTarget> { net45Target, dnx451Target },
PackageLibraries = new List<LockFilePackageLibrary>
{
metaPackageLibrary,
net451LibPackageLibrary,
net451RefPackageLibrary,
assemblyPlaceholderPackageLibrary
}
};
var resolver = new PackageDependencyProvider("/path/to/packages");
var lockFileLookup = new LockFileLookup(lockFile);
var targetFramework = new FrameworkName(framework);
var libToLookup = lockFile.Targets.First(t => t.TargetFramework == targetFramework)
.Libraries
.First(l => l.Name == packageName);
var description = resolver.GetDescription(lockFileLookup.GetPackage(libToLookup.Name, libToLookup.Version), libToLookup);
Assert.Equal(resolved, description.Compatible);
Assert.NotNull(description);
}
private static Dependency ReportDependency(LockFileTargetLibrary projectLibrary, LockFileTarget lockFileTargetFramework, int indentLevel, Dependency dependency = null)
{
if (projectLibrary == null)
return null;
if (indentLevel == 1)
dependency = new Dependency(projectLibrary.Name, projectLibrary.Version.OriginalVersion);
// stringBuilder.Append(new string(' ', indentLevel * 2));
// stringBuilder.AppendLine($"{projectLibrary.Name}, v{projectLibrary.Version}");
foreach (var childDependency in projectLibrary.Dependencies)
{
var childLibrary = lockFileTargetFramework.Libraries.FirstOrDefault(library => library.Name == childDependency.Id);
dependency.Children.Add(new Dependency(childDependency.Id, childDependency.VersionRange.MinVersion.OriginalVersion) { Parent = dependency.Name });
ReportDependency(childLibrary, lockFileTargetFramework, indentLevel + 1, dependency);
}
return dependency;
}
private void AddDependencies(Project.Dependency parentDependency, LockFileTargetLibrary parentLibrary, LockFileTarget target, int level, int transitiveDepth)
{
if (parentLibrary?.Dependencies != null)
{
foreach (var packageDependency in parentLibrary.Dependencies)
{
var childLibrary = target.Libraries.FirstOrDefault(library => library.Name == packageDependency.Id);
var childDependency = new Project.Dependency
{
Name = packageDependency.Id,
VersionRange = packageDependency.VersionRange,
ResolvedVersion = childLibrary?.Version
};
parentDependency.Dependencies.Add(childDependency);
// Process the dependency for this project depency
if (level < transitiveDepth)
{
AddDependencies(childDependency, childLibrary, target, level + 1, transitiveDepth);
}
}
}
}
static public IEnumerable <string> GetTopLevelDependencies(LockFile lockFile, LockFileTarget lockFileTarget)
{
Dictionary <string, LockFileTargetLibrary> libraryLookup =
lockFileTarget.Libraries.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);
return(lockFile
.ProjectFileDependencyGroups
.Where(dg => dg.FrameworkName == string.Empty ||
dg.FrameworkName == lockFileTarget.TargetFramework.DotNetFrameworkName)
.SelectMany(g => g.Dependencies)
.Select(projectFileDependency =>
{
int separatorIndex = projectFileDependency.IndexOf(' ');
string libraryName = separatorIndex > 0 ?
projectFileDependency.Substring(0, separatorIndex) :
projectFileDependency;
if (!string.IsNullOrEmpty(libraryName) && libraryLookup.ContainsKey(libraryName))
{
return libraryName;
}
return null;
})
.Where(libraryName => libraryName != null)
.ToArray());
}
public LockFile CreateLockFile(
LockFile previousLockFile,
PackageSpec project,
IEnumerable <RestoreTargetGraph> targetGraphs,
IReadOnlyList <NuGetv3LocalRepository> localRepositories,
RemoteWalkContext context)
{
var lockFile = new LockFile();
lockFile.Version = _lockFileVersion;
var previousLibraries = previousLockFile?.Libraries.ToDictionary(l => Tuple.Create(l.Name, l.Version));
if (project.RestoreMetadata?.ProjectStyle == ProjectStyle.PackageReference)
{
AddProjectFileDependenciesForNETCore(project, lockFile, targetGraphs);
}
else
{
AddProjectFileDependenciesForSpec(project, lockFile);
}
// Record all libraries used
foreach (var item in targetGraphs.SelectMany(g => g.Flattened).Distinct()
.OrderBy(x => x.Data.Match.Library))
{
var library = item.Data.Match.Library;
if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase))
{
// Do not include the project itself as a library.
continue;
}
if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject)
{
// Project
LocalMatch localMatch = (LocalMatch)item.Data.Match;
var projectLib = new LockFileLibrary()
{
Name = library.Name,
Version = library.Version,
Type = LibraryType.Project,
};
// Set the relative path if a path exists
// For projects without project.json this will be empty
if (!string.IsNullOrEmpty(localMatch.LocalLibrary.Path))
{
projectLib.Path = PathUtility.GetRelativePath(
project.FilePath,
localMatch.LocalLibrary.Path,
'/');
}
// The msbuild project path if it exists
object msbuildPath;
if (localMatch.LocalLibrary.Items.TryGetValue(KnownLibraryProperties.MSBuildProjectPath, out msbuildPath))
{
var msbuildRelativePath = PathUtility.GetRelativePath(
project.FilePath,
(string)msbuildPath,
'/');
projectLib.MSBuildProject = msbuildRelativePath;
}
lockFile.Libraries.Add(projectLib);
}
else if (library.Type == LibraryType.Package)
{
// Packages
var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version);
if (packageInfo == null)
{
continue;
}
var package = packageInfo.Package;
var resolver = packageInfo.Repository.PathResolver;
LockFileLibrary previousLibrary = null;
if (previousLibraries?.TryGetValue(Tuple.Create(package.Id, package.Version), out previousLibrary) == true)
{
// We mutate this previous library so we must take a clone of it. This is
// important because later, when deciding whether the lock file has changed,
// we compare the new lock file to the previous (in-memory) lock file.
previousLibrary = previousLibrary.Clone();
}
var sha512 = File.ReadAllText(resolver.GetHashPath(package.Id, package.Version));
var path = PathUtility.GetPathWithForwardSlashes(
resolver.GetPackageDirectory(package.Id, package.Version));
var lockFileLib = previousLibrary;
// If we have the same library in the lock file already, use that.
if (previousLibrary == null ||
previousLibrary.Sha512 != sha512 ||
previousLibrary.Path != path)
{
lockFileLib = CreateLockFileLibrary(
package,
sha512,
path);
}
else if (Path.DirectorySeparatorChar != LockFile.DirectorySeparatorChar)
{
// Fix slashes for content model patterns
lockFileLib.Files = lockFileLib.Files
.Select(p => p.Replace(Path.DirectorySeparatorChar, LockFile.DirectorySeparatorChar))
.ToList();
}
lockFile.Libraries.Add(lockFileLib);
var packageIdentity = new PackageIdentity(lockFileLib.Name, lockFileLib.Version);
context.PackageFileCache.TryAdd(packageIdentity, lockFileLib.Files);
}
}
var libraries = lockFile.Libraries.ToDictionary(lib => Tuple.Create(lib.Name, lib.Version));
var warnForImports = project.TargetFrameworks.Any(framework => framework.Warn);
var librariesWithWarnings = new HashSet <LibraryIdentity>();
var rootProjectStyle = project.RestoreMetadata?.ProjectStyle ?? ProjectStyle.Unknown;
// Add the targets
foreach (var targetGraph in targetGraphs
.OrderBy(graph => graph.Framework.ToString(), StringComparer.Ordinal)
.ThenBy(graph => graph.RuntimeIdentifier, StringComparer.Ordinal))
{
var target = new LockFileTarget();
target.TargetFramework = targetGraph.Framework;
target.RuntimeIdentifier = targetGraph.RuntimeIdentifier;
var flattenedFlags = IncludeFlagUtils.FlattenDependencyTypes(_includeFlagGraphs, project, targetGraph);
var fallbackFramework = target.TargetFramework as FallbackFramework;
var warnForImportsOnGraph = warnForImports && fallbackFramework != null;
foreach (var graphItem in targetGraph.Flattened.OrderBy(x => x.Key))
{
var library = graphItem.Key;
// include flags
LibraryIncludeFlags includeFlags;
if (!flattenedFlags.TryGetValue(library.Name, out includeFlags))
{
includeFlags = ~LibraryIncludeFlags.ContentFiles;
}
if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject)
{
if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase))
{
// Do not include the project itself as a library.
continue;
}
var projectLib = LockFileUtils.CreateLockFileTargetProject(
graphItem,
library,
includeFlags,
targetGraph,
rootProjectStyle);
target.Libraries.Add(projectLib);
continue;
}
else if (library.Type == LibraryType.Package)
{
var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version);
if (packageInfo == null)
{
continue;
}
var package = packageInfo.Package;
var targetLibrary = LockFileUtils.CreateLockFileTargetLibrary(
libraries[Tuple.Create(library.Name, library.Version)],
package,
targetGraph,
dependencyType: includeFlags,
targetFrameworkOverride: null,
dependencies: graphItem.Data.Dependencies);
target.Libraries.Add(targetLibrary);
// Log warnings if the target library used the fallback framework
if (warnForImportsOnGraph && !librariesWithWarnings.Contains(library))
{
var nonFallbackFramework = new NuGetFramework(fallbackFramework);
var targetLibraryWithoutFallback = LockFileUtils.CreateLockFileTargetLibrary(
libraries[Tuple.Create(library.Name, library.Version)],
package,
targetGraph,
targetFrameworkOverride: nonFallbackFramework,
dependencyType: includeFlags,
dependencies: graphItem.Data.Dependencies);
if (!targetLibrary.Equals(targetLibraryWithoutFallback))
{
var libraryName = $"{library.Name} {library.Version}";
_logger.LogWarning(string.Format(CultureInfo.CurrentCulture, Strings.Log_ImportsFallbackWarning, libraryName, String.Join(", ", fallbackFramework.Fallback), nonFallbackFramework));
// only log the warning once per library
librariesWithWarnings.Add(library);
}
}
}
}
lockFile.Targets.Add(target);
}
PopulatePackageFolders(localRepositories.Select(repo => repo.RepositoryRoot).Distinct(), lockFile);
// Add the original package spec to the lock file.
lockFile.PackageSpec = project;
return(lockFile);
}
public void LockFileFormat_WritesLockFileWithTools()
{
// Arrange
string lockFileContent = @"{
""version"": 2,
""targets"": {},
""libraries"": {},
""projectFileDependencyGroups"": {},
""tools"": {
"".NETPlatform,Version=v5.0"": {
""System.Runtime/4.0.20-beta-22927"": {
""type"": ""package"",
""dependencies"": {
""Frob"": ""4.0.20""
},
""compile"": {
""ref/dotnet/System.Runtime.dll"": {}
}
}
}
},
""projectFileToolGroups"": {
"""": [
""System.Runtime [4.0.10-beta-*, )""
],
"".NETPlatform,Version=v5.0"": []
}
}";
var lockFile = new LockFile();
lockFile.Version = 2;
var target = new LockFileTarget()
{
TargetFramework = FrameworkConstants.CommonFrameworks.DotNet
};
var targetLib = new LockFileTargetLibrary()
{
Name = "System.Runtime",
Version = NuGetVersion.Parse("4.0.20-beta-22927"),
Type = LibraryType.Package
};
targetLib.Dependencies.Add(new NuGet.Packaging.Core.PackageDependency("Frob",
new VersionRange(NuGetVersion.Parse("4.0.20"))));
targetLib.CompileTimeAssemblies.Add(new LockFileItem("ref/dotnet/System.Runtime.dll"));
target.Libraries.Add(targetLib);
lockFile.Tools.Add(target);
lockFile.ProjectFileToolGroups.Add(
new ProjectFileDependencyGroup("", new string[] { "System.Runtime [4.0.10-beta-*, )" }));
lockFile.ProjectFileToolGroups.Add(
new ProjectFileDependencyGroup(FrameworkConstants.CommonFrameworks.DotNet.DotNetFrameworkName, new string[0]));
// Act
var lockFileFormat = new LockFileFormat();
var output = JObject.Parse(lockFileFormat.Render(lockFile));
var expected = JObject.Parse(lockFileContent);
// Assert
Assert.Equal(expected.ToString(), output.ToString());
}
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved)
{
var repo = new PackageRepository("path/to/packages");
var resolver = new NuGetDependencyResolver(repo);
var net45Target = new LockFileTarget
{
TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"),
Libraries = new List<LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net45", "_._") },
RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net45", "_._") }
}
}
};
var dnx451Target = new LockFileTarget
{
TargetFramework = new FrameworkName("DNX,Version=v4.5.1"),
Libraries = new List<LockFileTargetLibrary>
{
new LockFileTargetLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
},
new LockFileTargetLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") },
RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }
},
new LockFileTargetLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") }
},
new LockFileTargetLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0")
}
}
};
var metaPackageLibrary = new LockFilePackageLibrary
{
Name = "MetaPackage",
Version = SemanticVersion.Parse("1.0.0")
};
var net451LibPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451LibPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("lib", "net451", "Net451LibPackage.dll"),
Path.Combine("lib", "net451", "Net451LibPackage.xml")
}
};
var net451RefPackageLibrary = new LockFilePackageLibrary
{
Name = "Net451RefPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("ref", "net451", "Net451LibPackage.dll")
}
};
var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary
{
Name = "AssemblyPlaceholderPackage",
Version = SemanticVersion.Parse("1.0.0"),
Files = new List<string>
{
Path.Combine("lib", "net45", "_._"),
Path.Combine("ref", "net45", "_._"),
}
};
var lockFile = new LockFile()
{
Targets = new List<LockFileTarget> { net45Target, dnx451Target },
PackageLibraries = new List<LockFilePackageLibrary>
{
metaPackageLibrary,
net451LibPackageLibrary,
net451RefPackageLibrary,
assemblyPlaceholderPackageLibrary
}
};
resolver.ApplyLockFile(lockFile);
var libToLookup = new LibraryRange(packageName, frameworkReference: false);
Assert.Equal(resolved, resolver.GetDescription(libToLookup, new FrameworkName(framework)).Resolved);
}
