159 lines
3.7 KiB
Go
159 lines
3.7 KiB
Go
package template
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"github.com/hashicorp/hil"
|
|
"github.com/hashicorp/hil/ast"
|
|
"github.com/hashicorp/terraform/config"
|
|
"github.com/hashicorp/terraform/helper/pathorcontents"
|
|
"github.com/hashicorp/terraform/helper/schema"
|
|
)
|
|
|
|
func dataSourceFile() *schema.Resource {
|
|
return &schema.Resource{
|
|
Read: dataSourceFileRead,
|
|
|
|
Schema: map[string]*schema.Schema{
|
|
"template": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Optional: true,
|
|
Description: "Contents of the template",
|
|
ConflictsWith: []string{"filename"},
|
|
ValidateFunc: validateTemplateAttribute,
|
|
},
|
|
"filename": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Optional: true,
|
|
Description: "file to read template from",
|
|
// Make a "best effort" attempt to relativize the file path.
|
|
StateFunc: func(v interface{}) string {
|
|
if v == nil || v.(string) == "" {
|
|
return ""
|
|
}
|
|
pwd, err := os.Getwd()
|
|
if err != nil {
|
|
return v.(string)
|
|
}
|
|
rel, err := filepath.Rel(pwd, v.(string))
|
|
if err != nil {
|
|
return v.(string)
|
|
}
|
|
return rel
|
|
},
|
|
Deprecated: "Use the 'template' attribute instead.",
|
|
ConflictsWith: []string{"template"},
|
|
},
|
|
"vars": &schema.Schema{
|
|
Type: schema.TypeMap,
|
|
Optional: true,
|
|
Default: make(map[string]interface{}),
|
|
Description: "variables to substitute",
|
|
},
|
|
"rendered": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Computed: true,
|
|
Description: "rendered template",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func dataSourceFileRead(d *schema.ResourceData, meta interface{}) error {
|
|
rendered, err := renderFile(d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d.Set("rendered", rendered)
|
|
d.SetId(hash(rendered))
|
|
return nil
|
|
}
|
|
|
|
type templateRenderError error
|
|
|
|
func renderFile(d *schema.ResourceData) (string, error) {
|
|
template := d.Get("template").(string)
|
|
filename := d.Get("filename").(string)
|
|
vars := d.Get("vars").(map[string]interface{})
|
|
|
|
if template == "" && filename != "" {
|
|
template = filename
|
|
}
|
|
|
|
contents, _, err := pathorcontents.Read(template)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
rendered, err := execute(contents, vars)
|
|
if err != nil {
|
|
return "", templateRenderError(
|
|
fmt.Errorf("failed to render %v: %v", filename, err),
|
|
)
|
|
}
|
|
|
|
return rendered, nil
|
|
}
|
|
|
|
// execute parses and executes a template using vars.
|
|
func execute(s string, vars map[string]interface{}) (string, error) {
|
|
root, err := hil.Parse(s)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
varmap := make(map[string]ast.Variable)
|
|
for k, v := range vars {
|
|
// As far as I can tell, v is always a string.
|
|
// If it's not, tell the user gracefully.
|
|
s, ok := v.(string)
|
|
if !ok {
|
|
return "", fmt.Errorf("unexpected type for variable %q: %T", k, v)
|
|
}
|
|
varmap[k] = ast.Variable{
|
|
Value: s,
|
|
Type: ast.TypeString,
|
|
}
|
|
}
|
|
|
|
cfg := hil.EvalConfig{
|
|
GlobalScope: &ast.BasicScope{
|
|
VarMap: varmap,
|
|
FuncMap: config.Funcs(),
|
|
},
|
|
}
|
|
|
|
result, err := hil.Eval(root, &cfg)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if result.Type != hil.TypeString {
|
|
return "", fmt.Errorf("unexpected output hil.Type: %v", result.Type)
|
|
}
|
|
|
|
return result.Value.(string), nil
|
|
}
|
|
|
|
func hash(s string) string {
|
|
sha := sha256.Sum256([]byte(s))
|
|
return hex.EncodeToString(sha[:])
|
|
}
|
|
|
|
func validateTemplateAttribute(v interface{}, key string) (ws []string, es []error) {
|
|
_, wasPath, err := pathorcontents.Read(v.(string))
|
|
if err != nil {
|
|
es = append(es, err)
|
|
return
|
|
}
|
|
|
|
if wasPath {
|
|
ws = append(ws, fmt.Sprintf("%s: looks like you specified a path instead of file contents. Use `file()` to load this path. Specifying a path directly is deprecated and will be removed in a future version.", key))
|
|
}
|
|
|
|
return
|
|
}
|