adding satisfication methods for constraints

go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/bmatcuk/doublestar/v4 v4.2.0
 	github.com/coreos/go-semver v0.3.0
 	github.com/davecgh/go-spew v1.1.1
-	github.com/dominikbraun/graph v0.16.1
+	github.com/dominikbraun/graph v0.22.2
 	github.com/fatih/color v1.13.0
 	github.com/gojek/heimdall/v7 v7.0.2
 	github.com/golang-jwt/jwt/v4 v4.4.3

go.sum

@@ -172,6 +172,8 @@ github.com/docker/libtrust v0.0.0-20150114040149-fa567046d9b1 h1:ZClxb8laGDf5arX
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
 github.com/dominikbraun/graph v0.16.1 h1:ZtzDQFo32vxwSUsK4ioX8bfE45xoh8hQfavFMlKpaC8=
 github.com/dominikbraun/graph v0.16.1/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=
+github.com/dominikbraun/graph v0.22.2 h1:rFtrufgqXJy7daEMTxHIQWQc12Y1XHelXi2Heo1Bfho=
+github.com/dominikbraun/graph v0.22.2/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=
 github.com/dprotaso/go-yit v0.0.0-20191028211022-135eb7262960 h1:aRd8M7HJVZOqn/vhOzrGcQH0lNAMkqMn+pXUYkatmcA=
 github.com/dprotaso/go-yit v0.0.0-20191028211022-135eb7262960/go.mod h1:9HQzr9D/0PGwMEbC3d5AB7oi67+h4TsQqItC1GVYG58=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=

pkg/core/construct_graph.go

@@ -83,6 +83,18 @@ func (cg *ConstructGraph) GetUpstreamConstructs(source BaseConstruct) []BaseCons
 	return cg.underlying.IncomingVertices(source)
 }
 
