terraform: destroy graph builder based on state

command/apply.go

@@ -115,6 +115,26 @@ func (c *ApplyCommand) Run(args []string) int {
 		}
 	}
 
+	// Check for the new destroy
+	if terraform.X_newDestroy {
+		desc := "Experimental new destroy graph has been enabled. This may still\n" +
+			"have bugs, and should be used with care. If you'd like to continue,\n" +
+			"you must enter exactly 'yes' as a response."
+		v, err := c.UIInput().Input(&terraform.InputOpts{
+			Id:          "Xnew-destroy",
+			Query:       "Experimental feature enabled: new destroy graph. Continue?",
+			Description: desc,
+		})
+		if err != nil {
+			c.Ui.Error(fmt.Sprintf("Error asking for confirmation: %s", err))
+			return 1
+		}
+		if v != "yes" {
+			c.Ui.Output("Apply cancelled.")
+			return 1
+		}
+	}
+
 	// Build the context based on the arguments given
 	ctx, planned, err := c.Context(contextOpts{
 		Destroy:     c.Destroy,

command/meta.go

@@ -337,6 +337,7 @@ func (m *Meta) flagSet(n string) *flag.FlagSet {
 
 	// Experimental features
 	f.BoolVar(&terraform.X_newApply, "Xnew-apply", false, "experiment: new apply")
+	f.BoolVar(&terraform.X_newDestroy, "Xnew-destroy", false, "experiment: new destroy")
 
 	// Create an io.Writer that writes to our Ui properly for errors.
 	// This is kind of a hack, but it does the job. Basically: create

go.sh

@@ -1 +1 @@
-go test ./terraform | grep -E '(FAIL|panic)' | tee /dev/tty | wc -l
+go test ./terraform -Xnew-apply -Xnew-destroy | grep -E '(FAIL|panic)' | tee /dev/tty | wc -l

terraform/context.go

@@ -21,6 +21,10 @@ var (
 	// X_newApply will enable the new apply graph. This will be removed
 	// and be on by default in 0.8.0.
 	X_newApply = false
+
+	// X_newDestroy will enable the new destroy graph. This will be removed
+	// and be on by default in 0.8.0.
+	X_newDestroy = false
 )
 
 // InputMode defines what sort of input will be asked for when Input
@@ -371,6 +375,8 @@ func (c *Context) Apply() (*State, error) {
 	// Copy our own state
 	c.state = c.state.DeepCopy()
 
+	newGraphEnabled := (c.destroy && X_newDestroy) || (!c.destroy && X_newApply)
+
 	// Build the original graph. This is before the new graph builders
 	// coming in 0.8. We do this for shadow graphing.
 	oldGraph, err := c.Graph(&ContextGraphOpts{Validate: true})
@@ -392,12 +398,13 @@ func (c *Context) Apply() (*State, error) {
 		State:        c.state,
 		Providers:    c.components.ResourceProviders(),
 		Provisioners: c.components.ResourceProvisioners(),
+		Destroy:      c.destroy,
 	}).Build(RootModulePath)
-	if err != nil && !X_newApply {
+	if err != nil && !newGraphEnabled {
 		// If we had an error graphing but we're not using this graph, just
 		// set it to nil and record it as a shadow error.
 		c.shadowErr = multierror.Append(c.shadowErr, fmt.Errorf(
-			"Error building new apply graph: %s", err))
+			"Error building new graph: %s", err))
 
 		newGraph = nil
 		err = nil
@@ -418,16 +425,11 @@ func (c *Context) Apply() (*State, error) {
 	//
 	real := oldGraph
 	shadow := newGraph
-	if c.destroy {
-		log.Printf("[WARN] terraform: real graph is original, shadow is nil")
-		shadow = nil
+	if newGraphEnabled {
+		log.Printf("[WARN] terraform: real graph is experiment, shadow is experiment")
+		real = shadow
 	} else {
-		if X_newApply {
-			log.Printf("[WARN] terraform: real graph is Xnew-apply, shadow is Xnew-apply")
-			real = shadow
-		} else {
-			log.Printf("[WARN] terraform: real graph is original, shadow is Xnew-apply")
-		}
+		log.Printf("[WARN] terraform: real graph is original, shadow is experiment")
 	}
 
 	// For now, always shadow with the real graph for verification. We don't
@@ -505,8 +507,20 @@ func (c *Context) Plan() (*Plan, error) {
 	c.diff.init()
 	c.diffLock.Unlock()
 
-	// Build the graph
-	graph, err := c.Graph(&ContextGraphOpts{Validate: true})
+	// Build the graph. We have a branch here since for the pure-destroy
+	// plan (c.destroy) we use a much simpler graph builder that simply
+	// walks the state and reverses edges.
+	var graph *Graph
+	var err error
+	if c.destroy && X_newDestroy {
+		graph, err = (&DestroyPlanGraphBuilder{
+			Module:  c.module,
+			State:   c.state,
+			Targets: c.targets,
+		}).Build(RootModulePath)
+	} else {
+		graph, err = c.Graph(&ContextGraphOpts{Validate: true})
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -529,11 +543,16 @@ func (c *Context) Plan() (*Plan, error) {
 		p.Diff.DeepCopy()
 	}
 
-	// Now that we have a diff, we can build the exact graph that Apply will use
-	// and catch any possible cycles during the Plan phase.
-	if _, err := c.Graph(&ContextGraphOpts{Validate: true}); err != nil {
-		return nil, err
+	// We don't do the reverification during the new destroy plan because
+	// it will use a different apply process.
+	if !(c.destroy && X_newDestroy) {
+		// Now that we have a diff, we can build the exact graph that Apply will use
+		// and catch any possible cycles during the Plan phase.
+		if _, err := c.Graph(&ContextGraphOpts{Validate: true}); err != nil {
+			return nil, err
+		}
 	}
+
 	var errs error
 	if len(walker.ValidationErrors) > 0 {
 		errs = multierror.Append(errs, walker.ValidationErrors...)

terraform/context_apply_test.go

@@ -739,7 +739,7 @@ func getContextForApply_destroyCrossProviders(
 				},
 			},
 			&ModuleState{
-				Path: []string{"root", "example"},
+				Path: []string{"root", "child"},
 				Resources: map[string]*ResourceState{
 					"aws_vpc.bar": &ResourceState{
 						Type: "aws_vpc",

terraform/context_plan_test.go

@@ -1582,7 +1582,7 @@ func TestContext2Plan_moduleDestroy(t *testing.T) {
 	actual := strings.TrimSpace(plan.String())
 	expected := strings.TrimSpace(testTerraformPlanModuleDestroyStr)
 	if actual != expected {
-		t.Fatalf("bad:\n%s", actual)
+		t.Fatalf("bad:\n%s\n\nexpected:\n\n%s", actual, expected)
 	}
 }
 
@@ -1634,7 +1634,7 @@ func TestContext2Plan_moduleDestroyCycle(t *testing.T) {
 	actual := strings.TrimSpace(plan.String())
 	expected := strings.TrimSpace(testTerraformPlanModuleDestroyCycleStr)
 	if actual != expected {
-		t.Fatalf("bad:\n%s", actual)
+		t.Fatalf("bad:\n%s\n\nexpected:\n\n%s", actual, expected)
 	}
 }
 
@@ -1684,7 +1684,7 @@ func TestContext2Plan_moduleDestroyMultivar(t *testing.T) {
 	actual := strings.TrimSpace(plan.String())
 	expected := strings.TrimSpace(testTerraformPlanModuleDestroyMultivarStr)
 	if actual != expected {
-		t.Fatalf("bad:\n%s", actual)
+		t.Fatalf("bad:\n%s\n\nexpected:\n\n%s", actual, expected)
 	}
 }
 

terraform/diff.go

@@ -100,8 +100,20 @@ func (d *Diff) Equal(d2 *Diff) bool {
 	sort.Sort(moduleDiffSort(d.Modules))
 	sort.Sort(moduleDiffSort(d2.Modules))
 
+	// Copy since we have to modify the module destroy flag to false so
+	// we don't compare that. TODO: delete this when we get rid of the
+	// destroy flag on modules.
+	dCopy := d.DeepCopy()
+	d2Copy := d2.DeepCopy()
+	for _, m := range dCopy.Modules {
+		m.Destroy = false
+	}
+	for _, m := range d2Copy.Modules {
+		m.Destroy = false
+	}
+
 	// Use DeepEqual
-	return reflect.DeepEqual(d, d2)
+	return reflect.DeepEqual(dCopy, d2Copy)
 }
 
 // DeepCopy performs a deep copy of all parts of the Diff, making the
@@ -238,10 +250,6 @@ func (d *ModuleDiff) IsRoot() bool {
 func (d *ModuleDiff) String() string {
 	var buf bytes.Buffer
 
-	if d.Destroy {
-		buf.WriteString("DESTROY MODULE\n")
-	}
-
 	names := make([]string, 0, len(d.Resources))
 	for name, _ := range d.Resources {
 		names = append(names, name)

terraform/diff_test.go

@@ -77,6 +77,20 @@ func TestDiffEqual(t *testing.T) {
 			},
 			true,
 		},
+
+		"different module diff destroys": {
+			&Diff{
+				Modules: []*ModuleDiff{
+					&ModuleDiff{Path: []string{"root", "foo"}, Destroy: true},
+				},
+			},
+			&Diff{
+				Modules: []*ModuleDiff{
+					&ModuleDiff{Path: []string{"root", "foo"}, Destroy: false},
+				},
+			},
+			true,
+		},
 	}
 
 	for name, tc := range cases {

terraform/graph_builder.go

@@ -26,6 +26,10 @@ type BasicGraphBuilder struct {
 func (b *BasicGraphBuilder) Build(path []string) (*Graph, error) {
 	g := &Graph{Path: path}
 	for _, step := range b.Steps {
+		if step == nil {
+			continue
+		}
+
 		if err := step.Transform(g); err != nil {
 			return g, err
 		}

terraform/graph_builder_apply.go

@@ -30,6 +30,9 @@ type ApplyGraphBuilder struct {
 
 	// DisableReduce, if true, will not reduce the graph. Great for testing.
 	DisableReduce bool
+
+	// Destroy, if true, represents a pure destroy operation
+	Destroy bool
 }
 
 // See GraphBuilder
@@ -77,7 +80,10 @@ func (b *ApplyGraphBuilder) Steps() []GraphTransformer {
 
 		// Destruction ordering
 		&DestroyEdgeTransformer{Module: b.Module, State: b.State},
-		&CBDEdgeTransformer{Module: b.Module, State: b.State},
+		GraphTransformIf(
+			func() bool { return !b.Destroy },
+			&CBDEdgeTransformer{Module: b.Module, State: b.State},
+		),
 
 		// Create all the providers
 		&MissingProviderTransformer{Providers: b.Providers, Factory: providerFactory},
@@ -87,8 +93,13 @@ func (b *ApplyGraphBuilder) Steps() []GraphTransformer {
 		&AttachProviderConfigTransformer{Module: b.Module},
 
 		// Provisioner-related transformations
-		&MissingProvisionerTransformer{Provisioners: b.Provisioners},
-		&ProvisionerTransformer{},
+		GraphTransformIf(
+			func() bool { return !b.Destroy },
+			GraphTransformMulti(
+				&MissingProvisionerTransformer{Provisioners: b.Provisioners},
+				&ProvisionerTransformer{},
+			),
+		),
 
 		// Add root variables
 		&RootVariableTransformer{Module: b.Module},

terraform/graph_builder_destroy_plan.go

@@ -0,0 +1,58 @@
+package terraform
+
+import (
+	"github.com/hashicorp/terraform/config/module"
+	"github.com/hashicorp/terraform/dag"
+)
+
+// DestroyPlanGraphBuilder implements GraphBuilder and is responsible for
+// planning a pure-destroy.
+//
+// Planning a pure destroy operation is simple because we can ignore most
+// ordering configuration and simply reverse the state.
+type DestroyPlanGraphBuilder struct {
+	// Module is the root module for the graph to build.
+	Module *module.Tree
+
+	// State is the current state
+	State *State
+
+	// Targets are resources to target
+	Targets []string
+}
+
+// See GraphBuilder
+func (b *DestroyPlanGraphBuilder) Build(path []string) (*Graph, error) {
+	return (&BasicGraphBuilder{
+		Steps:    b.Steps(),
+		Validate: true,
+	}).Build(path)
+}
+
+// See GraphBuilder
+func (b *DestroyPlanGraphBuilder) Steps() []GraphTransformer {
+	concreteResource := func(a *NodeAbstractResource) dag.Vertex {
+		return &NodePlanDestroyableResource{
+			NodeAbstractResource: a,
+		}
+	}
+
+	steps := []GraphTransformer{
+		// Creates all the nodes represented in the state.
+		&StateTransformer{
+			Concrete: concreteResource,
+			State:    b.State,
+		},
+
+		// Target
+		&TargetsTransformer{Targets: b.Targets},
+
+		// Attach the configuration to any resources
+		&AttachResourceConfigTransformer{Module: b.Module},
+
+		// Single root
+		&RootTransformer{},
+	}
+
+	return steps
+}

terraform/graph_config_node.go

@@ -24,8 +24,6 @@ type graphNodeConfig interface {
 // configuration graph need to implement in order to be be addressed / targeted
 // properly.
 type GraphNodeAddressable interface {
-	graphNodeConfig
-
 	ResourceAddress() *ResourceAddress
 }
 
@@ -35,7 +33,5 @@ type GraphNodeAddressable interface {
 // provided will contain every target provided, and each implementing graph
 // node must filter this list to targets considered relevant.
 type GraphNodeTargetable interface {
-	GraphNodeAddressable
-
 	SetTargets([]ResourceAddress)
 }

terraform/graph_config_node_module.go

@@ -59,7 +59,7 @@ func (n *GraphNodeConfigModule) Expand(b GraphBuilder) (GraphNodeSubgraph, error
 
 	{
 		// Add the destroy marker to the graph
-		t := &ModuleDestroyTransformer{}
+		t := &ModuleDestroyTransformerOld{}
 		if err := t.Transform(graph); err != nil {
 			return nil, err
 		}

terraform/node_module_destroy.go

@@ -0,0 +1,29 @@
+package terraform
+
+import (
+	"fmt"
+)
+
+// NodeDestroyableModule represents a module destruction.
+type NodeDestroyableModuleVariable struct {
+	PathValue []string
+}
+
+func (n *NodeDestroyableModuleVariable) Name() string {
+	result := "plan-destroy"
+	if len(n.PathValue) > 1 {
+		result = fmt.Sprintf("%s.%s", modulePrefixStr(n.PathValue), result)
+	}
+
+	return result
+}
+
+// GraphNodeSubPath
+func (n *NodeDestroyableModuleVariable) Path() []string {
+	return n.PathValue
+}
+
+// GraphNodeEvalable
+func (n *NodeDestroyableModuleVariable) EvalTree() EvalNode {
+	return &EvalDiffDestroyModule{Path: n.PathValue}
+}