core: Check variable types between modules

config/config.go

@@ -162,6 +162,17 @@ const (
 	VariableTypeMap
 )
 
+func (v VariableType) Printable() string {
+	switch v {
+	case VariableTypeString:
+		return "string"
+	case VariableTypeMap:
+		return "map"
+	default:
+		return "unknown"
+	}
+}
+
 // ProviderConfigName returns the name of the provider configuration in
 // the given mapping that maps to the proper provider configuration
 // for this resource.

terraform/eval_variable.go

@@ -2,12 +2,75 @@ package terraform
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/hashicorp/errwrap"
 	"github.com/hashicorp/terraform/config"
+	"github.com/hashicorp/terraform/config/module"
 	"github.com/mitchellh/mapstructure"
 )
 
+// EvalTypeCheckVariable is an EvalNode which ensures that the variable
+// values which are assigned as inputs to a module (including the root)
+// match the types which are either declared for the variables explicitly
+// or inferred from the default values.
+//
+// In order to achieve this three things are required:
+//     - a map of the proposed variable values
+//     - the configuration tree of the module in which the variable is
+//       declared
+//     - the path to the module (so we know which part of the tree to
+//       compare the values against).
+//
+// Currently since the type system is simple, we currently do not make
+// use of the values since it is only valid to pass string values. The
+// structure is in place for extension of the type system, however.
+type EvalTypeCheckVariable struct {
+	Variables  map[string]string
+	ModulePath []string
+	ModuleTree *module.Tree
+}
+
+func (n *EvalTypeCheckVariable) Eval(ctx EvalContext) (interface{}, error) {
+	currentTree := n.ModuleTree
+	for _, pathComponent := range n.ModulePath[1:] {
+		currentTree = currentTree.Children()[pathComponent]
+	}
+	targetConfig := currentTree.Config()
+
+	prototypes := make(map[string]config.VariableType)
+	for _, variable := range targetConfig.Variables {
+		prototypes[variable.Name] = variable.Type()
+	}
+
+	for name, declaredType := range prototypes {
+		// This is only necessary when we _actually_ check. It is left as a reminder
+		// that at the current time we are dealing with a type system consisting only
+		// of strings and maps - where the only valid inter-module variable type is
+		// string.
+		// proposedValue := n.Variables[name]
+
+		switch declaredType {
+		case config.VariableTypeString:
+			// This will need actual verification once we aren't dealing with
+			// a map[string]string but this is sufficient for now.
+			continue
+		default:
+			// Only display a module if we are not in the root module
+			modulePathDescription := fmt.Sprintf(" in module %s", strings.Join(n.ModulePath[1:], "."))
+			if len(n.ModulePath) == 1 {
+				modulePathDescription = ""
+			}
+			// This will need the actual type substituting when we have more than
+			// just strings and maps.
+			return nil, fmt.Errorf("variable %s%s should be type %s, got type string",
+				name, modulePathDescription, declaredType.Printable())
+		}
+	}
+
+	return nil, nil
+}
+
 // EvalSetVariables is an EvalNode implementation that sets the variables
 // explicitly for interpolation later.
 type EvalSetVariables struct {

terraform/graph_config_node_variable.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/hashicorp/terraform/config"
+	"github.com/hashicorp/terraform/config/module"
 	"github.com/hashicorp/terraform/dag"
 )
 
@@ -18,7 +19,8 @@ type GraphNodeConfigVariable struct {
 	Module string
 	Value  *config.RawConfig
 
-	depPrefix string
+	ModuleTree *module.Tree
+	ModulePath []string
 }
 
 func (n *GraphNodeConfigVariable) Name() string {
@@ -125,6 +127,12 @@ func (n *GraphNodeConfigVariable) EvalTree() EvalNode {
 				Variables: variables,
 			},
 
+			&EvalTypeCheckVariable{
+				Variables:  variables,
+				ModulePath: n.ModulePath,
+				ModuleTree: n.ModuleTree,
+			},
+
 			&EvalSetVariables{
 				Module:    &n.Module,
 				Variables: variables,

terraform/transform_config.go

@@ -45,7 +45,11 @@ func (t *ConfigTransformer) Transform(g *Graph) error {
 
 	// Write all the variables out
 	for _, v := range config.Variables {
-		nodes = append(nodes, &GraphNodeConfigVariable{Variable: v})
+		nodes = append(nodes, &GraphNodeConfigVariable{
+			Variable:   v,
+			ModuleTree: t.Module,
+			ModulePath: g.Path,
+		})
 	}
 
 	// Write all the provider configs out