+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
+	}
+	resources := make([]BaseConstruct, len(ids))
+	for i, id := range ids {
+		resources[i] = cg.underlying.GetVertex(id)
+	}
+	return resources, nil
+}
+
 func (cg *ConstructGraph) GetResourcesOfCapability(capability string) (filtered []Construct) {
 	vertices := cg.underlying.GetAllVertices()
 	for _, v := range vertices {

pkg/core/resource_graph.go

@@ -24,6 +24,18 @@ 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
+	}
+	resources := make([]Resource, len(ids))
+	for i, id := range ids {
+		resources[i] = rg.underlying.GetVertex(id)
+	}
+	return resources, nil
+}
+
 func (rg *ResourceGraph) AddResource(resource Resource) {
 	if rg.GetResource(resource.Id()) == nil {
 		rg.underlying.AddVertex(resource)
@@ -84,6 +96,16 @@ func GetResource[T Resource](g *ResourceGraph, id ResourceId) (resource T, ok bo
 	return
 }
 
+func (rg *ResourceGraph) FindResourcesWithRef(id ResourceId) []Resource {
+	result := []Resource{}
+	for _, resource := range rg.ListResources() {
+		if resource.BaseConstructsRef().HasId(id) {
+			result = append(result, resource)
+		}
+	}
+	return result
+}
+
 func (rg *ResourceGraph) GetDependency(source ResourceId, target ResourceId) *graph.Edge[Resource] {
 	return rg.underlying.GetEdge(source.String(), target.String())
 }

pkg/core/resources.go

@@ -67,6 +67,8 @@ type (
 	HasLocalOutput interface {
 		OutputTo(dest string) error
 	}
+
+	Capability string
 )
 
 const (
@@ -164,6 +166,15 @@ func (s BaseConstructSet) Has(k BaseConstruct) bool {
 	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)
 }

pkg/engine/constraints/application_constraint.go

@@ -1,14 +1,17 @@
 package constraints
 
-import "github.com/klothoplatform/klotho/pkg/core"
+import (
+	"errors"
+
+	"github.com/klothoplatform/klotho/pkg/core"
+)
 
 type (
 	// ApplicationConstraint is a struct that represents constraints that can be applied on the entire resource graph
 	ApplicationConstraint struct {
 		Operator        ConstraintOperator `yaml:"operator"`
 		Node            core.ResourceId    `yaml:"node"`
 		ReplacementNode core.ResourceId    `yaml:"replacement_node"`
-		Edge            Edge               `yaml:"edge"`
 	}
 )
 
@@ -17,13 +20,53 @@ func (b *ApplicationConstraint) Scope() ConstraintScope {
 }
 
 func (b *ApplicationConstraint) IsSatisfied(dag *core.ResourceGraph) bool {
-	return false
-}
+	switch b.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
+		}
+		return dag.GetResource(b.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
+		}
+		return dag.GetResource(b.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
 
-func (b *ApplicationConstraint) Apply(dag *core.ResourceGraph) error {
-	return nil
+		// 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
+		}
+		return dag.GetResource(b.Node) == nil && dag.GetResource(b.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{}) {
+		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 {
+		return errors.New("replace constraint cannot replace a resource with an abstract construct")
+	}
+	if b.Operator == AddConstraintOperator && (b.Node == core.ResourceId{}) {
+		return errors.New("add constraint must have a node defined")
+	}
+
+	if b.Operator == RemoveConstraintOperator && (b.Node == core.ResourceId{}) {
+		return errors.New("remove constraint must have a node defined")
+	}
+	return nil
+}

pkg/engine/constraints/application_constraint_test.go

@@ -0,0 +1,182 @@
+package constraints
+
+import (
+	"testing"
+
+	"github.com/klothoplatform/klotho/pkg/core"
+	"github.com/klothoplatform/klotho/pkg/provider/aws/resources"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_ApplicationConstraint_IsSatisfied(t *testing.T) {
+	eu := &core.ExecutionUnit{Name: "compute"}
+	eu2 := &core.ExecutionUnit{Name: "compute2"}
+
+	tests := []struct {
+		name       string
+		constraint []ApplicationConstraint
+		resources  []core.Resource
+		want       bool
+	}{
+		{
+			name: "Add is satisfied",
+			constraint: []ApplicationConstraint{
+				{
+					Operator: AddConstraintOperator,
+					Node:     core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+				},
+				{
+					Operator: AddConstraintOperator,
+					Node:     core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also"},
+				},
+			},
+			resources: []core.Resource{
+				&resources.LambdaFunction{
+					Name: "my_function_also",
+				},
+				&resources.LambdaFunction{
+					Name:          "my_function",
+					ConstructsRef: core.BaseConstructSetOf(eu),
+				},
+			},
+			want: true,
+		},
+		{
+			name: "Add is not satisfied",
+			constraint: []ApplicationConstraint{
+				{
+					Operator: AddConstraintOperator,
+					Node:     core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+				},
+				{
+					Operator: AddConstraintOperator,
+					Node:     core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also"},
+				},
+			},
+			resources: []core.Resource{
+				&resources.LambdaFunction{
+					Name: "my_function",
+				},
+			},
+			want: false,
+		},
+		{
+			name: "remove is satisfied",
+			constraint: []ApplicationConstraint{
+				{
+					Operator: RemoveConstraintOperator,
+					Node:     core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+				},
+				{
+					Operator: RemoveConstraintOperator,
+					Node:     core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also"},
+				},
+			},
+			resources: []core.Resource{
+				&resources.LambdaFunction{
+					Name: "my_function",
+				},
+			},
+			want: true,
+		},
+		{
+			name: "remove is not satisfied",
+			constraint: []ApplicationConstraint{
+				{
+					Operator: RemoveConstraintOperator,
+					Node:     core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+				},
+				{
+					Operator: RemoveConstraintOperator,
+					Node:     core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also"},
+				},
+			},
+			resources: []core.Resource{
+				&resources.LambdaFunction{
+					Name: "my_function_also",
+				},
+				&resources.LambdaFunction{
+					Name:          "my_function",
+					ConstructsRef: core.BaseConstructSetOf(eu),
+				},
+			},
+			want: false,
+		},
+		{
+			name: "replace is satisfied",
+			constraint: []ApplicationConstraint{
+				{
+					Operator:        ReplaceConstraintOperator,
+					Node:            core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+					ReplacementNode: core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute2"},
+				},
+				{
+					Operator:        ReplaceConstraintOperator,
+					Node:            core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+					ReplacementNode: core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "lambda_compute"},
+				},
+				{
+					Operator:        ReplaceConstraintOperator,
+					Node:            core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also"},
+					ReplacementNode: core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also2"},
+				},
+			},
+			resources: []core.Resource{
+				&resources.LambdaFunction{
+					Name: "lambda_compute",
+				},
+				&resources.LambdaFunction{
+					Name: "my_function_also2",
+				},
+				&resources.LambdaFunction{
+					Name:          "my_function",
+					ConstructsRef: core.BaseConstructSetOf(eu2),
+				},
+			},
+			want: true,
+		},
+		{
+			name: "replace is not satisfied",
+			constraint: []ApplicationConstraint{
+				{
+					Operator:        ReplaceConstraintOperator,
+					Node:            core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+					ReplacementNode: core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute2"},
+				},
+				{
+					Operator:        ReplaceConstraintOperator,
+					Node:            core.ResourceId{Provider: core.AbstractConstructProvider, Type: core.EXECUTION_UNIT_TYPE, Name: "compute"},
+					ReplacementNode: core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "lambda_compute"},
+				},
+				{
+					Operator:        ReplaceConstraintOperator,
+					Node:            core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also"},
+					ReplacementNode: core.ResourceId{Provider: "aws", Type: "lambda_function", Name: "my_function_also2"},
+				},
+			},
+			resources: []core.Resource{
+				&resources.LambdaFunction{
+					Name: "my_function_also",
+				},
+				&resources.LambdaFunction{
+					Name:          "my_function",
+					ConstructsRef: core.BaseConstructSetOf(eu),
+				},
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert := assert.New(t)
+			dag := core.NewResourceGraph()
+			for _, res := range tt.resources {
+				dag.AddResource(res)
+			}
+			for _, constraint := range tt.constraint {
+				result := constraint.IsSatisfied(dag)
+				assert.Equalf(tt.want, result, "constraint %s is not satisfied", constraint)
+			}
+		})
+	}
+}