feat(opm): fine-grained dependency selection in diffs (#756)

Signed-off-by: Eric Stroczynski <[email protected]>
Upstream-repository: operator-registry
Upstream-commit: a3253eb2fa97be52883af0a0c195d4a95500c04a

Author: Eric Stroczynski

staging/operator-registry/alpha/action/testdata/index-declcfgs/exp-headsonly/index.yaml

@@ -9,6 +9,7 @@ schema: olm.channel
 entries:
   - name: bar.v0.1.0
   - name: bar.v0.2.0
+    replaces: bar.v0.1.0
     skips:
       - bar.v0.1.0
   - name: bar.v1.0.0

staging/operator-registry/alpha/action/testdata/index-declcfgs/latest/index.yaml

@@ -9,6 +9,7 @@ schema: olm.channel
 entries:
   - name: bar.v0.1.0
   - name: bar.v0.2.0
+    replaces: bar.v0.1.0
     skipRange: <0.2.0
     skips:
       - bar.v0.1.0

staging/operator-registry/alpha/action/testdata/index-declcfgs/old/index.yaml

@@ -9,6 +9,7 @@ name: alpha
 entries:
   - name: bar.v0.1.0
   - name: bar.v0.2.0
+    replaces: bar.v0.1.0
     skipRange: <0.2.0
     skips:
       - bar.v0.1.0

staging/operator-registry/alpha/declcfg/diff.go

@@ -1,6 +1,7 @@
 package declcfg
 
 import (
+	"fmt"
 	"reflect"
 	"sort"
 	"sync"
@@ -167,7 +168,7 @@ func bundlesEqual(b1, b2 *model.Bundle) (bool, error) {
 
 func addAllDependencies(newModel, oldModel, outputModel model.Model) error {
 	// Get every oldModel's bundle's dependencies, and their dependencies, etc. by BFS.
-	allProvidingBundles := []*model.Bundle{}
+	providingBundlesByPackage := map[string][]*model.Bundle{}
 	for curr := getBundles(outputModel); len(curr) != 0; {
 		reqGVKs, reqPkgs, err := findDependencies(curr)
 		if err != nil {
@@ -183,36 +184,85 @@ func addAllDependencies(newModel, oldModel, outputModel model.Model) error {
 		for _, pkg := range newModel {
 			providingBundles := getBundlesThatProvide(pkg, reqGVKs, reqPkgs)
 			curr = append(curr, providingBundles...)
-			allProvidingBundles = append(allProvidingBundles, providingBundles...)
+
+			oldPkg, oldHasPkg := oldModel[pkg.Name]
+			for _, b := range providingBundles {
+				// If the bundle is not in oldModel, add it to the set.
+				// outputModel is checked below.
+				add := true
+				if oldHasPkg {
+					if oldCh, oldHasCh := oldPkg.Channels[b.Channel.Name]; oldHasCh {
+						_, oldHasBundle := oldCh.Bundles[b.Name]
+						add = !oldHasBundle
+					}
+				}
+				if add {
+					providingBundlesByPackage[b.Package.Name] = append(providingBundlesByPackage[b.Package.Name], b)
+				}
+			}
 		}
 	}
 
 	// Add the diff between an oldModel dependency package and its new counterpart
 	// or the entire package if oldModel does not have it.
-	//
-	// TODO(estroz): add bundles then fill in dependency upgrade graph
-	// by selecting latest versions, as the EP specifies.
-	dependencyPkgs := map[string]*model.Package{}
-	for _, b := range allProvidingBundles {
-		if _, copied := dependencyPkgs[b.Package.Name]; !copied {
-			dependencyPkgs[b.Package.Name] = copyPackage(b.Package)
-		}
-	}
-	for _, newDepPkg := range dependencyPkgs {
-		// newDepPkg is a copy of a newModel pkg, so running diffPackages
-		// on it and oldPkg, which may have some but not all bundles,
-		// will produce a set of all bundles that outputModel doesn't have.
-		// Otherwise, just add the whole package.
-		if oldPkg, oldHasPkg := oldModel[newDepPkg.Name]; oldHasPkg {
-			if err := diffPackages(oldPkg, newDepPkg); err != nil {
+	for pkgName, bundles := range providingBundlesByPackage {
+		newPkg := newModel[pkgName]
+		heads := make(map[string]*model.Bundle, len(newPkg.Channels))
+		for _, ch := range newPkg.Channels {
+			var err error
+			if heads[ch.Name], err = ch.Head(); err != nil {
 				return err
 			}
-			if len(newDepPkg.Channels) == 0 {
-				// Skip empty packages.
-				continue
+		}
+
+		// Sort by version then channel so bundles lower in the full graph are more likely
+		// to be included in previous loops.
+		sort.Slice(bundles, func(i, j int) bool {
+			if bundles[i].Channel.Name == bundles[j].Channel.Name {
+				return bundles[i].Version.LT(bundles[j].Version)
+			}
+			return bundles[i].Channel.Name < bundles[j].Channel.Name
+		})
+
+		for _, b := range bundles {
+			newCh := b.Channel
+
+			// Continue if b was added in a previous loop iteration.
+			// Otherwise create a new package/channel for b if they do not exist.
+			var (
+				outputPkg *model.Package
+				outputCh  *model.Channel
+
+				outHasPkg, outHasCh bool
+			)
+			if outputPkg, outHasPkg = outputModel[b.Package.Name]; outHasPkg {
+				if outputCh, outHasCh = outputPkg.Channels[b.Channel.Name]; outHasCh {
+					if _, outputHasBundle := outputCh.Bundles[b.Name]; outputHasBundle {
+						continue
+					}
+				}
+			} else {
+				outputPkg = copyPackageNoChannels(newPkg)
+				outputModel[outputPkg.Name] = outputPkg
+			}
+			if !outHasCh {
+				outputCh = copyChannelNoBundles(newCh, outputPkg)
+				outputPkg.Channels[outputCh.Name] = outputCh
+			}
+
+			head := heads[newCh.Name]
+			graph := makeUpgradeGraph(newCh)
+			intersectingBundles, intersectionFound := findIntersectingBundles(newCh, b, head, graph)
+			if !intersectionFound {
+				// This should never happen, since b and head are from the same model.
+				return fmt.Errorf("channel %s: head %q not reachable from bundle %q", newCh.Name, head.Name, b.Name)
+			}
+			for _, ib := range intersectingBundles {
+				if _, outHasBundle := outputCh.Bundles[ib.Name]; !outHasBundle {
+					outputCh.Bundles[ib.Name] = copyBundle(ib, outputCh, outputPkg)
+				}
 			}
 		}
-		outputModel[newDepPkg.Name] = newDepPkg
 	}
 
 	return nil

staging/operator-registry/alpha/declcfg/diff_include.go

@@ -0,0 +1,87 @@
+package declcfg
+
+import (
+	"github.com/operator-framework/operator-registry/alpha/model"
+)
+
+// makeUpgradeGraph creates a DAG of bundles with map key Bundle.Replaces.
+func makeUpgradeGraph(ch *model.Channel) map[string][]*model.Bundle {
+	graph := map[string][]*model.Bundle{}
+	for _, b := range ch.Bundles {
+		b := b
+		if b.Replaces != "" {
+			graph[b.Replaces] = append(graph[b.Replaces], b)
+		}
+	}
+	return graph
+}
+
+// findIntersectingBundles finds the intersecting bundle of start and end in the
+// replaces upgrade graph graph by traversing down to the lowest graph node,
+// then returns every bundle higher than the intersection. It is possible
+// to find no intersection; this should only happen when start and end
+// are not part of the same upgrade graph.
+// Output bundle order is not guaranteed.
+// Precondition: start must be a bundle in ch.
+// Precondition: end must be ch's head.
+func findIntersectingBundles(ch *model.Channel, start, end *model.Bundle, graph map[string][]*model.Bundle) ([]*model.Bundle, bool) {
+	// The intersecting set is equal to end if start is end.
+	if start.Name == end.Name {
+		return []*model.Bundle{end}, true
+	}
+
+	// Construct start's replaces chain for comparison against end's.
+	startChain := map[string]*model.Bundle{start.Name: nil}
+	for curr := start; curr != nil && curr.Replaces != ""; curr = ch.Bundles[curr.Replaces] {
+		startChain[curr.Replaces] = curr
+	}
+
+	// Trace end's replaces chain until it intersects with start's, or the root is reached.
+	var intersection string
+	if _, inChain := startChain[end.Name]; inChain {
+		intersection = end.Name
+	} else {
+		for curr := end; curr != nil && curr.Replaces != ""; curr = ch.Bundles[curr.Replaces] {
+			if _, inChain := startChain[curr.Replaces]; inChain {
+				intersection = curr.Replaces
+				break
+			}
+		}
+	}
+
+	// No intersection is found, delegate behavior to caller.
+	if intersection == "" {
+		return nil, false
+	}
+
+	// Find all bundles that replace the intersection via BFS,
+	// i.e. the set of bundles that fill the update graph between start and end.
+	replacesIntersection := graph[intersection]
+	replacesSet := map[string]*model.Bundle{}
+	for _, b := range replacesIntersection {
+		currName := ""
+		for next := []*model.Bundle{b}; len(next) > 0; next = next[1:] {
+			currName = next[0].Name
+			if _, hasReplaces := replacesSet[currName]; !hasReplaces {
+				replacers := graph[currName]
+				next = append(next, replacers...)
+				replacesSet[currName] = ch.Bundles[currName]
+			}
+		}
+	}
+
+	// Remove every bundle between start and intersection exclusively,
+	// since these bundles must already exist in the destination channel.
+	for rep := start; rep != nil && rep.Name != intersection; rep = ch.Bundles[rep.Replaces] {
+		delete(replacesSet, rep.Name)
+	}
+
+	// Ensure both start and end are added to the output.
+	replacesSet[start.Name] = start
+	replacesSet[end.Name] = end
+	var intersectingBundles []*model.Bundle
+	for _, b := range replacesSet {
+		intersectingBundles = append(intersectingBundles, b)
+	}
+	return intersectingBundles, true
+}