From 0ac53ae3ede3f38c90f96e5c46bbb7b84dd02f07 Mon Sep 17 00:00:00 2001 From: Kristin Laemmert Date: Tue, 29 Sep 2020 14:47:20 -0400 Subject: [PATCH] terraform: remove deprecated or unused Eval() bits --- terraform/eval.go | 62 ------------------- terraform/eval_check_prevent_destroy.go | 47 -------------- terraform/eval_diff.go | 39 ------------ terraform/eval_error.go | 21 ++----- terraform/eval_filter.go | 25 -------- terraform/eval_filter_operation.go | 49 --------------- terraform/eval_if.go | 26 -------- terraform/eval_noop.go | 8 --- terraform/eval_provider.go | 39 ------------ terraform/eval_provider_test.go | 28 --------- terraform/eval_sequence.go | 42 ------------- terraform/eval_sequence_test.go | 9 --- terraform/eval_state.go | 28 --------- terraform/eval_state_test.go | 82 ++++++++++++++++--------- terraform/eval_test.go | 40 ------------ terraform/graph.go | 27 -------- terraform/graph_walk.go | 13 +--- terraform/graph_walk_context.go | 45 -------------- terraform/node_resource_destroy.go | 7 +-- 19 files changed, 62 insertions(+), 575 deletions(-) delete mode 100644 terraform/eval.go delete mode 100644 terraform/eval_check_prevent_destroy.go delete mode 100644 terraform/eval_filter.go delete mode 100644 terraform/eval_filter_operation.go delete mode 100644 terraform/eval_if.go delete mode 100644 terraform/eval_noop.go delete mode 100644 terraform/eval_sequence.go delete mode 100644 terraform/eval_sequence_test.go delete mode 100644 terraform/eval_test.go diff --git a/terraform/eval.go b/terraform/eval.go deleted file mode 100644 index 2a8909aee..000000000 --- a/terraform/eval.go +++ /dev/null @@ -1,62 +0,0 @@ -package terraform - -import ( - "log" - - "github.com/hashicorp/terraform/tfdiags" -) - -// EvalNode is the interface that must be implemented by graph nodes to -// evaluate/execute. -type EvalNode interface { - // Eval evaluates this node with the given context. The second parameter - // are the argument values. These will match in order and 1-1 with the - // results of the Args() return value. - Eval(EvalContext) (interface{}, error) -} - -// GraphNodeEvalable is the interface that graph nodes must implement -// to enable valuation. -type GraphNodeEvalable interface { - EvalTree() EvalNode -} - -// EvalEarlyExitError is a special error return value that can be returned -// by eval nodes that does an early exit. -type EvalEarlyExitError struct{} - -func (EvalEarlyExitError) Error() string { return "early exit" } - -// Eval evaluates the given EvalNode with the given context, properly -// evaluating all args in the correct order. -func Eval(n EvalNode, ctx EvalContext) (interface{}, error) { - // Call the lower level eval which doesn't understand early exit, - // and if we early exit, it isn't an error. - result, err := EvalRaw(n, ctx) - if err != nil { - if _, ok := err.(EvalEarlyExitError); ok { - return nil, nil - } - } - - return result, err -} - -// EvalRaw is like Eval except that it returns all errors, even if they -// signal something normal such as EvalEarlyExitError. -func EvalRaw(n EvalNode, ctx EvalContext) (interface{}, error) { - log.Printf("[TRACE] eval: %T", n) - output, err := n.Eval(ctx) - if err != nil { - switch err.(type) { - case EvalEarlyExitError: - log.Printf("[TRACE] eval: %T, early exit err: %s", n, err) - case tfdiags.NonFatalError: - log.Printf("[WARN] eval: %T, non-fatal err: %s", n, err) - default: - log.Printf("[ERROR] eval: %T, err: %s", n, err) - } - } - - return output, err -} diff --git a/terraform/eval_check_prevent_destroy.go b/terraform/eval_check_prevent_destroy.go deleted file mode 100644 index e3400fe4c..000000000 --- a/terraform/eval_check_prevent_destroy.go +++ /dev/null @@ -1,47 +0,0 @@ -package terraform - -import ( - "fmt" - - "github.com/hashicorp/terraform/plans" - - "github.com/hashicorp/hcl/v2" - - "github.com/hashicorp/terraform/addrs" - "github.com/hashicorp/terraform/configs" - "github.com/hashicorp/terraform/tfdiags" -) - -// EvalPreventDestroy is an EvalNode implementation that returns an -// error if a resource has PreventDestroy configured and the diff -// would destroy the resource. -type EvalCheckPreventDestroy struct { - Addr addrs.ResourceInstance - Config *configs.Resource - Change **plans.ResourceInstanceChange -} - -func (n *EvalCheckPreventDestroy) Eval(ctx EvalContext) (interface{}, error) { - if n.Change == nil || *n.Change == nil || n.Config == nil || n.Config.Managed == nil { - return nil, nil - } - - change := *n.Change - preventDestroy := n.Config.Managed.PreventDestroy - - if (change.Action == plans.Delete || change.Action.IsReplace()) && preventDestroy { - var diags tfdiags.Diagnostics - diags = diags.Append(&hcl.Diagnostic{ - Severity: hcl.DiagError, - Summary: "Instance cannot be destroyed", - Detail: fmt.Sprintf( - "Resource %s has lifecycle.prevent_destroy set, but the plan calls for this resource to be destroyed. To avoid this error and continue with the plan, either disable lifecycle.prevent_destroy or reduce the scope of the plan using the -target flag.", - n.Addr.Absolute(ctx.Path()).String(), - ), - Subject: &n.Config.DeclRange, - }) - return nil, diags.Err() - } - - return nil, nil -} diff --git a/terraform/eval_diff.go b/terraform/eval_diff.go index 7cda14ce1..4ca4215b5 100644 --- a/terraform/eval_diff.go +++ b/terraform/eval_diff.go @@ -789,45 +789,6 @@ func (n *EvalReduceDiff) Eval(ctx EvalContext) (interface{}, error) { return nil, nil } -// EvalReadDiff is an EvalNode implementation that retrieves the planned -// change for a particular resource instance object. -type EvalReadDiff struct { - Addr addrs.ResourceInstance - ProviderSchema **ProviderSchema - Change **plans.ResourceInstanceChange -} - -func (n *EvalReadDiff) Eval(ctx EvalContext) (interface{}, error) { - providerSchema := *n.ProviderSchema - changes := ctx.Changes() - addr := n.Addr.Absolute(ctx.Path()) - - schema, _ := providerSchema.SchemaForResourceAddr(n.Addr.ContainingResource()) - if schema == nil { - // Should be caught during validation, so we don't bother with a pretty error here - return nil, fmt.Errorf("provider does not support resource type %q", n.Addr.Resource.Type) - } - - gen := states.CurrentGen - csrc := changes.GetResourceInstanceChange(addr, gen) - if csrc == nil { - log.Printf("[TRACE] EvalReadDiff: No planned change recorded for %s", addr) - return nil, nil - } - - change, err := csrc.Decode(schema.ImpliedType()) - if err != nil { - return nil, fmt.Errorf("failed to decode planned changes for %s: %s", addr, err) - } - if n.Change != nil { - *n.Change = change - } - - log.Printf("[TRACE] EvalReadDiff: Read %s change from plan for %s", change.Action, addr) - - return nil, nil -} - // EvalWriteDiff is an EvalNode implementation that saves a planned change // for an instance object into the set of global planned changes. type EvalWriteDiff struct { diff --git a/terraform/eval_error.go b/terraform/eval_error.go index 470f798b7..853ea2cc8 100644 --- a/terraform/eval_error.go +++ b/terraform/eval_error.go @@ -1,20 +1,7 @@ package terraform -// EvalReturnError is an EvalNode implementation that returns an -// error if it is present. -// -// This is useful for scenarios where an error has been captured by -// another EvalNode (like EvalApply) for special EvalTree-based error -// handling, and that handling has completed, so the error should be -// returned normally. -type EvalReturnError struct { - Error *error -} +// EvalEarlyExitError is a special error return value that can be returned +// by eval nodes that does an early exit. +type EvalEarlyExitError struct{} -func (n *EvalReturnError) Eval(ctx EvalContext) (interface{}, error) { - if n.Error == nil { - return nil, nil - } - - return nil, *n.Error -} +func (EvalEarlyExitError) Error() string { return "early exit" } diff --git a/terraform/eval_filter.go b/terraform/eval_filter.go deleted file mode 100644 index 711c625c8..000000000 --- a/terraform/eval_filter.go +++ /dev/null @@ -1,25 +0,0 @@ -package terraform - -// EvalNodeFilterFunc is the callback used to replace a node with -// another to node. To not do the replacement, just return the input node. -type EvalNodeFilterFunc func(EvalNode) EvalNode - -// EvalNodeFilterable is an interface that can be implemented by -// EvalNodes to allow filtering of sub-elements. Note that this isn't -// a common thing to implement and you probably don't need it. -type EvalNodeFilterable interface { - EvalNode - Filter(EvalNodeFilterFunc) -} - -// EvalFilter runs the filter on the given node and returns the -// final filtered value. This should be called rather than checking -// the EvalNode directly since this will properly handle EvalNodeFilterables. -func EvalFilter(node EvalNode, fn EvalNodeFilterFunc) EvalNode { - if f, ok := node.(EvalNodeFilterable); ok { - f.Filter(fn) - return node - } - - return fn(node) -} diff --git a/terraform/eval_filter_operation.go b/terraform/eval_filter_operation.go deleted file mode 100644 index 1a55f024a..000000000 --- a/terraform/eval_filter_operation.go +++ /dev/null @@ -1,49 +0,0 @@ -package terraform - -// EvalNodeOpFilterable is an interface that EvalNodes can implement -// to be filterable by the operation that is being run on Terraform. -type EvalNodeOpFilterable interface { - IncludeInOp(walkOperation) bool -} - -// EvalNodeFilterOp returns a filter function that filters nodes that -// include themselves in specific operations. -func EvalNodeFilterOp(op walkOperation) EvalNodeFilterFunc { - return func(n EvalNode) EvalNode { - include := true - if of, ok := n.(EvalNodeOpFilterable); ok { - include = of.IncludeInOp(op) - } - if include { - return n - } - - return EvalNoop{} - } -} - -// EvalOpFilter is an EvalNode implementation that is a proxy to -// another node but filters based on the operation. -type EvalOpFilter struct { - // Ops is the list of operations to include this node in. - Ops []walkOperation - - // Node is the node to execute - Node EvalNode -} - -// TODO: test -func (n *EvalOpFilter) Eval(ctx EvalContext) (interface{}, error) { - return EvalRaw(n.Node, ctx) -} - -// EvalNodeOpFilterable impl. -func (n *EvalOpFilter) IncludeInOp(op walkOperation) bool { - for _, v := range n.Ops { - if v == op { - return true - } - } - - return false -} diff --git a/terraform/eval_if.go b/terraform/eval_if.go deleted file mode 100644 index d6b46a1f2..000000000 --- a/terraform/eval_if.go +++ /dev/null @@ -1,26 +0,0 @@ -package terraform - -// EvalIf is an EvalNode that is a conditional. -type EvalIf struct { - If func(EvalContext) (bool, error) - Then EvalNode - Else EvalNode -} - -// TODO: test -func (n *EvalIf) Eval(ctx EvalContext) (interface{}, error) { - yes, err := n.If(ctx) - if err != nil { - return nil, err - } - - if yes { - return EvalRaw(n.Then, ctx) - } else { - if n.Else != nil { - return EvalRaw(n.Else, ctx) - } - } - - return nil, nil -} diff --git a/terraform/eval_noop.go b/terraform/eval_noop.go deleted file mode 100644 index f4bc8225c..000000000 --- a/terraform/eval_noop.go +++ /dev/null @@ -1,8 +0,0 @@ -package terraform - -// EvalNoop is an EvalNode that does nothing. -type EvalNoop struct{} - -func (EvalNoop) Eval(EvalContext) (interface{}, error) { - return nil, nil -} diff --git a/terraform/eval_provider.go b/terraform/eval_provider.go index 3e425e910..0af5964ea 100644 --- a/terraform/eval_provider.go +++ b/terraform/eval_provider.go @@ -60,42 +60,3 @@ func GetProvider(ctx EvalContext, addr addrs.AbsProviderConfig) (providers.Inter schema := ctx.ProviderSchema(addr) return provider, schema, nil } - -// EvalGetProvider is an EvalNode implementation that retrieves an already -// initialized provider instance for the given name. -// -// Unlike most eval nodes, this takes an _absolute_ provider configuration, -// because providers can be passed into and inherited between modules. -// Resource nodes must therefore know the absolute path of the provider they -// will use, which is usually accomplished by implementing -// interface GraphNodeProviderConsumer. -type EvalGetProvider struct { - Addr addrs.AbsProviderConfig - Output *providers.Interface - - // If non-nil, Schema will be updated after eval to refer to the - // schema of the provider. - Schema **ProviderSchema -} - -func (n *EvalGetProvider) Eval(ctx EvalContext) (interface{}, error) { - if n.Addr.Provider.Type == "" { - // Should never happen - panic("EvalGetProvider used with uninitialized provider configuration address") - } - - result := ctx.Provider(n.Addr) - if result == nil { - return nil, fmt.Errorf("provider %s not initialized", n.Addr) - } - - if n.Output != nil { - *n.Output = result - } - - if n.Schema != nil { - *n.Schema = ctx.ProviderSchema(n.Addr) - } - - return nil, nil -} diff --git a/terraform/eval_provider_test.go b/terraform/eval_provider_test.go index a029f3677..ff1eb8ab3 100644 --- a/terraform/eval_provider_test.go +++ b/terraform/eval_provider_test.go @@ -9,7 +9,6 @@ import ( "github.com/hashicorp/terraform/addrs" "github.com/hashicorp/terraform/configs" "github.com/hashicorp/terraform/configs/configschema" - "github.com/hashicorp/terraform/providers" ) func TestBuildProviderConfig(t *testing.T) { @@ -54,30 +53,3 @@ func TestBuildProviderConfig(t *testing.T) { t.Fatalf("incorrect merged config\ngot: %#v\nwant: %#v", got, want) } } - -func TestEvalGetProvider_impl(t *testing.T) { - var _ EvalNode = new(EvalGetProvider) -} - -func TestEvalGetProvider(t *testing.T) { - var actual providers.Interface - n := &EvalGetProvider{ - Addr: addrs.RootModuleInstance.ProviderConfigDefault(addrs.NewDefaultProvider("foo")), - Output: &actual, - } - provider := &MockProvider{} - ctx := &MockEvalContext{ProviderProvider: provider} - if _, err := n.Eval(ctx); err != nil { - t.Fatalf("err: %s", err) - } - if actual != provider { - t.Fatalf("bad: %#v", actual) - } - - if !ctx.ProviderCalled { - t.Fatal("should be called") - } - if ctx.ProviderAddr.String() != `provider["registry.terraform.io/hashicorp/foo"]` { - t.Fatalf("wrong provider address %s", ctx.ProviderAddr) - } -} diff --git a/terraform/eval_sequence.go b/terraform/eval_sequence.go deleted file mode 100644 index 3485e4f14..000000000 --- a/terraform/eval_sequence.go +++ /dev/null @@ -1,42 +0,0 @@ -package terraform - -import ( - "github.com/hashicorp/terraform/tfdiags" -) - -// EvalSequence is an EvalNode that evaluates in sequence. -type EvalSequence struct { - Nodes []EvalNode -} - -func (n *EvalSequence) Eval(ctx EvalContext) (interface{}, error) { - var diags tfdiags.Diagnostics - - for _, n := range n.Nodes { - if n == nil { - continue - } - - if _, err := EvalRaw(n, ctx); err != nil { - if _, isEarlyExit := err.(EvalEarlyExitError); isEarlyExit { - // In this path we abort early, losing any non-error - // diagnostics we saw earlier. - return nil, err - } - diags = diags.Append(err) - if diags.HasErrors() { - // Halt if we get some errors, but warnings are okay. - break - } - } - } - - return nil, diags.ErrWithWarnings() -} - -// EvalNodeFilterable impl. -func (n *EvalSequence) Filter(fn EvalNodeFilterFunc) { - for i, node := range n.Nodes { - n.Nodes[i] = fn(node) - } -} diff --git a/terraform/eval_sequence_test.go b/terraform/eval_sequence_test.go deleted file mode 100644 index 972f0cd6f..000000000 --- a/terraform/eval_sequence_test.go +++ /dev/null @@ -1,9 +0,0 @@ -package terraform - -import ( - "testing" -) - -func TestEvalSequence_impl(t *testing.T) { - var _ EvalNodeFilterable = new(EvalSequence) -} diff --git a/terraform/eval_state.go b/terraform/eval_state.go index aaf6fecfe..1edab4516 100644 --- a/terraform/eval_state.go +++ b/terraform/eval_state.go @@ -149,35 +149,7 @@ func (n *EvalReadStateDeposed) Eval(ctx EvalContext) (interface{}, error) { return obj, nil } -// EvalUpdateStateHook is an EvalNode implementation that calls the -// PostStateUpdate hook with the current state. -type EvalUpdateStateHook struct{} - -func (n *EvalUpdateStateHook) Eval(ctx EvalContext) (interface{}, error) { - // In principle we could grab the lock here just long enough to take a - // deep copy and then pass that to our hooks below, but we'll instead - // hold the hook for the duration to avoid the potential confusing - // situation of us racing to call PostStateUpdate concurrently with - // different state snapshots. - stateSync := ctx.State() - state := stateSync.Lock().DeepCopy() - defer stateSync.Unlock() - - // Call the hook - err := ctx.Hook(func(h Hook) (HookAction, error) { - return h.PostStateUpdate(state) - }) - if err != nil { - return nil, err - } - - return nil, nil -} - // UpdateStateHook calls the PostStateUpdate hook with the current state. -// -// TODO: UpdateStateHook will eventually replace EvalUpdateStateHook, at which -// point EvalUpdateStateHook can be removed and this comment updated. func UpdateStateHook(ctx EvalContext) error { // In principle we could grab the lock here just long enough to take a // deep copy and then pass that to our hooks below, but we'll instead diff --git a/terraform/eval_state_test.go b/terraform/eval_state_test.go index 6d6425a54..a9c73cded 100644 --- a/terraform/eval_state_test.go +++ b/terraform/eval_state_test.go @@ -12,29 +12,6 @@ import ( "github.com/hashicorp/terraform/states" ) -func TestEvalUpdateStateHook(t *testing.T) { - mockHook := new(MockHook) - - state := states.NewState() - state.Module(addrs.RootModuleInstance).SetLocalValue("foo", cty.StringVal("hello")) - - ctx := new(MockEvalContext) - ctx.HookHook = mockHook - ctx.StateState = state.SyncWrapper() - - node := &EvalUpdateStateHook{} - if _, err := node.Eval(ctx); err != nil { - t.Fatalf("err: %s", err) - } - - if !mockHook.PostStateUpdateCalled { - t.Fatal("should call PostStateUpdate") - } - if mockHook.PostStateUpdateState.LocalValue(addrs.LocalValue{Name: "foo"}.Absolute(addrs.RootModuleInstance)) != cty.StringVal("hello") { - t.Fatalf("wrong state passed to hook: %s", spew.Sdump(mockHook.PostStateUpdateState)) - } -} - func TestEvalReadState(t *testing.T) { var output *states.ResourceInstanceObject mockProvider := mockProviderWithResourceTypeSchema("aws_instance", &configschema.Block{ @@ -50,7 +27,7 @@ func TestEvalReadState(t *testing.T) { cases := map[string]struct { Resources map[string]*ResourceState - Node EvalNode + Node *EvalReadState ExpectedInstanceId string }{ "ReadState gets primary instance state": { @@ -74,6 +51,59 @@ func TestEvalReadState(t *testing.T) { }, ExpectedInstanceId: "i-abc123", }, + } + + for k, c := range cases { + t.Run(k, func(t *testing.T) { + ctx := new(MockEvalContext) + state := MustShimLegacyState(&State{ + Modules: []*ModuleState{ + &ModuleState{ + Path: rootModulePath, + Resources: c.Resources, + }, + }, + }) + ctx.StateState = state.SyncWrapper() + ctx.PathPath = addrs.RootModuleInstance + + result, err := c.Node.Eval(ctx) + if err != nil { + t.Fatalf("[%s] Got err: %#v", k, err) + } + + expected := c.ExpectedInstanceId + if !(result != nil && instanceObjectIdForTests(result.(*states.ResourceInstanceObject)) == expected) { + t.Fatalf("[%s] Expected return with ID %#v, got: %#v", k, expected, result) + } + + if !(output != nil && output.Value.GetAttr("id") == cty.StringVal(expected)) { + t.Fatalf("[%s] Expected output with ID %#v, got: %#v", k, expected, output) + } + + output = nil + }) + } +} + +func TestEvalReadStateDeposed(t *testing.T) { + var output *states.ResourceInstanceObject + mockProvider := mockProviderWithResourceTypeSchema("aws_instance", &configschema.Block{ + Attributes: map[string]*configschema.Attribute{ + "id": { + Type: cty.String, + Optional: true, + }, + }, + }) + providerSchema := mockProvider.GetSchemaReturn + provider := providers.Interface(mockProvider) + + cases := map[string]struct { + Resources map[string]*ResourceState + Node *EvalReadStateDeposed + ExpectedInstanceId string + }{ "ReadStateDeposed gets deposed instance": { Resources: map[string]*ResourceState{ "aws_instance.bar": &ResourceState{ @@ -97,7 +127,6 @@ func TestEvalReadState(t *testing.T) { ExpectedInstanceId: "i-abc123", }, } - for k, c := range cases { t.Run(k, func(t *testing.T) { ctx := new(MockEvalContext) @@ -225,9 +254,6 @@ aws_instance.foo: (1 deposed) `) } -// Same test as TestEvalUpdateStateHook, similar function, slightly different -// signature. The EvalUpdateStateHook test and function will be removed when the -// EvalNode Removal is complete. func TestUpdateStateHook(t *testing.T) { mockHook := new(MockHook) diff --git a/terraform/eval_test.go b/terraform/eval_test.go deleted file mode 100644 index 29ae25843..000000000 --- a/terraform/eval_test.go +++ /dev/null @@ -1,40 +0,0 @@ -package terraform - -import ( - "testing" -) - -func TestMockEvalContext_impl(t *testing.T) { - var _ EvalContext = new(MockEvalContext) -} - -func TestEval(t *testing.T) { - var result int - n := &testEvalAdd{ - Items: []int{10, 32}, - Result: &result, - } - - if _, err := Eval(n, nil); err != nil { - t.Fatalf("err: %s", err) - } - - if result != 42 { - t.Fatalf("bad: %#v", result) - } -} - -type testEvalAdd struct { - Items []int - Result *int -} - -func (n *testEvalAdd) Eval(ctx EvalContext) (interface{}, error) { - result := 0 - for _, item := range n.Items { - result += item - } - - *n.Result = result - return nil, nil -} diff --git a/terraform/graph.go b/terraform/graph.go index df1ecf134..73996c1f7 100644 --- a/terraform/graph.go +++ b/terraform/graph.go @@ -1,7 +1,6 @@ package terraform import ( - "fmt" "log" "github.com/hashicorp/terraform/tfdiags" @@ -57,38 +56,12 @@ func (g *Graph) walk(walker GraphWalker) tfdiags.Diagnostics { // If the node is exec-able, then execute it. if ev, ok := v.(GraphNodeExecutable); ok { - // A node must not be both Evalable and Executable. This will be - // removed when GraphNodeEvalable is fully removed. - if _, ok := v.(GraphNodeEvalable); ok { - panic(fmt.Sprintf( - "%T implements both GraphNodeEvalable and GraphNodeExecutable", v, - )) - } diags = diags.Append(walker.Execute(vertexCtx, ev)) if diags.HasErrors() { return } } - // If the node is eval-able, then evaluate it. - if ev, ok := v.(GraphNodeEvalable); ok { - tree := ev.EvalTree() - if tree == nil { - panic(fmt.Sprintf("%q (%T): nil eval tree", dag.VertexName(v), v)) - } - - // Allow the walker to change our tree if needed. Eval, - // then callback with the output. - log.Printf("[TRACE] vertex %q: evaluating", dag.VertexName(v)) - - tree = walker.EnterEvalTree(v, tree) - output, err := Eval(tree, vertexCtx) - diags = diags.Append(walker.ExitEvalTree(v, output, err)) - if diags.HasErrors() { - return - } - } - // If the node is dynamically expanded, then expand it if ev, ok := v.(GraphNodeDynamicExpandable); ok { log.Printf("[TRACE] vertex %q: expanding dynamic subgraph", dag.VertexName(v)) diff --git a/terraform/graph_walk.go b/terraform/graph_walk.go index 1ec099b3c..4ede23513 100644 --- a/terraform/graph_walk.go +++ b/terraform/graph_walk.go @@ -2,7 +2,6 @@ package terraform import ( "github.com/hashicorp/terraform/addrs" - "github.com/hashicorp/terraform/dag" "github.com/hashicorp/terraform/tfdiags" ) @@ -12,8 +11,6 @@ type GraphWalker interface { EvalContext() EvalContext EnterPath(addrs.ModuleInstance) EvalContext ExitPath(addrs.ModuleInstance) - EnterEvalTree(dag.Vertex, EvalNode) EvalNode - ExitEvalTree(dag.Vertex, interface{}, error) tfdiags.Diagnostics Execute(EvalContext, GraphNodeExecutable) tfdiags.Diagnostics } @@ -22,11 +19,7 @@ type GraphWalker interface { // implementing all the required functions. type NullGraphWalker struct{} -func (NullGraphWalker) EvalContext() EvalContext { return new(MockEvalContext) } -func (NullGraphWalker) EnterPath(addrs.ModuleInstance) EvalContext { return new(MockEvalContext) } -func (NullGraphWalker) ExitPath(addrs.ModuleInstance) {} -func (NullGraphWalker) EnterEvalTree(v dag.Vertex, n EvalNode) EvalNode { return n } -func (NullGraphWalker) ExitEvalTree(dag.Vertex, interface{}, error) tfdiags.Diagnostics { - return nil -} +func (NullGraphWalker) EvalContext() EvalContext { return new(MockEvalContext) } +func (NullGraphWalker) EnterPath(addrs.ModuleInstance) EvalContext { return new(MockEvalContext) } +func (NullGraphWalker) ExitPath(addrs.ModuleInstance) {} func (NullGraphWalker) Execute(EvalContext, GraphNodeExecutable) tfdiags.Diagnostics { return nil } diff --git a/terraform/graph_walk_context.go b/terraform/graph_walk_context.go index d3ca73b3f..c7492ed06 100644 --- a/terraform/graph_walk_context.go +++ b/terraform/graph_walk_context.go @@ -2,14 +2,12 @@ package terraform import ( "context" - "log" "sync" "github.com/zclconf/go-cty/cty" "github.com/hashicorp/terraform/addrs" "github.com/hashicorp/terraform/configs/configschema" - "github.com/hashicorp/terraform/dag" "github.com/hashicorp/terraform/instances" "github.com/hashicorp/terraform/plans" "github.com/hashicorp/terraform/providers" @@ -106,49 +104,6 @@ func (w *ContextGraphWalker) EvalContext() EvalContext { return ctx } -func (w *ContextGraphWalker) EnterEvalTree(v dag.Vertex, n EvalNode) EvalNode { - log.Printf("[TRACE] [%s] Entering eval tree: %s", w.Operation, dag.VertexName(v)) - - // Acquire a lock on the semaphore - w.Context.parallelSem.Acquire() - - // We want to filter the evaluation tree to only include operations - // that belong in this operation. - return EvalFilter(n, EvalNodeFilterOp(w.Operation)) -} - -func (w *ContextGraphWalker) ExitEvalTree(v dag.Vertex, output interface{}, err error) tfdiags.Diagnostics { - log.Printf("[TRACE] [%s] Exiting eval tree: %s", w.Operation, dag.VertexName(v)) - - // Release the semaphore - w.Context.parallelSem.Release() - - if err == nil { - return nil - } - - // Acquire the lock because anything is going to require a lock. - w.errorLock.Lock() - defer w.errorLock.Unlock() - - // If the error is non-fatal then we'll accumulate its diagnostics in our - // non-fatal list, rather than returning it directly, so that the graph - // walk can continue. - if nferr, ok := err.(tfdiags.NonFatalError); ok { - log.Printf("[WARN] %s: %s", dag.VertexName(v), nferr) - w.NonFatalDiagnostics = w.NonFatalDiagnostics.Append(nferr.Diagnostics) - return nil - } - - // Otherwise, we'll let our usual diagnostics machinery figure out how to - // unpack this as one or more diagnostic messages and return that. If we - // get down here then the returned diagnostics will contain at least one - // error, causing the graph walk to halt. - var diags tfdiags.Diagnostics - diags = diags.Append(err) - return diags -} - func (w *ContextGraphWalker) init() { w.contexts = make(map[string]*BuiltinEvalContext) w.providerCache = make(map[string]providers.Interface) diff --git a/terraform/node_resource_destroy.go b/terraform/node_resource_destroy.go index 7b1a2f580..d07b2c2e9 100644 --- a/terraform/node_resource_destroy.go +++ b/terraform/node_resource_destroy.go @@ -143,12 +143,7 @@ func (n *NodeDestroyResourceInstance) Execute(ctx EvalContext, op walkOperation) return err } - evalReadDiff := &EvalReadDiff{ - Addr: addr.Resource, - ProviderSchema: &providerSchema, - Change: &changeApply, - } - _, err = evalReadDiff.Eval(ctx) + changeApply, err = n.ReadDiff(ctx, providerSchema) if err != nil { return err }