public override bool Execute()
{
if (RuntimeGroups != null && RuntimeGroups.Any() && RuntimeJson == null)
{
Log.LogError($"{nameof(RuntimeJson)} argument must be specified when {nameof(RuntimeGroups)} is specified.");
return(false);
}
RuntimeGraph runtimeGraph;
if (!String.IsNullOrEmpty(SourceRuntimeJson))
{
if (!File.Exists(SourceRuntimeJson))
{
Log.LogError($"{nameof(SourceRuntimeJson)} did not exist at {SourceRuntimeJson}.");
return(false);
}
runtimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(SourceRuntimeJson);
}
else
{
runtimeGraph = new RuntimeGraph();
}
foreach (var runtimeGroup in RuntimeGroups.NullAsEmpty().Select(i => new RuntimeGroup(i)))
{
runtimeGraph = SafeMerge(runtimeGraph, runtimeGroup);
}
Dictionary <string, string> externalRids = new Dictionary <string, string>();
if (ExternalRuntimeJsons != null)
{
foreach (var externalRuntimeJson in ExternalRuntimeJsons)
{
RuntimeGraph externalRuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(externalRuntimeJson);
foreach (var runtime in externalRuntimeGraph.Runtimes.Keys)
{
// don't check for duplicates, we merely care what is external
externalRids.Add(runtime, externalRuntimeJson);
}
}
}
ValidateImports(runtimeGraph, externalRids);
if (!String.IsNullOrEmpty(RuntimeJson))
{
if (UpdateRuntimeFiles)
{
EnsureWritable(RuntimeJson);
NuGetUtility.WriteRuntimeGraph(RuntimeJson, runtimeGraph);
}
else
{
// validate that existing file matches generated file
if (!File.Exists(RuntimeJson))
{
Log.LogError($"{nameof(RuntimeJson)} did not exist at {RuntimeJson} and {nameof(UpdateRuntimeFiles)} was not specified.");
}
else
{
var existingRuntimeGraph = JsonRuntimeFormat.ReadRuntimeGraph(RuntimeJson);
if (!existingRuntimeGraph.Equals(runtimeGraph))
{
Log.LogError($"The generated {nameof(RuntimeJson)} differs from {RuntimeJson} and {nameof(UpdateRuntimeFiles)} was not specified. Please specify {nameof(UpdateRuntimeFiles)}=true to commit the changes.");
}
}
}
}
if (!String.IsNullOrEmpty(CompatibilityMap))
{
var compatibilityMap = GetCompatibilityMap(runtimeGraph);
if (UpdateRuntimeFiles)
{
EnsureWritable(CompatibilityMap);
WriteCompatibilityMap(compatibilityMap, CompatibilityMap);
}
else
{
// validate that existing file matches generated file
if (!File.Exists(CompatibilityMap))
{
Log.LogError($"{nameof(CompatibilityMap)} did not exist at {CompatibilityMap} and {nameof(UpdateRuntimeFiles)} was not specified.");
}
else
{
var existingCompatibilityMap = ReadCompatibilityMap(CompatibilityMap);
if (!CompatibilityMapEquals(existingCompatibilityMap, compatibilityMap))
{
Log.LogError($"The generated {nameof(CompatibilityMap)} differs from {CompatibilityMap} and {nameof(UpdateRuntimeFiles)} was not specified. Please specify {nameof(UpdateRuntimeFiles)}=true to commit the changes.");
}
}
}
}
if (!String.IsNullOrEmpty(RuntimeDirectedGraph))
{
WriteRuntimeGraph(runtimeGraph, RuntimeDirectedGraph);
}
return(!Log.HasLoggedErrors);
}
public override bool Execute()
{
if (Dependencies == null || Dependencies.Length == 0)
{
Log.LogError("Dependencies argument must be specified");
return(false);
}
if (String.IsNullOrEmpty(PackageId))
{
Log.LogError("PackageID argument must be specified");
return(false);
}
if (RuntimeJson == null)
{
Log.LogError("RuntimeJson argument must be specified");
return(false);
}
string sourceRuntimeFilePath = null;
if (RuntimeJsonTemplate != null)
{
sourceRuntimeFilePath = RuntimeJsonTemplate.GetMetadata("FullPath");
}
string destRuntimeFilePath = RuntimeJson.GetMetadata("FullPath");
Dictionary <string, string> packageAliases = new Dictionary <string, string>();
foreach (var dependency in Dependencies)
{
string alias = dependency.GetMetadata("PackageAlias");
if (String.IsNullOrEmpty(alias))
{
continue;
}
Log.LogMessage(LogImportance.Low, "Aliasing {0} -> {1}", alias, dependency.ItemSpec);
packageAliases[alias] = dependency.ItemSpec;
}
var runtimeGroups = Dependencies.GroupBy(d => d.GetMetadata("TargetRuntime"));
List <RuntimeDescription> runtimes = new List <RuntimeDescription>();
foreach (var runtimeGroup in runtimeGroups)
{
string targetRuntimeId = runtimeGroup.Key;
if (String.IsNullOrEmpty(targetRuntimeId))
{
Log.LogMessage(LogImportance.Low, "Skipping dependencies {0} since they don't have a TargetRuntime.", String.Join(", ", runtimeGroup.Select(d => d.ItemSpec)));
continue;
}
if (runtimeGroup.Any(d => d.ItemSpec == c_emptyDependency))
{
runtimes.Add(new RuntimeDescription(targetRuntimeId));
continue;
}
List <RuntimeDependencySet> runtimeDependencySets = new List <RuntimeDependencySet>();
var targetPackageGroups = runtimeGroup.GroupBy(d => GetTargetPackageId(d, packageAliases));
foreach (var targetPackageGroup in targetPackageGroups)
{
string targetPackageId = targetPackageGroup.Key;
List <RuntimePackageDependency> runtimePackageDependencies = new List <RuntimePackageDependency>();
var dependencyGroups = targetPackageGroup.GroupBy(d => d.ItemSpec);
foreach (var dependencyGroup in dependencyGroups)
{
string dependencyId = dependencyGroup.Key;
var dependencyVersions = dependencyGroup.Select(d => GetDependencyVersion(d));
var maxDependencyVersion = dependencyVersions.Max();
runtimePackageDependencies.Add(new RuntimePackageDependency(dependencyId, new VersionRange(maxDependencyVersion)));
}
runtimeDependencySets.Add(new RuntimeDependencySet(targetPackageId, runtimePackageDependencies));
}
runtimes.Add(new RuntimeDescription(targetRuntimeId, runtimeDependencySets));
}
RuntimeGraph runtimeGraph = new RuntimeGraph(runtimes);
// read in existing JSON, if it was provided so that we preserve any
// hand authored #imports or dependencies
if (!String.IsNullOrEmpty(sourceRuntimeFilePath))
{
RuntimeGraph existingGraph = JsonRuntimeFormat.ReadRuntimeGraph(sourceRuntimeFilePath);
runtimeGraph = RuntimeGraph.Merge(existingGraph, runtimeGraph);
}
string destRuntimeFileDir = Path.GetDirectoryName(destRuntimeFilePath);
if (!String.IsNullOrEmpty(destRuntimeFileDir) && !Directory.Exists(destRuntimeFileDir))
{
Directory.CreateDirectory(destRuntimeFileDir);
}
NuGetUtility.WriteRuntimeGraph(destRuntimeFilePath, runtimeGraph);
return(true);
}
