Flatten modules into main graph

terraform/context_test.go

@@ -4053,6 +4053,88 @@ func TestContext2Apply_module(t *testing.T) {
 	}
 }
 
+func TestContext2Apply_moduleDestroyOrder(t *testing.T) {
+	m := testModule(t, "apply-module-destroy-order")
+	p := testProvider("aws")
+	p.DiffFn = testDiffFn
+
+	// Create a custom apply function to track the order they were destroyed
+	var order []string
+	var orderLock sync.Mutex
+	p.ApplyFn = func(
+		info *InstanceInfo,
+		is *InstanceState,
+		id *InstanceDiff) (*InstanceState, error) {
+		orderLock.Lock()
+		defer orderLock.Unlock()
+
+		order = append(order, is.ID)
+		return nil, nil
+	}
+
+	state := &State{
+		Modules: []*ModuleState{
+			&ModuleState{
+				Path: rootModulePath,
+				Resources: map[string]*ResourceState{
+					"aws_instance.b": &ResourceState{
+						Type: "aws_instance",
+						Primary: &InstanceState{
+							ID: "b",
+						},
+					},
+				},
+			},
+
+			&ModuleState{
+				Path: []string{"root", "child"},
+				Resources: map[string]*ResourceState{
+					"aws_instance.a": &ResourceState{
+						Type: "aws_instance",
+						Primary: &InstanceState{
+							ID: "a",
+						},
+					},
+				},
+				Outputs: map[string]string{
+					"a_output": "a",
+				},
+			},
+		},
+	}
+
+	ctx := testContext2(t, &ContextOpts{
+		Module: m,
+		Providers: map[string]ResourceProviderFactory{
+			"aws": testProviderFuncFixed(p),
+		},
+		State:   state,
+		Destroy: true,
+	})
+
+	if _, err := ctx.Plan(); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	state, err := ctx.Apply()
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	expected := []string{"b", "a"}
+	if !reflect.DeepEqual(order, expected) {
+		t.Fatalf("bad: %#v", order)
+	}
+
+	{
+		actual := strings.TrimSpace(state.String())
+		expected := strings.TrimSpace(testTerraformApplyModuleDestroyOrderStr)
+		if actual != expected {
+			t.Fatalf("bad: \n%s", actual)
+		}
+	}
+}
+
 func TestContext2Apply_moduleVarResourceCount(t *testing.T) {
 	m := testModule(t, "apply-module-var-resource-count")
 	p := testProvider("aws")

terraform/eval_context.go

@@ -58,10 +58,10 @@ type EvalContext interface {
 	// that is currently being acted upon.
 	Interpolate(*config.RawConfig, *Resource) (*ResourceConfig, error)
 
-	// SetVariables sets the variables for interpolation. These variables
-	// should not have a "var." prefix. For example: "var.foo" should be
-	// "foo" as the key.
-	SetVariables(map[string]string)
+	// SetVariables sets the variables for the module within
+	// this context with the name n. This function call is additive:
+	// the second parameter is merged with any previous call.
+	SetVariables(string, map[string]string)
 
 	// Diff returns the global diff as well as the lock that should
 	// be used to modify that diff.

terraform/eval_context_builtin.go

@@ -14,6 +14,8 @@ import (
 type BuiltinEvalContext struct {
 	PathValue           []string
 	Interpolater        *Interpolater
+	InterpolaterVars    map[string]map[string]string
+	InterpolaterVarLock *sync.Mutex
 	Hooks               []Hook
 	InputValue          UIInput
 	Providers           map[string]ResourceProviderFactory
@@ -237,9 +239,23 @@ func (ctx *BuiltinEvalContext) Path() []string {
 	return ctx.PathValue
 }
 
-func (ctx *BuiltinEvalContext) SetVariables(vs map[string]string) {
+func (ctx *BuiltinEvalContext) SetVariables(n string, vs map[string]string) {
+	ctx.InterpolaterVarLock.Lock()
+	defer ctx.InterpolaterVarLock.Unlock()
+
+	path := make([]string, len(ctx.Path())+1)
+	copy(path, ctx.Path())
+	path[len(path)-1] = n
+	key := PathCacheKey(path)
+
+	vars := ctx.InterpolaterVars[key]
+	if vars == nil {
+		vars = make(map[string]string)
+		ctx.InterpolaterVars[key] = vars
+	}
+
 	for k, v := range vs {
-		ctx.Interpolater.Variables[k] = v
+		vars[k] = v
 	}
 }
 

terraform/eval_context_mock.go

@@ -65,6 +65,7 @@ type MockEvalContext struct {
 	PathPath   []string
 
 	SetVariablesCalled    bool
+	SetVariablesModule    string
 	SetVariablesVariables map[string]string
 
 	DiffCalled bool
@@ -162,8 +163,9 @@ func (c *MockEvalContext) Path() []string {
 	return c.PathPath
 }
 
-func (c *MockEvalContext) SetVariables(vs map[string]string) {
+func (c *MockEvalContext) SetVariables(n string, vs map[string]string) {
 	c.SetVariablesCalled = true
+	c.SetVariablesModule = n
 	c.SetVariablesVariables = vs
 }
 

terraform/eval_variable.go

@@ -11,12 +11,13 @@ import (
 // EvalSetVariables is an EvalNode implementation that sets the variables
 // explicitly for interpolation later.
 type EvalSetVariables struct {
+	Module    *string
 	Variables map[string]string
 }
 
 // TODO: test
 func (n *EvalSetVariables) Eval(ctx EvalContext) (interface{}, error) {
-	ctx.SetVariables(n.Variables)
+	ctx.SetVariables(*n.Module, n.Variables)
 	return nil, nil
 }
 

terraform/graph.go

@@ -54,6 +54,33 @@ func (g *Graph) Add(v dag.Vertex) dag.Vertex {
 	return v
 }
 
+// Remove is the same as dag.Graph.Remove
+func (g *Graph) Remove(v dag.Vertex) dag.Vertex {
+	g.once.Do(g.init)
+
+	// If this is a depend-able node, then remove the lookaside info
+	if dv, ok := v.(GraphNodeDependable); ok {
+		for _, n := range dv.DependableName() {
+			delete(g.dependableMap, n)
+		}
+	}
+
+	// Call upwards to remove it from the actual graph
+	return g.Graph.Remove(v)
+}
+
+// Replace is the same as dag.Graph.Replace
+func (g *Graph) Replace(o, n dag.Vertex) bool {
+	// Go through and update our lookaside to point to the new vertex
+	for k, v := range g.dependableMap {
+		if v == o {
+			g.dependableMap[k] = n
+		}
+	}
+
+	return g.Graph.Replace(o, n)
+}
+
 // ConnectDependent connects a GraphNodeDependent to all of its
 // GraphNodeDependables. It returns the list of dependents it was
 // unable to connect to.
@@ -129,8 +156,8 @@ func (g *Graph) init() {
 
 func (g *Graph) walk(walker GraphWalker) error {
 	// The callbacks for enter/exiting a graph
-	ctx := walker.EnterGraph(g)
-	defer walker.ExitGraph(g)
+	ctx := walker.EnterPath(g.Path)
+	defer walker.ExitPath(g.Path)
 
 	// Get the path for logs
 	path := strings.Join(ctx.Path(), ".")
@@ -143,6 +170,15 @@ func (g *Graph) walk(walker GraphWalker) error {
 		walker.EnterVertex(v)
 		defer func() { walker.ExitVertex(v, rerr) }()
 
+		// vertexCtx is the context that we use when evaluating. This
+		// is normally the context of our graph but can be overridden
+		// with a GraphNodeSubPath impl.
+		vertexCtx := ctx
+		if pn, ok := v.(GraphNodeSubPath); ok && len(pn.Path()) > 0 {
+			vertexCtx = walker.EnterPath(pn.Path())
+			defer walker.ExitPath(pn.Path())
+		}
+
 		// If the node is eval-able, then evaluate it.
 		if ev, ok := v.(GraphNodeEvalable); ok {
 			tree := ev.EvalTree()
@@ -155,7 +191,7 @@ func (g *Graph) walk(walker GraphWalker) error {
 			// then callback with the output.
 			log.Printf("[DEBUG] vertex %s.%s: evaluating", path, dag.VertexName(v))
 			tree = walker.EnterEvalTree(v, tree)
-			output, err := Eval(tree, ctx)
+			output, err := Eval(tree, vertexCtx)
 			if rerr = walker.ExitEvalTree(v, output, err); rerr != nil {
 				return
 			}
@@ -167,7 +203,7 @@ func (g *Graph) walk(walker GraphWalker) error {
 				"[DEBUG] vertex %s.%s: expanding/walking dynamic subgraph",
 				path,
 				dag.VertexName(v))
-			g, err := ev.DynamicExpand(ctx)
+			g, err := ev.DynamicExpand(vertexCtx)
 			if err != nil {
 				rerr = err
 				return

terraform/graph_builder.go

@@ -91,7 +91,7 @@ type BuiltinGraphBuilder struct {
 // Build builds the graph according to the steps returned by Steps.
 func (b *BuiltinGraphBuilder) Build(path []string) (*Graph, error) {
 	basic := &BasicGraphBuilder{
-		Steps:    b.Steps(),
+		Steps:    b.Steps(path),
 		Validate: b.Validate,
 	}
 
@@ -100,7 +100,7 @@ func (b *BuiltinGraphBuilder) Build(path []string) (*Graph, error) {
 
 // Steps returns the ordered list of GraphTransformers that must be executed
 // to build a complete graph.
-func (b *BuiltinGraphBuilder) Steps() []GraphTransformer {
+func (b *BuiltinGraphBuilder) Steps(path []string) []GraphTransformer {
 	steps := []GraphTransformer{
 		// Create all our resources from the configuration and state
 		&ConfigTransformer{Module: b.Root},
@@ -134,24 +134,41 @@ func (b *BuiltinGraphBuilder) Steps() []GraphTransformer {
 			},
 		},
 
+		// Flatten stuff
+		&FlattenTransformer{},
+
+		// Make sure all the connections that are proxies are connected through
+		&ProxyTransformer{},
+
 		// Optionally reduces the graph to a user-specified list of targets and
 		// their dependencies.
 		&TargetsTransformer{Targets: b.Targets, Destroy: b.Destroy},
 
-		// Create the destruction nodes
-		&DestroyTransformer{},
-		&CreateBeforeDestroyTransformer{},
-		b.conditional(&conditionalOpts{
-			If:   func() bool { return !b.Verbose },
-			Then: &PruneDestroyTransformer{Diff: b.Diff, State: b.State},
-		}),
-
-		// Make sure we create one root
+		// Make sure we have a single root
 		&RootTransformer{},
+	}
 
-		// Perform the transitive reduction to make our graph a bit
-		// more sane if possible (it usually is possible).
-		&TransitiveReductionTransformer{},
+	// If we're on the root path, then we do a bunch of other stuff.
+	// We don't do the following for modules.
+	if len(path) <= 1 {
+		steps = append(steps,
+			// Create the destruction nodes
+			&DestroyTransformer{},
+			&CreateBeforeDestroyTransformer{},
+			b.conditional(&conditionalOpts{
+				If:   func() bool { return !b.Verbose },
+				Then: &PruneDestroyTransformer{Diff: b.Diff, State: b.State},
+			}),
+
+			// Make sure we have a single root after the above changes.
+			// This is the 2nd root transformer. In practice this shouldn't
+			// actually matter as the RootTransformer is idempotent.
+			&RootTransformer{},
+
+			// Perform the transitive reduction to make our graph a bit
+			// more sane if possible (it usually is possible).
+			&TransitiveReductionTransformer{},
+		)
 	}
 
 	// Remove nils