Use constraints library from api with simplified CEL library

Signed-off-by: Vu Dinh <[email protected]>

Author: dinhxuanvu

Diff for: pkg/controller/registry/resolver/cache/predicates.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/blang/semver/v4"
 
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/constraints"
+	"github.com/operator-framework/api/pkg/constraints"
 	opregistry "github.com/operator-framework/operator-registry/pkg/registry"
 )
 
@@ -331,13 +331,13 @@ func CountingPredicate(p Predicate, n *int) Predicate {
 	return countingPredicate{p: p, n: n}
 }
 
-type evaluatorPredicate struct {
-	evaluator constraints.Evaluator
-	rule      string
-	message   string
+type celPredicate struct {
+	program constraints.CelProgram
+	rule    string
+	message string
 }
 
-func (ep *evaluatorPredicate) Test(entry *Entry) bool {
+func (cp *celPredicate) Test(entry *Entry) bool {
 	props := make([]map[string]interface{}, len(entry.Properties))
 	for i, p := range entry.Properties {
 		var v interface{}
@@ -350,21 +350,21 @@ func (ep *evaluatorPredicate) Test(entry *Entry) bool {
 		}
 	}
 
-	ok, err := ep.evaluator.Evaluate(map[string]interface{}{"properties": props})
+	ok, err := cp.program.Evaluate(map[string]interface{}{"properties": props})
 	if err != nil {
 		return false
 	}
 	return ok
 }
 
-func EvaluatorPredicate(provider constraints.EvaluatorProvider, rule string, message string) (Predicate, error) {
-	eval, err := provider.Evaluator(rule)
+func CreateCelPredicate(env *constraints.CelEnvironment, rule string, message string) (Predicate, error) {
+	prog, err := env.Validate(rule)
 	if err != nil {
 		return nil, err
 	}
-	return &evaluatorPredicate{evaluator: eval, rule: rule, message: message}, nil
+	return &celPredicate{program: prog, rule: rule, message: message}, nil
 }
 
-func (ep *evaluatorPredicate) String() string {
-	return fmt.Sprintf("with constraint: %q and message: %q", ep.rule, ep.message)
+func (cp *celPredicate) String() string {
+	return fmt.Sprintf("with constraint: %q and message: %q", cp.rule, cp.message)
 }

Diff for: pkg/controller/registry/resolver/resolver.go

@@ -11,10 +11,10 @@ import (
 	"github.com/sirupsen/logrus"
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
 
+	"github.com/operator-framework/api/pkg/constraints"
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	v1alpha1listers "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/constraints"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/projection"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver"
 	"github.com/operator-framework/operator-registry/pkg/api"
@@ -26,16 +26,16 @@ type OperatorResolver interface {
 }
 
 type SatResolver struct {
-	cache             cache.OperatorCacheProvider
-	log               logrus.FieldLogger
-	evaluatorProvider constraints.EvaluatorProvider
+	cache  cache.OperatorCacheProvider
+	log    logrus.FieldLogger
+	celEnv *constraints.CelEnvironment
 }
 
 func NewDefaultSatResolver(rcp cache.SourceProvider, catsrcLister v1alpha1listers.CatalogSourceLister, logger logrus.FieldLogger) *SatResolver {
 	return &SatResolver{
-		cache:             cache.New(rcp, cache.WithLogger(logger), cache.WithCatalogSourceLister(catsrcLister)),
-		log:               logger,
-		evaluatorProvider: constraints.NewCelEvaluatorProvider(),
+		cache:  cache.New(rcp, cache.WithLogger(logger), cache.WithCatalogSourceLister(catsrcLister)),
+		log:    logger,
+		celEnv: constraints.NewCelEnvironment(),
 	}
 }
 
@@ -351,17 +351,13 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta
 				continue
 			}
 
-			var val struct {
-				Message string           `json:"message"`
-				Cel     *constraints.Cel `json:"cel"`
-			}
-
+			var val constraints.Constraint
 			if err := json.Unmarshal([]byte(prop.Value), &val); err != nil {
 				errs = append(errs, err)
 				continue
 			}
 
-			pred, err := cache.EvaluatorPredicate(r.evaluatorProvider, val.Cel.Rule, val.Message)
+			pred, err := cache.CreateCelPredicate(r.celEnv, val.Cel.Rule, val.Message)
 			if err != nil {
 				errs = append(errs, err)
 				continue

Diff for: pkg/controller/registry/resolver/resolver_test.go

@@ -14,11 +14,11 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 
+	"github.com/operator-framework/api/pkg/constraints"
 	opver "github.com/operator-framework/api/pkg/lib/version"
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	listersv1alpha1 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/constraints"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver"
 	"github.com/operator-framework/operator-registry/pkg/api"
 	opregistry "github.com/operator-framework/operator-registry/pkg/registry"
@@ -2169,8 +2169,8 @@ func TestSolveOperators_GenericConstraint(t *testing.T) {
 				cache: cache.New(cache.StaticSourceProvider{
 					catalog: tt.catalog,
 				}),
-				log:               logrus.New(),
-				evaluatorProvider: constraints.NewCelEvaluatorProvider(),
+				log:    logrus.New(),
+				celEnv: constraints.NewCelEnvironment(),
 			}
 
 			operators, err = satResolver.SolveOperators([]string{namespace}, nil, tt.subs)