package config
import (
"bytes"
"compress/gzip"
"crypto/md5"
"crypto/rsa"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
"crypto/x509"
"encoding/base64"
"encoding/hex"
"encoding/json"
"encoding/pem"
"fmt"
"io/ioutil"
"math"
"net"
"net/url"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"time"
"github.com/apparentlymart/go-cidr/cidr"
"github.com/hashicorp/go-uuid"
"github.com/hashicorp/hil"
"github.com/hashicorp/hil/ast"
"github.com/mitchellh/go-homedir"
"golang.org/x/crypto/bcrypt"
)
// stringSliceToVariableValue converts a string slice into the value
// required to be returned from interpolation functions which return
// TypeList.
func stringSliceToVariableValue(values []string) []ast.Variable {
output := make([]ast.Variable, len(values))
for index, value := range values {
output[index] = ast.Variable{
Type: ast.TypeString,
Value: value,
}
}
return output
}
func listVariableValueToStringSlice(values []ast.Variable) ([]string, error) {
output := make([]string, len(values))
for index, value := range values {
if value.Type != ast.TypeString {
return []string{}, fmt.Errorf("list has non-string element (%T)", value.Type.String())
}
output[index] = value.Value.(string)
}
return output, nil
}
// Funcs is the mapping of built-in functions for configuration.
func Funcs() map[string]ast.Function {
return map[string]ast.Function{
"abs": interpolationFuncAbs(),
"basename": interpolationFuncBasename(),
"base64decode": interpolationFuncBase64Decode(),
"base64encode": interpolationFuncBase64Encode(),
"base64gzip": interpolationFuncBase64Gzip(),
"base64sha256": interpolationFuncBase64Sha256(),
"base64sha512": interpolationFuncBase64Sha512(),
"bcrypt": interpolationFuncBcrypt(),
"ceil": interpolationFuncCeil(),
"chomp": interpolationFuncChomp(),
"cidrhost": interpolationFuncCidrHost(),
"cidrnetmask": interpolationFuncCidrNetmask(),
"cidrsubnet": interpolationFuncCidrSubnet(),
"coalesce": interpolationFuncCoalesce(),
"coalescelist": interpolationFuncCoalesceList(),
"compact": interpolationFuncCompact(),
"concat": interpolationFuncConcat(),
"contains": interpolationFuncContains(),
"dirname": interpolationFuncDirname(),
"distinct": interpolationFuncDistinct(),
"element": interpolationFuncElement(),
"chunklist": interpolationFuncChunklist(),
"file": interpolationFuncFile(),
"filebase64sha256": interpolationFuncMakeFileHash(interpolationFuncBase64Sha256()),
"filebase64sha512": interpolationFuncMakeFileHash(interpolationFuncBase64Sha512()),
"filemd5": interpolationFuncMakeFileHash(interpolationFuncMd5()),
"filesha1": interpolationFuncMakeFileHash(interpolationFuncSha1()),
"filesha256": interpolationFuncMakeFileHash(interpolationFuncSha256()),
"filesha512": interpolationFuncMakeFileHash(interpolationFuncSha512()),
"matchkeys": interpolationFuncMatchKeys(),
"flatten": interpolationFuncFlatten(),
"floor": interpolationFuncFloor(),
"format": interpolationFuncFormat(),
"formatlist": interpolationFuncFormatList(),
"indent": interpolationFuncIndent(),
"index": interpolationFuncIndex(),
"join": interpolationFuncJoin(),
"jsonencode": interpolationFuncJSONEncode(),
"length": interpolationFuncLength(),
"list": interpolationFuncList(),
"log": interpolationFuncLog(),
"lower": interpolationFuncLower(),
"map": interpolationFuncMap(),
"max": interpolationFuncMax(),
"md5": interpolationFuncMd5(),
"merge": interpolationFuncMerge(),
"min": interpolationFuncMin(),
"pathexpand": interpolationFuncPathExpand(),
"pow": interpolationFuncPow(),
"uuid": interpolationFuncUUID(),
"replace": interpolationFuncReplace(),
"rsadecrypt": interpolationFuncRsaDecrypt(),
"sha1": interpolationFuncSha1(),
"sha256": interpolationFuncSha256(),
"sha512": interpolationFuncSha512(),
"signum": interpolationFuncSignum(),
"slice": interpolationFuncSlice(),
"sort": interpolationFuncSort(),
"split": interpolationFuncSplit(),
"substr": interpolationFuncSubstr(),
"timestamp": interpolationFuncTimestamp(),
"timeadd": interpolationFuncTimeAdd(),
"title": interpolationFuncTitle(),
"transpose": interpolationFuncTranspose(),
"trimspace": interpolationFuncTrimSpace(),
"upper": interpolationFuncUpper(),
"urlencode": interpolationFuncURLEncode(),
"zipmap": interpolationFuncZipMap(),
}
}
// interpolationFuncList creates a list from the parameters passed
// to it.
func interpolationFuncList() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{},
ReturnType: ast.TypeList,
Variadic: true,
VariadicType: ast.TypeAny,
Callback: func(args []interface{}) (interface{}, error) {
var outputList []ast.Variable
for i, val := range args {
switch v := val.(type) {
case string:
outputList = append(outputList, ast.Variable{Type: ast.TypeString, Value: v})
case []ast.Variable:
outputList = append(outputList, ast.Variable{Type: ast.TypeList, Value: v})
case map[string]ast.Variable:
outputList = append(outputList, ast.Variable{Type: ast.TypeMap, Value: v})
default:
return nil, fmt.Errorf("unexpected type %T for argument %d in list", v, i)
}
}
// we don't support heterogeneous types, so make sure all types match the first
if len(outputList) > 0 {
firstType := outputList[0].Type
for i, v := range outputList[1:] {
if v.Type != firstType {
return nil, fmt.Errorf("unexpected type %s for argument %d in list", v.Type, i+1)
}
}
}
return outputList, nil
},
}
}
// interpolationFuncMap creates a map from the parameters passed
// to it.
func interpolationFuncMap() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{},
ReturnType: ast.TypeMap,
Variadic: true,
VariadicType: ast.TypeAny,
Callback: func(args []interface{}) (interface{}, error) {
outputMap := make(map[string]ast.Variable)
if len(args)%2 != 0 {
return nil, fmt.Errorf("requires an even number of arguments, got %d", len(args))
}
var firstType *ast.Type
for i := 0; i < len(args); i += 2 {
key, ok := args[i].(string)
if !ok {
return nil, fmt.Errorf("argument %d represents a key, so it must be a string", i+1)
}
val := args[i+1]
variable, err := hil.InterfaceToVariable(val)
if err != nil {
return nil, err
}
// Enforce map type homogeneity
if firstType == nil {
firstType = &variable.Type
} else if variable.Type != *firstType {
return nil, fmt.Errorf("all map values must have the same type, got %s then %s", firstType.Printable(), variable.Type.Printable())
}
// Check for duplicate keys
if _, ok := outputMap[key]; ok {
return nil, fmt.Errorf("argument %d is a duplicate key: %q", i+1, key)
}
outputMap[key] = variable
}
return outputMap, nil
},
}
}
// interpolationFuncCompact strips a list of multi-variable values
// (e.g. as returned by "split") of any empty strings.
func interpolationFuncCompact() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList},
ReturnType: ast.TypeList,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
inputList := args[0].([]ast.Variable)
var outputList []string
for _, val := range inputList {
strVal, ok := val.Value.(string)
if !ok {
return nil, fmt.Errorf(
"compact() may only be used with flat lists, this list contains elements of %s",
val.Type.Printable())
}
if strVal == "" {
continue
}
outputList = append(outputList, strVal)
}
return stringSliceToVariableValue(outputList), nil
},
}
}
// interpolationFuncCidrHost implements the "cidrhost" function that
// fills in the host part of a CIDR range address to create a single
// host address
func interpolationFuncCidrHost() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeString, // starting CIDR mask
ast.TypeInt, // host number to insert
},
ReturnType: ast.TypeString,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
hostNum := args[1].(int)
_, network, err := net.ParseCIDR(args[0].(string))
if err != nil {
return nil, fmt.Errorf("invalid CIDR expression: %s", err)
}
ip, err := cidr.Host(network, hostNum)
if err != nil {
return nil, err
}
return ip.String(), nil
},
}
}
// interpolationFuncCidrNetmask implements the "cidrnetmask" function
// that returns the subnet mask in IP address notation.
func interpolationFuncCidrNetmask() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeString, // CIDR mask
},
ReturnType: ast.TypeString,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
_, network, err := net.ParseCIDR(args[0].(string))
if err != nil {
return nil, fmt.Errorf("invalid CIDR expression: %s", err)
}
return net.IP(network.Mask).String(), nil
},
}
}
// interpolationFuncCidrSubnet implements the "cidrsubnet" function that
// adds an additional subnet of the given length onto an existing
// IP block expressed in CIDR notation.
func interpolationFuncCidrSubnet() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeString, // starting CIDR mask
ast.TypeInt, // number of bits to extend the prefix
ast.TypeInt, // network number to append to the prefix
},
ReturnType: ast.TypeString,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
extraBits := args[1].(int)
subnetNum := args[2].(int)
_, network, err := net.ParseCIDR(args[0].(string))
if err != nil {
return nil, fmt.Errorf("invalid CIDR expression: %s", err)
}
// For portability with 32-bit systems where the subnet number
// will be a 32-bit int, we only allow extension of 32 bits in
// one call even if we're running on a 64-bit machine.
// (Of course, this is significant only for IPv6.)
if extraBits > 32 {
return nil, fmt.Errorf("may not extend prefix by more than 32 bits")
}
newNetwork, err := cidr.Subnet(network, extraBits, subnetNum)
if err != nil {
return nil, err
}
return newNetwork.String(), nil
},
}
}
// interpolationFuncCoalesce implements the "coalesce" function that
// returns the first non null / empty string from the provided input
func interpolationFuncCoalesce() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Variadic: true,
VariadicType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
if len(args) < 2 {
return nil, fmt.Errorf("must provide at least two arguments")
}
for _, arg := range args {
argument := arg.(string)
if argument != "" {
return argument, nil
}
}
return "", nil
},
}
}
// interpolationFuncCoalesceList implements the "coalescelist" function that
// returns the first non empty list from the provided input
func interpolationFuncCoalesceList() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList},
ReturnType: ast.TypeList,
Variadic: true,
VariadicType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
if len(args) < 2 {
return nil, fmt.Errorf("must provide at least two arguments")
}
for _, arg := range args {
argument := arg.([]ast.Variable)
if len(argument) > 0 {
return argument, nil
}
}
return make([]ast.Variable, 0), nil
},
}
}
// interpolationFuncContains returns true if an element is in the list
// and return false otherwise
func interpolationFuncContains() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList, ast.TypeString},
ReturnType: ast.TypeBool,
Callback: func(args []interface{}) (interface{}, error) {
_, err := interpolationFuncIndex().Callback(args)
if err != nil {
return false, nil
}
return true, nil
},
}
}
// interpolationFuncConcat implements the "concat" function that concatenates
// multiple lists.
func interpolationFuncConcat() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList},
ReturnType: ast.TypeList,
Variadic: true,
VariadicType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
var outputList []ast.Variable
for _, arg := range args {
for _, v := range arg.([]ast.Variable) {
switch v.Type {
case ast.TypeString:
outputList = append(outputList, v)
case ast.TypeList:
outputList = append(outputList, v)
case ast.TypeMap:
outputList = append(outputList, v)
default:
return nil, fmt.Errorf("concat() does not support lists of %s", v.Type.Printable())
}
}
}
// we don't support heterogeneous types, so make sure all types match the first
if len(outputList) > 0 {
firstType := outputList[0].Type
for _, v := range outputList[1:] {
if v.Type != firstType {
return nil, fmt.Errorf("unexpected %s in list of %s", v.Type.Printable(), firstType.Printable())
}
}
}
return outputList, nil
},
}
}
// interpolationFuncPow returns base x exponential of y.
func interpolationFuncPow() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeFloat, ast.TypeFloat},
ReturnType: ast.TypeFloat,
Callback: func(args []interface{}) (interface{}, error) {
return math.Pow(args[0].(float64), args[1].(float64)), nil
},
}
}
// interpolationFuncFile implements the "file" function that allows
// loading contents from a file.
func interpolationFuncFile() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
path, err := homedir.Expand(args[0].(string))
if err != nil {
return "", err
}
data, err := ioutil.ReadFile(path)
if err != nil {
return "", err
}
return string(data), nil
},
}
}
// interpolationFuncFormat implements the "format" function that does
// string formatting.
func interpolationFuncFormat() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
Variadic: true,
VariadicType: ast.TypeAny,
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
format := args[0].(string)
return fmt.Sprintf(format, args[1:]...), nil
},
}
}
// interpolationFuncMax returns the maximum of the numeric arguments
func interpolationFuncMax() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeFloat},
ReturnType: ast.TypeFloat,
Variadic: true,
VariadicType: ast.TypeFloat,
Callback: func(args []interface{}) (interface{}, error) {
max := args[0].(float64)
for i := 1; i < len(args); i++ {
max = math.Max(max, args[i].(float64))
}
return max, nil
},
}
}
// interpolationFuncMin returns the minimum of the numeric arguments
func interpolationFuncMin() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeFloat},
ReturnType: ast.TypeFloat,
Variadic: true,
VariadicType: ast.TypeFloat,
Callback: func(args []interface{}) (interface{}, error) {
min := args[0].(float64)
for i := 1; i < len(args); i++ {
min = math.Min(min, args[i].(float64))
}
return min, nil
},
}
}
// interpolationFuncPathExpand will expand any `~`'s found with the full file path
func interpolationFuncPathExpand() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
return homedir.Expand(args[0].(string))
},
}
}
// interpolationFuncCeil returns the the least integer value greater than or equal to the argument
func interpolationFuncCeil() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeFloat},
ReturnType: ast.TypeInt,
Callback: func(args []interface{}) (interface{}, error) {
return int(math.Ceil(args[0].(float64))), nil
},
}
}
// interpolationFuncLog returns the logarithnm.
func interpolationFuncLog() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeFloat, ast.TypeFloat},
ReturnType: ast.TypeFloat,
Callback: func(args []interface{}) (interface{}, error) {
return math.Log(args[0].(float64)) / math.Log(args[1].(float64)), nil
},
}
}
// interpolationFuncChomp removes trailing newlines from the given string
func interpolationFuncChomp() ast.Function {
newlines := regexp.MustCompile(`(?:\r\n?|\n)*\z`)
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
return newlines.ReplaceAllString(args[0].(string), ""), nil
},
}
}
// interpolationFuncFloorreturns returns the greatest integer value less than or equal to the argument
func interpolationFuncFloor() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeFloat},
ReturnType: ast.TypeInt,
Callback: func(args []interface{}) (interface{}, error) {
return int(math.Floor(args[0].(float64))), nil
},
}
}
func interpolationFuncZipMap() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeList, // Keys
ast.TypeList, // Values
},
ReturnType: ast.TypeMap,
Callback: func(args []interface{}) (interface{}, error) {
keys := args[0].([]ast.Variable)
values := args[1].([]ast.Variable)
if len(keys) != len(values) {
return nil, fmt.Errorf("count of keys (%d) does not match count of values (%d)",
len(keys), len(values))
}
for i, val := range keys {
if val.Type != ast.TypeString {
return nil, fmt.Errorf("keys must be strings. value at position %d is %s",
i, val.Type.Printable())
}
}
result := map[string]ast.Variable{}
for i := 0; i < len(keys); i++ {
result[keys[i].Value.(string)] = values[i]
}
return result, nil
},
}
}
// interpolationFuncFormatList implements the "formatlist" function that does
// string formatting on lists.
func interpolationFuncFormatList() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeAny},
Variadic: true,
VariadicType: ast.TypeAny,
ReturnType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
// Make a copy of the variadic part of args
// to avoid modifying the original.
varargs := make([]interface{}, len(args)-1)
copy(varargs, args[1:])
// Verify we have some arguments
if len(varargs) == 0 {
return nil, fmt.Errorf("no arguments to formatlist")
}
// Convert arguments that are lists into slices.
// Confirm along the way that all lists have the same length (n).
var n int
listSeen := false
for i := 1; i < len(args); i++ {
s, ok := args[i].([]ast.Variable)
if !ok {
continue
}
// Mark that we've seen at least one list
listSeen = true
// Convert the ast.Variable to a slice of strings
parts, err := listVariableValueToStringSlice(s)
if err != nil {
return nil, err
}
// otherwise the list is sent down to be indexed
varargs[i-1] = parts
// Check length
if n == 0 {
// first list we've seen
n = len(parts)
continue
}
if n != len(parts) {
return nil, fmt.Errorf("format: mismatched list lengths: %d != %d", n, len(parts))
}
}
// If we didn't see a list this is an error because we
// can't determine the return value length.
if !listSeen {
return nil, fmt.Errorf(
"formatlist requires at least one list argument")
}
// Do the formatting.
format := args[0].(string)
// Generate a list of formatted strings.
list := make([]string, n)
fmtargs := make([]interface{}, len(varargs))
for i := 0; i < n; i++ {
for j, arg := range varargs {
switch arg := arg.(type) {
default:
fmtargs[j] = arg
case []string:
fmtargs[j] = arg[i]
}
}
list[i] = fmt.Sprintf(format, fmtargs...)
}
return stringSliceToVariableValue(list), nil
},
}
}
// interpolationFuncIndent indents a multi-line string with the
// specified number of spaces
func interpolationFuncIndent() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeInt, ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
spaces := args[0].(int)
data := args[1].(string)
pad := strings.Repeat(" ", spaces)
return strings.Replace(data, "\n", "\n"+pad, -1), nil
},
}
}
// interpolationFuncIndex implements the "index" function that allows one to
// find the index of a specific element in a list
func interpolationFuncIndex() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList, ast.TypeString},
ReturnType: ast.TypeInt,
Callback: func(args []interface{}) (interface{}, error) {
haystack := args[0].([]ast.Variable)
needle := args[1].(string)
for index, element := range haystack {
if needle == element.Value {
return index, nil
}
}
return nil, fmt.Errorf("Could not find '%s' in '%s'", needle, haystack)
},
}
}
// interpolationFuncBasename implements the "dirname" function.
func interpolationFuncDirname() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
return filepath.Dir(args[0].(string)), nil
},
}
}
// interpolationFuncDistinct implements the "distinct" function that
// removes duplicate elements from a list.
func interpolationFuncDistinct() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList},
ReturnType: ast.TypeList,
Variadic: true,
VariadicType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
var list []string
if len(args) != 1 {
return nil, fmt.Errorf("accepts only one argument.")
}
if argument, ok := args[0].([]ast.Variable); ok {
for _, element := range argument {
if element.Type != ast.TypeString {
return nil, fmt.Errorf(
"only works for flat lists, this list contains elements of %s",
element.Type.Printable())
}
list = appendIfMissing(list, element.Value.(string))
}
}
return stringSliceToVariableValue(list), nil
},
}
}
// helper function to add an element to a list, if it does not already exsit
func appendIfMissing(slice []string, element string) []string {
for _, ele := range slice {
if ele == element {
return slice
}
}
return append(slice, element)
}
// for two lists `keys` and `values` of equal length, returns all elements
// from `values` where the corresponding element from `keys` is in `searchset`.
func interpolationFuncMatchKeys() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList, ast.TypeList, ast.TypeList},
ReturnType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
output := make([]ast.Variable, 0)
values, _ := args[0].([]ast.Variable)
keys, _ := args[1].([]ast.Variable)
searchset, _ := args[2].([]ast.Variable)
if len(keys) != len(values) {
return nil, fmt.Errorf("length of keys and values should be equal")
}
for i, key := range keys {
for _, search := range searchset {
if res, err := compareSimpleVariables(key, search); err != nil {
return nil, err
} else if res == true {
output = append(output, values[i])
break
}
}
}
// if searchset is empty, then output is an empty list as well.
// if we haven't matched any key, then output is an empty list.
return output, nil
},
}
}
// compare two variables of the same type, i.e. non complex one, such as TypeList or TypeMap
func compareSimpleVariables(a, b ast.Variable) (bool, error) {
if a.Type != b.Type {
return false, fmt.Errorf(
"won't compare items of different types %s and %s",
a.Type.Printable(), b.Type.Printable())
}
switch a.Type {
case ast.TypeString:
return a.Value.(string) == b.Value.(string), nil
default:
return false, fmt.Errorf(
"can't compare items of type %s",
a.Type.Printable())
}
}
// interpolationFuncJoin implements the "join" function that allows
// multi-variable values to be joined by some character.
func interpolationFuncJoin() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
Variadic: true,
VariadicType: ast.TypeList,
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
var list []string
if len(args) < 2 {
return nil, fmt.Errorf("not enough arguments to join()")
}
for _, arg := range args[1:] {
for _, part := range arg.([]ast.Variable) {
if part.Type != ast.TypeString {
return nil, fmt.Errorf(
"only works on flat lists, this list contains elements of %s",
part.Type.Printable())
}
list = append(list, part.Value.(string))
}
}
return strings.Join(list, args[0].(string)), nil
},
}
}
// interpolationFuncJSONEncode implements the "jsonencode" function that encodes
// a string, list, or map as its JSON representation.
func interpolationFuncJSONEncode() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeAny},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
var toEncode interface{}
switch typedArg := args[0].(type) {
case string:
toEncode = typedArg
case []ast.Variable:
strings := make([]string, len(typedArg))
for i, v := range typedArg {
if v.Type != ast.TypeString {
variable, _ := hil.InterfaceToVariable(typedArg)
toEncode, _ = hil.VariableToInterface(variable)
jEnc, err := json.Marshal(toEncode)
if err != nil {
return "", fmt.Errorf("failed to encode JSON data '%s'", toEncode)
}
return string(jEnc), nil
}
strings[i] = v.Value.(string)
}
toEncode = strings
case map[string]ast.Variable:
stringMap := make(map[string]string)
for k, v := range typedArg {
if v.Type != ast.TypeString {
variable, _ := hil.InterfaceToVariable(typedArg)
toEncode, _ = hil.VariableToInterface(variable)
jEnc, err := json.Marshal(toEncode)
if err != nil {
return "", fmt.Errorf("failed to encode JSON data '%s'", toEncode)
}
return string(jEnc), nil
}
stringMap[k] = v.Value.(string)
}
toEncode = stringMap
default:
return "", fmt.Errorf("unknown type for JSON encoding: %T", args[0])
}
jEnc, err := json.Marshal(toEncode)
if err != nil {
return "", fmt.Errorf("failed to encode JSON data '%s'", toEncode)
}
return string(jEnc), nil
},
}
}
// interpolationFuncReplace implements the "replace" function that does
// string replacement.
func interpolationFuncReplace() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString, ast.TypeString, ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
search := args[1].(string)
replace := args[2].(string)
// We search/replace using a regexp if the string is surrounded
// in forward slashes.
if len(search) > 1 && search[0] == '/' && search[len(search)-1] == '/' {
re, err := regexp.Compile(search[1 : len(search)-1])
if err != nil {
return nil, err
}
return re.ReplaceAllString(s, replace), nil
}
return strings.Replace(s, search, replace, -1), nil
},
}
}
func interpolationFuncLength() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeAny},
ReturnType: ast.TypeInt,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
subject := args[0]
switch typedSubject := subject.(type) {
case string:
return len(typedSubject), nil
case []ast.Variable:
return len(typedSubject), nil
case map[string]ast.Variable:
return len(typedSubject), nil
}
return 0, fmt.Errorf("arguments to length() must be a string, list, or map")
},
}
}
func interpolationFuncSignum() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeInt},
ReturnType: ast.TypeInt,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
num := args[0].(int)
switch {
case num < 0:
return -1, nil
case num > 0:
return +1, nil
default:
return 0, nil
}
},
}
}
// interpolationFuncSlice returns a portion of the input list between from, inclusive and to, exclusive.
func interpolationFuncSlice() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeList, // inputList
ast.TypeInt, // from
ast.TypeInt, // to
},
ReturnType: ast.TypeList,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
inputList := args[0].([]ast.Variable)
from := args[1].(int)
to := args[2].(int)
if from < 0 {
return nil, fmt.Errorf("from index must be >= 0")
}
if to > len(inputList) {
return nil, fmt.Errorf("to index must be <= length of the input list")
}
if from > to {
return nil, fmt.Errorf("from index must be <= to index")
}
var outputList []ast.Variable
for i, val := range inputList {
if i >= from && i < to {
outputList = append(outputList, val)
}
}
return outputList, nil
},
}
}
// interpolationFuncSort sorts a list of a strings lexographically
func interpolationFuncSort() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList},
ReturnType: ast.TypeList,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
inputList := args[0].([]ast.Variable)
// Ensure that all the list members are strings and
// create a string slice from them
members := make([]string, len(inputList))
for i, val := range inputList {
if val.Type != ast.TypeString {
return nil, fmt.Errorf(
"sort() may only be used with lists of strings - %s at index %d",
val.Type.String(), i)
}
members[i] = val.Value.(string)
}
sort.Strings(members)
return stringSliceToVariableValue(members), nil
},
}
}
// interpolationFuncSplit implements the "split" function that allows
// strings to split into multi-variable values
func interpolationFuncSplit() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString, ast.TypeString},
ReturnType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
sep := args[0].(string)
s := args[1].(string)
elements := strings.Split(s, sep)
return stringSliceToVariableValue(elements), nil
},
}
}
// interpolationFuncLookup implements the "lookup" function that allows
// dynamic lookups of map types within a Terraform configuration.
func interpolationFuncLookup(vs map[string]ast.Variable) ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeMap, ast.TypeString},
ReturnType: ast.TypeString,
Variadic: true,
VariadicType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
defaultValue := ""
defaultValueSet := false
if len(args) > 2 {
defaultValue = args[2].(string)
defaultValueSet = true
}
if len(args) > 3 {
return "", fmt.Errorf("lookup() takes no more than three arguments")
}
index := args[1].(string)
mapVar := args[0].(map[string]ast.Variable)
v, ok := mapVar[index]
if !ok {
if defaultValueSet {
return defaultValue, nil
} else {
return "", fmt.Errorf(
"lookup failed to find '%s'",
args[1].(string))
}
}
if v.Type != ast.TypeString {
return nil, fmt.Errorf(
"lookup() may only be used with flat maps, this map contains elements of %s",
v.Type.Printable())
}
return v.Value.(string), nil
},
}
}
// interpolationFuncElement implements the "element" function that allows
// a specific index to be looked up in a multi-variable value. Note that this will
// wrap if the index is larger than the number of elements in the multi-variable value.
func interpolationFuncElement() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList, ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
list := args[0].([]ast.Variable)
if len(list) == 0 {
return nil, fmt.Errorf("element() may not be used with an empty list")
}
index, err := strconv.Atoi(args[1].(string))
if err != nil || index < 0 {
return "", fmt.Errorf(
"invalid number for index, got %s", args[1])
}
resolvedIndex := index % len(list)
v := list[resolvedIndex]
if v.Type != ast.TypeString {
return nil, fmt.Errorf(
"element() may only be used with flat lists, this list contains elements of %s",
v.Type.Printable())
}
return v.Value, nil
},
}
}
// returns the `list` items chunked by `size`.
func interpolationFuncChunklist() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeList, // inputList
ast.TypeInt, // size
},
ReturnType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
output := make([]ast.Variable, 0)
values, _ := args[0].([]ast.Variable)
size, _ := args[1].(int)
// errors if size is negative
if size < 0 {
return nil, fmt.Errorf("The size argument must be positive")
}
// if size is 0, returns a list made of the initial list
if size == 0 {
output = append(output, ast.Variable{
Type: ast.TypeList,
Value: values,
})
return output, nil
}
variables := make([]ast.Variable, 0)
chunk := ast.Variable{
Type: ast.TypeList,
Value: variables,
}
l := len(values)
for i, v := range values {
variables = append(variables, v)
// Chunk when index isn't 0, or when reaching the values's length
if (i+1)%size == 0 || (i+1) == l {
chunk.Value = variables
output = append(output, chunk)
variables = make([]ast.Variable, 0)
}
}
return output, nil
},
}
}
// interpolationFuncKeys implements the "keys" function that yields a list of
// keys of map types within a Terraform configuration.
func interpolationFuncKeys(vs map[string]ast.Variable) ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeMap},
ReturnType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
mapVar := args[0].(map[string]ast.Variable)
keys := make([]string, 0)
for k, _ := range mapVar {
keys = append(keys, k)
}
sort.Strings(keys)
// Keys are guaranteed to be strings
return stringSliceToVariableValue(keys), nil
},
}
}
// interpolationFuncValues implements the "values" function that yields a list of
// keys of map types within a Terraform configuration.
func interpolationFuncValues(vs map[string]ast.Variable) ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeMap},
ReturnType: ast.TypeList,
Callback: func(args []interface{}) (interface{}, error) {
mapVar := args[0].(map[string]ast.Variable)
keys := make([]string, 0)
for k, _ := range mapVar {
keys = append(keys, k)
}
sort.Strings(keys)
values := make([]string, len(keys))
for index, key := range keys {
if value, ok := mapVar[key].Value.(string); ok {
values[index] = value
} else {
return "", fmt.Errorf("values(): %q has element with bad type %s",
key, mapVar[key].Type)
}
}
variable, err := hil.InterfaceToVariable(values)
if err != nil {
return nil, err
}
return variable.Value, nil
},
}
}
// interpolationFuncBasename implements the "basename" function.
func interpolationFuncBasename() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
return filepath.Base(args[0].(string)), nil
},
}
}
// interpolationFuncBase64Encode implements the "base64encode" function that
// allows Base64 encoding.
func interpolationFuncBase64Encode() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
return base64.StdEncoding.EncodeToString([]byte(s)), nil
},
}
}
// interpolationFuncBase64Decode implements the "base64decode" function that
// allows Base64 decoding.
func interpolationFuncBase64Decode() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
sDec, err := base64.StdEncoding.DecodeString(s)
if err != nil {
return "", fmt.Errorf("failed to decode base64 data '%s'", s)
}
return string(sDec), nil
},
}
}
// interpolationFuncBase64Gzip implements the "gzip" function that allows gzip
// compression encoding the result using base64
func interpolationFuncBase64Gzip() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
var b bytes.Buffer
gz := gzip.NewWriter(&b)
if _, err := gz.Write([]byte(s)); err != nil {
return "", fmt.Errorf("failed to write gzip raw data: '%s'", s)
}
if err := gz.Flush(); err != nil {
return "", fmt.Errorf("failed to flush gzip writer: '%s'", s)
}
if err := gz.Close(); err != nil {
return "", fmt.Errorf("failed to close gzip writer: '%s'", s)
}
return base64.StdEncoding.EncodeToString(b.Bytes()), nil
},
}
}
// interpolationFuncLower implements the "lower" function that does
// string lower casing.
func interpolationFuncLower() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
toLower := args[0].(string)
return strings.ToLower(toLower), nil
},
}
}
func interpolationFuncMd5() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
h := md5.New()
h.Write([]byte(s))
hash := hex.EncodeToString(h.Sum(nil))
return hash, nil
},
}
}
func interpolationFuncMerge() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeMap},
ReturnType: ast.TypeMap,
Variadic: true,
VariadicType: ast.TypeMap,
Callback: func(args []interface{}) (interface{}, error) {
outputMap := make(map[string]ast.Variable)
for _, arg := range args {
for k, v := range arg.(map[string]ast.Variable) {
outputMap[k] = v
}
}
return outputMap, nil
},
}
}
// interpolationFuncUpper implements the "upper" function that does
// string upper casing.
func interpolationFuncUpper() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
toUpper := args[0].(string)
return strings.ToUpper(toUpper), nil
},
}
}
func interpolationFuncSha1() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
h := sha1.New()
h.Write([]byte(s))
hash := hex.EncodeToString(h.Sum(nil))
return hash, nil
},
}
}
// hexadecimal representation of sha256 sum
func interpolationFuncSha256() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
h := sha256.New()
h.Write([]byte(s))
hash := hex.EncodeToString(h.Sum(nil))
return hash, nil
},
}
}
func interpolationFuncSha512() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
h := sha512.New()
h.Write([]byte(s))
hash := hex.EncodeToString(h.Sum(nil))
return hash, nil
},
}
}
func interpolationFuncTrimSpace() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
trimSpace := args[0].(string)
return strings.TrimSpace(trimSpace), nil
},
}
}
func interpolationFuncBase64Sha256() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
h := sha256.New()
h.Write([]byte(s))
shaSum := h.Sum(nil)
encoded := base64.StdEncoding.EncodeToString(shaSum[:])
return encoded, nil
},
}
}
func interpolationFuncBase64Sha512() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
h := sha512.New()
h.Write([]byte(s))
shaSum := h.Sum(nil)
encoded := base64.StdEncoding.EncodeToString(shaSum[:])
return encoded, nil
},
}
}
func interpolationFuncBcrypt() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
Variadic: true,
VariadicType: ast.TypeString,
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
defaultCost := 10
if len(args) > 1 {
costStr := args[1].(string)
cost, err := strconv.Atoi(costStr)
if err != nil {
return "", err
}
defaultCost = cost
}
if len(args) > 2 {
return "", fmt.Errorf("bcrypt() takes no more than two arguments")
}
input := args[0].(string)
out, err := bcrypt.GenerateFromPassword([]byte(input), defaultCost)
if err != nil {
return "", fmt.Errorf("error occured generating password %s", err.Error())
}
return string(out), nil
},
}
}
func interpolationFuncUUID() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
return uuid.GenerateUUID()
},
}
}
// interpolationFuncTimestamp
func interpolationFuncTimestamp() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
return time.Now().UTC().Format(time.RFC3339), nil
},
}
}
func interpolationFuncTimeAdd() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeString, // input timestamp string in RFC3339 format
ast.TypeString, // duration to add to input timestamp that should be parsable by time.ParseDuration
},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
ts, err := time.Parse(time.RFC3339, args[0].(string))
if err != nil {
return nil, err
}
duration, err := time.ParseDuration(args[1].(string))
if err != nil {
return nil, err
}
return ts.Add(duration).Format(time.RFC3339), nil
},
}
}
// interpolationFuncTitle implements the "title" function that returns a copy of the
// string in which first characters of all the words are capitalized.
func interpolationFuncTitle() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
toTitle := args[0].(string)
return strings.Title(toTitle), nil
},
}
}
// interpolationFuncSubstr implements the "substr" function that allows strings
// to be truncated.
func interpolationFuncSubstr() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{
ast.TypeString, // input string
ast.TypeInt, // offset
ast.TypeInt, // length
},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
str := args[0].(string)
offset := args[1].(int)
length := args[2].(int)
// Interpret a negative offset as being equivalent to a positive
// offset taken from the end of the string.
if offset < 0 {
offset += len(str)
}
// Interpret a length of `-1` as indicating that the substring
// should start at `offset` and continue until the end of the
// string. Any other negative length (other than `-1`) is invalid.
if length == -1 {
length = len(str)
} else if length >= 0 {
length += offset
} else {
return nil, fmt.Errorf("length should be a non-negative integer")
}
if offset > len(str) || offset < 0 {
return nil, fmt.Errorf("offset cannot be larger than the length of the string")
}
if length > len(str) {
return nil, fmt.Errorf("'offset + length' cannot be larger than the length of the string")
}
return str[offset:length], nil
},
}
}
// Flatten until it's not ast.TypeList
func flattener(finalList []ast.Variable, flattenList []ast.Variable) []ast.Variable {
for _, val := range flattenList {
if val.Type == ast.TypeList {
finalList = flattener(finalList, val.Value.([]ast.Variable))
} else {
finalList = append(finalList, val)
}
}
return finalList
}
// Flatten to single list
func interpolationFuncFlatten() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeList},
ReturnType: ast.TypeList,
Variadic: false,
Callback: func(args []interface{}) (interface{}, error) {
inputList := args[0].([]ast.Variable)
var outputList []ast.Variable
return flattener(outputList, inputList), nil
},
}
}
func interpolationFuncURLEncode() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
return url.QueryEscape(s), nil
},
}
}
// interpolationFuncTranspose implements the "transpose" function
// that converts a map (string,list) to a map (string,list) where
// the unique values of the original lists become the keys of the
// new map and the keys of the original map become values for the
// corresponding new keys.
func interpolationFuncTranspose() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeMap},
ReturnType: ast.TypeMap,
Callback: func(args []interface{}) (interface{}, error) {
inputMap := args[0].(map[string]ast.Variable)
outputMap := make(map[string]ast.Variable)
tmpMap := make(map[string][]string)
for inKey, inVal := range inputMap {
if inVal.Type != ast.TypeList {
return nil, fmt.Errorf("transpose requires a map of lists of strings")
}
values := inVal.Value.([]ast.Variable)
for _, listVal := range values {
if listVal.Type != ast.TypeString {
return nil, fmt.Errorf("transpose requires the given map values to be lists of strings")
}
outKey := listVal.Value.(string)
if _, ok := tmpMap[outKey]; !ok {
tmpMap[outKey] = make([]string, 0)
}
outVal := tmpMap[outKey]
outVal = append(outVal, inKey)
sort.Strings(outVal)
tmpMap[outKey] = outVal
}
}
for outKey, outVal := range tmpMap {
values := make([]ast.Variable, 0)
for _, v := range outVal {
values = append(values, ast.Variable{Type: ast.TypeString, Value: v})
}
outputMap[outKey] = ast.Variable{Type: ast.TypeList, Value: values}
}
return outputMap, nil
},
}
}
// interpolationFuncAbs returns the absolute value of a given float.
func interpolationFuncAbs() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeFloat},
ReturnType: ast.TypeFloat,
Callback: func(args []interface{}) (interface{}, error) {
return math.Abs(args[0].(float64)), nil
},
}
}
// interpolationFuncRsaDecrypt implements the "rsadecrypt" function that does
// RSA decryption.
func interpolationFuncRsaDecrypt() ast.Function {
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString, ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
s := args[0].(string)
key := args[1].(string)
b, err := base64.StdEncoding.DecodeString(s)
if err != nil {
return "", fmt.Errorf("Failed to decode input %q: cipher text must be base64-encoded", s)
}
block, _ := pem.Decode([]byte(key))
if block == nil {
return "", fmt.Errorf("Failed to read key %q: no key found", key)
}
if block.Headers["Proc-Type"] == "4,ENCRYPTED" {
return "", fmt.Errorf(
"Failed to read key %q: password protected keys are\n"+
"not supported. Please decrypt the key prior to use.", key)
}
x509Key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return "", err
}
out, err := rsa.DecryptPKCS1v15(nil, x509Key, b)
if err != nil {
return "", err
}
return string(out), nil
},
}
}
// interpolationFuncMakeFileHash constructs a function that hashes the contents
// of a file by combining the implementations of the file(...) function and
// a given other function that is assumed to take a single string argument and
// return a hash value.
func interpolationFuncMakeFileHash(hashFunc ast.Function) ast.Function {
fileFunc := interpolationFuncFile()
return ast.Function{
ArgTypes: []ast.Type{ast.TypeString},
ReturnType: ast.TypeString,
Callback: func(args []interface{}) (interface{}, error) {
filename := args[0].(string)
contents, err := fileFunc.Callback([]interface{}{filename})
if err != nil {
return nil, err
}
return hashFunc.Callback([]interface{}{contents})
},
}
}