terraform

Documentation

Index

• Variables

Variables

var DecodeTfvarsFunc = function.New(&function.Spec{
	Params: []function.Parameter{
		{
			Name:      "src",
			Type:      cty.String,
			AllowNull: true,
		},
	},
	Type: function.StaticReturnType(cty.DynamicPseudoType),
	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {

		if len(args) > 1 {
			return cty.NilVal, function.NewArgErrorf(1, "too many arguments; only one expected")
		}
		if len(args) == 0 {
			return cty.NilVal, fmt.Errorf("exactly one argument is required")
		}
		if args[0].Type() != cty.String {
			return cty.NilVal, fmt.Errorf("argument must be a string")
		}
		if args[0].IsNull() {
			return cty.NilVal, fmt.Errorf("cannot decode tfvars from a null value")
		}
		if !args[0].IsKnown() {

			return cty.DynamicVal, nil
		}

		src := []byte(args[0].AsString())

		f, hclDiags := hclsyntax.ParseConfig(src, "<decode_tfvars argument>", hcl.InitialPos)
		if hclDiags.HasErrors() {
			return cty.NilVal, fmt.Errorf("invalid tfvars syntax: %s", hclDiags.Error())
		}
		attrs, hclDiags := f.Body.JustAttributes()
		if hclDiags.HasErrors() {
			return cty.NilVal, fmt.Errorf("invalid tfvars content: %s", hclDiags.Error())
		}
		retAttrs := make(map[string]cty.Value, len(attrs))
		for name, attr := range attrs {

			v, hclDiags := attr.Expr.Value(nil)
			if hclDiags.HasErrors() {
				return cty.NilVal, fmt.Errorf("invalid expression for variable %q: %s", name, hclDiags.Error())
			}
			retAttrs[name] = v
		}

		return cty.ObjectVal(retAttrs), nil
	},
})

var EncodeExprFunc = function.New(&function.Spec{
	Params: []function.Parameter{
		{
			Name:             "value",
			Type:             cty.DynamicPseudoType,
			AllowNull:        true,
			AllowDynamicType: true,
			AllowUnknown:     true,
		},
	},
	Type: function.StaticReturnType(cty.String),
	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {

		if len(args) > 1 {
			return cty.NilVal, function.NewArgErrorf(1, "too many arguments; only one expected")
		}
		if len(args) == 0 {
			return cty.NilVal, fmt.Errorf("exactly one argument is required")
		}

		v := args[0]
		if !v.IsWhollyKnown() {
			ret := cty.UnknownVal(cty.String).RefineNotNull()

			if !v.Range().CouldBeNull() {
				ty := v.Type()
				switch {
				case ty.IsObjectType() || ty.IsMapType():
					ret = ret.Refine().StringPrefixFull("{").NewValue()
				case ty.IsTupleType() || ty.IsListType() || ty.IsSetType():
					ret = ret.Refine().StringPrefixFull("[").NewValue()
				case ty == cty.String:
					ret = ret.Refine().StringPrefixFull(`"`).NewValue()
				}
			}
			return ret, nil
		}

		src := bytes.TrimSpace(hclwrite.TokensForValue(v).Bytes())
		return cty.StringVal(string(src)), nil
	},
})

var EncodeTfvarsFunc = function.New(&function.Spec{
	Params: []function.Parameter{
		{
			Name:             "value",
			Type:             cty.DynamicPseudoType,
			AllowNull:        true,
			AllowDynamicType: true,
			AllowUnknown:     true,
		},
	},
	Type: function.StaticReturnType(cty.String),
	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {

		if len(args) > 1 {
			return cty.NilVal, function.NewArgErrorf(1, "too many arguments; only one expected")
		}
		if len(args) == 0 {
			return cty.NilVal, fmt.Errorf("exactly one argument is required")
		}

		v := args[0]
		ty := v.Type()

		if v.IsNull() {

			return cty.NilVal, function.NewArgErrorf(1, "cannot encode a null value in tfvars syntax")
		}
		if !v.IsWhollyKnown() {
			return cty.UnknownVal(cty.String).RefineNotNull(), nil
		}

		var keys []string
		switch {
		case ty.IsObjectType():
			atys := ty.AttributeTypes()
			keys = make([]string, 0, len(atys))
			for key := range atys {
				keys = append(keys, key)
			}
		case ty.IsMapType():
			keys = make([]string, 0, v.LengthInt())
			for it := v.ElementIterator(); it.Next(); {
				k, _ := it.Element()
				keys = append(keys, k.AsString())
			}
		default:
			return cty.NilVal, function.NewArgErrorf(1, "invalid value to encode: must be an object whose attribute names will become the encoded variable names")
		}
		sort.Strings(keys)

		f := hclwrite.NewEmptyFile()
		body := f.Body()
		for _, key := range keys {
			if !hclsyntax.ValidIdentifier(key) {

				return cty.NilVal, function.NewArgErrorf(1, "invalid variable name %q: must be a valid identifier, per Terraform's rules for input variable declarations", key)
			}

			v, _ := hcl.Index(v, cty.StringVal(key), nil)
			body.SetAttributeValue(key, v)
		}

		result := f.Bytes()
		return cty.StringVal(string(result)), nil
	},
})