mirror of
https://github.com/opentofu/opentofu.git
synced 2025-01-08 15:13:56 -06:00
bdc6a49ae3
The work integrated in hashicorp/terraform#6322 silently broke the ability to use remote state correctly. This commit adds a fix for that, making use of the work integrated in hashicorp/terraform#7124. In order to deal with outputs which are complex structures, we use a forked version of the flatmap package - the difference in the version this commit vs the github.com/hashicorp/terraform/flatmap package is that we add in an additional key for map counts which state requires. Because we bypass the normal helper/schema mechanism, this is not set for us. Because of the HIL type checking of maps, values must be of a homogenous type. This is unfortunate, as it means we can no longer refer to outputs as: ${terraform_remote_state.foo.output.outputname} Instead we had to bring them to the top level namespace: ${terraform_remote_state.foo.outputname} This actually does lead to better overall usability - and the BC breakage is made better by the fact that indexing would have broken the original syntax anyway. We also add a real-world test and assert against specific values. Tests which were previously acceptance tests are now run as unit tests, so regression should be identified at a much earlier stage.
77 lines
1.9 KiB
Go
77 lines
1.9 KiB
Go
package terraform
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
)
|
|
|
|
// remoteStateFlatten takes a structure and turns into a flat map[string]string.
|
|
//
|
|
// Within the "thing" parameter, only primitive values are allowed. Structs are
|
|
// not supported. Therefore, it can only be slices, maps, primitives, and
|
|
// any combination of those together.
|
|
//
|
|
// The difference between this version and the version in package flatmap is that
|
|
// we add the count key for maps in this version, and return a normal
|
|
// map[string]string instead of a flatmap.Map
|
|
func remoteStateFlatten(thing map[string]interface{}) map[string]string {
|
|
result := make(map[string]string)
|
|
|
|
for k, raw := range thing {
|
|
flatten(result, k, reflect.ValueOf(raw))
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func flatten(result map[string]string, prefix string, v reflect.Value) {
|
|
if v.Kind() == reflect.Interface {
|
|
v = v.Elem()
|
|
}
|
|
|
|
switch v.Kind() {
|
|
case reflect.Bool:
|
|
if v.Bool() {
|
|
result[prefix] = "true"
|
|
} else {
|
|
result[prefix] = "false"
|
|
}
|
|
case reflect.Int:
|
|
result[prefix] = fmt.Sprintf("%d", v.Int())
|
|
case reflect.Map:
|
|
flattenMap(result, prefix, v)
|
|
case reflect.Slice:
|
|
flattenSlice(result, prefix, v)
|
|
case reflect.String:
|
|
result[prefix] = v.String()
|
|
default:
|
|
panic(fmt.Sprintf("Unknown: %s", v))
|
|
}
|
|
}
|
|
|
|
func flattenMap(result map[string]string, prefix string, v reflect.Value) {
|
|
mapKeys := v.MapKeys()
|
|
|
|
result[fmt.Sprintf("%s.%%", prefix)] = fmt.Sprintf("%d", len(mapKeys))
|
|
for _, k := range mapKeys {
|
|
if k.Kind() == reflect.Interface {
|
|
k = k.Elem()
|
|
}
|
|
|
|
if k.Kind() != reflect.String {
|
|
panic(fmt.Sprintf("%s: map key is not string: %s", prefix, k))
|
|
}
|
|
|
|
flatten(result, fmt.Sprintf("%s.%s", prefix, k.String()), v.MapIndex(k))
|
|
}
|
|
}
|
|
|
|
func flattenSlice(result map[string]string, prefix string, v reflect.Value) {
|
|
prefix = prefix + "."
|
|
|
|
result[prefix+"#"] = fmt.Sprintf("%d", v.Len())
|
|
for i := 0; i < v.Len(); i++ {
|
|
flatten(result, fmt.Sprintf("%s%d", prefix, i), v.Index(i))
|
|
}
|
|
}
|