terraform: goodbye context.go (old)

terraform/context.go

@@ -387,3 +387,16 @@ func (c *Context2) walk(operation walkOperation) (*ContextGraphWalker, error) {
 	walker := &ContextGraphWalker{Context: c, Operation: operation}
 	return walker, graph.Walk(walker)
 }
+
+// walkOperation is an enum which tells the walkContext what to do.
+type walkOperation byte
+
+const (
+	walkInvalid walkOperation = iota
+	walkInput
+	walkApply
+	walkPlan
+	walkPlanDestroy
+	walkRefresh
+	walkValidate
+)

terraform/context_test.go

@@ -4630,3 +4630,171 @@ func TestContext2Apply_singleDestroy(t *testing.T) {
 func testContext2(t *testing.T, opts *ContextOpts) *Context2 {
 	return NewContext2(opts)
 }
+
+func testApplyFn(
+	info *InstanceInfo,
+	s *InstanceState,
+	d *InstanceDiff) (*InstanceState, error) {
+	if d.Destroy {
+		return nil, nil
+	}
+
+	id := "foo"
+	if idAttr, ok := d.Attributes["id"]; ok && !idAttr.NewComputed {
+		id = idAttr.New
+	}
+
+	result := &InstanceState{
+		ID: id,
+	}
+
+	if d != nil {
+		result = result.MergeDiff(d)
+	}
+	return result, nil
+}
+
+func testDiffFn(
+	info *InstanceInfo,
+	s *InstanceState,
+	c *ResourceConfig) (*InstanceDiff, error) {
+	var diff InstanceDiff
+	diff.Attributes = make(map[string]*ResourceAttrDiff)
+
+	for k, v := range c.Raw {
+		if _, ok := v.(string); !ok {
+			continue
+		}
+
+		if k == "nil" {
+			return nil, nil
+		}
+
+		// This key is used for other purposes
+		if k == "compute_value" {
+			continue
+		}
+
+		if k == "compute" {
+			attrDiff := &ResourceAttrDiff{
+				Old:         "",
+				New:         "",
+				NewComputed: true,
+			}
+
+			if cv, ok := c.Config["compute_value"]; ok {
+				if cv.(string) == "1" {
+					attrDiff.NewComputed = false
+					attrDiff.New = fmt.Sprintf("computed_%s", v.(string))
+				}
+			}
+
+			diff.Attributes[v.(string)] = attrDiff
+			continue
+		}
+
+		// If this key is not computed, then look it up in the
+		// cleaned config.
+		found := false
+		for _, ck := range c.ComputedKeys {
+			if ck == k {
+				found = true
+				break
+			}
+		}
+		if !found {
+			v = c.Config[k]
+		}
+
+		attrDiff := &ResourceAttrDiff{
+			Old: "",
+			New: v.(string),
+		}
+
+		if k == "require_new" {
+			attrDiff.RequiresNew = true
+		}
+		diff.Attributes[k] = attrDiff
+	}
+
+	for _, k := range c.ComputedKeys {
+		diff.Attributes[k] = &ResourceAttrDiff{
+			Old:         "",
+			NewComputed: true,
+		}
+	}
+
+	for k, v := range diff.Attributes {
+		if v.NewComputed {
+			continue
+		}
+
+		old, ok := s.Attributes[k]
+		if !ok {
+			continue
+		}
+		if old == v.New {
+			delete(diff.Attributes, k)
+		}
+	}
+
+	if !diff.Empty() {
+		diff.Attributes["type"] = &ResourceAttrDiff{
+			Old: "",
+			New: info.Type,
+		}
+	}
+
+	return &diff, nil
+}
+
+func testProvider(prefix string) *MockResourceProvider {
+	p := new(MockResourceProvider)
+	p.RefreshFn = func(info *InstanceInfo, s *InstanceState) (*InstanceState, error) {
+		return s, nil
+	}
+	p.ResourcesReturn = []ResourceType{
+		ResourceType{
+			Name: fmt.Sprintf("%s_instance", prefix),
+		},
+	}
+
+	return p
+}
+
+func testProvisioner() *MockResourceProvisioner {
+	p := new(MockResourceProvisioner)
+	return p
+}
+
+const testContextGraph = `
+root: root
+aws_instance.bar
+  aws_instance.bar -> provider.aws
+aws_instance.foo
+  aws_instance.foo -> provider.aws
+provider.aws
+root
+  root -> aws_instance.bar
+  root -> aws_instance.foo
+`
+
+const testContextRefreshModuleStr = `
+aws_instance.web: (1 tainted)
+  ID = <not created>
+  Tainted ID 1 = bar
+
+module.child:
+  aws_instance.web:
+    ID = new
+`
+
+const testContextRefreshOutputPartialStr = `
+<no state>
+`
+
+const testContextRefreshTaintedStr = `
+aws_instance.web: (1 tainted)
+  ID = <not created>
+  Tainted ID 1 = foo
+`

terraform/plan.go

@@ -42,12 +42,12 @@ type Plan struct {
 //
 // The following fields in opts are overridden by the plan: Config,
 // Diff, State, Variables.
-func (p *Plan) Context(opts *ContextOpts) *Context {
+func (p *Plan) Context(opts *ContextOpts) *Context2 {
 	opts.Diff = p.Diff
 	opts.Module = p.Module
 	opts.State = p.State
 	opts.Variables = p.Vars
-	return NewContext(opts)
+	return NewContext2(opts)
 }
 
 func (p *Plan) String() string {

terraform/resource.go

@@ -93,7 +93,7 @@ type ResourceConfig struct {
 // NewResourceConfig creates a new ResourceConfig from a config.RawConfig.
 func NewResourceConfig(c *config.RawConfig) *ResourceConfig {
 	result := &ResourceConfig{raw: c}
-	result.interpolate(nil, nil)
+	result.interpolateForce()
 	return result
 }
 
@@ -201,36 +201,18 @@ func (c *ResourceConfig) get(
 	return current, true
 }
 
-func (c *ResourceConfig) interpolate(
-	ctx *walkContext, r *Resource) error {
-	if c == nil {
-		return nil
-	}
-
-	if ctx != nil {
-		if err := ctx.computeVars(c.raw, r); err != nil {
-			return err
-		}
-	}
-
-	if c.raw == nil {
-		var err error
-		c.raw, err = config.NewRawConfig(make(map[string]interface{}))
-		if err != nil {
-			return err
-		}
-	}
-
-	c.ComputedKeys = c.raw.UnknownKeys()
-	c.Raw = c.raw.Raw
-	c.Config = c.raw.Config()
-	return nil
-}
-
 // interpolateForce is a temporary thing. We want to get rid of interpolate
 // above and likewise this, but it can only be done after the f-ast-graph
 // refactor is complete.
 func (c *ResourceConfig) interpolateForce() {
+	if c.raw == nil {
+		var err error
+		c.raw, err = config.NewRawConfig(make(map[string]interface{}))
+		if err != nil {
+			panic(err)
+		}
+	}
+
 	c.ComputedKeys = c.raw.UnknownKeys()
 	c.Raw = c.raw.Raw
 	c.Config = c.raw.Config()

terraform/resource_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/hashicorp/terraform/config"
+	"github.com/hashicorp/terraform/config/lang/ast"
 )
 
 func TestInstanceInfo(t *testing.T) {
@@ -99,17 +100,20 @@ func TestResourceConfigGet(t *testing.T) {
 			}
 		}
 
-		rc := NewResourceConfig(rawC)
 		if tc.Vars != nil {
-			ctx := NewContext(&ContextOpts{Variables: tc.Vars})
-			err := rc.interpolate(
-				ctx.walkContext(walkInvalid, rootModulePath),
-				nil)
-			if err != nil {
+			vs := make(map[string]ast.Variable)
+			for k, v := range tc.Vars {
+				vs["var."+k] = ast.Variable{Value: v, Type: ast.TypeString}
+			}
+
+			if err := rawC.Interpolate(vs); err != nil {
 				t.Fatalf("err: %s", err)
 			}
 		}
 
+		rc := NewResourceConfig(rawC)
+		rc.interpolateForce()
+
 		v, _ := rc.Get(tc.Key)
 		if !reflect.DeepEqual(v, tc.Value) {
 			t.Fatalf("%d bad: %#v", i, v)