Implement support for upgrade Edges

Signed-off-by: Joaquim Moreno Prusi <joaquim@redhat.com>
Signed-off-by: Per Goncalves da Silva <pegoncal@redhat.com>

Co-authored-by: Per Goncalves da Silva <pegoncal@redhat.com>

Makefile

@@ -116,10 +116,14 @@ kind-cluster-cleanup: $(KIND) ## Delete the kind cluster
 	$(KIND) delete cluster --name ${KIND_CLUSTER_NAME}
 
 kind-load-test-artifacts: $(KIND) ## Load the e2e testdata container images into a kind cluster
+	$(CONTAINER_RUNTIME) build $(TESTDATA_DIR)/bundles/registry-v1/prometheus-operator.v0.37.0 -t localhost/testdata/bundles/registry-v1/prometheus-operator:v0.37.0
 	$(CONTAINER_RUNTIME) build $(TESTDATA_DIR)/bundles/registry-v1/prometheus-operator.v0.47.0 -t localhost/testdata/bundles/registry-v1/prometheus-operator:v0.47.0
+	$(CONTAINER_RUNTIME) build $(TESTDATA_DIR)/bundles/registry-v1/prometheus-operator.v0.65.1 -t localhost/testdata/bundles/registry-v1/prometheus-operator:v0.65.1
 	$(CONTAINER_RUNTIME) build $(TESTDATA_DIR)/bundles/plain-v0/plain.v0.1.0 -t localhost/testdata/bundles/plain-v0/plain:v0.1.0
 	$(CONTAINER_RUNTIME) build $(TESTDATA_DIR)/catalogs -f $(TESTDATA_DIR)/catalogs/test-catalog.Dockerfile -t localhost/testdata/catalogs/test-catalog:e2e
+	$(KIND) load docker-image localhost/testdata/bundles/registry-v1/prometheus-operator:v0.37.0 --name $(KIND_CLUSTER_NAME)
 	$(KIND) load docker-image localhost/testdata/bundles/registry-v1/prometheus-operator:v0.47.0 --name $(KIND_CLUSTER_NAME)
+	$(KIND) load docker-image localhost/testdata/bundles/registry-v1/prometheus-operator:v0.65.1 --name $(KIND_CLUSTER_NAME)
 	$(KIND) load docker-image localhost/testdata/bundles/plain-v0/plain:v0.1.0 --name $(KIND_CLUSTER_NAME)
 	$(KIND) load docker-image localhost/testdata/catalogs/test-catalog:e2e --name $(KIND_CLUSTER_NAME)
 

config/samples/operators_v1alpha1_operator.yaml

@@ -10,3 +10,4 @@ metadata:
   name: operator-sample
 spec:
   packageName: argocd-operator
+  version: 0.6.0

internal/controllers/variable_source.go

