packer-cn/config.go

119 lines
2.8 KiB
Go
Raw Normal View History

package main
import (
2013-05-08 21:13:15 -04:00
"github.com/BurntSushi/toml"
"github.com/mitchellh/packer/packer"
"github.com/mitchellh/packer/packer/plugin"
"log"
"os/exec"
)
2013-05-08 21:13:15 -04:00
// This is the default, built-in configuration that ships with
// Packer.
const defaultConfig = `
2013-05-09 14:32:03 -04:00
[builders]
amazon-ebs = "packer-builder-amazon-ebs"
vmware = "packer-builder-vmware"
2013-05-09 14:32:03 -04:00
2013-05-08 21:13:15 -04:00
[commands]
build = "packer-command-build"
[provisioners]
shell = "packer-provisioner-shell"
2013-05-08 21:13:15 -04:00
`
type config struct {
2013-05-24 00:59:03 -04:00
Builders map[string]string
Commands map[string]string
2013-05-24 00:39:00 -04:00
Provisioners map[string]string
}
2013-05-08 23:37:07 -04:00
// Merge the configurations. Anything in the "new" configuration takes
// precedence over the "old" configuration.
func mergeConfig(a, b *config) *config {
configs := []*config{a, b}
result := newConfig()
for _, config := range configs {
for k, v := range config.Builders {
result.Builders[k] = v
}
for k, v := range config.Commands {
result.Commands[k] = v
}
2013-05-24 00:39:00 -04:00
for k, v := range config.Provisioners {
result.Provisioners[k] = v
}
2013-05-08 23:37:07 -04:00
}
return result
}
// Creates and initializes a new config struct.
func newConfig() *config {
result := new(config)
result.Builders = make(map[string]string)
result.Commands = make(map[string]string)
2013-05-24 00:39:00 -04:00
result.Provisioners = make(map[string]string)
2013-05-08 23:37:07 -04:00
return result
}
2013-05-08 21:13:15 -04:00
// Parses a configuration file and returns a proper configuration
// struct.
func parseConfig(data string) (result *config, err error) {
result = new(config)
2013-05-08 21:13:15 -04:00
_, err = toml.Decode(data, &result)
return
}
2013-05-08 21:13:15 -04:00
// Returns an array of defined command names.
func (c *config) CommandNames() (result []string) {
result = make([]string, 0, len(c.Commands))
for name, _ := range c.Commands {
result = append(result, name)
}
return
}
func (c *config) LoadBuilder(name string) (packer.Builder, error) {
log.Printf("Loading builder: %s\n", name)
bin, ok := c.Builders[name]
if !ok {
log.Printf("Builder not found: %s\n", name)
return nil, nil
}
return plugin.Builder(exec.Command(bin))
}
2013-05-08 21:13:15 -04:00
// This is a proper packer.CommandFunc that can be used to load packer.Command
// implementations from the defined plugins.
func (c *config) LoadCommand(name string) (packer.Command, error) {
log.Printf("Loading command: %s\n", name)
2013-05-08 21:13:15 -04:00
commandBin, ok := c.Commands[name]
if !ok {
log.Printf("Command not found: %s\n", name)
return nil, nil
}
return plugin.Command(exec.Command(commandBin))
}
2013-05-11 14:11:40 -04:00
func (c *config) LoadHook(name string) (packer.Hook, error) {
log.Printf("Loading hook: %s\n", name)
return plugin.Hook(exec.Command(name))
}
2013-05-24 00:39:00 -04:00
func (c *config) LoadProvisioner(name string) (packer.Provisioner, error) {
log.Printf("Loading provisioner: %s\n", name)
provBin, ok := c.Provisioners[name]
if !ok {
log.Printf("Provisioner not found: %s\n", name)
return nil, nil
}
return plugin.Provisioner(exec.Command(provBin))
}