2015-05-19 17:25:56 -04:00
|
|
|
package template
|
|
|
|
|
|
|
|
import (
|
2015-05-26 12:38:02 -04:00
|
|
|
"bytes"
|
2015-05-19 17:25:56 -04:00
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
|
|
|
"io"
|
2015-05-23 18:44:54 -04:00
|
|
|
"os"
|
2015-05-19 17:25:56 -04:00
|
|
|
"sort"
|
|
|
|
|
|
|
|
"github.com/hashicorp/go-multierror"
|
|
|
|
"github.com/mitchellh/mapstructure"
|
|
|
|
)
|
|
|
|
|
|
|
|
// rawTemplate is the direct JSON document format of the template file.
|
|
|
|
// This is what is decoded directly from the file, and then it is turned
|
|
|
|
// into a Template object thereafter.
|
|
|
|
type rawTemplate struct {
|
|
|
|
MinVersion string `mapstructure:"min_packer_version"`
|
|
|
|
Description string
|
|
|
|
|
2015-05-21 16:32:22 -04:00
|
|
|
Builders []map[string]interface{}
|
|
|
|
Push map[string]interface{}
|
|
|
|
PostProcessors []interface{} `mapstructure:"post-processors"`
|
|
|
|
Provisioners []map[string]interface{}
|
|
|
|
Variables map[string]interface{}
|
2015-05-26 12:38:02 -04:00
|
|
|
|
|
|
|
RawContents []byte
|
2015-05-19 17:25:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Template returns the actual Template object built from this raw
|
|
|
|
// structure.
|
|
|
|
func (r *rawTemplate) Template() (*Template, error) {
|
|
|
|
var result Template
|
|
|
|
var errs error
|
|
|
|
|
2015-05-21 16:41:33 -04:00
|
|
|
// Copy some literals
|
|
|
|
result.Description = r.Description
|
|
|
|
result.MinVersion = r.MinVersion
|
2015-05-26 12:38:02 -04:00
|
|
|
result.RawContents = r.RawContents
|
2015-05-21 16:41:33 -04:00
|
|
|
|
2015-05-21 15:40:33 -04:00
|
|
|
// Gather the variables
|
|
|
|
if len(r.Variables) > 0 {
|
|
|
|
result.Variables = make(map[string]*Variable, len(r.Variables))
|
|
|
|
}
|
|
|
|
for k, rawV := range r.Variables {
|
|
|
|
var v Variable
|
|
|
|
|
|
|
|
// Variable is required if the value is exactly nil
|
|
|
|
v.Required = rawV == nil
|
|
|
|
|
|
|
|
// Weak decode the default if we have one
|
|
|
|
if err := r.decoder(&v.Default, nil).Decode(rawV); err != nil {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"variable %s: %s", k, err))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
result.Variables[k] = &v
|
|
|
|
}
|
|
|
|
|
2015-05-19 17:25:56 -04:00
|
|
|
// Let's start by gathering all the builders
|
2015-05-21 15:34:44 -04:00
|
|
|
if len(r.Builders) > 0 {
|
|
|
|
result.Builders = make(map[string]*Builder, len(r.Builders))
|
|
|
|
}
|
2015-05-19 17:25:56 -04:00
|
|
|
for i, rawB := range r.Builders {
|
|
|
|
var b Builder
|
|
|
|
if err := mapstructure.WeakDecode(rawB, &b); err != nil {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"builder %d: %s", i+1, err))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the raw configuration and delete any special keys
|
|
|
|
b.Config = rawB
|
|
|
|
delete(b.Config, "name")
|
|
|
|
delete(b.Config, "type")
|
|
|
|
if len(b.Config) == 0 {
|
|
|
|
b.Config = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there is no type set, it is an error
|
|
|
|
if b.Type == "" {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"builder %d: missing 'type'", i+1))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// The name defaults to the type if it isn't set
|
|
|
|
if b.Name == "" {
|
|
|
|
b.Name = b.Type
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this builder already exists, it is an error
|
|
|
|
if _, ok := result.Builders[b.Name]; ok {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"builder %d: builder with name '%s' already exists",
|
|
|
|
i+1, b.Name))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Append the builders
|
|
|
|
result.Builders[b.Name] = &b
|
|
|
|
}
|
|
|
|
|
2015-05-21 16:32:22 -04:00
|
|
|
// Gather all the post-processors
|
|
|
|
if len(r.PostProcessors) > 0 {
|
|
|
|
result.PostProcessors = make([][]*PostProcessor, 0, len(r.PostProcessors))
|
|
|
|
}
|
|
|
|
for i, v := range r.PostProcessors {
|
|
|
|
// Parse the configurations. We need to do this because post-processors
|
|
|
|
// can take three different formats.
|
|
|
|
configs, err := r.parsePostProcessor(i, v)
|
|
|
|
if err != nil {
|
|
|
|
errs = multierror.Append(errs, err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Parse the PostProcessors out of the configs
|
|
|
|
pps := make([]*PostProcessor, 0, len(configs))
|
|
|
|
for j, c := range configs {
|
|
|
|
var pp PostProcessor
|
|
|
|
if err := r.decoder(&pp, nil).Decode(c); err != nil {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"post-processor %d.%d: %s", i+1, j+1, err))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Type is required
|
|
|
|
if pp.Type == "" {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"post-processor %d.%d: type is required", i+1, j+1))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the configuration
|
|
|
|
delete(c, "keep_input_artifact")
|
|
|
|
delete(c, "type")
|
|
|
|
if len(c) > 0 {
|
|
|
|
pp.Config = c
|
|
|
|
}
|
|
|
|
|
|
|
|
pps = append(pps, &pp)
|
|
|
|
}
|
|
|
|
|
|
|
|
result.PostProcessors = append(result.PostProcessors, pps)
|
|
|
|
}
|
|
|
|
|
2015-05-21 15:34:44 -04:00
|
|
|
// Gather all the provisioners
|
|
|
|
if len(r.Provisioners) > 0 {
|
|
|
|
result.Provisioners = make([]*Provisioner, 0, len(r.Provisioners))
|
|
|
|
}
|
|
|
|
for i, v := range r.Provisioners {
|
|
|
|
var p Provisioner
|
|
|
|
if err := r.decoder(&p, nil).Decode(v); err != nil {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"provisioner %d: %s", i+1, err))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Type is required before any richer validation
|
|
|
|
if p.Type == "" {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"provisioner %d: missing 'type'", i+1))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// Copy the configuration
|
|
|
|
delete(v, "except")
|
|
|
|
delete(v, "only")
|
|
|
|
delete(v, "override")
|
|
|
|
delete(v, "pause_before")
|
|
|
|
delete(v, "type")
|
|
|
|
if len(v) > 0 {
|
|
|
|
p.Config = v
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: stuff
|
|
|
|
result.Provisioners = append(result.Provisioners, &p)
|
|
|
|
}
|
|
|
|
|
2015-05-21 16:44:29 -04:00
|
|
|
// Push
|
|
|
|
if len(r.Push) > 0 {
|
|
|
|
var p Push
|
|
|
|
if err := r.decoder(&p, nil).Decode(r.Push); err != nil {
|
|
|
|
errs = multierror.Append(errs, fmt.Errorf(
|
|
|
|
"push: %s", err))
|
|
|
|
}
|
|
|
|
|
|
|
|
result.Push = &p
|
|
|
|
}
|
|
|
|
|
2015-05-19 17:25:56 -04:00
|
|
|
// If we have errors, return those with a nil result
|
|
|
|
if errs != nil {
|
|
|
|
return nil, errs
|
|
|
|
}
|
|
|
|
|
|
|
|
return &result, nil
|
|
|
|
}
|
|
|
|
|
2015-05-21 15:34:44 -04:00
|
|
|
func (r *rawTemplate) decoder(
|
|
|
|
result interface{},
|
|
|
|
md *mapstructure.Metadata) *mapstructure.Decoder {
|
|
|
|
d, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
|
|
|
|
DecodeHook: mapstructure.StringToTimeDurationHookFunc(),
|
|
|
|
Metadata: md,
|
|
|
|
Result: result,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
// This really shouldn't happen since we have firm control over
|
|
|
|
// all the arguments and they're all unit tested. So we use a
|
|
|
|
// panic here to note this would definitely be a bug.
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return d
|
|
|
|
}
|
|
|
|
|
2015-05-21 16:32:22 -04:00
|
|
|
func (r *rawTemplate) parsePostProcessor(
|
|
|
|
i int, raw interface{}) ([]map[string]interface{}, error) {
|
|
|
|
switch v := raw.(type) {
|
|
|
|
case string:
|
|
|
|
return []map[string]interface{}{
|
|
|
|
{"type": v},
|
|
|
|
}, nil
|
|
|
|
case map[string]interface{}:
|
|
|
|
return []map[string]interface{}{v}, nil
|
|
|
|
case []interface{}:
|
|
|
|
var err error
|
|
|
|
result := make([]map[string]interface{}, len(v))
|
|
|
|
for j, innerRaw := range v {
|
|
|
|
switch innerV := innerRaw.(type) {
|
|
|
|
case string:
|
|
|
|
result[j] = map[string]interface{}{"type": innerV}
|
|
|
|
case map[string]interface{}:
|
|
|
|
result[j] = innerV
|
|
|
|
case []interface{}:
|
|
|
|
err = multierror.Append(err, fmt.Errorf(
|
|
|
|
"post-processor %d.%d: sequence not allowed to be nested in a sequence",
|
|
|
|
i+1, j+1))
|
|
|
|
default:
|
|
|
|
err = multierror.Append(err, fmt.Errorf(
|
|
|
|
"post-processor %d.%d: unknown format",
|
|
|
|
i+1, j+1))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return result, nil
|
|
|
|
default:
|
|
|
|
return nil, fmt.Errorf("post-processor %d: bad format", i+1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-19 17:25:56 -04:00
|
|
|
// Parse takes the given io.Reader and parses a Template object out of it.
|
|
|
|
func Parse(r io.Reader) (*Template, error) {
|
2015-05-26 12:38:02 -04:00
|
|
|
// Create a buffer to copy what we read
|
|
|
|
var buf bytes.Buffer
|
|
|
|
r = io.TeeReader(r, &buf)
|
|
|
|
|
2015-05-19 17:25:56 -04:00
|
|
|
// First, decode the object into an interface{}. We do this instead of
|
|
|
|
// the rawTemplate directly because we'd rather use mapstructure to
|
|
|
|
// decode since it has richer errors.
|
|
|
|
var raw interface{}
|
|
|
|
if err := json.NewDecoder(r).Decode(&raw); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create our decoder
|
|
|
|
var md mapstructure.Metadata
|
|
|
|
var rawTpl rawTemplate
|
2015-05-26 12:38:02 -04:00
|
|
|
rawTpl.RawContents = buf.Bytes()
|
2015-05-19 17:25:56 -04:00
|
|
|
decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
|
|
|
|
Metadata: &md,
|
|
|
|
Result: &rawTpl,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Do the actual decode into our structure
|
|
|
|
if err := decoder.Decode(raw); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build an error if there are unused root level keys
|
|
|
|
if len(md.Unused) > 0 {
|
|
|
|
sort.Strings(md.Unused)
|
|
|
|
for _, unused := range md.Unused {
|
|
|
|
err = multierror.Append(err, fmt.Errorf(
|
|
|
|
"Unknown root level key in template: '%s'", unused))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return early for these errors
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the template parsed from the raw structure
|
|
|
|
return rawTpl.Template()
|
|
|
|
}
|
2015-05-23 18:44:54 -04:00
|
|
|
|
|
|
|
// ParseFile is the same as Parse but is a helper to automatically open
|
|
|
|
// a file for parsing.
|
|
|
|
func ParseFile(path string) (*Template, error) {
|
|
|
|
f, err := os.Open(path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer f.Close()
|
|
|
|
|
|
|
|
return Parse(f)
|
|
|
|
}
|