diff options
Diffstat (limited to 'vendor/github.com/hashicorp/terraform/helper/config')
-rw-r--r-- | vendor/github.com/hashicorp/terraform/helper/config/decode.go | 28 | ||||
-rw-r--r-- | vendor/github.com/hashicorp/terraform/helper/config/validator.go | 214 |
2 files changed, 242 insertions, 0 deletions
diff --git a/vendor/github.com/hashicorp/terraform/helper/config/decode.go b/vendor/github.com/hashicorp/terraform/helper/config/decode.go new file mode 100644 index 0000000..f470c9b --- /dev/null +++ b/vendor/github.com/hashicorp/terraform/helper/config/decode.go | |||
@@ -0,0 +1,28 @@ | |||
1 | package config | ||
2 | |||
3 | import ( | ||
4 | "github.com/mitchellh/mapstructure" | ||
5 | ) | ||
6 | |||
7 | func Decode(target interface{}, raws ...interface{}) (*mapstructure.Metadata, error) { | ||
8 | var md mapstructure.Metadata | ||
9 | decoderConfig := &mapstructure.DecoderConfig{ | ||
10 | Metadata: &md, | ||
11 | Result: target, | ||
12 | WeaklyTypedInput: true, | ||
13 | } | ||
14 | |||
15 | decoder, err := mapstructure.NewDecoder(decoderConfig) | ||
16 | if err != nil { | ||
17 | return nil, err | ||
18 | } | ||
19 | |||
20 | for _, raw := range raws { | ||
21 | err := decoder.Decode(raw) | ||
22 | if err != nil { | ||
23 | return nil, err | ||
24 | } | ||
25 | } | ||
26 | |||
27 | return &md, nil | ||
28 | } | ||
diff --git a/vendor/github.com/hashicorp/terraform/helper/config/validator.go b/vendor/github.com/hashicorp/terraform/helper/config/validator.go new file mode 100644 index 0000000..1a6e023 --- /dev/null +++ b/vendor/github.com/hashicorp/terraform/helper/config/validator.go | |||
@@ -0,0 +1,214 @@ | |||
1 | package config | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "strconv" | ||
6 | "strings" | ||
7 | |||
8 | "github.com/hashicorp/terraform/flatmap" | ||
9 | "github.com/hashicorp/terraform/terraform" | ||
10 | ) | ||
11 | |||
12 | // Validator is a helper that helps you validate the configuration | ||
13 | // of your resource, resource provider, etc. | ||
14 | // | ||
15 | // At the most basic level, set the Required and Optional lists to be | ||
16 | // specifiers of keys that are required or optional. If a key shows up | ||
17 | // that isn't in one of these two lists, then an error is generated. | ||
18 | // | ||
19 | // The "specifiers" allowed in this is a fairly rich syntax to help | ||
20 | // describe the format of your configuration: | ||
21 | // | ||
22 | // * Basic keys are just strings. For example: "foo" will match the | ||
23 | // "foo" key. | ||
24 | // | ||
25 | // * Nested structure keys can be matched by doing | ||
26 | // "listener.*.foo". This will verify that there is at least one | ||
27 | // listener element that has the "foo" key set. | ||
28 | // | ||
29 | // * The existence of a nested structure can be checked by simply | ||
30 | // doing "listener.*" which will verify that there is at least | ||
31 | // one element in the "listener" structure. This is NOT | ||
32 | // validating that "listener" is an array. It is validating | ||
33 | // that it is a nested structure in the configuration. | ||
34 | // | ||
35 | type Validator struct { | ||
36 | Required []string | ||
37 | Optional []string | ||
38 | } | ||
39 | |||
40 | func (v *Validator) Validate( | ||
41 | c *terraform.ResourceConfig) (ws []string, es []error) { | ||
42 | // Flatten the configuration so it is easier to reason about | ||
43 | flat := flatmap.Flatten(c.Raw) | ||
44 | |||
45 | keySet := make(map[string]validatorKey) | ||
46 | for i, vs := range [][]string{v.Required, v.Optional} { | ||
47 | req := i == 0 | ||
48 | for _, k := range vs { | ||
49 | vk, err := newValidatorKey(k, req) | ||
50 | if err != nil { | ||
51 | es = append(es, err) | ||
52 | continue | ||
53 | } | ||
54 | |||
55 | keySet[k] = vk | ||
56 | } | ||
57 | } | ||
58 | |||
59 | purged := make([]string, 0) | ||
60 | for _, kv := range keySet { | ||
61 | p, w, e := kv.Validate(flat) | ||
62 | if len(w) > 0 { | ||
63 | ws = append(ws, w...) | ||
64 | } | ||
65 | if len(e) > 0 { | ||
66 | es = append(es, e...) | ||
67 | } | ||
68 | |||
69 | purged = append(purged, p...) | ||
70 | } | ||
71 | |||
72 | // Delete all the keys we processed in order to find | ||
73 | // the unknown keys. | ||
74 | for _, p := range purged { | ||
75 | delete(flat, p) | ||
76 | } | ||
77 | |||
78 | // The rest are unknown | ||
79 | for k, _ := range flat { | ||
80 | es = append(es, fmt.Errorf("Unknown configuration: %s", k)) | ||
81 | } | ||
82 | |||
83 | return | ||
84 | } | ||
85 | |||
86 | type validatorKey interface { | ||
87 | // Validate validates the given configuration and returns viewed keys, | ||
88 | // warnings, and errors. | ||
89 | Validate(map[string]string) ([]string, []string, []error) | ||
90 | } | ||
91 | |||
92 | func newValidatorKey(k string, req bool) (validatorKey, error) { | ||
93 | var result validatorKey | ||
94 | |||
95 | parts := strings.Split(k, ".") | ||
96 | if len(parts) > 1 && parts[1] == "*" { | ||
97 | result = &nestedValidatorKey{ | ||
98 | Parts: parts, | ||
99 | Required: req, | ||
100 | } | ||
101 | } else { | ||
102 | result = &basicValidatorKey{ | ||
103 | Key: k, | ||
104 | Required: req, | ||
105 | } | ||
106 | } | ||
107 | |||
108 | return result, nil | ||
109 | } | ||
110 | |||
111 | // basicValidatorKey validates keys that are basic such as "foo" | ||
112 | type basicValidatorKey struct { | ||
113 | Key string | ||
114 | Required bool | ||
115 | } | ||
116 | |||
117 | func (v *basicValidatorKey) Validate( | ||
118 | m map[string]string) ([]string, []string, []error) { | ||
119 | for k, _ := range m { | ||
120 | // If we have the exact key its a match | ||
121 | if k == v.Key { | ||
122 | return []string{k}, nil, nil | ||
123 | } | ||
124 | } | ||
125 | |||
126 | if !v.Required { | ||
127 | return nil, nil, nil | ||
128 | } | ||
129 | |||
130 | return nil, nil, []error{fmt.Errorf( | ||
131 | "Key not found: %s", v.Key)} | ||
132 | } | ||
133 | |||
134 | type nestedValidatorKey struct { | ||
135 | Parts []string | ||
136 | Required bool | ||
137 | } | ||
138 | |||
139 | func (v *nestedValidatorKey) validate( | ||
140 | m map[string]string, | ||
141 | prefix string, | ||
142 | offset int) ([]string, []string, []error) { | ||
143 | if offset >= len(v.Parts) { | ||
144 | // We're at the end. Look for a specific key. | ||
145 | v2 := &basicValidatorKey{Key: prefix, Required: v.Required} | ||
146 | return v2.Validate(m) | ||
147 | } | ||
148 | |||
149 | current := v.Parts[offset] | ||
150 | |||
151 | // If we're at offset 0, special case to start at the next one. | ||
152 | if offset == 0 { | ||
153 | return v.validate(m, current, offset+1) | ||
154 | } | ||
155 | |||
156 | // Determine if we're doing a "for all" or a specific key | ||
157 | if current != "*" { | ||
158 | // We're looking at a specific key, continue on. | ||
159 | return v.validate(m, prefix+"."+current, offset+1) | ||
160 | } | ||
161 | |||
162 | // We're doing a "for all", so we loop over. | ||
163 | countStr, ok := m[prefix+".#"] | ||
164 | if !ok { | ||
165 | if !v.Required { | ||
166 | // It wasn't required, so its no problem. | ||
167 | return nil, nil, nil | ||
168 | } | ||
169 | |||
170 | return nil, nil, []error{fmt.Errorf( | ||
171 | "Key not found: %s", prefix)} | ||
172 | } | ||
173 | |||
174 | count, err := strconv.ParseInt(countStr, 0, 0) | ||
175 | if err != nil { | ||
176 | // This shouldn't happen if flatmap works properly | ||
177 | panic("invalid flatmap array") | ||
178 | } | ||
179 | |||
180 | var e []error | ||
181 | var w []string | ||
182 | u := make([]string, 1, count+1) | ||
183 | u[0] = prefix + ".#" | ||
184 | for i := 0; i < int(count); i++ { | ||
185 | prefix := fmt.Sprintf("%s.%d", prefix, i) | ||
186 | |||
187 | // Mark that we saw this specific key | ||
188 | u = append(u, prefix) | ||
189 | |||
190 | // Mark all prefixes of this | ||
191 | for k, _ := range m { | ||
192 | if !strings.HasPrefix(k, prefix+".") { | ||
193 | continue | ||
194 | } | ||
195 | u = append(u, k) | ||
196 | } | ||
197 | |||
198 | // If we have more parts, then validate deeper | ||
199 | if offset+1 < len(v.Parts) { | ||
200 | u2, w2, e2 := v.validate(m, prefix, offset+1) | ||
201 | |||
202 | u = append(u, u2...) | ||
203 | w = append(w, w2...) | ||
204 | e = append(e, e2...) | ||
205 | } | ||
206 | } | ||
207 | |||
208 | return u, w, e | ||
209 | } | ||
210 | |||
211 | func (v *nestedValidatorKey) Validate( | ||
212 | m map[string]string) ([]string, []string, []error) { | ||
213 | return v.validate(m, "", 0) | ||
214 | } | ||