diff options
Diffstat (limited to 'vendor/github.com/hashicorp/terraform/config/config_string.go')
-rw-r--r-- | vendor/github.com/hashicorp/terraform/config/config_string.go | 338 |
1 files changed, 338 insertions, 0 deletions
diff --git a/vendor/github.com/hashicorp/terraform/config/config_string.go b/vendor/github.com/hashicorp/terraform/config/config_string.go new file mode 100644 index 0000000..0b3abbc --- /dev/null +++ b/vendor/github.com/hashicorp/terraform/config/config_string.go | |||
@@ -0,0 +1,338 @@ | |||
1 | package config | ||
2 | |||
3 | import ( | ||
4 | "bytes" | ||
5 | "fmt" | ||
6 | "sort" | ||
7 | "strings" | ||
8 | ) | ||
9 | |||
10 | // TestString is a Stringer-like function that outputs a string that can | ||
11 | // be used to easily compare multiple Config structures in unit tests. | ||
12 | // | ||
13 | // This function has no practical use outside of unit tests and debugging. | ||
14 | func (c *Config) TestString() string { | ||
15 | if c == nil { | ||
16 | return "<nil config>" | ||
17 | } | ||
18 | |||
19 | var buf bytes.Buffer | ||
20 | if len(c.Modules) > 0 { | ||
21 | buf.WriteString("Modules:\n\n") | ||
22 | buf.WriteString(modulesStr(c.Modules)) | ||
23 | buf.WriteString("\n\n") | ||
24 | } | ||
25 | |||
26 | if len(c.Variables) > 0 { | ||
27 | buf.WriteString("Variables:\n\n") | ||
28 | buf.WriteString(variablesStr(c.Variables)) | ||
29 | buf.WriteString("\n\n") | ||
30 | } | ||
31 | |||
32 | if len(c.ProviderConfigs) > 0 { | ||
33 | buf.WriteString("Provider Configs:\n\n") | ||
34 | buf.WriteString(providerConfigsStr(c.ProviderConfigs)) | ||
35 | buf.WriteString("\n\n") | ||
36 | } | ||
37 | |||
38 | if len(c.Resources) > 0 { | ||
39 | buf.WriteString("Resources:\n\n") | ||
40 | buf.WriteString(resourcesStr(c.Resources)) | ||
41 | buf.WriteString("\n\n") | ||
42 | } | ||
43 | |||
44 | if len(c.Outputs) > 0 { | ||
45 | buf.WriteString("Outputs:\n\n") | ||
46 | buf.WriteString(outputsStr(c.Outputs)) | ||
47 | buf.WriteString("\n") | ||
48 | } | ||
49 | |||
50 | return strings.TrimSpace(buf.String()) | ||
51 | } | ||
52 | |||
53 | func terraformStr(t *Terraform) string { | ||
54 | result := "" | ||
55 | |||
56 | if b := t.Backend; b != nil { | ||
57 | result += fmt.Sprintf("backend (%s)\n", b.Type) | ||
58 | |||
59 | keys := make([]string, 0, len(b.RawConfig.Raw)) | ||
60 | for k, _ := range b.RawConfig.Raw { | ||
61 | keys = append(keys, k) | ||
62 | } | ||
63 | sort.Strings(keys) | ||
64 | |||
65 | for _, k := range keys { | ||
66 | result += fmt.Sprintf(" %s\n", k) | ||
67 | } | ||
68 | } | ||
69 | |||
70 | return strings.TrimSpace(result) | ||
71 | } | ||
72 | |||
73 | func modulesStr(ms []*Module) string { | ||
74 | result := "" | ||
75 | order := make([]int, 0, len(ms)) | ||
76 | ks := make([]string, 0, len(ms)) | ||
77 | mapping := make(map[string]int) | ||
78 | for i, m := range ms { | ||
79 | k := m.Id() | ||
80 | ks = append(ks, k) | ||
81 | mapping[k] = i | ||
82 | } | ||
83 | sort.Strings(ks) | ||
84 | for _, k := range ks { | ||
85 | order = append(order, mapping[k]) | ||
86 | } | ||
87 | |||
88 | for _, i := range order { | ||
89 | m := ms[i] | ||
90 | result += fmt.Sprintf("%s\n", m.Id()) | ||
91 | |||
92 | ks := make([]string, 0, len(m.RawConfig.Raw)) | ||
93 | for k, _ := range m.RawConfig.Raw { | ||
94 | ks = append(ks, k) | ||
95 | } | ||
96 | sort.Strings(ks) | ||
97 | |||
98 | result += fmt.Sprintf(" source = %s\n", m.Source) | ||
99 | |||
100 | for _, k := range ks { | ||
101 | result += fmt.Sprintf(" %s\n", k) | ||
102 | } | ||
103 | } | ||
104 | |||
105 | return strings.TrimSpace(result) | ||
106 | } | ||
107 | |||
108 | func outputsStr(os []*Output) string { | ||
109 | ns := make([]string, 0, len(os)) | ||
110 | m := make(map[string]*Output) | ||
111 | for _, o := range os { | ||
112 | ns = append(ns, o.Name) | ||
113 | m[o.Name] = o | ||
114 | } | ||
115 | sort.Strings(ns) | ||
116 | |||
117 | result := "" | ||
118 | for _, n := range ns { | ||
119 | o := m[n] | ||
120 | |||
121 | result += fmt.Sprintf("%s\n", n) | ||
122 | |||
123 | if len(o.DependsOn) > 0 { | ||
124 | result += fmt.Sprintf(" dependsOn\n") | ||
125 | for _, d := range o.DependsOn { | ||
126 | result += fmt.Sprintf(" %s\n", d) | ||
127 | } | ||
128 | } | ||
129 | |||
130 | if len(o.RawConfig.Variables) > 0 { | ||
131 | result += fmt.Sprintf(" vars\n") | ||
132 | for _, rawV := range o.RawConfig.Variables { | ||
133 | kind := "unknown" | ||
134 | str := rawV.FullKey() | ||
135 | |||
136 | switch rawV.(type) { | ||
137 | case *ResourceVariable: | ||
138 | kind = "resource" | ||
139 | case *UserVariable: | ||
140 | kind = "user" | ||
141 | } | ||
142 | |||
143 | result += fmt.Sprintf(" %s: %s\n", kind, str) | ||
144 | } | ||
145 | } | ||
146 | } | ||
147 | |||
148 | return strings.TrimSpace(result) | ||
149 | } | ||
150 | |||
151 | // This helper turns a provider configs field into a deterministic | ||
152 | // string value for comparison in tests. | ||
153 | func providerConfigsStr(pcs []*ProviderConfig) string { | ||
154 | result := "" | ||
155 | |||
156 | ns := make([]string, 0, len(pcs)) | ||
157 | m := make(map[string]*ProviderConfig) | ||
158 | for _, n := range pcs { | ||
159 | ns = append(ns, n.Name) | ||
160 | m[n.Name] = n | ||
161 | } | ||
162 | sort.Strings(ns) | ||
163 | |||
164 | for _, n := range ns { | ||
165 | pc := m[n] | ||
166 | |||
167 | result += fmt.Sprintf("%s\n", n) | ||
168 | |||
169 | keys := make([]string, 0, len(pc.RawConfig.Raw)) | ||
170 | for k, _ := range pc.RawConfig.Raw { | ||
171 | keys = append(keys, k) | ||
172 | } | ||
173 | sort.Strings(keys) | ||
174 | |||
175 | for _, k := range keys { | ||
176 | result += fmt.Sprintf(" %s\n", k) | ||
177 | } | ||
178 | |||
179 | if len(pc.RawConfig.Variables) > 0 { | ||
180 | result += fmt.Sprintf(" vars\n") | ||
181 | for _, rawV := range pc.RawConfig.Variables { | ||
182 | kind := "unknown" | ||
183 | str := rawV.FullKey() | ||
184 | |||
185 | switch rawV.(type) { | ||
186 | case *ResourceVariable: | ||
187 | kind = "resource" | ||
188 | case *UserVariable: | ||
189 | kind = "user" | ||
190 | } | ||
191 | |||
192 | result += fmt.Sprintf(" %s: %s\n", kind, str) | ||
193 | } | ||
194 | } | ||
195 | } | ||
196 | |||
197 | return strings.TrimSpace(result) | ||
198 | } | ||
199 | |||
200 | // This helper turns a resources field into a deterministic | ||
201 | // string value for comparison in tests. | ||
202 | func resourcesStr(rs []*Resource) string { | ||
203 | result := "" | ||
204 | order := make([]int, 0, len(rs)) | ||
205 | ks := make([]string, 0, len(rs)) | ||
206 | mapping := make(map[string]int) | ||
207 | for i, r := range rs { | ||
208 | k := r.Id() | ||
209 | ks = append(ks, k) | ||
210 | mapping[k] = i | ||
211 | } | ||
212 | sort.Strings(ks) | ||
213 | for _, k := range ks { | ||
214 | order = append(order, mapping[k]) | ||
215 | } | ||
216 | |||
217 | for _, i := range order { | ||
218 | r := rs[i] | ||
219 | result += fmt.Sprintf( | ||
220 | "%s (x%s)\n", | ||
221 | r.Id(), | ||
222 | r.RawCount.Value()) | ||
223 | |||
224 | ks := make([]string, 0, len(r.RawConfig.Raw)) | ||
225 | for k, _ := range r.RawConfig.Raw { | ||
226 | ks = append(ks, k) | ||
227 | } | ||
228 | sort.Strings(ks) | ||
229 | |||
230 | for _, k := range ks { | ||
231 | result += fmt.Sprintf(" %s\n", k) | ||
232 | } | ||
233 | |||
234 | if len(r.Provisioners) > 0 { | ||
235 | result += fmt.Sprintf(" provisioners\n") | ||
236 | for _, p := range r.Provisioners { | ||
237 | when := "" | ||
238 | if p.When != ProvisionerWhenCreate { | ||
239 | when = fmt.Sprintf(" (%s)", p.When.String()) | ||
240 | } | ||
241 | |||
242 | result += fmt.Sprintf(" %s%s\n", p.Type, when) | ||
243 | |||
244 | if p.OnFailure != ProvisionerOnFailureFail { | ||
245 | result += fmt.Sprintf(" on_failure = %s\n", p.OnFailure.String()) | ||
246 | } | ||
247 | |||
248 | ks := make([]string, 0, len(p.RawConfig.Raw)) | ||
249 | for k, _ := range p.RawConfig.Raw { | ||
250 | ks = append(ks, k) | ||
251 | } | ||
252 | sort.Strings(ks) | ||
253 | |||
254 | for _, k := range ks { | ||
255 | result += fmt.Sprintf(" %s\n", k) | ||
256 | } | ||
257 | } | ||
258 | } | ||
259 | |||
260 | if len(r.DependsOn) > 0 { | ||
261 | result += fmt.Sprintf(" dependsOn\n") | ||
262 | for _, d := range r.DependsOn { | ||
263 | result += fmt.Sprintf(" %s\n", d) | ||
264 | } | ||
265 | } | ||
266 | |||
267 | if len(r.RawConfig.Variables) > 0 { | ||
268 | result += fmt.Sprintf(" vars\n") | ||
269 | |||
270 | ks := make([]string, 0, len(r.RawConfig.Variables)) | ||
271 | for k, _ := range r.RawConfig.Variables { | ||
272 | ks = append(ks, k) | ||
273 | } | ||
274 | sort.Strings(ks) | ||
275 | |||
276 | for _, k := range ks { | ||
277 | rawV := r.RawConfig.Variables[k] | ||
278 | kind := "unknown" | ||
279 | str := rawV.FullKey() | ||
280 | |||
281 | switch rawV.(type) { | ||
282 | case *ResourceVariable: | ||
283 | kind = "resource" | ||
284 | case *UserVariable: | ||
285 | kind = "user" | ||
286 | } | ||
287 | |||
288 | result += fmt.Sprintf(" %s: %s\n", kind, str) | ||
289 | } | ||
290 | } | ||
291 | } | ||
292 | |||
293 | return strings.TrimSpace(result) | ||
294 | } | ||
295 | |||
296 | // This helper turns a variables field into a deterministic | ||
297 | // string value for comparison in tests. | ||
298 | func variablesStr(vs []*Variable) string { | ||
299 | result := "" | ||
300 | ks := make([]string, 0, len(vs)) | ||
301 | m := make(map[string]*Variable) | ||
302 | for _, v := range vs { | ||
303 | ks = append(ks, v.Name) | ||
304 | m[v.Name] = v | ||
305 | } | ||
306 | sort.Strings(ks) | ||
307 | |||
308 | for _, k := range ks { | ||
309 | v := m[k] | ||
310 | |||
311 | required := "" | ||
312 | if v.Required() { | ||
313 | required = " (required)" | ||
314 | } | ||
315 | |||
316 | declaredType := "" | ||
317 | if v.DeclaredType != "" { | ||
318 | declaredType = fmt.Sprintf(" (%s)", v.DeclaredType) | ||
319 | } | ||
320 | |||
321 | if v.Default == nil || v.Default == "" { | ||
322 | v.Default = "<>" | ||
323 | } | ||
324 | if v.Description == "" { | ||
325 | v.Description = "<>" | ||
326 | } | ||
327 | |||
328 | result += fmt.Sprintf( | ||
329 | "%s%s%s\n %v\n %s\n", | ||
330 | k, | ||
331 | required, | ||
332 | declaredType, | ||
333 | v.Default, | ||
334 | v.Description) | ||
335 | } | ||
336 | |||
337 | return strings.TrimSpace(result) | ||
338 | } | ||