@@ -29,6 +29,9 @@ func NewVariableSource(cl client.Client) variablesources.NestedVariableSource {
 		func(inputVariableSource input.VariableSource) (input.VariableSource, error) {
 			return variablesources.NewOperatorVariableSource(cl, inputVariableSource), nil
 		},
+		func(inputVariableSource input.VariableSource) (input.VariableSource, error) {
+			return variablesources.NewBundleDeploymentVariableSource(cl, inputVariableSource), nil
+		},
 		func(inputVariableSource input.VariableSource) (input.VariableSource, error) {
 			return variablesources.NewBundlesAndDepsVariableSource(inputVariableSource), nil
 		},

internal/resolution/entities/bundle_entity.go

@@ -25,13 +25,6 @@ const (
 
 // ----
 
-type ChannelProperties struct {
-	property.Channel
-	Replaces  string   `json:"replaces,omitempty"`
-	Skips     []string `json:"skips,omitempty"`
-	SkipRange string   `json:"skipRange,omitempty"`
-}
-
 type propertyRequirement bool
 
 const (
@@ -46,6 +39,10 @@ type PackageRequired struct {
 
 type GVK property.GVK
 
+type Replaces struct {
+	Replaces string `json:"replaces"`
+}
+
 func (g GVK) String() string {
 	return fmt.Sprintf(`group:"%s" version:"%s" kind:"%s"`, g.Group, g.Version, g.Kind)
 }
@@ -64,15 +61,16 @@ type BundleEntity struct {
 	*input.Entity
 
 	// these properties are lazy loaded as they are requested
-	bundlePackage     *property.Package
-	providedGVKs      []GVK
-	requiredGVKs      []GVKRequired
-	requiredPackages  []PackageRequired
-	channelProperties *ChannelProperties
-	semVersion        *semver.Version
-	bundlePath        string
-	mediaType         string
-	mu                sync.RWMutex
+	bundlePackage    *property.Package
+	providedGVKs     []GVK
+	requiredGVKs     []GVKRequired
+	requiredPackages []PackageRequired
+	channel          *property.Channel
+	replaces         *Replaces
+	semVersion       *semver.Version
+	bundlePath       string
+	mediaType        string
+	mu               sync.RWMutex
 }
 
 func NewBundleEntity(entity *input.Entity) *BundleEntity {
@@ -121,14 +119,35 @@ func (b *BundleEntity) ChannelName() (string, error) {
 	if err := b.loadChannelProperties(); err != nil {
 		return "", err
 	}
-	return b.channelProperties.ChannelName, nil
+	return b.channel.ChannelName, nil
 }
 
-func (b *BundleEntity) ChannelProperties() (*ChannelProperties, error) {
+func (b *BundleEntity) Channel() (*property.Channel, error) {
 	if err := b.loadChannelProperties(); err != nil {
 		return nil, err
 	}
-	return b.channelProperties, nil
+	return b.channel, nil
+}
+
+func (b *BundleEntity) Replaces() (string, error) {
+	if err := b.loadReplaces(); err != nil {
+		return "", err
+	}
+	return b.replaces.Replaces, nil
+}
+
+func (b *BundleEntity) loadReplaces() error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if b.replaces == nil {
+		// TODO: move property name to constant
+		replaces, err := loadFromEntity[Replaces](b.Entity, "olm.replaces", optional)
+		if err != nil {
+			return fmt.Errorf("error determining replaces for entity '%s': %w", b.ID, err)
+		}
+		b.replaces = &replaces
+	}
+	return nil
 }
 
 func (b *BundleEntity) BundlePath() (string, error) {
@@ -228,12 +247,12 @@ func (b *BundleEntity) loadRequiredPackages() error {
 func (b *BundleEntity) loadChannelProperties() error {
 	b.mu.Lock()
 	defer b.mu.Unlock()
-	if b.channelProperties == nil {
-		channel, err := loadFromEntity[ChannelProperties](b.Entity, property.TypeChannel, required)
+	if b.channel == nil {
+		channel, err := loadFromEntity[property.Channel](b.Entity, property.TypeChannel, required)
 		if err != nil {
 			return fmt.Errorf("error determining bundle channel properties for entity '%s': %w", b.ID, err)
 		}
-		b.channelProperties = &channel
+		b.channel = &channel
 	}
 	return nil
 }
@@ -255,6 +274,8 @@ func loadFromEntity[T interface{}](entity *input.Entity, propertyName string, re
 	deserializedProperty := *new(T)
 	propertyValue, ok := entity.Properties[propertyName]
 	if ok {
+		// TODO: In order to avoid invalid properties we should use a decoder that only allows the properties we expect.
+		//       ie. decoder.DisallowUnknownFields()
 		if err := json.Unmarshal([]byte(propertyValue), &deserializedProperty); err != nil {
 			return deserializedProperty, fmt.Errorf("property '%s' ('%s') could not be parsed: %w", propertyName, propertyValue, err)
 		}

internal/resolution/entities/bundle_entity_test.go

@@ -205,28 +205,24 @@ var _ = Describe("BundleEntity", func() {
 		})
 	})
 
-	Describe("ChannelProperties", func() {
+	Describe("Channel", func() {
 		It("should return the bundle channel properties if present", func() {
 			entity := input.NewEntity("operatorhub/prometheus/0.14.0", map[string]string{
 				"olm.channel": `{"channelName":"beta","priority":0, "replaces": "bundle.v1.0.0", "skips": ["bundle.v0.9.0", "bundle.v0.9.6"], "skipRange": ">=0.9.0 <=0.9.6"}`,
 			})
 			bundleEntity := olmentity.NewBundleEntity(entity)
-			channelProperties, err := bundleEntity.ChannelProperties()
+			channelProperties, err := bundleEntity.Channel()
 			Expect(err).ToNot(HaveOccurred())
-			Expect(*channelProperties).To(Equal(olmentity.ChannelProperties{
-				Channel: property.Channel{
-					ChannelName: "beta",
-					Priority:    0,
-				},
-				Replaces:  "bundle.v1.0.0",
-				Skips:     []string{"bundle.v0.9.0", "bundle.v0.9.6"},
-				SkipRange: ">=0.9.0 <=0.9.6",
-			}))
+			Expect(*channelProperties).To(Equal(property.Channel{
+				ChannelName: "beta",
+				Priority:    0,
+			},
+			))
 		})
 		It("should return an error if the property is not found", func() {
 			entity := input.NewEntity("operatorhub/prometheus/0.14.0", map[string]string{})
 			bundleEntity := olmentity.NewBundleEntity(entity)
-			channelProperties, err := bundleEntity.ChannelProperties()
+			channelProperties, err := bundleEntity.Channel()
 			Expect(channelProperties).To(BeNil())
 			Expect(err.Error()).To(Equal("error determining bundle channel properties for entity 'operatorhub/prometheus/0.14.0': required property 'olm.channel' not found"))
 		})
@@ -235,7 +231,7 @@ var _ = Describe("BundleEntity", func() {
 				"olm.channel": "badChannelPropertiesStructure",
 			})
 			bundleEntity := olmentity.NewBundleEntity(entity)
-			channelProperties, err := bundleEntity.ChannelProperties()
+			channelProperties, err := bundleEntity.Channel()
 			Expect(channelProperties).To(BeNil())
 			Expect(err.Error()).To(Equal("error determining bundle channel properties for entity 'operatorhub/prometheus/0.14.0': property 'olm.channel' ('badChannelPropertiesStructure') could not be parsed: invalid character 'b' looking for beginning of value"))
 		})
@@ -269,6 +265,27 @@ var _ = Describe("BundleEntity", func() {
 		})
 	})
 
+	Describe("Replaces", func() {
+		It("should return the replaces property if present", func() {
+			entity := input.NewEntity("test", map[string]string{
+				"olm.replaces": `{"replaces": "test.v0.2.0"}`,
+			})
+			bundleEntity := olmentity.NewBundleEntity(entity)
+			replaces, err := bundleEntity.Replaces()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(replaces).To(Equal("test.v0.2.0"))
+		})
+		It("should not return an error if the property is not found", func() {
+			entity := input.NewEntity("test", map[string]string{
+				"olm.thingy": `{"whatever":"this"}`,
+			})
+			bundleEntity := olmentity.NewBundleEntity(entity)
+			replaces, err := bundleEntity.Replaces()
+			Expect(replaces).To(BeEmpty())
+			Expect(err).NotTo(HaveOccurred())
+		})
+	})
+
 	Describe("MediaType", func() {
 		It("should return the bundle mediatype property if present", func() {
 			entity := input.NewEntity("operatorhub/prometheus/0.14.0", map[string]string{

internal/resolution/entitysources/catalogdsource.go

@@ -71,6 +71,10 @@ func (es *CatalogdEntitySource) Iterate(ctx context.Context, fn input.IteratorFu
 	return nil
 }
 
+type replacesProperty struct {
+	Replaces string `json:"replaces"`
+}
+
 func getEntities(ctx context.Context, client client.Client) (input.EntityList, error) {
 	entityList := input.EntityList{}
 	bundleMetadatas, packageMetdatas, err := fetchMetadata(ctx, client)
@@ -106,6 +110,9 @@ func getEntities(ctx context.Context, client client.Client) (input.EntityList, e
 				if catalogScopedEntryName == bundle.Name {
 					channelValue, _ := json.Marshal(property.Channel{ChannelName: ch.Name, Priority: 0})
 					props[property.TypeChannel] = string(channelValue)
+					// TODO(jmprusi): Add the proper PropertyType for this
+					replacesValue, _ := json.Marshal(replacesProperty{Replaces: b.Replaces})
+					props["olm.replaces"] = string(replacesValue)
 					entity := input.Entity{
 						ID:         deppy.IdentifierFromString(fmt.Sprintf("%s%s%s", bundle.Name, bundle.Spec.Package, ch.Name)),
 						Properties: props,

internal/resolution/util/predicates/predicates.go

@@ -56,3 +56,25 @@ func ProvidesGVK(gvk *olmentity.GVK) input.Predicate {
 		return false
 	}
 }
+
+func WithBundleImage(bundleImage string) input.Predicate {
+	return func(entity *input.Entity) bool {
+		bundleEntity := olmentity.NewBundleEntity(entity)
+		bundlePath, err := bundleEntity.BundlePath()
+		if err != nil {
+			return false
+		}
+		return bundlePath == bundleImage
+	}
+}
+
+func Replaces(bundleID string) input.Predicate {
+	return func(entity *input.Entity) bool {
+		bundleEntity := olmentity.NewBundleEntity(entity)
+		replaces, err := bundleEntity.Replaces()
+		if err != nil {
+			return false
+		}
+		return replaces == bundleID
+	}
+}

internal/resolution/util/predicates/predicates_test.go

@@ -68,4 +68,24 @@ var _ = Describe("Predicates", func() {
 			})(entity)).To(BeFalse())
 		})
 	})
+
+	Describe("WithBundleImage", func() {
+		It("should return true when the entity provides the same bundle image", func() {
+			entity := input.NewEntity("test", map[string]string{
+				olmentity.PropertyBundlePath: `"registry.io/repo/image@sha256:1234567890"`,
+			})
+			Expect(predicates.WithBundleImage("registry.io/repo/image@sha256:1234567890")(entity)).To(BeTrue())
+			Expect(predicates.WithBundleImage("registry.io/repo/image@sha256:0987654321")(entity)).To(BeFalse())
+		})
+	})
+
+	Describe("Replaces", func() {
+		It("should return true when the entity provides the replaces property", func() {
+			entity := input.NewEntity("test", map[string]string{
+				"olm.replaces": `{"replaces": "test.v0.2.0"}`,
+			})
+			Expect(predicates.Replaces("test.v0.2.0")(entity)).To(BeTrue())
+			Expect(predicates.Replaces("test.v0.1.0")(entity)).To(BeFalse())
+		})
+	})
 })

internal/resolution/util/sort/sort.go

@@ -55,8 +55,8 @@ func packageOrder(e1, e2 *entities.BundleEntity) int {
 }
 
 func channelOrder(e1, e2 *entities.BundleEntity) int {
-	channelProperties1, err1 := e1.ChannelProperties()
-	channelProperties2, err2 := e2.ChannelProperties()
+	channelProperties1, err1 := e1.Channel()
+	channelProperties2, err2 := e2.Channel()
 	errComp := compareErrors(err1, err2)
 	if errComp != 0 {
 		return errComp

internal/resolution/variables/installed_package.go

@@ -0,0 +1,32 @@
+package variables
+
+import (
+	"fmt"
+
+	"github.com/operator-framework/deppy/pkg/deppy"
+	"github.com/operator-framework/deppy/pkg/deppy/constraint"
+	"github.com/operator-framework/deppy/pkg/deppy/input"
+
+	olmentity "github.com/operator-framework/operator-controller/internal/resolution/entities"
+)
+
+type InstalledPackageVariable struct {
+	*input.SimpleVariable
+	bundleEntities []*olmentity.BundleEntity
+}
+
+func (r *InstalledPackageVariable) BundleEntities() []*olmentity.BundleEntity {
+	return r.bundleEntities
+}
+
+func NewInstalledPackageVariable(bundleImage string, bundleEntities []*olmentity.BundleEntity) *InstalledPackageVariable {
+	id := deppy.IdentifierFromString(fmt.Sprintf("installed package %s", bundleImage))
+	entityIDs := make([]deppy.Identifier, 0, len(bundleEntities))
+	for _, bundle := range bundleEntities {
+		entityIDs = append(entityIDs, bundle.ID)
+	}
+	return &InstalledPackageVariable{
+		SimpleVariable: input.NewSimpleVariable(id, constraint.Mandatory(), constraint.Dependency(entityIDs...)),
+		bundleEntities: bundleEntities,
+	}
+}

internal/resolution/variablesources/bundle_deployment.go

@@ -0,0 +1,58 @@
+package variablesources
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/operator-framework/deppy/pkg/deppy"
+	"github.com/operator-framework/deppy/pkg/deppy/input"
+	rukpakv1alpha1 "github.com/operator-framework/rukpak/api/v1alpha1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+var _ input.VariableSource = &BundleDeploymentVariableSource{}
+
+type BundleDeploymentVariableSource struct {
+	client              client.Client
+	inputVariableSource input.VariableSource
+}
+
+func NewBundleDeploymentVariableSource(cl client.Client, inputVariableSource input.VariableSource) *BundleDeploymentVariableSource {
+	return &BundleDeploymentVariableSource{
+		client:              cl,
+		inputVariableSource: inputVariableSource,
+	}
+}
+
+func (o *BundleDeploymentVariableSource) GetVariables(ctx context.Context, entitySource input.EntitySource) ([]deppy.Variable, error) {
+	variableSources := SliceVariableSource{}
+	if o.inputVariableSource != nil {
+		variableSources = append(variableSources, o.inputVariableSource)
+	}
+
+	bundleDeployments := rukpakv1alpha1.BundleDeploymentList{}
+	if err := o.client.List(ctx, &bundleDeployments); err != nil {
+		return nil, err
+	}
+
+	processed := map[string]struct{}{}
+	if len(bundleDeployments.Items) > 1 {
+		fmt.Println("hello")
+	}
+	for _, bundleDeployment := range bundleDeployments.Items {
+		sourceImage := bundleDeployment.Spec.Template.Spec.Source.Image
+		if sourceImage != nil && sourceImage.Ref != "" {
+			if _, ok := processed[sourceImage.Ref]; ok {
+				continue
+			}
+			processed[sourceImage.Ref] = struct{}{}
+			ips, err := NewInstalledPackageVariableSource(bundleDeployment.Spec.Template.Spec.Source.Image.Ref)
+			if err != nil {
+				return nil, err
+			}
+			variableSources = append(variableSources, ips)
+		}
+	}
+
+	return variableSources.GetVariables(ctx, entitySource)
+}