Remove ConstraintProvider from the exported solver package API. (#2675)

This interface is a resolver package concern, so its definition can
live beside the code that accepts it. Removing it from solver also
removes the only solver->cache package dependency.

As I understand it, the only way to inject an implementation of this
interface today is by having access to unexported fields of
resolver.Resolver, so for now I've also made the interface
unexported. In the context of the ongoing desire to support resolution
as a separate library module, this will allow more time to evaluate
the shape of a stable library API.

Signed-off-by: Ben Luddy <[email protected]>

Author: benluddy

pkg/controller/registry/resolver/resolver.go

@@ -19,11 +19,20 @@ import (
 	opregistry "github.com/operator-framework/operator-registry/pkg/registry"
 )
 
+// constraintProvider knows how to provide solver constraints for a given cache entry.
+// For instance, it could be used to surface additional constraints against an entry given some
+// properties it may expose. E.g. olm.maxOpenShiftVersion could be checked against the cluster version
+// and prohibit any entry that doesn't meet the requirement
+type constraintProvider interface {
+	// Constraints returns a set of solver constraints for a cache entry.
+	Constraints(e *cache.Entry) ([]solver.Constraint, error)
+}
+
 type Resolver struct {
 	cache                     cache.OperatorCacheProvider
 	log                       logrus.FieldLogger
 	pc                        *predicateConverter
-	systemConstraintsProvider solver.ConstraintProvider
+	systemConstraintsProvider constraintProvider
 }
 
 func NewDefaultResolver(rcp cache.SourceProvider, sourcePriorityProvider cache.SourcePriorityProvider, logger logrus.FieldLogger) *Resolver {

pkg/controller/registry/resolver/resolver_test.go

@@ -80,6 +80,13 @@ func TestSolveOperators(t *testing.T) {
 	require.ElementsMatch(t, expected, operators)
 }
 
+// ConstraintProviderFunc is a simple implementation of ConstraintProvider
+type ConstraintProviderFunc func(e *cache.Entry) ([]solver.Constraint, error)
+
+func (c ConstraintProviderFunc) Constraints(e *cache.Entry) ([]solver.Constraint, error) {
+	return c(e)
+}
+
 func TestSolveOperators_WithSystemConstraints(t *testing.T) {
 	const namespace = "test-namespace"
 	catalog := cache.SourceKey{Name: "test-catalog", Namespace: namespace}
@@ -99,7 +106,7 @@ func TestSolveOperators_WithSystemConstraints(t *testing.T) {
 	existingPackageD := existingOperator(namespace, "packageD.v1", "packageD", "alpha", "", nil, nil, nil, nil)
 	existingPackageD.Annotations = map[string]string{"operatorframework.io/properties": `{"properties":[{"type":"olm.package","value":{"packageName":"packageD","version":"1.0.0"}}]}`}
 
-	whiteListConstraintProvider := func(whiteList ...*cache.Entry) solver.ConstraintProviderFunc {
+	whiteListConstraintProvider := func(whiteList ...*cache.Entry) ConstraintProviderFunc {
 		return func(entry *cache.Entry) ([]solver.Constraint, error) {
 			for _, whiteListedEntry := range whiteList {
 				if whiteListedEntry.Package() == entry.Package() &&
@@ -117,7 +124,7 @@ func TestSolveOperators_WithSystemConstraints(t *testing.T) {
 
 	testCases := []struct {
 		title                     string
-		systemConstraintsProvider solver.ConstraintProvider
+		systemConstraintsProvider constraintProvider
 		expectedOperators         []*cache.Entry
 		csvs                      []*v1alpha1.ClusterServiceVersion
 		subs                      []*v1alpha1.Subscription