diff --git a/config/hcl2shim/flatmap.go b/config/hcl2shim/flatmap.go new file mode 100644 index 0000000000..f013bf8875 --- /dev/null +++ b/config/hcl2shim/flatmap.go @@ -0,0 +1,317 @@ +package hcl2shim + +import ( + "fmt" + "strconv" + "strings" + + "github.com/zclconf/go-cty/cty/convert" + + "github.com/zclconf/go-cty/cty" +) + +// FlatmapValueFromHCL2 converts a value from HCL2 (really, from the cty dynamic +// types library that HCL2 uses) to a map compatible with what would be +// produced by the "flatmap" package. +// +// The type of the given value informs the structure of the resulting map. +// The value must be of an object type or this function will panic. +// +// Flatmap values can only represent maps when they are of primitive types, +// so the given value must not have any maps of complex types or the result +// is undefined. +func FlatmapValueFromHCL2(v cty.Value) map[string]string { + if !v.Type().IsObjectType() { + panic(fmt.Sprintf("HCL2ValueFromFlatmap called on %#v", v.Type())) + } + + m := make(map[string]string) + flatmapValueFromHCL2Map(m, "", v) + return m +} + +func flatmapValueFromHCL2Value(m map[string]string, key string, val cty.Value) { + ty := val.Type() + switch { + case ty.IsPrimitiveType(): + flatmapValueFromHCL2Primitive(m, key, val) + case ty.IsObjectType() || ty.IsMapType(): + flatmapValueFromHCL2Map(m, key+".", val) + case ty.IsTupleType() || ty.IsListType() || ty.IsSetType(): + flatmapValueFromHCL2Seq(m, key+".", val) + default: + panic(fmt.Sprintf("cannot encode %s to flatmap", ty.FriendlyName())) + } +} + +func flatmapValueFromHCL2Primitive(m map[string]string, key string, val cty.Value) { + if !val.IsKnown() { + m[key] = UnknownVariableValue + return + } + if val.IsNull() { + // Omit entirely + return + } + + var err error + val, err = convert.Convert(val, cty.String) + if err != nil { + // Should not be possible, since all primitive types can convert to string. + panic(fmt.Sprintf("invalid primitive encoding to flatmap: %s", err)) + } + m[key] = val.AsString() +} + +func flatmapValueFromHCL2Map(m map[string]string, prefix string, val cty.Value) { + len := 0 + for it := val.ElementIterator(); it.Next(); { + ak, av := it.Element() + name := ak.AsString() + flatmapValueFromHCL2Value(m, prefix+name, av) + len++ + } + if !val.Type().IsObjectType() { // objects don't have an explicit count included, since their attribute count is fixed + m[prefix+"%"] = strconv.Itoa(len) + } +} + +func flatmapValueFromHCL2Seq(m map[string]string, prefix string, val cty.Value) { + // For sets this won't actually generate exactly what helper/schema would've + // generated, because we don't have access to the set key function it + // would've used. However, in practice it doesn't actually matter what the + // keys are as long as they are unique, so we'll just generate sequential + // indexes for them as if it were a list. + // + // An important implication of this, however, is that the set ordering will + // not be consistent across mutations and so different keys may be assigned + // to the same value when round-tripping. Since this shim is intended to + // be short-lived and not used for round-tripping, we accept this. + i := 0 + for it := val.ElementIterator(); it.Next(); { + _, av := it.Element() + key := prefix + strconv.Itoa(i) + flatmapValueFromHCL2Value(m, key, av) + i++ + } + m[prefix+"#"] = strconv.Itoa(i) +} + +// HCL2ValueFromFlatmap converts a map compatible with what would be produced +// by the "flatmap" package to a HCL2 (really, the cty dynamic types library +// that HCL2 uses) object type. +// +// The intended result type must be provided in order to guide how the +// map contents are decoded. This must be an object type or this function +// will panic. +// +// Flatmap values can only represent maps when they are of primitive types, +// so the given type must not have any maps of complex types or the result +// is undefined. +// +// The result may contain null values if the given map does not contain keys +// for all of the different key paths implied by the given type. +func HCL2ValueFromFlatmap(m map[string]string, ty cty.Type) (cty.Value, error) { + if !ty.IsObjectType() { + panic(fmt.Sprintf("HCL2ValueFromFlatmap called on %#v", ty)) + } + + return hcl2ValueFromFlatmapObject(m, "", ty.AttributeTypes()) +} + +func hcl2ValueFromFlatmapValue(m map[string]string, key string, ty cty.Type) (cty.Value, error) { + var val cty.Value + var err error + switch { + case ty.IsPrimitiveType(): + val, err = hcl2ValueFromFlatmapPrimitive(m, key, ty) + case ty.IsObjectType(): + val, err = hcl2ValueFromFlatmapObject(m, key+".", ty.AttributeTypes()) + case ty.IsTupleType(): + val, err = hcl2ValueFromFlatmapTuple(m, key+".", ty.TupleElementTypes()) + case ty.IsMapType(): + val, err = hcl2ValueFromFlatmapMap(m, key+".", ty) + case ty.IsListType(): + val, err = hcl2ValueFromFlatmapList(m, key+".", ty) + case ty.IsSetType(): + val, err = hcl2ValueFromFlatmapSet(m, key+".", ty) + default: + err = fmt.Errorf("cannot decode %s from flatmap", ty.FriendlyName()) + } + + if err != nil { + return cty.DynamicVal, err + } + return val, nil +} + +func hcl2ValueFromFlatmapPrimitive(m map[string]string, key string, ty cty.Type) (cty.Value, error) { + rawVal, exists := m[key] + if !exists { + return cty.NullVal(ty), nil + } + + var err error + val := cty.StringVal(rawVal) + val, err = convert.Convert(val, ty) + if err != nil { + // This should never happen for _valid_ input, but flatmap data might + // be tampered with by the user and become invalid. + return cty.DynamicVal, fmt.Errorf("invalid value for %q in state: %s", key, err) + } + + return val, nil +} + +func hcl2ValueFromFlatmapObject(m map[string]string, prefix string, atys map[string]cty.Type) (cty.Value, error) { + vals := make(map[string]cty.Value) + for name, aty := range atys { + val, err := hcl2ValueFromFlatmapValue(m, prefix+name, aty) + if err != nil { + return cty.DynamicVal, err + } + vals[name] = val + } + return cty.ObjectVal(vals), nil +} + +func hcl2ValueFromFlatmapTuple(m map[string]string, prefix string, etys []cty.Type) (cty.Value, error) { + var vals []cty.Value + + countStr, exists := m[prefix+"#"] + if !exists { + return cty.NullVal(cty.Tuple(etys)), nil + } + count, err := strconv.Atoi(countStr) + if err != nil { + return cty.DynamicVal, fmt.Errorf("invalid count value for %q in state: %s", prefix, err) + } + if count != len(etys) { + return cty.DynamicVal, fmt.Errorf("wrong number of values for %q in state: got %d, but need %d", prefix, count, len(etys)) + } + + vals = make([]cty.Value, len(etys)) + for i, ety := range etys { + key := prefix + strconv.Itoa(i) + val, err := hcl2ValueFromFlatmapValue(m, key, ety) + if err != nil { + return cty.DynamicVal, err + } + vals[i] = val + } + return cty.TupleVal(vals), nil +} + +func hcl2ValueFromFlatmapMap(m map[string]string, prefix string, ty cty.Type) (cty.Value, error) { + vals := make(map[string]cty.Value) + ety := ty.ElementType() + + // We actually don't really care about the "count" of a map for our + // purposes here, but we do need to check if it _exists_ in order to + // recognize the difference between null (not set at all) and empty. + if _, exists := m[prefix+"%"]; !exists { + return cty.NullVal(ty), nil + } + + for fullKey := range m { + if !strings.HasPrefix(fullKey, prefix) { + continue + } + + // The flatmap format doesn't allow us to distinguish between keys + // that contain periods and nested objects, so by convention a + // map is only ever of primitive type in flatmap, and we just assume + // that the remainder of the raw key (dots and all) is the key we + // want in the result value. + key := fullKey[len(prefix):] + if key == "%" { + // Ignore the "count" key + continue + } + + val, err := hcl2ValueFromFlatmapValue(m, fullKey, ety) + if err != nil { + return cty.DynamicVal, err + } + vals[key] = val + } + + if len(vals) == 0 { + return cty.MapValEmpty(ety), nil + } + return cty.MapVal(vals), nil +} + +func hcl2ValueFromFlatmapList(m map[string]string, prefix string, ty cty.Type) (cty.Value, error) { + var vals []cty.Value + + countStr, exists := m[prefix+"#"] + if !exists { + return cty.NullVal(ty), nil + } + count, err := strconv.Atoi(countStr) + if err != nil { + return cty.DynamicVal, fmt.Errorf("invalid count value for %q in state: %s", prefix, err) + } + + ety := ty.ElementType() + if count == 0 { + return cty.ListValEmpty(ety), nil + } + + vals = make([]cty.Value, count) + for i := 0; i < count; i++ { + key := prefix + strconv.Itoa(i) + val, err := hcl2ValueFromFlatmapValue(m, key, ety) + if err != nil { + return cty.DynamicVal, err + } + vals[i] = val + } + + return cty.ListVal(vals), nil +} + +func hcl2ValueFromFlatmapSet(m map[string]string, prefix string, ty cty.Type) (cty.Value, error) { + var vals []cty.Value + ety := ty.ElementType() + + // We actually don't really care about the "count" of a set for our + // purposes here, but we do need to check if it _exists_ in order to + // recognize the difference between null (not set at all) and empty. + if _, exists := m[prefix+"#"]; !exists { + return cty.NullVal(ty), nil + } + + for fullKey := range m { + if !strings.HasPrefix(fullKey, prefix) { + continue + } + subKey := fullKey[len(prefix):] + if subKey == "#" { + // Ignore the "count" key + continue + } + key := fullKey + if dot := strings.IndexByte(subKey, '.'); dot != -1 { + key = fullKey[:dot+len(prefix)] + } + + // The flatmap format doesn't allow us to distinguish between keys + // that contain periods and nested objects, so by convention a + // map is only ever of primitive type in flatmap, and we just assume + // that the remainder of the raw key (dots and all) is the key we + // want in the result value. + + val, err := hcl2ValueFromFlatmapValue(m, key, ety) + if err != nil { + return cty.DynamicVal, err + } + vals = append(vals, val) + } + + if len(vals) == 0 { + return cty.SetValEmpty(ety), nil + } + return cty.SetVal(vals), nil +} diff --git a/config/hcl2shim/flatmap_test.go b/config/hcl2shim/flatmap_test.go new file mode 100644 index 0000000000..ee0a5d6f81 --- /dev/null +++ b/config/hcl2shim/flatmap_test.go @@ -0,0 +1,451 @@ +package hcl2shim + +import ( + "fmt" + "testing" + + "github.com/go-test/deep" + + "github.com/zclconf/go-cty/cty" +) + +func TestFlatmapValueFromHCL2(t *testing.T) { + tests := []struct { + Value cty.Value + Want map[string]string + }{ + { + cty.EmptyObjectVal, + map[string]string{}, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.StringVal("hello"), + }), + map[string]string{ + "foo": "hello", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.NumberIntVal(12), + }), + map[string]string{ + "foo": "12", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.True, + "bar": cty.False, + }), + map[string]string{ + "foo": "true", + "bar": "false", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.StringVal("hello"), + "bar": cty.StringVal("world"), + "baz": cty.StringVal("whelp"), + }), + map[string]string{ + "foo": "hello", + "bar": "world", + "baz": "whelp", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListValEmpty(cty.String), + }), + map[string]string{ + "foo.#": "0", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListVal([]cty.Value{ + cty.StringVal("hello"), + }), + }), + map[string]string{ + "foo.#": "1", + "foo.0": "hello", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListVal([]cty.Value{ + cty.StringVal("hello"), + cty.StringVal("world"), + }), + }), + map[string]string{ + "foo.#": "2", + "foo.0": "hello", + "foo.1": "world", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.MapVal(map[string]cty.Value{ + "hello": cty.NumberIntVal(12), + "hello.world": cty.NumberIntVal(10), + }), + }), + map[string]string{ + "foo.%": "2", + "foo.hello": "12", + "foo.hello.world": "10", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.MapVal(map[string]cty.Value{ + "hello": cty.NumberIntVal(12), + "hello.world": cty.NumberIntVal(10), + }), + }), + map[string]string{ + "foo.%": "2", + "foo.hello": "12", + "foo.hello.world": "10", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.SetVal([]cty.Value{ + cty.StringVal("hello"), + cty.StringVal("world"), + }), + }), + map[string]string{ + "foo.#": "2", + "foo.0": "hello", + "foo.1": "world", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("hello"), + "baz": cty.StringVal("world"), + }), + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("bloo"), + "baz": cty.StringVal("blaa"), + }), + }), + }), + map[string]string{ + "foo.#": "2", + "foo.0.bar": "hello", + "foo.0.baz": "world", + "foo.1.bar": "bloo", + "foo.1.baz": "blaa", + }, + }, + { + cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("hello"), + "baz": cty.ListVal([]cty.Value{ + cty.True, + cty.True, + }), + }), + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("bloo"), + "baz": cty.ListVal([]cty.Value{ + cty.False, + cty.True, + }), + }), + }), + }), + map[string]string{ + "foo.#": "2", + "foo.0.bar": "hello", + "foo.0.baz.#": "2", + "foo.0.baz.0": "true", + "foo.0.baz.1": "true", + "foo.1.bar": "bloo", + "foo.1.baz.#": "2", + "foo.1.baz.0": "false", + "foo.1.baz.1": "true", + }, + }, + } + + for _, test := range tests { + t.Run(test.Value.GoString(), func(t *testing.T) { + got := FlatmapValueFromHCL2(test.Value) + + for _, problem := range deep.Equal(got, test.Want) { + t.Error(problem) + } + }) + } +} + +func TestHCL2ValueFromFlatmap(t *testing.T) { + tests := []struct { + Flatmap map[string]string + Type cty.Type + Want cty.Value + WantErr string + }{ + { + Flatmap: map[string]string{}, + Type: cty.EmptyObject, + Want: cty.EmptyObjectVal, + }, + { + Flatmap: map[string]string{ + "ignored": "foo", + }, + Type: cty.EmptyObject, + Want: cty.EmptyObjectVal, + }, + { + Flatmap: map[string]string{ + "foo": "blah", + "bar": "true", + "baz": "12.5", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.String, + "bar": cty.Bool, + "baz": cty.Number, + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.StringVal("blah"), + "bar": cty.True, + "baz": cty.NumberFloatVal(12.5), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "0", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.List(cty.String), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListValEmpty(cty.String), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "1", + "foo.0": "hello", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.List(cty.String), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListVal([]cty.Value{ + cty.StringVal("hello"), + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "2", + "foo.0": "true", + "foo.1": "false", + "foo.2": "ignored", // (because the count is 2, so this is out of range) + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.List(cty.Bool), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListVal([]cty.Value{ + cty.True, + cty.False, + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "2", + "foo.0": "hello", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.Tuple([]cty.Type{ + cty.String, + cty.Bool, + }), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.TupleVal([]cty.Value{ + cty.StringVal("hello"), + cty.NullVal(cty.Bool), + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "0", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.Set(cty.String), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.SetValEmpty(cty.String), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "1", + "foo.24534534": "hello", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.Set(cty.String), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.SetVal([]cty.Value{ + cty.StringVal("hello"), + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "1", + "foo.24534534": "true", + "foo.95645644": "true", + "foo.34533452": "false", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.Set(cty.Bool), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.SetVal([]cty.Value{ + cty.True, + cty.False, + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.%": "0", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.Map(cty.String), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.MapValEmpty(cty.String), + }), + }, + { + Flatmap: map[string]string{ + "foo.%": "2", + "foo.baz": "true", + "foo.bar.baz": "false", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.Map(cty.Bool), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.MapVal(map[string]cty.Value{ + "baz": cty.True, + "bar.baz": cty.False, + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "2", + "foo.0.bar": "hello", + "foo.0.baz": "1", + "foo.1.bar": "world", + "foo.1.baz": "false", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.List(cty.Object(map[string]cty.Type{ + "bar": cty.String, + "baz": cty.Bool, + })), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.ListVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("hello"), + "baz": cty.True, + }), + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("world"), + "baz": cty.False, + }), + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "2", + "foo.34534534.bar": "hello", + "foo.34534534.baz": "1", + "foo.93453345.bar": "world", + "foo.93453345.baz": "false", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.Set(cty.Object(map[string]cty.Type{ + "bar": cty.String, + "baz": cty.Bool, + })), + }), + Want: cty.ObjectVal(map[string]cty.Value{ + "foo": cty.SetVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("hello"), + "baz": cty.True, + }), + cty.ObjectVal(map[string]cty.Value{ + "bar": cty.StringVal("world"), + "baz": cty.False, + }), + }), + }), + }, + { + Flatmap: map[string]string{ + "foo.#": "not-valid", + }, + Type: cty.Object(map[string]cty.Type{ + "foo": cty.List(cty.String), + }), + WantErr: `invalid count value for "foo." in state: strconv.Atoi: parsing "not-valid": invalid syntax`, + }, + } + + for _, test := range tests { + t.Run(fmt.Sprintf("%#v as %#v", test.Flatmap, test.Type), func(t *testing.T) { + got, err := HCL2ValueFromFlatmap(test.Flatmap, test.Type) + + if test.WantErr != "" { + if err == nil { + t.Fatalf("succeeded; want error: %s", test.WantErr) + } + if got, want := err.Error(), test.WantErr; got != want { + t.Fatalf("wrong error\ngot: %s\nwant: %s", got, want) + } + if got == cty.NilVal { + t.Fatalf("result is cty.NilVal; want valid placeholder value") + } + return + } else { + if err != nil { + t.Fatalf("unexpected error: %s", err.Error()) + } + } + + if !got.RawEquals(test.Want) { + t.Errorf("wrong result\ngot: %#v\nwant: %#v", got, test.Want) + } + }) + } +}