2014-05-24 20:36:22 +02:00
|
|
|
// The config package is responsible for loading and validating the
|
|
|
|
// configuration.
|
2014-05-23 01:56:28 +02:00
|
|
|
package config
|
|
|
|
|
2014-05-24 06:58:06 +02:00
|
|
|
import (
|
2014-05-24 22:57:51 +02:00
|
|
|
"fmt"
|
2014-07-06 22:56:18 +02:00
|
|
|
"strconv"
|
2014-05-24 06:58:06 +02:00
|
|
|
"strings"
|
2014-07-03 19:14:17 +02:00
|
|
|
|
|
|
|
"github.com/hashicorp/terraform/helper/multierror"
|
2014-05-24 06:58:06 +02:00
|
|
|
)
|
|
|
|
|
2014-05-23 01:56:28 +02:00
|
|
|
// Config is the configuration that comes from loading a collection
|
|
|
|
// of Terraform templates.
|
|
|
|
type Config struct {
|
2014-07-20 01:05:48 +02:00
|
|
|
ProviderConfigs []*ProviderConfig
|
2014-05-26 03:05:18 +02:00
|
|
|
Resources []*Resource
|
2014-07-19 02:48:30 +02:00
|
|
|
Variables []*Variable
|
2014-07-19 07:21:52 +02:00
|
|
|
Outputs []*Output
|
2014-07-19 01:00:21 +02:00
|
|
|
|
|
|
|
// The fields below can be filled in by loaders for validation
|
|
|
|
// purposes.
|
|
|
|
unknownKeys []string
|
2014-05-26 03:05:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// ProviderConfig is the configuration for a resource provider.
|
|
|
|
//
|
|
|
|
// For example, Terraform needs to set the AWS access keys for the AWS
|
|
|
|
// resource provider.
|
|
|
|
type ProviderConfig struct {
|
2014-07-20 01:05:48 +02:00
|
|
|
Name string
|
2014-06-13 02:40:59 +02:00
|
|
|
RawConfig *RawConfig
|
2014-05-23 01:56:28 +02:00
|
|
|
}
|
|
|
|
|
2014-05-24 06:58:06 +02:00
|
|
|
// A resource represents a single Terraform resource in the configuration.
|
|
|
|
// A Terraform resource is something that represents some component that
|
|
|
|
// can be created and managed, and has some properties associated with it.
|
2014-05-23 01:56:28 +02:00
|
|
|
type Resource struct {
|
2014-07-03 05:20:13 +02:00
|
|
|
Name string
|
|
|
|
Type string
|
|
|
|
Count int
|
|
|
|
RawConfig *RawConfig
|
|
|
|
Provisioners []*Provisioner
|
|
|
|
}
|
|
|
|
|
|
|
|
// Provisioner is a configured provisioner step on a resource.
|
|
|
|
type Provisioner struct {
|
2014-05-24 06:58:06 +02:00
|
|
|
Type string
|
2014-06-13 02:40:59 +02:00
|
|
|
RawConfig *RawConfig
|
2014-07-11 02:14:47 +02:00
|
|
|
ConnInfo *RawConfig
|
2014-05-23 01:56:28 +02:00
|
|
|
}
|
|
|
|
|
2014-06-04 00:55:51 +02:00
|
|
|
// Variable is a variable defined within the configuration.
|
2014-05-23 01:56:28 +02:00
|
|
|
type Variable struct {
|
2014-07-19 02:48:30 +02:00
|
|
|
Name string
|
2014-07-21 16:32:36 +02:00
|
|
|
Default interface{}
|
2014-05-23 01:56:28 +02:00
|
|
|
Description string
|
|
|
|
}
|
2014-05-24 06:58:06 +02:00
|
|
|
|
2014-07-04 19:43:06 +02:00
|
|
|
// Output is an output defined within the configuration. An output is
|
|
|
|
// resulting data that is highlighted by Terraform when finished.
|
|
|
|
type Output struct {
|
|
|
|
Name string
|
|
|
|
RawConfig *RawConfig
|
|
|
|
}
|
|
|
|
|
2014-05-24 06:58:06 +02:00
|
|
|
// An InterpolatedVariable is a variable that is embedded within a string
|
|
|
|
// in the configuration, such as "hello ${world}" (world in this case is
|
|
|
|
// an interpolated variable).
|
|
|
|
//
|
|
|
|
// These variables can come from a variety of sources, represented by
|
|
|
|
// implementations of this interface.
|
|
|
|
type InterpolatedVariable interface {
|
|
|
|
FullKey() string
|
|
|
|
}
|
|
|
|
|
|
|
|
// A ResourceVariable is a variable that is referencing the field
|
|
|
|
// of a resource, such as "${aws_instance.foo.ami}"
|
|
|
|
type ResourceVariable struct {
|
2014-07-05 19:34:52 +02:00
|
|
|
Type string // Resource type, i.e. "aws_instance"
|
|
|
|
Name string // Resource name
|
|
|
|
Field string // Resource field
|
2014-07-06 22:46:56 +02:00
|
|
|
|
|
|
|
Multi bool // True if multi-variable: aws_instance.foo.*.id
|
|
|
|
Index int // Index for multi-variable: aws_instance.foo.1.id == 1
|
2014-05-24 06:58:06 +02:00
|
|
|
|
|
|
|
key string
|
|
|
|
}
|
|
|
|
|
|
|
|
// A UserVariable is a variable that is referencing a user variable
|
|
|
|
// that is inputted from outside the configuration. This looks like
|
|
|
|
// "${var.foo}"
|
|
|
|
type UserVariable struct {
|
2014-05-24 20:41:19 +02:00
|
|
|
Name string
|
|
|
|
|
2014-05-24 21:51:31 +02:00
|
|
|
key string
|
2014-05-24 06:58:06 +02:00
|
|
|
}
|
|
|
|
|
2014-06-05 21:21:05 +02:00
|
|
|
// ProviderConfigName returns the name of the provider configuration in
|
|
|
|
// the given mapping that maps to the proper provider configuration
|
|
|
|
// for this resource.
|
2014-07-20 01:05:48 +02:00
|
|
|
func ProviderConfigName(t string, pcs []*ProviderConfig) string {
|
2014-06-05 21:21:05 +02:00
|
|
|
lk := ""
|
2014-07-20 01:05:48 +02:00
|
|
|
for _, v := range pcs {
|
|
|
|
k := v.Name
|
2014-06-24 22:29:07 +02:00
|
|
|
if strings.HasPrefix(t, k) && len(k) > len(lk) {
|
2014-06-05 21:21:05 +02:00
|
|
|
lk = k
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return lk
|
|
|
|
}
|
|
|
|
|
2014-06-24 22:29:07 +02:00
|
|
|
// A unique identifier for this resource.
|
|
|
|
func (r *Resource) Id() string {
|
|
|
|
return fmt.Sprintf("%s.%s", r.Type, r.Name)
|
|
|
|
}
|
|
|
|
|
2014-06-05 21:47:28 +02:00
|
|
|
// Validate does some basic semantic checking of the configuration.
|
|
|
|
func (c *Config) Validate() error {
|
2014-07-03 06:06:26 +02:00
|
|
|
var errs []error
|
|
|
|
|
2014-07-19 01:00:21 +02:00
|
|
|
for _, k := range c.unknownKeys {
|
|
|
|
errs = append(errs, fmt.Errorf(
|
|
|
|
"Unknown root level key: %s", k))
|
|
|
|
}
|
|
|
|
|
2014-07-03 06:06:26 +02:00
|
|
|
vars := c.allVariables()
|
2014-07-19 02:48:30 +02:00
|
|
|
varMap := make(map[string]*Variable)
|
|
|
|
for _, v := range c.Variables {
|
|
|
|
varMap[v.Name] = v
|
|
|
|
}
|
2014-07-03 06:06:26 +02:00
|
|
|
|
2014-07-03 06:00:06 +02:00
|
|
|
// Check for references to user variables that do not actually
|
|
|
|
// exist and record those errors.
|
2014-07-04 19:53:36 +02:00
|
|
|
for source, vs := range vars {
|
|
|
|
for _, v := range vs {
|
|
|
|
uv, ok := v.(*UserVariable)
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-07-19 02:48:30 +02:00
|
|
|
if _, ok := varMap[uv.Name]; !ok {
|
2014-07-04 19:53:36 +02:00
|
|
|
errs = append(errs, fmt.Errorf(
|
|
|
|
"%s: unknown variable referenced: %s",
|
|
|
|
source,
|
|
|
|
uv.Name))
|
|
|
|
}
|
2014-07-03 06:00:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-03 06:06:26 +02:00
|
|
|
// Check that all references to resources are valid
|
2014-07-06 22:46:56 +02:00
|
|
|
resources := make(map[string]*Resource)
|
2014-07-19 01:31:01 +02:00
|
|
|
dupped := make(map[string]struct{})
|
2014-07-03 06:06:26 +02:00
|
|
|
for _, r := range c.Resources {
|
2014-07-19 01:31:01 +02:00
|
|
|
if _, ok := resources[r.Id()]; ok {
|
|
|
|
if _, ok := dupped[r.Id()]; !ok {
|
|
|
|
dupped[r.Id()] = struct{}{}
|
|
|
|
|
|
|
|
errs = append(errs, fmt.Errorf(
|
|
|
|
"%s: resource repeated multiple times",
|
|
|
|
r.Id()))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-06 22:46:56 +02:00
|
|
|
resources[r.Id()] = r
|
2014-07-03 06:06:26 +02:00
|
|
|
}
|
2014-07-19 01:31:32 +02:00
|
|
|
dupped = nil
|
|
|
|
|
2014-07-04 19:53:36 +02:00
|
|
|
for source, vs := range vars {
|
|
|
|
for _, v := range vs {
|
|
|
|
rv, ok := v.(*ResourceVariable)
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
id := fmt.Sprintf("%s.%s", rv.Type, rv.Name)
|
2014-07-06 22:46:56 +02:00
|
|
|
r, ok := resources[id]
|
|
|
|
if !ok {
|
2014-07-04 19:53:36 +02:00
|
|
|
errs = append(errs, fmt.Errorf(
|
|
|
|
"%s: unknown resource '%s' referenced in variable %s",
|
|
|
|
source,
|
|
|
|
id,
|
|
|
|
rv.FullKey()))
|
2014-07-06 22:46:56 +02:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// If it is a multi reference and resource has a single
|
|
|
|
// count, it is an error.
|
|
|
|
if r.Count > 1 && !rv.Multi {
|
|
|
|
errs = append(errs, fmt.Errorf(
|
|
|
|
"%s: variable '%s' must specify index for multi-count "+
|
|
|
|
"resource %s",
|
|
|
|
source,
|
|
|
|
rv.FullKey(),
|
|
|
|
id))
|
|
|
|
continue
|
2014-07-04 19:53:36 +02:00
|
|
|
}
|
2014-07-03 06:06:26 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-04 19:53:36 +02:00
|
|
|
// Check that all outputs are valid
|
2014-07-04 19:57:09 +02:00
|
|
|
for _, o := range c.Outputs {
|
|
|
|
invalid := false
|
|
|
|
for k, _ := range o.RawConfig.Raw {
|
|
|
|
if k != "value" {
|
|
|
|
invalid = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if invalid {
|
|
|
|
errs = append(errs, fmt.Errorf(
|
|
|
|
"%s: output should only have 'value' field", o.Name))
|
|
|
|
}
|
|
|
|
}
|
2014-07-04 19:53:36 +02:00
|
|
|
|
2014-07-03 06:00:06 +02:00
|
|
|
if len(errs) > 0 {
|
2014-07-03 19:14:17 +02:00
|
|
|
return &multierror.Error{Errors: errs}
|
2014-07-03 06:00:06 +02:00
|
|
|
}
|
2014-06-05 21:47:28 +02:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-07-03 06:00:06 +02:00
|
|
|
// allVariables is a helper that returns a mapping of all the interpolated
|
|
|
|
// variables within the configuration. This is used to verify references
|
|
|
|
// are valid in the Validate step.
|
2014-07-04 19:53:36 +02:00
|
|
|
func (c *Config) allVariables() map[string][]InterpolatedVariable {
|
|
|
|
result := make(map[string][]InterpolatedVariable)
|
2014-07-03 06:00:06 +02:00
|
|
|
for n, pc := range c.ProviderConfigs {
|
|
|
|
source := fmt.Sprintf("provider config '%s'", n)
|
|
|
|
for _, v := range pc.RawConfig.Variables {
|
2014-07-04 19:53:36 +02:00
|
|
|
result[source] = append(result[source], v)
|
2014-07-03 06:00:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, rc := range c.Resources {
|
|
|
|
source := fmt.Sprintf("resource '%s'", rc.Id())
|
|
|
|
for _, v := range rc.RawConfig.Variables {
|
2014-07-04 19:53:36 +02:00
|
|
|
result[source] = append(result[source], v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, o := range c.Outputs {
|
|
|
|
source := fmt.Sprintf("output '%s'", o.Name)
|
|
|
|
for _, v := range o.RawConfig.Variables {
|
|
|
|
result[source] = append(result[source], v)
|
2014-07-03 06:00:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
2014-07-21 02:17:03 +02:00
|
|
|
func (o *Output) mergerName() string {
|
|
|
|
return o.Name
|
|
|
|
}
|
|
|
|
|
|
|
|
func (o *Output) mergerMerge(m merger) merger {
|
|
|
|
o2 := m.(*Output)
|
|
|
|
|
|
|
|
result := *o
|
|
|
|
result.Name = o2.Name
|
|
|
|
result.RawConfig = result.RawConfig.merge(o2.RawConfig)
|
|
|
|
|
|
|
|
return &result
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *ProviderConfig) mergerName() string {
|
|
|
|
return c.Name
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *ProviderConfig) mergerMerge(m merger) merger {
|
|
|
|
c2 := m.(*ProviderConfig)
|
|
|
|
|
|
|
|
result := *c
|
|
|
|
result.Name = c2.Name
|
|
|
|
result.RawConfig = result.RawConfig.merge(c2.RawConfig)
|
|
|
|
|
|
|
|
return &result
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *Resource) mergerName() string {
|
|
|
|
return fmt.Sprintf("%s.%s", r.Type, r.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *Resource) mergerMerge(m merger) merger {
|
|
|
|
r2 := m.(*Resource)
|
|
|
|
|
|
|
|
result := *r
|
|
|
|
result.Name = r2.Name
|
|
|
|
result.Type = r2.Type
|
|
|
|
result.RawConfig = result.RawConfig.merge(r2.RawConfig)
|
|
|
|
|
|
|
|
if r2.Count > 0 {
|
|
|
|
result.Count = r2.Count
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(r2.Provisioners) > 0 {
|
|
|
|
result.Provisioners = r2.Provisioners
|
|
|
|
}
|
|
|
|
|
|
|
|
return &result
|
|
|
|
}
|
|
|
|
|
|
|
|
// Merge merges two variables to create a new third variable.
|
|
|
|
func (v *Variable) Merge(v2 *Variable) *Variable {
|
|
|
|
// Shallow copy the variable
|
|
|
|
result := *v
|
|
|
|
|
|
|
|
// The names should be the same, but the second name always wins.
|
|
|
|
result.Name = v2.Name
|
|
|
|
|
2014-07-21 16:32:36 +02:00
|
|
|
if v2.Default != nil {
|
2014-07-21 02:17:03 +02:00
|
|
|
result.Default = v2.Default
|
|
|
|
}
|
|
|
|
if v2.Description != "" {
|
|
|
|
result.Description = v2.Description
|
|
|
|
}
|
|
|
|
|
|
|
|
return &result
|
|
|
|
}
|
|
|
|
|
|
|
|
func (v *Variable) mergerName() string {
|
|
|
|
return v.Name
|
|
|
|
}
|
|
|
|
|
|
|
|
func (v *Variable) mergerMerge(m merger) merger {
|
|
|
|
return v.Merge(m.(*Variable))
|
|
|
|
}
|
|
|
|
|
2014-06-04 00:55:51 +02:00
|
|
|
// Required tests whether a variable is required or not.
|
|
|
|
func (v *Variable) Required() bool {
|
2014-07-21 16:32:36 +02:00
|
|
|
return v.Default == nil
|
2014-06-04 00:55:51 +02:00
|
|
|
}
|
|
|
|
|
2014-05-24 06:58:06 +02:00
|
|
|
func NewResourceVariable(key string) (*ResourceVariable, error) {
|
|
|
|
parts := strings.SplitN(key, ".", 3)
|
2014-07-05 19:34:52 +02:00
|
|
|
field := parts[2]
|
|
|
|
multi := false
|
2014-07-06 22:56:18 +02:00
|
|
|
var index int
|
|
|
|
|
|
|
|
if idx := strings.Index(field, "."); idx != -1 {
|
|
|
|
indexStr := field[:idx]
|
|
|
|
multi = indexStr == "*"
|
|
|
|
index = -1
|
|
|
|
|
|
|
|
if !multi {
|
|
|
|
indexInt, err := strconv.ParseInt(indexStr, 0, 0)
|
|
|
|
if err == nil {
|
|
|
|
multi = true
|
|
|
|
index = int(indexInt)
|
|
|
|
}
|
|
|
|
}
|
2014-07-05 19:34:52 +02:00
|
|
|
|
2014-07-06 22:56:18 +02:00
|
|
|
if multi {
|
|
|
|
field = field[idx+1:]
|
|
|
|
}
|
2014-07-05 19:34:52 +02:00
|
|
|
}
|
|
|
|
|
2014-05-24 06:58:06 +02:00
|
|
|
return &ResourceVariable{
|
|
|
|
Type: parts[0],
|
|
|
|
Name: parts[1],
|
2014-07-05 19:34:52 +02:00
|
|
|
Field: field,
|
|
|
|
Multi: multi,
|
2014-07-06 22:56:18 +02:00
|
|
|
Index: index,
|
2014-05-24 06:58:06 +02:00
|
|
|
key: key,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2014-05-24 22:57:51 +02:00
|
|
|
func (v *ResourceVariable) ResourceId() string {
|
|
|
|
return fmt.Sprintf("%s.%s", v.Type, v.Name)
|
|
|
|
}
|
|
|
|
|
2014-05-24 06:58:06 +02:00
|
|
|
func (v *ResourceVariable) FullKey() string {
|
|
|
|
return v.key
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewUserVariable(key string) (*UserVariable, error) {
|
|
|
|
name := key[len("var."):]
|
|
|
|
return &UserVariable{
|
|
|
|
key: key,
|
2014-05-24 20:41:19 +02:00
|
|
|
Name: name,
|
2014-05-24 06:58:06 +02:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (v *UserVariable) FullKey() string {
|
|
|
|
return v.key
|
|
|
|
}
|