// Making this method protected virtual for tests.
protected virtual string GetLatestStableVersionForPackageRelease(string packageId, int releaseMajorVersion, int releaseMinorVersion)
{
IEnumerable <Version> packageVersions = NuGetUtility.GetAllVersionsForPackageId(packageId, includePrerelease: false, includeUnlisted: false, Log, CancellationToken.None);
Version latestPatchVersion = packageVersions.GetLatestPatchStableVersionForRelease(releaseMajorVersion, releaseMinorVersion);
return((latestPatchVersion == null) ? string.Empty : $"{latestPatchVersion.Major}.{latestPatchVersion.Minor}.{latestPatchVersion.Build}");
}
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);
}
private void UpdateFromValues(PackageIndex index, string id, NuGetVersion version, IEnumerable <Version> assemblyVersions, IEnumerable <string> dllNames)
{
PackageInfo info = GetOrCreatePackageInfo(index, id);
if (UpdateStablePackageInfo)
{
try
{
IEnumerable <Version> allStableVersions = NuGetUtility.GetAllVersionsForPackageId(id, includePrerelease: false, includeUnlisted: false, Log, CancellationToken.None);
info.StableVersions.AddRange(allStableVersions);
}
catch (NuGetProtocolException)
{
Log.LogWarning("Failed fetching stable nuget package versions from one or more of your feeds. Make sure you are connected to the internet and that all your feeds are reachable.");
}
}
var packageVersion = VersionUtility.As3PartVersion(version.Version);
// if we have a stable version, add it to the stable versions list
if (!version.IsPrerelease)
{
info.StableVersions.Add(packageVersion);
}
var assmVersions = new HashSet <Version>(assemblyVersions.NullAsEmpty().Where(v => v != null));
// add any new assembly versions
info.AddAssemblyVersionsInPackage(assmVersions, packageVersion);
// try to find an identity package to also add a mapping in the case this is a runtime package
if (id.StartsWith("runtime."))
{
foreach (var dllName in dllNames)
{
PackageInfo identityInfo;
if (index.Packages.TryGetValue(dllName, out identityInfo))
{
identityInfo.AddAssemblyVersionsInPackage(assmVersions, packageVersion);
}
}
}
// remove any assembly mappings which claim to be in this package version, but aren't in the assemblyList
var orphanedAssemblyVersions = info.AssemblyVersionInPackageVersion
.Where(pair => pair.Value == packageVersion && !assmVersions.Contains(pair.Key))
.Select(pair => pair.Key);
if (orphanedAssemblyVersions.Any())
{
// make sure these aren't coming from a runtime package.
var runtimeAssemblyVersions = index.Packages
.Where(p => p.Key.StartsWith("runtime.") && p.Key.EndsWith(id))
.SelectMany(p => p.Value.AssemblyVersionInPackageVersion)
.Where(pair => pair.Value == packageVersion)
.Select(pair => pair.Key);
orphanedAssemblyVersions = orphanedAssemblyVersions.Except(runtimeAssemblyVersions);
}
foreach (var orphanedAssemblyVersion in orphanedAssemblyVersions.ToArray())
{
info.AssemblyVersionInPackageVersion.Remove(orphanedAssemblyVersion);
}
// if no assemblies are present in this package nor were ever present
if (assmVersions.Count == 0 &&
info.AssemblyVersionInPackageVersion.Count == 0)
{
// if in the native module map
if (index.ModulesToPackages.Values.Any(p => p.Equals(id)))
{
// ensure the baseline is set
info.BaselineVersion = packageVersion;
}
}
}
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);
}
public override bool Execute()
{
string indexFilePath = PackageIndexFile.GetMetadata("FullPath");
PackageIndex index = File.Exists(indexFilePath) ?
index = PackageIndex.Load(indexFilePath) :
new PackageIndex();
if (PackageIds != null && PackageIds.Any())
{
_packageIdsToInclude = new HashSet <string>(PackageIds.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase);
}
foreach (var package in Packages.NullAsEmpty().Select(f => f.GetMetadata("FullPath")))
{
Log.LogMessage($"Updating from {package}.");
UpdateFromPackage(index, package);
}
foreach (var packageFolder in PackageFolders.NullAsEmpty().Select(f => f.GetMetadata("FullPath")))
{
var nupkgs = Directory.EnumerateFiles(packageFolder, "*.nupkg", SearchOption.TopDirectoryOnly);
if (nupkgs.Any())
{
foreach (var nupkg in nupkgs)
{
Log.LogMessage($"Updating from {nupkg}.");
UpdateFromPackage(index, nupkg, true);
}
}
else
{
var nuspecFolders = Directory.EnumerateFiles(packageFolder, "*.nuspec", SearchOption.AllDirectories)
.Select(nuspec => Path.GetDirectoryName(nuspec));
foreach (var nuspecFolder in nuspecFolders)
{
Log.LogMessage($"Updating from {nuspecFolder}.");
UpdateFromFolderLayout(index, nuspecFolder, true);
}
}
}
if (BaselinePackages != null)
{
foreach (var baselinePackage in BaselinePackages)
{
var info = GetOrCreatePackageInfo(index, baselinePackage.ItemSpec);
var version = baselinePackage.GetMetadata("Version");
info.BaselineVersion = Version.Parse(version);
}
}
if (StablePackages != null)
{
foreach (var stablePackage in StablePackages)
{
var info = GetOrCreatePackageInfo(index, stablePackage.ItemSpec);
var version = stablePackage.GetMetadata("Version");
info.StableVersions.Add(Version.Parse(version));
}
}
if (ModuleToPackages != null)
{
foreach (var moduleToPackage in ModuleToPackages)
{
var package = moduleToPackage.GetMetadata("Package");
index.ModulesToPackages[moduleToPackage.ItemSpec] = package;
}
}
if (InboxFrameworkListFolder != null)
{
index.MergeFrameworkLists(InboxFrameworkListFolder.GetMetadata("FullPath"));
}
if (InboxFrameworkLayoutFolders != null)
{
foreach (var inboxFrameworkLayoutFolder in InboxFrameworkLayoutFolders)
{
var layoutDirectory = inboxFrameworkLayoutFolder.GetMetadata("FullPath");
var targetFramework = NuGetFramework.Parse(inboxFrameworkLayoutFolder.GetMetadata("TargetFramework"));
index.MergeInboxFromLayout(targetFramework, layoutDirectory);
}
}
if (SetBaselineVersionsToLatestStableVersion)
{
foreach (var packageInfo in index.Packages.Values)
{
var maxVersion = packageInfo.StableVersions.Max();
packageInfo.BaselineVersion = maxVersion;
}
}
if (UpdateStablePackageInfo && Packages == null && PackageFolders == null)
{
// Given we will query the web for every package, we should run in parallel to try to optimize the performance.
Parallel.ForEach(index.Packages, (package) =>
{
IEnumerable <Version> stablePackageVersions = NuGetUtility.GetAllVersionsForPackageId(package.Key, includePrerelease: false, includeUnlisted: false, Log, CancellationToken.None);
package.Value.StableVersions.Clear();
package.Value.StableVersions.AddRange(stablePackageVersions);
});
}
if (!String.IsNullOrEmpty(PreRelease))
{
index.PreRelease = PreRelease;
}
index.Save(indexFilePath);
return(!Log.HasLoggedErrors);
}
