// 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); }