packer-cn/config.go

180 lines
5.2 KiB
Go
Raw Normal View History

package main
import (
"encoding/json"
"github.com/mitchellh/osext"
"github.com/mitchellh/packer/packer"
"github.com/mitchellh/packer/packer/plugin"
"io"
"log"
"os/exec"
"path/filepath"
)
2013-05-08 21:13:15 -04:00
// This is the default, built-in configuration that ships with
// Packer.
const defaultConfig = `
{
"plugin_min_port": 10000,
"plugin_max_port": 25000,
"builders": {
"amazon-ebs": "packer-builder-amazon-ebs",
"amazon-chroot": "packer-builder-amazon-chroot",
"amazon-instance": "packer-builder-amazon-instance",
2013-06-18 19:52:22 -04:00
"digitalocean": "packer-builder-digitalocean",
2013-11-08 19:57:34 -05:00
"docker": "packer-builder-docker",
"googlecompute": "packer-builder-googlecompute",
"openstack": "packer-builder-openstack",
"qemu": "packer-builder-qemu",
"virtualbox-iso": "packer-builder-virtualbox-iso",
2013-12-22 18:47:02 -05:00
"virtualbox-ovf": "packer-builder-virtualbox-ovf",
2013-12-26 16:55:06 -05:00
"vmware-iso": "packer-builder-vmware-iso",
"vmware-vmx": "packer-builder-vmware-vmx"
},
"commands": {
2013-06-13 13:03:44 -04:00
"build": "packer-command-build",
"fix": "packer-command-fix",
"inspect": "packer-command-inspect",
2013-06-13 13:03:44 -04:00
"validate": "packer-command-validate"
},
"post-processors": {
2013-11-11 03:56:51 -05:00
"vagrant": "packer-post-processor-vagrant",
"vsphere": "packer-post-processor-vsphere",
"docker-push": "packer-post-processor-docker-push",
"docker-import": "packer-post-processor-docker-import"
},
"provisioners": {
2013-09-29 19:24:21 -04:00
"ansible-local": "packer-provisioner-ansible-local",
"chef-client": "packer-provisioner-chef-client",
"chef-solo": "packer-provisioner-chef-solo",
"file": "packer-provisioner-file",
"puppet-masterless": "packer-provisioner-puppet-masterless",
"puppet-server": "packer-provisioner-puppet-server",
2013-07-22 00:20:39 -04:00
"shell": "packer-provisioner-shell",
"salt-masterless": "packer-provisioner-salt-masterless"
}
}
2013-05-08 21:13:15 -04:00
`
type config struct {
PluginMinPort uint
PluginMaxPort uint
Builders map[string]string
Commands map[string]string
PostProcessors map[string]string `json:"post-processors"`
Provisioners map[string]string
}
// Decodes configuration in JSON format from the given io.Reader into
// the config object pointed to.
func decodeConfig(r io.Reader, c *config) error {
decoder := json.NewDecoder(r)
return decoder.Decode(c)
}
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))
2013-06-17 19:36:22 -04:00
for name := range c.Commands {
result = append(result, name)
}
return
}
// This is a proper packer.BuilderFunc that can be used to load packer.Builder
// implementations from the defined plugins.
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
}
2013-06-11 14:06:23 -04:00
return c.pluginClient(bin).Builder()
}
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-06-11 14:06:23 -04:00
bin, ok := c.Commands[name]
if !ok {
log.Printf("Command not found: %s\n", name)
return nil, nil
}
2013-06-11 14:06:23 -04:00
return c.pluginClient(bin).Command()
}
2013-05-11 14:11:40 -04:00
// This is a proper implementation of packer.HookFunc that can be used
// to load packer.Hook implementations from the defined plugins.
2013-05-11 14:11:40 -04:00
func (c *config) LoadHook(name string) (packer.Hook, error) {
log.Printf("Loading hook: %s\n", name)
2013-06-11 14:06:23 -04:00
return c.pluginClient(name).Hook()
2013-05-11 14:11:40 -04:00
}
2013-05-24 00:39:00 -04:00
// This is a proper packer.PostProcessorFunc that can be used to load
// packer.PostProcessor implementations from defined plugins.
func (c *config) LoadPostProcessor(name string) (packer.PostProcessor, error) {
log.Printf("Loading post-processor: %s", name)
bin, ok := c.PostProcessors[name]
if !ok {
log.Printf("Post-processor not found: %s", name)
return nil, nil
}
return c.pluginClient(bin).PostProcessor()
}
// This is a proper packer.ProvisionerFunc that can be used to load
// packer.Provisioner implementations from defined plugins.
2013-05-24 00:39:00 -04:00
func (c *config) LoadProvisioner(name string) (packer.Provisioner, error) {
log.Printf("Loading provisioner: %s\n", name)
2013-06-11 14:06:23 -04:00
bin, ok := c.Provisioners[name]
2013-05-24 00:39:00 -04:00
if !ok {
log.Printf("Provisioner not found: %s\n", name)
return nil, nil
}
2013-06-11 14:06:23 -04:00
return c.pluginClient(bin).Provisioner()
}
func (c *config) pluginClient(path string) *plugin.Client {
originalPath := path
// First attempt to find the executable by consulting the PATH.
path, err := exec.LookPath(path)
if err != nil {
// If that doesn't work, look for it in the same directory
// as the `packer` executable (us).
log.Printf("Plugin could not be found. Checking same directory as executable.")
exePath, err := osext.Executable()
if err != nil {
log.Printf("Couldn't get current exe path: %s", err)
} else {
log.Printf("Current exe path: %s", exePath)
path = filepath.Join(filepath.Dir(exePath), filepath.Base(originalPath))
}
}
// If everything failed, just use the original path and let the error
// bubble through.
if path == "" {
path = originalPath
}
log.Printf("Creating plugin client for path: %s", path)
2013-06-11 14:06:23 -04:00
var config plugin.ClientConfig
config.Cmd = exec.Command(path)
config.Managed = true
2013-06-11 14:08:21 -04:00
config.MinPort = c.PluginMinPort
config.MaxPort = c.PluginMaxPort
2013-06-11 14:06:23 -04:00
return plugin.NewClient(&config)
2013-05-24 00:39:00 -04:00
}