Constraints satisfication checks

pkg/collectionutil/slices.go

@@ -22,3 +22,12 @@ func FlattenUnique[E comparable](slices ...[]E) []E {
 
 	return result
 }
+
+func Contains[E comparable](slice []E, elem E) bool {
+	for _, e := range slice {
+		if e == elem {
+			return true
+		}
+	}
+	return false
+}

pkg/collectionutil/slices_test.go

@@ -67,3 +67,36 @@ func Test_AppendUnique(t *testing.T) {
 		})
 	}
 }
+
+func Test_Contains(t *testing.T) {
+	cases := []struct {
+		name   string
+		inputs []int
+		b      int
+		want   bool
+	}{
+		{
+			name: "contains",
+			inputs: []int{
+				4, 5, 6,
+			},
+			b:    4,
+			want: true,
+		},
+		{
+			name: " does not contain",
+			inputs: []int{
+				4, 5, 6,
+			},
+			b:    3,
+			want: false,
+		},
+	}
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			assert := assert.New(t)
+			actual := Contains(tt.inputs, tt.b)
+			assert.Equal(tt.want, actual)
+		})
+	}
+}

pkg/core/construct_graph.go

@@ -86,7 +86,7 @@ func (cg *ConstructGraph) GetUpstreamConstructs(source BaseConstruct) []BaseCons
 func (cg *ConstructGraph) ShortestPath(source ResourceId, dest ResourceId) ([]BaseConstruct, error) {
 	ids, err := cg.underlying.ShortestPath(source.String(), dest.String())
 	if err != nil {
-		return []BaseConstruct{}, err
+		return nil, err
 	}
 	resources := make([]BaseConstruct, len(ids))
 	for i, id := range ids {

pkg/core/resource_graph.go

@@ -27,7 +27,7 @@ func NewResourceGraph() *ResourceGraph {
 func (rg *ResourceGraph) ShortestPath(source ResourceId, dest ResourceId) ([]Resource, error) {
 	ids, err := rg.underlying.ShortestPath(source.String(), dest.String())
 	if err != nil {
-		return []Resource{}, err
+		return nil, err
 	}
 	resources := make([]Resource, len(ids))
 	for i, id := range ids {
@@ -97,9 +97,9 @@ func GetResource[T Resource](g *ResourceGraph, id ResourceId) (resource T, ok bo
 }
 
 func (rg *ResourceGraph) FindResourcesWithRef(id ResourceId) []Resource {
-	result := []Resource{}
+	var result []Resource
 	for _, resource := range rg.ListResources() {
-		if resource.BaseConstructsRef().HasId(id) {
+		if resource.BaseConstructsRef().Has(id) {
 			result = append(result, resource)
 		}
 	}

pkg/core/resources.go

@@ -23,7 +23,7 @@ type (
 		AnnotationCapability() string
 	}
 
-	BaseConstructSet map[BaseConstruct]struct{}
+	BaseConstructSet map[ResourceId]BaseConstruct
 
 	// Resource describes a resource at the provider, infrastructure level
 	Resource interface {
@@ -158,30 +158,21 @@ func (s *BaseConstructSet) Add(k BaseConstruct) {
 	if *s == nil {
 		*s = make(BaseConstructSet)
 	}
-	(*s)[k] = struct{}{}
+	(*s)[k.Id()] = k
 }
 
-func (s BaseConstructSet) Has(k BaseConstruct) bool {
+func (s BaseConstructSet) Has(k ResourceId) bool {
 	_, ok := s[k]
 	return ok
 }
 
-func (s BaseConstructSet) HasId(k ResourceId) bool {
-	for c := range s {
-		if c.Id() == k {
-			return true
-		}
-	}
-	return false
-}
-
 func (s BaseConstructSet) Delete(k BaseConstruct) {
-	delete(s, k)
+	delete(s, k.Id())
 }
 
 func (s *BaseConstructSet) AddAll(ks BaseConstructSet) {
-	for k := range ks {
-		s.Add(k)
+	for _, c := range ks {
+		s.Add(c)
 	}
 }
 

pkg/engine/constraints/application_constraint.go

@@ -8,64 +8,71 @@ import (
 
 type (
 	// ApplicationConstraint is a struct that represents constraints that can be applied on the entire resource graph
+	//
+	// Example
+	//
+	// To specify a constraint detailing application level intents in yaml
+	//
+	//- scope: application
+	//  operator: add
+	//  node: klotho:execution_unit:my_compute
+	//
+	// The end result of this should be that the execution unit construct is added to the construct graph for processing
 	ApplicationConstraint struct {
 		Operator        ConstraintOperator `yaml:"operator"`
 		Node            core.ResourceId    `yaml:"node"`
 		ReplacementNode core.ResourceId    `yaml:"replacement_node"`
 	}
 )
 
-func (b *ApplicationConstraint) Scope() ConstraintScope {
-	return EdgeConstraintScope
+func (constraint *ApplicationConstraint) Scope() ConstraintScope {
+	return ApplicationConstraintScope
 }
 
-func (b *ApplicationConstraint) IsSatisfied(dag *core.ResourceGraph) bool {
-	switch b.Operator {
+func (constraint *ApplicationConstraint) IsSatisfied(dag *core.ResourceGraph) bool {
+	switch constraint.Operator {
 	case AddConstraintOperator:
 		// If the add was for a construct, we need to check if any resource references the construct
-		if b.Node.Provider == core.AbstractConstructProvider {
-			return len(dag.FindResourcesWithRef(b.Node)) > 0
+		if constraint.Node.Provider == core.AbstractConstructProvider {
+			return len(dag.FindResourcesWithRef(constraint.Node)) > 0
 		}
-		return dag.GetResource(b.Node) != nil
+		return dag.GetResource(constraint.Node) != nil
 	case RemoveConstraintOperator:
 		// If the remove was for a construct, we need to check if any resource references the construct
-		if b.Node.Provider == core.AbstractConstructProvider {
-			return len(dag.FindResourcesWithRef(b.Node)) == 0
+		if constraint.Node.Provider == core.AbstractConstructProvider {
+			return len(dag.FindResourcesWithRef(constraint.Node)) == 0
 		}
-		return dag.GetResource(b.Node) == nil
+		return dag.GetResource(constraint.Node) == nil
 	case ReplaceConstraintOperator:
-		// We should entail edges are copied from the original source to the new replacement node in the dag
-		// Ignoring for now, but will be an optimization we can make
+
+		// We should ensure edges are copied from the original source to the new replacement node in the dag
+		// Ignoring for now, but will be an extra check we can make later to ensure that the Replace constraint is fully satisfied
 
 		// If any of the nodes are abstract constructs, we need to check if any resource references the construct
-		if b.Node.Provider == core.AbstractConstructProvider && b.ReplacementNode.Provider == core.AbstractConstructProvider {
-			return len(dag.FindResourcesWithRef(b.Node)) == 0 && len(dag.FindResourcesWithRef(b.ReplacementNode)) > 0
-		} else if b.Node.Provider == core.AbstractConstructProvider && b.ReplacementNode.Provider != core.AbstractConstructProvider {
-			return len(dag.FindResourcesWithRef(b.Node)) == 0 && dag.GetResource(b.ReplacementNode) != nil
-		} else if b.Node.Provider != core.AbstractConstructProvider && b.ReplacementNode.Provider == core.AbstractConstructProvider {
-			return dag.GetResource(b.Node) == nil && len(dag.FindResourcesWithRef(b.Node)) > 0
+		if constraint.Node.Provider == core.AbstractConstructProvider && constraint.ReplacementNode.Provider == core.AbstractConstructProvider {
+			return len(dag.FindResourcesWithRef(constraint.Node)) == 0 && len(dag.FindResourcesWithRef(constraint.ReplacementNode)) > 0
+		} else if constraint.Node.Provider == core.AbstractConstructProvider && constraint.ReplacementNode.Provider != core.AbstractConstructProvider {
+			return len(dag.FindResourcesWithRef(constraint.Node)) == 0 && dag.GetResource(constraint.ReplacementNode) != nil
+		} else if constraint.Node.Provider != core.AbstractConstructProvider && constraint.ReplacementNode.Provider == core.AbstractConstructProvider {
+			return dag.GetResource(constraint.Node) == nil && len(dag.FindResourcesWithRef(constraint.Node)) > 0
 		}
-		return dag.GetResource(b.Node) == nil && dag.GetResource(b.ReplacementNode) != nil
+		return dag.GetResource(constraint.Node) == nil && dag.GetResource(constraint.ReplacementNode) != nil
 	}
 	return false
 }
 
-func (b *ApplicationConstraint) Conflict(other Constraint) bool {
-	return false
-}
-
-func (b *ApplicationConstraint) Validate() error {
-	if b.Operator == ReplaceConstraintOperator && (b.Node == core.ResourceId{} || b.ReplacementNode == core.ResourceId{}) {
+func (constraint *ApplicationConstraint) Validate() error {
+	if constraint.Operator == ReplaceConstraintOperator && (constraint.Node == core.ResourceId{} || constraint.ReplacementNode == core.ResourceId{}) {
 		return errors.New("replace constraint must have a node and replacement node defined")
 	}
-	if b.Operator == ReplaceConstraintOperator && b.Node.Provider != core.AbstractConstructProvider && b.ReplacementNode.Provider == core.AbstractConstructProvider {
+	if constraint.Operator == ReplaceConstraintOperator && constraint.Node.Provider != core.AbstractConstructProvider && constraint.ReplacementNode.Provider == core.AbstractConstructProvider {
 		return errors.New("replace constraint cannot replace a resource with an abstract construct")
 	}
-	if b.Operator == AddConstraintOperator && (b.Node == core.ResourceId{}) {
+	if constraint.Operator == AddConstraintOperator && (constraint.Node == core.ResourceId{}) {
 		return errors.New("add constraint must have a node defined")
 	}
 
-	if b.Operator == RemoveConstraintOperator && (b.Node == core.ResourceId{}) {
+	if constraint.Operator == RemoveConstraintOperator && (constraint.Node == core.ResourceId{}) {
 		return errors.New("remove constraint must have a node defined")
 	}
 	return nil

pkg/engine/constraints/constraint.go

@@ -3,9 +3,9 @@ package constraints
 import (
 	"errors"
 	"fmt"
-	"os"
 	"reflect"
 
+	"github.com/klothoplatform/klotho/pkg/collectionutil"
 	"github.com/klothoplatform/klotho/pkg/core"
 	"gopkg.in/yaml.v3"
 	"k8s.io/utils/strings/slices"
@@ -20,9 +20,6 @@ type (
 		// IsSatisfied returns whether or not the constraint is satisfied based on the resource graph
 		// For a resource graph to be valid all constraints must be satisfied
 		IsSatisfied(dag *core.ResourceGraph) bool
-		// Conflict returns whether or not the constraint conflicts with another constraint
-		// If constraints conflict, then the constraints passed in are unsolveable
-		Conflict(other Constraint) bool
 		// Validate returns whether or not the constraint is valid
 		Validate() error
 	}
@@ -49,7 +46,7 @@ const (
 	ApplicationConstraintScope ConstraintScope = "application"
 	ConstructConstraintScope   ConstraintScope = "construct"
 	EdgeConstraintScope        ConstraintScope = "edge"
-	NodeConstraintScope        ConstraintScope = "node"
+	ResourceConstraintScope    ConstraintScope = "resource"
 
 	MustExistConstraintOperator      ConstraintOperator = "must_exist"
 	MustNotExistConstraintOperator   ConstraintOperator = "must_not_exist"
@@ -76,21 +73,16 @@ func DecodeYAMLNode[T interface {
 	return constraint, err
 }
 
-// ParseConstraintsFromFile is a helper function that parses a yaml file into a map of constraints
+// ParseConstraintsFromFile parses a yaml file into a map of constraints
 //
 // Future spec may include ordering of the application of constraints, but for now we assume that the order of the constraints is based on the yaml file and they cannot be grouped outside of scope
-func ParseConstraintsFromFile(path string) (map[ConstraintScope][]Constraint, error) {
+func ParseConstraintsFromFile(bytes []byte) (map[ConstraintScope][]Constraint, error) {
 	constraints := map[ConstraintScope][]Constraint{}
-	f, err := os.Open(path)
-	if err != nil {
-		return constraints, err
-	}
-	defer f.Close() // nolint:errcheck
 
 	node := &yaml.Node{}
-	err = yaml.NewDecoder(f).Decode(node)
+	err := yaml.Unmarshal(bytes, node)
 	if err != nil {
-		return constraints, err
+		return nil, err
 	}
 
 	var joinedErr error
@@ -104,25 +96,25 @@ func ParseConstraintsFromFile(path string) (map[ConstraintScope][]Constraint, er
 			}
 			switch base.Scope {
 			case ApplicationConstraintScope:
-				appConstraint, err := DecodeYAMLNode[*ApplicationConstraint](a)
+				constraint, err := DecodeYAMLNode[*ApplicationConstraint](a)
 				if err != nil {
 					joinedErr = errors.Join(joinedErr, err)
 					continue
 				}
-				validOperators := []string{string(AddConstraintOperator), string(RemoveConstraintOperator), string(ReplaceConstraintOperator)}
-				if !slices.Contains(validOperators, string(appConstraint.Operator)) {
-					joinedErr = errors.Join(joinedErr, fmt.Errorf("invalid operator %s for application constraint", appConstraint.Operator))
+				validOperators := []ConstraintOperator{AddConstraintOperator, RemoveConstraintOperator, ReplaceConstraintOperator}
+				if !collectionutil.Contains(validOperators, constraint.Operator) {
+					joinedErr = errors.Join(joinedErr, fmt.Errorf("invalid operator %s for application constraint", constraint.Operator))
 					continue
 				}
-				constraints[ApplicationConstraintScope] = append(constraints[ApplicationConstraintScope], appConstraint)
+				constraints[ApplicationConstraintScope] = append(constraints[ApplicationConstraintScope], constraint)
 			case ConstructConstraintScope:
 				constraint, err := DecodeYAMLNode[*ConstructConstraint](a)
 				if err != nil {
 					joinedErr = errors.Join(joinedErr, err)
 					continue
 				}
-				validOperators := []string{string(EqualsConstraintOperator)}
-				if !slices.Contains(validOperators, string(constraint.Operator)) {
+				validOperators := []ConstraintOperator{EqualsConstraintOperator}
+				if !collectionutil.Contains(validOperators, constraint.Operator) {
 					joinedErr = errors.Join(joinedErr, fmt.Errorf("invalid operator %s for application constraint", constraint.Operator))
 					continue
 				}
@@ -133,24 +125,24 @@ func ParseConstraintsFromFile(path string) (map[ConstraintScope][]Constraint, er
 					joinedErr = errors.Join(joinedErr, err)
 					continue
 				}
-				validOperators := []string{string(MustContainConstraintOperator), string(MustNotContainConstraintOperator), string(MustExistConstraintOperator), string(MustNotExistConstraintOperator)}
-				if !slices.Contains(validOperators, string(constraint.Operator)) {
+				validOperators := []ConstraintOperator{MustContainConstraintOperator, MustNotContainConstraintOperator, MustExistConstraintOperator, MustNotExistConstraintOperator}
+				if !collectionutil.Contains(validOperators, constraint.Operator) {
 					joinedErr = errors.Join(joinedErr, fmt.Errorf("invalid operator %s for application constraint", constraint.Operator))
 					continue
 				}
 				constraints[EdgeConstraintScope] = append(constraints[EdgeConstraintScope], constraint)
-			case NodeConstraintScope:
-				constraint, err := DecodeYAMLNode[*NodeConstraint](a)
+			case ResourceConstraintScope:
+				constraint, err := DecodeYAMLNode[*ResourceConstraint](a)
 				if err != nil {
 					joinedErr = errors.Join(joinedErr, err)
 					continue
 				}
-				validOperators := []string{string(EqualsConstraintOperator)}
-				if !slices.Contains(validOperators, string(constraint.Operator)) {
+				validOperators := []ConstraintOperator{EqualsConstraintOperator}
+				if !collectionutil.Contains(validOperators, constraint.Operator) {
 					joinedErr = errors.Join(joinedErr, fmt.Errorf("invalid operator %s for application constraint", constraint.Operator))
 					continue
 				}
-				constraints[NodeConstraintScope] = append(constraints[NodeConstraintScope], constraint)
+				constraints[ResourceConstraintScope] = append(constraints[ResourceConstraintScope], constraint)
 			}
 		}
 	}
@@ -160,9 +152,14 @@ func ParseConstraintsFromFile(path string) (map[ConstraintScope][]Constraint, er
 // extraFields is a helper function that checks if there are any extra fields in a yaml node that are not in the struct
 // Because you cant use the KnownFields in a nodes decode funtion we handle it ourselves
 func extraFields(n *yaml.Node, object reflect.Value) error {
-	knownFields := []string{}
+	knownFields := []string{"scope"}
 	for i := 0; i < object.Elem().NumField(); i++ {
-		knownFields = append(knownFields, object.Elem().Type().Field(i).Tag.Get("yaml"))
+		fieldName := object.Elem().Type().Field(i).Name
+		yamlTag := object.Elem().Type().Field(i).Tag.Get("yaml")
+		if yamlTag != "" {
+			fieldName = yamlTag
+		}
+		knownFields = append(knownFields, fieldName)
 	}
 
 	if n.Kind != yaml.MappingNode {
@@ -174,7 +171,7 @@ func extraFields(n *yaml.Node, object reflect.Value) error {
 	}
 
 	for k := range m {
-		if !slices.Contains(knownFields, k) && k != "scope" {
+		if !slices.Contains(knownFields, k) {
 			return fmt.Errorf("unexpected field %s", k)
 		}
 	}