public RestoreRequest(PackageSpec project, IEnumerable<PackageSource> sources, string packagesDirectory)
{
Project = project;
Sources = sources.ToList().AsReadOnly();
PackagesDirectory = packagesDirectory;
ExternalProjects = new List<ExternalProjectReference>();
WriteMSBuildFiles = true;
}
public PackageSpecResolver(PackageSpec packageSpec)
{
// Preload the cache with the package spec provided
_projects[packageSpec.Name] = new PackageSpecInformation()
{
Name = packageSpec.Name,
FullPath = packageSpec.FilePath,
PackageSpec = packageSpec
};
var rootPath = ResolveRootDirectory(packageSpec.FilePath);
Initialize(packageSpec.FilePath, rootPath);
}
public bool TryResolvePackageSpec(string name, out PackageSpec project)
{
project = null;
PackageSpecInformation projectInfo;
if (_projects.TryGetValue(name, out projectInfo))
{
project = projectInfo.PackageSpec;
return project != null;
}
return false;
}
public bool IsValidForPackageSpec(PackageSpec spec)
{
if (Version != LockFileFormat.Version)
{
return false;
}
var actualTargetFrameworks = spec.TargetFrameworks;
// The lock file should contain dependencies for each framework plus dependencies shared by all frameworks
if (ProjectFileDependencyGroups.Count != actualTargetFrameworks.Count() + 1)
{
return false;
}
foreach (var group in ProjectFileDependencyGroups)
{
IOrderedEnumerable<string> actualDependencies;
var expectedDependencies = group.Dependencies.OrderBy(x => x);
// If the framework name is empty, the associated dependencies are shared by all frameworks
if (string.IsNullOrEmpty(group.FrameworkName))
{
actualDependencies = spec.Dependencies.Select(x => RuntimeStyleLibraryRangeToString(x.LibraryRange)).OrderBy(x => x);
}
else
{
var framework = actualTargetFrameworks
.FirstOrDefault(f =>
string.Equals(f.FrameworkName.ToString(), group.FrameworkName, StringComparison.OrdinalIgnoreCase));
if (framework == null)
{
return false;
}
actualDependencies = framework.Dependencies.Select(d => RuntimeStyleLibraryRangeToString(d.LibraryRange)).OrderBy(x => x);
}
if (!actualDependencies.SequenceEqual(expectedDependencies))
{
return false;
}
}
return true;
}
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 Project(PackageSpec packageSpec)
{
BaseDirectory = Path.GetDirectoryName(packageSpec.FilePath);
Metadata = packageSpec;
Files = new ProjectFilesCollection(packageSpec.Properties, packageSpec.BaseDirectory, packageSpec.FilePath);
// Load additional metadata from the project json
EntryPoint = Metadata.Properties.GetValue<string>("entryPoint");
var commands = Metadata.Properties["commands"] as JObject;
if (commands != null)
{
foreach (var command in commands)
{
Commands[command.Key] = command.Value.Value<string>();
}
}
}
public static PackageSpec GetPackageSpec(Stream stream, string name, string packageSpecPath)
{
// Load the raw JSON into the package spec object
var reader = new JsonTextReader(new StreamReader(stream));
JObject rawPackageSpec;
try
{
rawPackageSpec = JObject.Load(reader);
}
catch (JsonReaderException ex)
{
throw FileFormatException.Create(ex, packageSpecPath);
}
var packageSpec = new PackageSpec(rawPackageSpec);
// Parse properties we know about
var version = rawPackageSpec["version"];
var authors = rawPackageSpec["authors"];
var owners = rawPackageSpec["owners"];
var tags = rawPackageSpec["tags"];
var contentFiles = rawPackageSpec["contentFiles"];
packageSpec.Name = name;
packageSpec.FilePath = Path.GetFullPath(packageSpecPath);
if (version == null)
{
packageSpec.Version = new NuGetVersion("1.0.0");
packageSpec.IsDefaultVersion = true;
}
else
{
try
{
packageSpec.Version = SpecifySnapshot(version.Value <string>(), snapshotValue: string.Empty);
}
catch (Exception ex)
{
var lineInfo = (IJsonLineInfo)version;
throw FileFormatException.Create(ex, version, packageSpec.FilePath);
}
}
var packInclude = rawPackageSpec["packInclude"] as JObject;
if (packInclude != null)
{
foreach (var include in packInclude)
{
packageSpec.PackInclude.Add(new KeyValuePair <string, string>(include.Key, include.Value.ToString()));
}
}
packageSpec.Title = rawPackageSpec.GetValue <string>("title");
packageSpec.Description = rawPackageSpec.GetValue <string>("description");
packageSpec.Authors = authors == null ? new string[] { } : authors.ValueAsArray <string>();
packageSpec.Owners = owners == null ? new string[] { } : owners.ValueAsArray <string>();
packageSpec.ContentFiles = contentFiles == null ? new string[] { } : contentFiles.ValueAsArray <string>();
packageSpec.Dependencies = new List <LibraryDependency>();
packageSpec.ProjectUrl = rawPackageSpec.GetValue <string>("projectUrl");
packageSpec.IconUrl = rawPackageSpec.GetValue <string>("iconUrl");
packageSpec.LicenseUrl = rawPackageSpec.GetValue <string>("licenseUrl");
packageSpec.Copyright = rawPackageSpec.GetValue <string>("copyright");
packageSpec.Language = rawPackageSpec.GetValue <string>("language");
packageSpec.Summary = rawPackageSpec.GetValue <string>("summary");
packageSpec.ReleaseNotes = rawPackageSpec.GetValue <string>("releaseNotes");
var requireLicenseAcceptance = rawPackageSpec["requireLicenseAcceptance"];
if (requireLicenseAcceptance != null)
{
try
{
packageSpec.RequireLicenseAcceptance = rawPackageSpec.GetValue <bool?>("requireLicenseAcceptance") ?? false;
}
catch (Exception ex)
{
throw FileFormatException.Create(ex, requireLicenseAcceptance, packageSpecPath);
}
}
packageSpec.Tags = tags == null ? new string[] { } : tags.ValueAsArray <string>();
var scripts = rawPackageSpec["scripts"] as JObject;
if (scripts != null)
{
foreach (var script in scripts)
{
var value = script.Value;
if (value.Type == JTokenType.String)
{
packageSpec.Scripts[script.Key] = new string[] { value.Value <string>() };
}
else if (value.Type == JTokenType.Array)
{
packageSpec.Scripts[script.Key] = script.Value.ValueAsArray <string>();
}
else
{
throw FileFormatException.Create(
string.Format("The value of a script in '{0}' can only be a string or an array of strings", PackageSpec.PackageSpecFileName),
value,
packageSpec.FilePath);
}
}
}
BuildTargetFrameworks(packageSpec, rawPackageSpec);
PopulateDependencies(
packageSpec.FilePath,
packageSpec.Dependencies,
rawPackageSpec,
"dependencies",
isGacOrFrameworkReference: false);
packageSpec.Tools = ReadTools(packageSpec, rawPackageSpec).ToList();
packageSpec.PackOptions = GetPackOptions(packageSpec, rawPackageSpec);
// Read the runtime graph
packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec);
return(packageSpec);
}
public static PackageSpec GetPackageSpec(Stream stream, string name, string packageSpecPath)
{
// Load the raw JSON into the package spec object
var reader = new JsonTextReader(new StreamReader(stream));
var rawPackageSpec = JObject.Load(reader);
var packageSpec = new PackageSpec(rawPackageSpec);
// Parse properties we know about
var version = rawPackageSpec["version"];
var authors = rawPackageSpec["authors"];
var owners = rawPackageSpec["owners"];
var tags = rawPackageSpec["tags"];
var buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION");
packageSpec.Name = name;
packageSpec.FilePath = Path.GetFullPath(packageSpecPath);
if (version == null)
{
packageSpec.Version = new NuGetVersion("1.0.0");
}
else
{
try
{
packageSpec.Version = SpecifySnapshot(version.Value<string>(), buildVersion);
}
catch (Exception ex)
{
var lineInfo = (IJsonLineInfo)version;
throw PackageSpecFormatException.Create(ex, version, packageSpec.FilePath);
}
}
packageSpec.Description = rawPackageSpec.GetValue<string>("description");
packageSpec.Authors = authors == null ? new string[] { } : authors.ValueAsArray<string>();
packageSpec.Owners = owners == null ? new string[] { } : owners.ValueAsArray<string>();
packageSpec.Dependencies = new List<LibraryDependency>();
packageSpec.ProjectUrl = rawPackageSpec.GetValue<string>("projectUrl");
packageSpec.IconUrl = rawPackageSpec.GetValue<string>("iconUrl");
packageSpec.LicenseUrl = rawPackageSpec.GetValue<string>("licenseUrl");
packageSpec.Copyright = rawPackageSpec.GetValue<string>("copyright");
packageSpec.Language = rawPackageSpec.GetValue<string>("language");
packageSpec.RequireLicenseAcceptance = rawPackageSpec.GetValue<bool?>("requireLicenseAcceptance") ?? false;
packageSpec.Tags = tags == null ? new string[] { } : tags.ValueAsArray<string>();
var scripts = rawPackageSpec["scripts"] as JObject;
if (scripts != null)
{
foreach (var script in scripts)
{
var value = script.Value;
if (value.Type == JTokenType.String)
{
packageSpec.Scripts[script.Key] = new string[] { value.Value<string>() };
}
else if (value.Type == JTokenType.Array)
{
packageSpec.Scripts[script.Key] = script.Value.ValueAsArray<string>();
}
else
{
throw PackageSpecFormatException.Create(
string.Format("The value of a script in '{0}' can only be a string or an array of strings", PackageSpec.PackageSpecFileName),
value,
packageSpec.FilePath);
}
}
}
BuildTargetFrameworks(packageSpec, rawPackageSpec);
PopulateDependencies(
packageSpec.FilePath,
packageSpec.Dependencies,
rawPackageSpec,
"dependencies",
isGacOrFrameworkReference: false);
// Read the runtime graph
packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec);
return packageSpec;
}
public bool IsValidForPackageSpec(PackageSpec spec)
{
return(IsValidForPackageSpec(spec, Version));
}
private static bool BuildTargetFrameworkNode(PackageSpec packageSpec, KeyValuePair <string, JToken> targetFramework, string filePath)
{
var frameworkName = GetFramework(targetFramework.Key);
var properties = targetFramework.Value.Value <JObject>();
var assetTargetFallback = GetBoolOrFalse(properties, "assetTargetFallback", filePath);
var importFrameworks = GetImports(properties, packageSpec);
// If a fallback framework exists, update the framework to contain both.
var updatedFramework = frameworkName;
if (importFrameworks.Count != 0)
{
if (assetTargetFallback)
{
updatedFramework = new AssetTargetFallbackFramework(frameworkName, importFrameworks);
}
else
{
updatedFramework = new FallbackFramework(frameworkName, importFrameworks);
}
}
var targetFrameworkInformation = new TargetFrameworkInformation
{
FrameworkName = updatedFramework,
Dependencies = new List <LibraryDependency>(),
Imports = importFrameworks,
Warn = GetWarnSetting(properties),
AssetTargetFallback = assetTargetFallback,
RuntimeIdentifierGraphPath = GetRuntimeIdentifierGraphPath(properties)
};
PopulateDependencies(
packageSpec.FilePath,
targetFrameworkInformation.Dependencies,
properties,
"dependencies",
isGacOrFrameworkReference: false);
PopulateDownloadDependencies(
targetFrameworkInformation.DownloadDependencies,
properties,
packageSpec.FilePath);
var frameworkAssemblies = new List <LibraryDependency>();
PopulateDependencies(
packageSpec.FilePath,
frameworkAssemblies,
properties,
"frameworkAssemblies",
isGacOrFrameworkReference: true);
PopulateFrameworkReferences(
targetFrameworkInformation.FrameworkReferences,
properties,
"frameworkReferences",
packageSpec.FilePath
);
frameworkAssemblies.ForEach(d => targetFrameworkInformation.Dependencies.Add(d));
packageSpec.TargetFrameworks.Add(targetFrameworkInformation);
return(true);
}
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;
}
/// <summary>
/// The lock file will get invalidated if one or more of the below are true
/// 1. The target frameworks list of the current project was updated.
/// 2. The runtime list of the current project waw updated.
/// 3. The packages of the current project were updated.
/// 4. The packages of the dependent projects were updated.
/// 5. The framework list of the dependent projects were updated with frameworks incompatible with the main project framework.
/// 6. If the version of the <paramref name="nuGetLockFile"/> is larger than the current tools <see cref="PackagesLockFileFormat.PackagesLockFileVersion"/>.
/// </summary>
/// <param name="dgSpec">The <see cref="DependencyGraphSpec"/> for the new project defintion.</param>
/// <param name="nuGetLockFile">The current <see cref="PackagesLockFile"/>.</param>
/// <returns>Returns LockFileValidityWithInvalidReasons object with IsValid set to true if the lock file is valid false otherwise.
/// The second return type is a localized message that indicates in further detail the reason for the inconsistency.</returns>
public static LockFileValidationResult IsLockFileValid(DependencyGraphSpec dgSpec, PackagesLockFile nuGetLockFile)
{
if (dgSpec == null)
{
throw new ArgumentNullException(nameof(dgSpec));
}
if (nuGetLockFile == null)
{
throw new ArgumentNullException(nameof(nuGetLockFile));
}
List <string> invalidReasons = new List <string>();
// Current tools know how to read only previous formats including the current
if (PackagesLockFileFormat.PackagesLockFileVersion < nuGetLockFile.Version)
{
invalidReasons.Add(string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_IncompatibleLockFileVersion,
PackagesLockFileFormat.PackagesLockFileVersion
));
return(new LockFileValidationResult(false, invalidReasons));
}
var uniqueName = dgSpec.Restore.First();
var project = dgSpec.GetProjectSpec(uniqueName);
// Validate all the direct dependencies
NuGetFramework[] lockFileFrameworks = nuGetLockFile.Targets
.Where(t => t.TargetFramework != null)
.Select(t => t.TargetFramework)
.Distinct()
.ToArray();
if (project.TargetFrameworks.Count != lockFileFrameworks.Length)
{
invalidReasons.Add(string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_MismatchedTargetFrameworks,
string.Join(",", project.TargetFrameworks.Select(e => e.FrameworkName.GetShortFolderName())),
string.Join(",", lockFileFrameworks.Select(e => e.GetShortFolderName()))
));
}
else
{
// Validate the runtimes for the current project did not change.
var projectRuntimesKeys = project.RuntimeGraph.Runtimes.Select(r => r.Key).Where(k => k != null);
var lockFileRuntimes = nuGetLockFile.Targets.Select(t => t.RuntimeIdentifier).Where(r => r != null).Distinct();
if (!projectRuntimesKeys.OrderedEquals(
lockFileRuntimes,
x => x,
StringComparer.InvariantCultureIgnoreCase,
StringComparer.InvariantCultureIgnoreCase))
{
invalidReasons.Add(string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_RuntimeIdentifiersChanged,
string.Join(";", projectRuntimesKeys.OrderBy(e => e)),
string.Join(";", lockFileRuntimes.OrderBy(e => e))
));
}
foreach (var framework in project.TargetFrameworks)
{
var target = nuGetLockFile.Targets.FirstOrDefault(
t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, framework.FrameworkName));
if (target == null)
{
// a new target found in the dgSpec so invalidate existing lock file.
invalidReasons.Add(string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_NewTargetFramework,
framework.FrameworkName.GetShortFolderName())
);
continue;
}
IEnumerable <LockFileDependency> directDependencies = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.Direct);
(var hasProjectDependencyChanged, var pmessage) = HasDirectPackageDependencyChanged(framework.Dependencies, directDependencies, target.TargetFramework);
if (hasProjectDependencyChanged)
{
// lock file is out of sync
invalidReasons.Add(pmessage);
}
var transitiveDependenciesEnforcedByCentralVersions = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.CentralTransitive).ToList();
var transitiveDependencies = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.Transitive).ToList();
(var hasTransitiveDependencyChanged, var tmessage) = HasProjectTransitiveDependencyChanged(framework.CentralPackageVersions, transitiveDependenciesEnforcedByCentralVersions, transitiveDependencies);
if (hasTransitiveDependencyChanged)
{
// lock file is out of sync
invalidReasons.Add(tmessage);
}
}
// Validate all P2P references
foreach (var restoreMetadataFramework in project.RestoreMetadata.TargetFrameworks)
{
var target = nuGetLockFile.Targets.FirstOrDefault(
t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, restoreMetadataFramework.FrameworkName));
if (target == null)
{
continue;
}
var queue = new Queue <Tuple <string, string> >();
var visitedP2PReference = new HashSet <string>();
foreach (var projectReference in restoreMetadataFramework.ProjectReferences)
{
if (visitedP2PReference.Add(projectReference.ProjectUniqueName))
{
PackageSpec spec = dgSpec.GetProjectSpec(projectReference.ProjectUniqueName);
queue.Enqueue(new Tuple <string, string>(spec.Name, projectReference.ProjectUniqueName));
while (queue.Count > 0)
{
var projectNames = queue.Dequeue();
var p2pUniqueName = projectNames.Item2;
var p2pProjectName = projectNames.Item1;
var projectDependency = target.Dependencies.FirstOrDefault(
dep => dep.Type == PackageDependencyType.Project &&
StringComparer.OrdinalIgnoreCase.Equals(dep.Id, p2pProjectName));
if (projectDependency == null)
{
// new direct project dependency.
// If there are changes in the P2P2P references, they will be caught in HasP2PDependencyChanged.
invalidReasons.Add(string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_ProjectReferenceAdded,
p2pProjectName,
target.TargetFramework.GetShortFolderName()
));
continue;
}
var p2pSpec = dgSpec.GetProjectSpec(p2pUniqueName);
if (p2pSpec != null)
{
TargetFrameworkInformation p2pSpecTargetFrameworkInformation = default;
if (p2pSpec.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig || p2pSpec.RestoreMetadata.ProjectStyle == ProjectStyle.Unknown)
{
// Skip compat check and dependency check for non PR projects.
// Projects that are not PR do not undergo compat checks by NuGet and do not contribute anything transitively.
p2pSpecTargetFrameworkInformation = p2pSpec.TargetFrameworks.FirstOrDefault();
}
else
{
// This does not consider ATF.
p2pSpecTargetFrameworkInformation = NuGetFrameworkUtility.GetNearest(p2pSpec.TargetFrameworks, restoreMetadataFramework.FrameworkName, e => e.FrameworkName);
}
// No compatible framework found
if (p2pSpecTargetFrameworkInformation != null)
{
// We need to compare the main framework only. Ignoring fallbacks.
var p2pSpecProjectRestoreMetadataFrameworkInfo = p2pSpec.RestoreMetadata.TargetFrameworks.FirstOrDefault(
t => NuGetFramework.Comparer.Equals(p2pSpecTargetFrameworkInformation.FrameworkName, t.FrameworkName));
if (p2pSpecProjectRestoreMetadataFrameworkInfo != null)
{
(var hasChanged, var message) = HasP2PDependencyChanged(p2pSpecTargetFrameworkInformation.Dependencies, p2pSpecProjectRestoreMetadataFrameworkInfo.ProjectReferences, projectDependency, dgSpec);
if (hasChanged)
{
// P2P transitive package dependencies have changed
invalidReasons.Add(message);
}
foreach (var reference in p2pSpecProjectRestoreMetadataFrameworkInfo.ProjectReferences)
{
// Do not add private assets for processing.
if (visitedP2PReference.Add(reference.ProjectUniqueName) && reference.PrivateAssets != LibraryIncludeFlags.All)
{
var referenceSpec = dgSpec.GetProjectSpec(reference.ProjectUniqueName);
queue.Enqueue(new Tuple <string, string>(referenceSpec.Name, reference.ProjectUniqueName));
}
}
}
else // This should never happen.
{
throw new Exception(string.Format(CultureInfo.CurrentCulture, Strings.PackagesLockFile_RestoreMetadataMissingTfms));
}
}
else
{
invalidReasons.Add(string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_ProjectReferenceHasNoCompatibleTargetFramework,
p2pProjectName,
restoreMetadataFramework.FrameworkName.GetShortFolderName()
));
}
}
else // This can't happen. When adding the queue, the referenceSpec HAS to be discovered. If the project is otherwise missing, it will be discovered in HasP2PDependencyChanged
{
throw new Exception(string.Format(
CultureInfo.CurrentCulture,
Strings.PackagesLockFile_UnableToLoadPackagespec,
p2pUniqueName));
}
}
}
}
}
}
bool isLockFileValid = invalidReasons.Count == 0;
return(new LockFileValidationResult(isLockFileValid, invalidReasons));
}
public static void AddOrUpdateDependency(PackageSpec spec, PackageIdentity identity)
{
AddOrUpdateDependency(spec, new PackageDependency(identity.Id, new VersionRange(identity.Version)));
}
/// <summary>
/// Writes a PackageSpec to an <c>NuGet.Common.IObjectWriter</c> instance.
/// </summary>
/// <param name="packageSpec">A <c>PackageSpec</c> instance.</param>
/// <param name="writer">An <c>NuGet.Common.IObjectWriter</c> instance.</param>
public static void Write(PackageSpec packageSpec, IObjectWriter writer)
{
Write(packageSpec, writer, hashing: false);
}
/// <summary>
/// Get restore metadata framework. This is based on the project's target frameworks, then an
/// exact match is found under restore metadata.
/// </summary>
public static ProjectRestoreMetadataFrameworkInfo GetRestoreMetadataFramework(this PackageSpec project, NuGetFramework targetFramework)
{
ProjectRestoreMetadataFrameworkInfo frameworkInfo = null;
var projectFrameworkInfo = GetTargetFramework(project, targetFramework);
if (projectFrameworkInfo.FrameworkName != null)
{
frameworkInfo = project.RestoreMetadata?.TargetFrameworks
.FirstOrDefault(f => f.FrameworkName.Equals(projectFrameworkInfo.FrameworkName));
}
return(frameworkInfo ?? new ProjectRestoreMetadataFrameworkInfo());
}
public static void WritePackageSpec(PackageSpec packageSpec, JObject json)
{
SetValue(json, "title", packageSpec.Title);
if (!packageSpec.IsDefaultVersion)
{
SetValue(json, "version", packageSpec.Version?.ToNormalizedString());
}
SetValue(json, "description", packageSpec.Description);
SetArrayValue(json, "authors", packageSpec.Authors);
SetArrayValue(json, "owners", packageSpec.Owners);
SetArrayValue(json, "tags", packageSpec.Tags);
SetValue(json, "projectUrl", packageSpec.ProjectUrl);
SetValue(json, "iconUrl", packageSpec.IconUrl);
SetValue(json, "licenseUrl", packageSpec.LicenseUrl);
SetValue(json, "copyright", packageSpec.Copyright);
SetValue(json, "language", packageSpec.Language);
SetValue(json, "summary", packageSpec.Summary);
SetValue(json, "releaseNotes", packageSpec.ReleaseNotes);
SetValue(json, "requireLicenseAcceptance", packageSpec.RequireLicenseAcceptance.ToString());
SetArrayValue(json, "contentFiles", packageSpec.ContentFiles);
SetDictionaryValue(json, "packInclude", packageSpec.PackInclude);
SetPackOptions(json, packageSpec.PackOptions);
SetDictionaryValues(json, "scripts", packageSpec.Scripts);
if (packageSpec.Dependencies.Any())
{
SetDependencies(json, packageSpec.Dependencies);
}
if (packageSpec.Tools.Any())
{
JObject tools = new JObject();
foreach (var tool in packageSpec.Tools)
{
JObject toolObject = new JObject();
toolObject["version"] = tool.LibraryRange.VersionRange.ToNormalizedString();
if (tool.Imports.Any())
{
SetImports(toolObject, tool.Imports);
}
tools[tool.LibraryRange.Name] = toolObject;
}
SetValue(json, "tools", tools);
}
if (packageSpec.TargetFrameworks.Any())
{
JObject frameworks = new JObject();
foreach (var framework in packageSpec.TargetFrameworks)
{
JObject frameworkObject = new JObject();
SetDependencies(frameworkObject, framework.Dependencies);
SetImports(frameworkObject, framework.Imports);
frameworks[framework.FrameworkName.GetShortFolderName()] = frameworkObject;
}
SetValue(json, "frameworks", frameworks);
}
JsonRuntimeFormat.WriteRuntimeGraph(json, packageSpec.RuntimeGraph);
}
private static void SetMSBuildMetadata(IObjectWriter writer, PackageSpec packageSpec)
{
var msbuildMetadata = packageSpec.RestoreMetadata;
if (msbuildMetadata == null)
{
return;
}
if (msbuildMetadata.ProjectUniqueName == null && msbuildMetadata.ProjectName == null &&
msbuildMetadata.ProjectPath == null && msbuildMetadata.ProjectJsonPath == null &&
msbuildMetadata.PackagesPath == null && msbuildMetadata.OutputPath == null)
{
return;
}
writer.WriteObjectStart(JsonPackageSpecReader.RestoreOptions);
SetValue(writer, "projectUniqueName", msbuildMetadata.ProjectUniqueName);
SetValue(writer, "projectName", msbuildMetadata.ProjectName);
SetValue(writer, "projectPath", msbuildMetadata.ProjectPath);
SetValue(writer, "projectJsonPath", msbuildMetadata.ProjectJsonPath);
SetValue(writer, "packagesPath", msbuildMetadata.PackagesPath);
SetValue(writer, "outputPath", msbuildMetadata.OutputPath);
if (msbuildMetadata.ProjectStyle != ProjectStyle.Unknown)
{
SetValue(writer, "projectStyle", msbuildMetadata.ProjectStyle.ToString());
}
SetValueIfTrue(writer, "crossTargeting", msbuildMetadata.CrossTargeting);
SetValueIfTrue(
writer,
"legacyPackagesDirectory",
msbuildMetadata.LegacyPackagesDirectory);
SetValueIfTrue(
writer,
"validateRuntimeAssets",
msbuildMetadata.ValidateRuntimeAssets);
SetValueIfTrue(
writer,
"skipContentFileWrite",
msbuildMetadata.SkipContentFileWrite);
SetArrayValue(writer, "fallbackFolders", msbuildMetadata.FallbackFolders);
SetArrayValue(writer, "originalTargetFrameworks", msbuildMetadata.OriginalTargetFrameworks);
if (msbuildMetadata.Sources?.Count > 0)
{
writer.WriteObjectStart("sources");
foreach (var source in msbuildMetadata.Sources)
{
// "source": {}
writer.WriteObjectStart(source.Source);
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
if (msbuildMetadata.Files?.Count > 0)
{
writer.WriteObjectStart("files");
foreach (var file in msbuildMetadata.Files)
{
SetValue(writer, file.PackagePath, file.AbsolutePath);
}
writer.WriteObjectEnd();
}
if (msbuildMetadata.TargetFrameworks?.Count > 0)
{
writer.WriteObjectStart("frameworks");
var frameworkNames = new HashSet <string>();
foreach (var framework in msbuildMetadata.TargetFrameworks)
{
var frameworkName = framework.FrameworkName.GetShortFolderName();
if (!frameworkNames.Contains(frameworkName))
{
frameworkNames.Add(frameworkName);
writer.WriteObjectStart(frameworkName);
writer.WriteObjectStart("projectReferences");
foreach (var project in framework.ProjectReferences)
{
writer.WriteObjectStart(project.ProjectUniqueName);
writer.WriteNameValue("projectPath", project.ProjectPath);
if (project.IncludeAssets != LibraryIncludeFlags.All)
{
writer.WriteNameValue("includeAssets", LibraryIncludeFlagUtils.GetFlagString(project.IncludeAssets));
}
if (project.ExcludeAssets != LibraryIncludeFlags.None)
{
writer.WriteNameValue("excludeAssets", LibraryIncludeFlagUtils.GetFlagString(project.ExcludeAssets));
}
if (project.PrivateAssets != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
writer.WriteNameValue("privateAssets", LibraryIncludeFlagUtils.GetFlagString(project.PrivateAssets));
}
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
writer.WriteObjectEnd();
}
}
writer.WriteObjectEnd();
}
writer.WriteObjectEnd();
}
public static bool IsNuGetLockFileEnabled(PackageSpec project)
{
var restorePackagesWithLockFile = project.RestoreMetadata?.RestoreLockProperties.RestorePackagesWithLockFile;
return(MSBuildStringUtility.IsTrue(restorePackagesWithLockFile) || File.Exists(GetNuGetLockFilePath(project)));
}
private static PackOptions GetPackOptions(PackageSpec packageSpec, JObject rawPackageSpec)
{
var rawPackOptions = rawPackageSpec.Value <JToken>(PackOptions) as JObject;
if (rawPackOptions == null)
{
packageSpec.Owners = new string[] { };
packageSpec.Tags = new string[] { };
return(new PackOptions
{
PackageType = new PackageType[0]
});
}
var owners = rawPackOptions["owners"];
var tags = rawPackOptions["tags"];
packageSpec.Owners = owners == null?Array.Empty <string>() : owners.ValueAsArray <string>();
packageSpec.Tags = tags == null?Array.Empty <string>() : tags.ValueAsArray <string>();
packageSpec.ProjectUrl = rawPackOptions.GetValue <string>("projectUrl");
packageSpec.IconUrl = rawPackOptions.GetValue <string>("iconUrl");
packageSpec.Summary = rawPackOptions.GetValue <string>("summary");
packageSpec.ReleaseNotes = rawPackOptions.GetValue <string>("releaseNotes");
packageSpec.LicenseUrl = rawPackOptions.GetValue <string>("licenseUrl");
packageSpec.RequireLicenseAcceptance = GetBoolOrFalse(rawPackOptions, "requireLicenseAcceptance", packageSpec.FilePath);
var rawPackageType = rawPackOptions[PackageType];
if (rawPackageType != null &&
rawPackageType.Type != JTokenType.String &&
(rawPackageType.Type != JTokenType.Array || // The array must be all strings.
rawPackageType.Type == JTokenType.Array && rawPackageType.Any(t => t.Type != JTokenType.String)) &&
rawPackageType.Type != JTokenType.Null)
{
throw FileFormatException.Create(
string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidPackageType,
PackageSpec.PackageSpecFileName),
rawPackageType,
packageSpec.FilePath);
}
IEnumerable <string> packageTypeNames;
if (!TryGetStringEnumerableFromJArray(rawPackageType, out packageTypeNames))
{
packageTypeNames = Enumerable.Empty <string>();
}
Dictionary <string, IncludeExcludeFiles> mappings = null;
IncludeExcludeFiles files = null;
var rawFiles = rawPackOptions[Files] as JObject;
if (rawFiles != null)
{
files = new IncludeExcludeFiles();
if (!files.HandleIncludeExcludeFiles(rawFiles))
{
files = null;
}
var rawMappings = rawFiles["mappings"] as JObject;
if (rawMappings != null)
{
mappings = new Dictionary <string, IncludeExcludeFiles>();
foreach (var pair in rawMappings)
{
var key = pair.Key;
var value = pair.Value;
if (value.Type == JTokenType.String ||
value.Type == JTokenType.Array)
{
IEnumerable <string> includeFiles;
TryGetStringEnumerableFromJArray(value, out includeFiles);
var includeExcludeFiles = new IncludeExcludeFiles()
{
Include = includeFiles?.ToList()
};
mappings.Add(key, includeExcludeFiles);
}
else if (value.Type == JTokenType.Object)
{
var includeExcludeFiles = new IncludeExcludeFiles();
if (includeExcludeFiles.HandleIncludeExcludeFiles(value as JObject))
{
mappings.Add(key, includeExcludeFiles);
}
}
}
}
}
return(new PackOptions
{
PackageType = packageTypeNames
.Select(name => new PackageType(name, Packaging.Core.PackageType.EmptyVersion))
.ToList(),
IncludeExcludeFiles = files,
Mappings = mappings
});
}
public static bool HasPackage(PackageSpec spec, string packageId)
{
return(GetExistingDependencies(spec, packageId).Any());
}
private static bool BuildTargetFrameworkNode(PackageSpec packageSpec, KeyValuePair<string, JToken> targetFramework)
{
var frameworkName = GetFramework(targetFramework.Key);
// If it's not unsupported then keep it
if (frameworkName == NuGetFramework.UnsupportedFramework)
{
// REVIEW: Should we skip unsupported target frameworks
return false;
}
var targetFrameworkInformation = new TargetFrameworkInformation
{
FrameworkName = frameworkName,
Dependencies = new List<LibraryDependency>()
};
var properties = targetFramework.Value.Value<JObject>();
PopulateDependencies(
packageSpec.FilePath,
targetFrameworkInformation.Dependencies,
properties,
"dependencies",
isGacOrFrameworkReference: false);
var frameworkAssemblies = new List<LibraryDependency>();
PopulateDependencies(
packageSpec.FilePath,
frameworkAssemblies,
properties,
"frameworkAssemblies",
isGacOrFrameworkReference: true);
frameworkAssemblies.ForEach(d => targetFrameworkInformation.Dependencies.Add(d));
packageSpec.TargetFrameworks.Add(targetFrameworkInformation);
return true;
}
private static ProjectRestoreMetadata GetMSBuildMetadata(PackageSpec packageSpec, JObject rawPackageSpec)
{
var rawMSBuildMetadata = rawPackageSpec.Value <JToken>(RestoreOptions) as JObject;
if (rawMSBuildMetadata == null)
{
return(null);
}
var projectStyleString = rawMSBuildMetadata.GetValue <string>("projectStyle");
ProjectStyle?projectStyle = null;
if (!string.IsNullOrEmpty(projectStyleString) &&
Enum.TryParse <ProjectStyle>(projectStyleString, ignoreCase: true, result: out var projectStyleValue))
{
projectStyle = projectStyleValue;
}
var msbuildMetadata = projectStyle == ProjectStyle.PackagesConfig
? new PackagesConfigProjectRestoreMetadata()
: new ProjectRestoreMetadata();
if (projectStyle.HasValue)
{
msbuildMetadata.ProjectStyle = projectStyle.Value;
}
msbuildMetadata.ProjectUniqueName = rawMSBuildMetadata.GetValue <string>("projectUniqueName");
msbuildMetadata.OutputPath = rawMSBuildMetadata.GetValue <string>("outputPath");
msbuildMetadata.PackagesPath = rawMSBuildMetadata.GetValue <string>("packagesPath");
msbuildMetadata.ProjectJsonPath = rawMSBuildMetadata.GetValue <string>("projectJsonPath");
msbuildMetadata.ProjectName = rawMSBuildMetadata.GetValue <string>("projectName");
msbuildMetadata.ProjectPath = rawMSBuildMetadata.GetValue <string>("projectPath");
msbuildMetadata.CrossTargeting = GetBoolOrFalse(rawMSBuildMetadata, "crossTargeting", packageSpec.FilePath);
msbuildMetadata.LegacyPackagesDirectory = GetBoolOrFalse(rawMSBuildMetadata, "legacyPackagesDirectory", packageSpec.FilePath);
msbuildMetadata.ValidateRuntimeAssets = GetBoolOrFalse(rawMSBuildMetadata, "validateRuntimeAssets", packageSpec.FilePath);
msbuildMetadata.SkipContentFileWrite = GetBoolOrFalse(rawMSBuildMetadata, "skipContentFileWrite", packageSpec.FilePath);
msbuildMetadata.Sources = new List <PackageSource>();
var sourcesObj = rawMSBuildMetadata.GetValue <JObject>("sources");
if (sourcesObj != null)
{
foreach (var prop in sourcesObj.Properties())
{
msbuildMetadata.Sources.Add(new PackageSource(prop.Name));
}
}
var filesObj = rawMSBuildMetadata.GetValue <JObject>("files");
if (filesObj != null)
{
foreach (var prop in filesObj.Properties())
{
msbuildMetadata.Files.Add(new ProjectRestoreMetadataFile(prop.Name, prop.Value.ToObject <string>()));
}
}
var frameworksObj = rawMSBuildMetadata.GetValue <JObject>("frameworks");
if (frameworksObj != null)
{
foreach (var frameworkProperty in frameworksObj.Properties())
{
var framework = NuGetFramework.Parse(frameworkProperty.Name);
var frameworkGroup = new ProjectRestoreMetadataFrameworkInfo(framework);
var projectsObj = frameworkProperty.Value.GetValue <JObject>("projectReferences");
if (projectsObj != null)
{
foreach (var prop in projectsObj.Properties())
{
frameworkGroup.ProjectReferences.Add(new ProjectRestoreReference()
{
ProjectUniqueName = prop.Name,
ProjectPath = prop.Value.GetValue <string>("projectPath"),
IncludeAssets = LibraryIncludeFlagUtils.GetFlags(
flags: prop.Value.GetValue <string>("includeAssets"),
defaultFlags: LibraryIncludeFlags.All),
ExcludeAssets = LibraryIncludeFlagUtils.GetFlags(
flags: prop.Value.GetValue <string>("excludeAssets"),
defaultFlags: LibraryIncludeFlags.None),
PrivateAssets = LibraryIncludeFlagUtils.GetFlags(
flags: prop.Value.GetValue <string>("privateAssets"),
defaultFlags: LibraryIncludeFlagUtils.DefaultSuppressParent),
});
}
}
msbuildMetadata.TargetFrameworks.Add(frameworkGroup);
}
}
// Add the config file paths to the equals method
msbuildMetadata.ConfigFilePaths = new List <string>();
var configFilePaths = rawMSBuildMetadata.GetValue <JArray>("configFilePaths");
if (configFilePaths != null)
{
foreach (var fallbackFolder in configFilePaths.Select(t => t.Value <string>()))
{
msbuildMetadata.ConfigFilePaths.Add(fallbackFolder);
}
}
msbuildMetadata.FallbackFolders = new List <string>();
var fallbackObj = rawMSBuildMetadata.GetValue <JArray>("fallbackFolders");
if (fallbackObj != null)
{
foreach (var fallbackFolder in fallbackObj.Select(t => t.Value <string>()))
{
msbuildMetadata.FallbackFolders.Add(fallbackFolder);
}
}
msbuildMetadata.OriginalTargetFrameworks = new List <string>();
var originalFrameworksObj = rawMSBuildMetadata.GetValue <JArray>("originalTargetFrameworks");
if (originalFrameworksObj != null)
{
foreach (var orignalFramework in originalFrameworksObj.Select(t => t.Value <string>()))
{
msbuildMetadata.OriginalTargetFrameworks.Add(orignalFramework);
}
}
var warningPropertiesObj = rawMSBuildMetadata.GetValue <JObject>("warningProperties");
if (warningPropertiesObj != null)
{
var allWarningsAsErrors = warningPropertiesObj.GetValue <bool>("allWarningsAsErrors");
var warnAsError = new HashSet <NuGetLogCode>(GetNuGetLogCodeEnumerableFromJArray(warningPropertiesObj["warnAsError"]));
var noWarn = new HashSet <NuGetLogCode>(GetNuGetLogCodeEnumerableFromJArray(warningPropertiesObj["noWarn"]));
msbuildMetadata.ProjectWideWarningProperties = new WarningProperties(warnAsError, noWarn, allWarningsAsErrors);
}
// read NuGet lock file msbuild properties
var restoreLockProperties = rawMSBuildMetadata.GetValue <JObject>("restoreLockProperties");
if (restoreLockProperties != null)
{
msbuildMetadata.RestoreLockProperties = new RestoreLockProperties(
restoreLockProperties.GetValue <string>("restorePackagesWithLockFile"),
restoreLockProperties.GetValue <string>("nuGetLockFilePath"),
GetBoolOrFalse(restoreLockProperties, "restoreLockedMode", packageSpec.FilePath));
}
if (msbuildMetadata is PackagesConfigProjectRestoreMetadata pcMsbuildMetadata)
{
pcMsbuildMetadata.PackagesConfigPath = rawMSBuildMetadata.GetValue <string>("packagesConfigPath");
}
return(msbuildMetadata);
}
private void WriteTargetsAndProps(PackageSpec project, List<RestoreTargetGraph> targetGraphs, NuGetv3LocalRepository repository)
{
// Get the runtime-independent graphs
var tfmGraphs = targetGraphs.Where(g => string.IsNullOrEmpty(g.RuntimeIdentifier)).ToList();
if (tfmGraphs.Count > 1)
{
var name = $"{project.Name}.nuget.targets";
var path = Path.Combine(project.BaseDirectory, name);
_log.LogInformation($"Generating MSBuild file {name}");
GenerateMSBuildErrorFile(path);
return;
}
var graph = tfmGraphs[0];
var pathResolver = new DefaultPackagePathResolver(repository.RepositoryRoot);
var targets = new List<string>();
var props = new List<string>();
foreach (var library in graph.Flattened.Distinct().OrderBy(g => g.Data.Match.Library))
{
var package = repository.FindPackagesById(library.Key.Name).FirstOrDefault(p => p.Version == library.Key.Version);
if (package != null)
{
var criteria = graph.Conventions.Criteria.ForFramework(graph.Framework);
var contentItemCollection = new ContentItemCollection();
using (var nupkgStream = File.OpenRead(package.ZipPath))
{
var reader = new PackageReader(nupkgStream);
contentItemCollection.Load(reader.GetFiles());
}
// Find MSBuild thingies
var buildItems = contentItemCollection.FindBestItemGroup(criteria, graph.Conventions.Patterns.MSBuildFiles);
if (buildItems != null)
{
// We need to additionally filter to items that are named "{packageId}.targets" and "{packageId}.props"
// Filter by file name here and we'll filter by extension when we add things to the lists.
var items = buildItems.Items
.Where(item => Path.GetFileNameWithoutExtension(item.Path).Equals(package.Id, StringComparison.OrdinalIgnoreCase))
.ToList();
targets.AddRange(items
.Select(c => c.Path)
.Where(path => Path.GetExtension(path).Equals(".targets", StringComparison.OrdinalIgnoreCase))
.Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar))));
props.AddRange(items
.Select(c => c.Path)
.Where(path => Path.GetExtension(path).Equals(".props", StringComparison.OrdinalIgnoreCase))
.Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar))));
}
}
}
// Generate the files as needed
var targetsName = $"{project.Name}.nuget.targets";
var propsName = $"{project.Name}.nuget.props";
var targetsPath = Path.Combine(project.BaseDirectory, targetsName);
var propsPath = Path.Combine(project.BaseDirectory, propsName);
if (targets.Any())
{
_log.LogInformation($"Generating MSBuild file {targetsName}");
GenerateImportsFile(repository, targetsPath, targets);
}
else if (File.Exists(targetsPath))
{
File.Delete(targetsPath);
}
if (props.Any())
{
_log.LogInformation($"Generating MSBuild file {propsName}");
GenerateImportsFile(repository, propsPath, props);
}
else if (File.Exists(propsPath))
{
File.Delete(propsPath);
}
}
public static PackageSpec GetPackageSpec(JObject rawPackageSpec, string name, string packageSpecPath, string snapshotValue)
{
var packageSpec = new PackageSpec();
// Parse properties we know about
var version = rawPackageSpec["version"];
var authors = rawPackageSpec["authors"];
var contentFiles = rawPackageSpec["contentFiles"];
packageSpec.Name = name;
packageSpec.FilePath = name == null ? null : Path.GetFullPath(packageSpecPath);
if (version != null)
{
try
{
var versionString = version.Value <string>();
packageSpec.HasVersionSnapshot = PackageSpecUtility.IsSnapshotVersion(versionString);
packageSpec.Version = PackageSpecUtility.SpecifySnapshot(versionString, snapshotValue);
}
catch (Exception ex)
{
throw FileFormatException.Create(ex, version, packageSpec.FilePath);
}
}
var packInclude = rawPackageSpec["packInclude"] as JObject;
if (packInclude != null)
{
foreach (var include in packInclude)
{
packageSpec.PackInclude.Add(new KeyValuePair <string, string>(include.Key, include.Value.ToString()));
}
}
packageSpec.Title = rawPackageSpec.GetValue <string>("title");
packageSpec.Description = rawPackageSpec.GetValue <string>("description");
packageSpec.Authors = authors == null ? new string[] { } : authors.ValueAsArray <string>();
packageSpec.ContentFiles = contentFiles == null ? new string[] { } : contentFiles.ValueAsArray <string>();
packageSpec.Dependencies = new List <LibraryDependency>();
packageSpec.Copyright = rawPackageSpec.GetValue <string>("copyright");
packageSpec.Language = rawPackageSpec.GetValue <string>("language");
var buildOptions = rawPackageSpec["buildOptions"] as JObject;
if (buildOptions != null)
{
packageSpec.BuildOptions = new BuildOptions()
{
OutputName = buildOptions.GetValue <string>("outputName")
};
}
var scripts = rawPackageSpec["scripts"] as JObject;
if (scripts != null)
{
foreach (var script in scripts)
{
var value = script.Value;
if (value.Type == JTokenType.String)
{
packageSpec.Scripts[script.Key] = new string[] { value.Value <string>() };
}
else if (value.Type == JTokenType.Array)
{
packageSpec.Scripts[script.Key] = script.Value.ValueAsArray <string>();
}
else
{
throw FileFormatException.Create(
string.Format("The value of a script in '{0}' can only be a string or an array of strings", PackageSpec.PackageSpecFileName),
value,
packageSpec.FilePath);
}
}
}
BuildTargetFrameworks(packageSpec, rawPackageSpec);
PopulateDependencies(
packageSpec.FilePath,
packageSpec.Dependencies,
rawPackageSpec,
"dependencies",
isGacOrFrameworkReference: false);
packageSpec.PackOptions = GetPackOptions(packageSpec, rawPackageSpec);
packageSpec.RestoreSettings = GetRestoreSettings(packageSpec, rawPackageSpec);
packageSpec.RestoreMetadata = GetMSBuildMetadata(packageSpec, rawPackageSpec);
// Read the runtime graph
packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec);
// Read the name/path if it exists
if (packageSpec.Name == null)
{
packageSpec.Name = packageSpec.RestoreMetadata?.ProjectName;
}
// Use the project.json path if one is set, otherwise use the project path
if (packageSpec.FilePath == null)
{
packageSpec.FilePath = packageSpec.RestoreMetadata?.ProjectJsonPath
?? packageSpec.RestoreMetadata?.ProjectPath;
}
return(packageSpec);
}
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;
}
public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramework)
{
Library library = null;
var name = libraryRange.Name;
ExternalProjectReference externalReference = null;
PackageSpec packageSpec = null;
// This must exist in the external references
if (_externalProjectsByUniqueName.TryGetValue(name, out externalReference))
{
packageSpec = externalReference.PackageSpec;
}
if (externalReference == null && packageSpec == null)
{
// unable to find any projects
return(null);
}
// create a dictionary of dependencies to make sure that no duplicates exist
var dependencies = new List <LibraryDependency>();
var projectStyle = packageSpec?.RestoreMetadata?.ProjectStyle ?? ProjectStyle.Unknown;
// Read references from external project - we don't care about dotnettool projects, since they don't have project refs
if (projectStyle == ProjectStyle.PackageReference)
{
// NETCore
dependencies.AddRange(GetDependenciesFromSpecRestoreMetadata(packageSpec, targetFramework));
}
else
{
// UWP
dependencies.AddRange(GetDependenciesFromExternalReference(externalReference, packageSpec, targetFramework));
}
// Remove duplicate dependencies. A reference can exist both in csproj and project.json
// dependencies is already ordered by importance here
var uniqueDependencies = new List <LibraryDependency>(dependencies.Count);
var projectNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var project in dependencies)
{
if (projectNames.Add(project.Name))
{
uniqueDependencies.Add(project);
}
}
library = new Library
{
LibraryRange = libraryRange,
Identity = new LibraryIdentity
{
Name = externalReference?.ProjectName ?? packageSpec.Name,
Version = packageSpec?.Version ?? new NuGetVersion(1, 0, 0),
Type = LibraryType.Project,
},
Path = packageSpec?.FilePath,
Dependencies = uniqueDependencies,
Resolved = true
};
// Add msbuild path
var msbuildPath = externalReference?.MSBuildProjectPath;
if (msbuildPath != null)
{
library[KnownLibraryProperties.MSBuildProjectPath] = msbuildPath;
}
if (packageSpec != null)
{
// Additional library properties
AddLibraryProperties(library, packageSpec, targetFramework, msbuildPath);
}
return(library);
}
public static PackageSpec GetPackageSpec(Stream stream, string name, string packageSpecPath)
{
// Load the raw JSON into the package spec object
var reader = new JsonTextReader(new StreamReader(stream));
var rawPackageSpec = JObject.Load(reader);
var packageSpec = new PackageSpec(rawPackageSpec);
// Parse properties we know about
var version = rawPackageSpec["version"];
var authors = rawPackageSpec["authors"];
var owners = rawPackageSpec["owners"];
var tags = rawPackageSpec["tags"];
var buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION");
packageSpec.Name = name;
packageSpec.FilePath = Path.GetFullPath(packageSpecPath);
if (version == null)
{
packageSpec.Version = new NuGetVersion("1.0.0");
}
else
{
try
{
packageSpec.Version = SpecifySnapshot(version.Value <string>(), buildVersion);
}
catch (Exception ex)
{
var lineInfo = (IJsonLineInfo)version;
throw PackageSpecFormatException.Create(ex, version, packageSpec.FilePath);
}
}
packageSpec.Description = rawPackageSpec.GetValue <string>("description");
packageSpec.Authors = authors == null ? new string[] { } : authors.ValueAsArray <string>();
packageSpec.Owners = owners == null ? new string[] { } : owners.ValueAsArray <string>();
packageSpec.Dependencies = new List <LibraryDependency>();
packageSpec.ProjectUrl = rawPackageSpec.GetValue <string>("projectUrl");
packageSpec.IconUrl = rawPackageSpec.GetValue <string>("iconUrl");
packageSpec.LicenseUrl = rawPackageSpec.GetValue <string>("licenseUrl");
packageSpec.Copyright = rawPackageSpec.GetValue <string>("copyright");
packageSpec.Language = rawPackageSpec.GetValue <string>("language");
packageSpec.RequireLicenseAcceptance = rawPackageSpec.GetValue <bool?>("requireLicenseAcceptance") ?? false;
packageSpec.Tags = tags == null ? new string[] { } : tags.ValueAsArray <string>();
var scripts = rawPackageSpec["scripts"] as JObject;
if (scripts != null)
{
foreach (var script in scripts)
{
var value = script.Value;
if (value.Type == JTokenType.String)
{
packageSpec.Scripts[script.Key] = new string[] { value.Value <string>() };
}
else if (value.Type == JTokenType.Array)
{
packageSpec.Scripts[script.Key] = script.Value.ValueAsArray <string>();
}
else
{
throw PackageSpecFormatException.Create(
string.Format("The value of a script in '{0}' can only be a string or an array of strings", PackageSpec.PackageSpecFileName),
value,
packageSpec.FilePath);
}
}
}
BuildTargetFrameworks(packageSpec, rawPackageSpec);
PopulateDependencies(
packageSpec.FilePath,
packageSpec.Dependencies,
rawPackageSpec,
"dependencies",
isGacOrFrameworkReference: false);
// Read the runtime graph
packageSpec.RuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(rawPackageSpec);
return(packageSpec);
}
/// <summary>
/// PackageSpec -> id
/// </summary>
private static string GetPackageSpecId(PackageSpec spec)
{
return(spec.RestoreMetadata.ProjectUniqueName);
}
/// <summary>
/// Writes a PackageSpec to an <c>NuGet.Common.IObjectWriter</c> instance.
/// </summary>
/// <param name="packageSpec">A <c>PackageSpec</c> instance.</param>
/// <param name="writer">An <c>NuGet.Common.IObjectWriter</c> instance.</param>
public static void Write(PackageSpec packageSpec, IObjectWriter writer)
{
Write(packageSpec, writer, compressed: false);
}
private static IEnumerable <ToolDependency> ReadTools(PackageSpec packageSpec, JObject rawPackageSpec)
{
var tools = rawPackageSpec["tools"] as JObject;
if (tools != null)
{
foreach (var tool in tools)
{
if (string.IsNullOrEmpty(tool.Key))
{
throw FileFormatException.Create(
Strings.MissingToolName,
tool.Value,
packageSpec.FilePath);
}
var value = tool.Value;
JToken versionToken = null;
string versionValue = null;
var imports = new List <NuGetFramework>();
if (value.Type == JTokenType.String)
{
versionToken = value;
versionValue = value.Value <string>();
}
else
{
if (value.Type == JTokenType.Object)
{
versionToken = value["version"];
if (versionToken != null && versionToken.Type == JTokenType.String)
{
versionValue = versionToken.Value <string>();
}
imports.AddRange(GetImports((JObject)value, packageSpec));
}
}
if (versionValue == null)
{
throw FileFormatException.Create(
Strings.MissingVersionOnTool,
tool.Value,
packageSpec.FilePath);
}
VersionRange versionRange;
try
{
versionRange = VersionRange.Parse(versionValue);
}
catch (Exception ex)
{
throw FileFormatException.Create(
ex,
versionToken,
packageSpec.FilePath);
}
yield return(new ToolDependency
{
LibraryRange = new LibraryRange
{
Name = tool.Key,
TypeConstraint = LibraryDependencyTarget.Package,
VersionRange = versionRange
},
Imports = imports
});
}
}
}
private static void BuildTargetFrameworks(PackageSpec packageSpec, JObject rawPackageSpec)
{
// The frameworks node is where target frameworks go
/*
{
"frameworks": {
"net45": {
},
"aspnet50": {
}
}
}
*/
var frameworks = rawPackageSpec["frameworks"] as JObject;
if (frameworks != null)
{
foreach (var framework in frameworks)
{
try
{
BuildTargetFrameworkNode(packageSpec, framework);
}
catch (Exception ex)
{
throw PackageSpecFormatException.Create(ex, framework.Value, packageSpec.FilePath);
}
}
}
}
