1 files changed, 364 insertions, 65 deletions

diff --git a/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go b/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go
index a298cf2..421edb0 100644
--- a/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go
+++ b/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go
@@ -1,17 +1,23 @@
 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"
@@ -55,59 +61,74 @@ func listVariableValueToStringSlice(values []ast.Variable) ([]string, error) {
 // Funcs is the mapping of built-in functions for configuration.
 func Funcs() map[string]ast.Function {
         return map[string]ast.Function{
-                "basename":     interpolationFuncBasename(),
-                "base64decode": interpolationFuncBase64Decode(),
-                "base64encode": interpolationFuncBase64Encode(),
-                "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(),
-                "file":         interpolationFuncFile(),
-                "matchkeys":    interpolationFuncMatchKeys(),
-                "floor":        interpolationFuncFloor(),
-                "format":       interpolationFuncFormat(),
-                "formatlist":   interpolationFuncFormatList(),
-                "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(),
-                "sha1":         interpolationFuncSha1(),
-                "sha256":       interpolationFuncSha256(),
-                "sha512":       interpolationFuncSha512(),
-                "signum":       interpolationFuncSignum(),
-                "slice":        interpolationFuncSlice(),
-                "sort":         interpolationFuncSort(),
-                "split":        interpolationFuncSplit(),
-                "substr":       interpolationFuncSubstr(),
-                "timestamp":    interpolationFuncTimestamp(),
-                "title":        interpolationFuncTitle(),
-                "trimspace":    interpolationFuncTrimSpace(),
-                "upper":        interpolationFuncUpper(),
-                "zipmap":       interpolationFuncZipMap(),
+                "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(),
         }
 }
 
@@ -669,6 +690,21 @@ func interpolationFuncFormatList() ast.Function {
         }
 }
 
+// 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 {
@@ -823,8 +859,7 @@ func interpolationFuncJoin() ast.Function {
 }
 
 // interpolationFuncJSONEncode implements the "jsonencode" function that encodes
-// a string, list, or map as its JSON representation. For now, values in the
-// list or map may only be strings.
+// a string, list, or map as its JSON representation.
 func interpolationFuncJSONEncode() ast.Function {
         return ast.Function{
                 ArgTypes:   []ast.Type{ast.TypeAny},
@@ -837,28 +872,36 @@ func interpolationFuncJSONEncode() ast.Function {
                                 toEncode = typedArg
 
                         case []ast.Variable:
-                                // We preallocate the list here. Note that it's important that in
-                                // the length 0 case, we have an empty list rather than nil, as
-                                // they encode differently.
-                                // XXX It would be nice to support arbitrarily nested data here. Is
-                                // there an inverse of hil.InterfaceToVariable?
                                 strings := make([]string, len(typedArg))
 
                                 for i, v := range typedArg {
                                         if v.Type != ast.TypeString {
-                                                return "", fmt.Errorf("list elements must be strings")
+                                                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:
-                                // XXX It would be nice to support arbitrarily nested data here. Is
-                                // there an inverse of hil.InterfaceToVariable?
                                 stringMap := make(map[string]string)
                                 for k, v := range typedArg {
                                         if v.Type != ast.TypeString {
-                                                return "", fmt.Errorf("map values must be strings")
+                                                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)
                                 }
@@ -1098,6 +1141,56 @@ func interpolationFuncElement() ast.Function {
         }
 }
 
+// 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 {
@@ -1197,6 +1290,32 @@ func interpolationFuncBase64Decode() ast.Function {
         }
 }
 
+// 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 {
@@ -1396,6 +1515,29 @@ func interpolationFuncTimestamp() ast.Function {
         }
 }
 
+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 {
@@ -1441,7 +1583,7 @@ func interpolationFuncSubstr() ast.Function {
                                 return nil, fmt.Errorf("length should be a non-negative integer")
                         }
 
-                        if offset > len(str) {
+                        if offset > len(str) || offset < 0 {
                                 return nil, fmt.Errorf("offset cannot be larger than the length of the string")
                         }
 
@@ -1453,3 +1595,160 @@ func interpolationFuncSubstr() ast.Function {
                 },
         }
 }
+
+// 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})
+                },
+        }
+}