packer-cn/post-processor/vagrant/post-processor.go

270 lines
6.8 KiB
Go
Raw Normal View History

2013-06-26 20:37:46 -04:00
// vagrant implements the packer.PostProcessor interface and adds a
// post-processor that turns artifacts of known builders into Vagrant
// boxes.
package vagrant
import (
"compress/flate"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"text/template"
2017-04-04 16:39:01 -04:00
"github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/helper/config"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
2015-05-27 17:36:15 -04:00
"github.com/mitchellh/mapstructure"
2013-06-26 20:37:46 -04:00
)
var builtins = map[string]string{
2014-05-10 13:19:35 -04:00
"mitchellh.amazonebs": "aws",
"mitchellh.amazon.instance": "aws",
"mitchellh.virtualbox": "virtualbox",
"mitchellh.vmware": "vmware",
"mitchellh.vmware-esx": "vmware",
2014-05-10 13:19:35 -04:00
"pearkes.digitalocean": "digitalocean",
"packer.googlecompute": "google",
2017-07-11 02:46:55 -04:00
"hashicorp.scaleway": "scaleway",
2014-05-10 13:19:35 -04:00
"packer.parallels": "parallels",
2014-06-23 14:19:06 -04:00
"MSOpenTech.hyperv": "hyperv",
"transcend.qemu": "libvirt",
2018-03-06 15:02:19 -05:00
"ustream.lxc": "lxc",
2013-06-26 20:37:46 -04:00
}
2013-06-26 22:09:39 -04:00
type Config struct {
common.PackerConfig `mapstructure:",squash"`
2013-12-19 17:44:15 -05:00
CompressionLevel int `mapstructure:"compression_level"`
Include []string `mapstructure:"include"`
OutputPath string `mapstructure:"output"`
2013-12-19 17:44:15 -05:00
Override map[string]interface{}
VagrantfileTemplate string `mapstructure:"vagrantfile_template"`
2015-05-27 17:36:15 -04:00
ctx interpolate.Context
}
2013-06-26 20:37:46 -04:00
type PostProcessor struct {
2013-12-19 17:44:15 -05:00
configs map[string]*Config
}
func (p *PostProcessor) Configure(raws ...interface{}) error {
2013-12-19 17:44:15 -05:00
p.configs = make(map[string]*Config)
p.configs[""] = new(Config)
if err := p.configureSingle(p.configs[""], raws...); err != nil {
return err
}
2013-12-19 17:44:15 -05:00
// Go over any of the provider-specific overrides and load those up.
for name, override := range p.configs[""].Override {
subRaws := make([]interface{}, len(raws)+1)
copy(subRaws, raws)
subRaws[len(raws)] = override
2013-12-19 17:44:15 -05:00
config := new(Config)
p.configs[name] = config
if err := p.configureSingle(config, subRaws...); err != nil {
return fmt.Errorf("Error configuring %s: %s", name, err)
}
}
2013-06-26 20:37:46 -04:00
return nil
}
func (p *PostProcessor) PostProcessProvider(name string, provider Provider, ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
2013-12-19 17:44:15 -05:00
config := p.configs[""]
if specificConfig, ok := p.configs[name]; ok {
config = specificConfig
}
ui.Say(fmt.Sprintf("Creating Vagrant box for '%s' provider", name))
config.ctx.Data = &outputPathTemplate{
ArtifactId: artifact.Id(),
BuildName: config.PackerBuildName,
Provider: name,
}
outputPath, err := interpolate.Render(config.OutputPath, &config.ctx)
if err != nil {
return nil, false, err
}
// Create a temporary directory for us to build the contents of the box in
dir, err := ioutil.TempDir("", "packer")
if err != nil {
return nil, false, err
}
defer os.RemoveAll(dir)
// Copy all of the includes files into the temporary directory
2013-12-19 17:44:15 -05:00
for _, src := range config.Include {
ui.Message(fmt.Sprintf("Copying from include: %s", src))
dst := filepath.Join(dir, filepath.Base(src))
if err := CopyContents(dst, src); err != nil {
err = fmt.Errorf("Error copying include file: %s\n\n%s", src, err)
return nil, false, err
}
}
// Run the provider processing step
vagrantfile, metadata, err := provider.Process(ui, artifact, dir)
if err != nil {
return nil, false, err
}
// Write the metadata we got
if err := WriteMetadata(dir, metadata); err != nil {
return nil, false, err
}
// Write our Vagrantfile
var customVagrantfile string
2013-12-19 17:44:15 -05:00
if config.VagrantfileTemplate != "" {
ui.Message(fmt.Sprintf("Using custom Vagrantfile: %s", config.VagrantfileTemplate))
customBytes, err := ioutil.ReadFile(config.VagrantfileTemplate)
if err != nil {
return nil, false, err
}
customVagrantfile = string(customBytes)
}
f, err := os.Create(filepath.Join(dir, "Vagrantfile"))
if err != nil {
return nil, false, err
}
t := template.Must(template.New("root").Parse(boxVagrantfileContents))
err = t.Execute(f, &vagrantfileTemplate{
ProviderVagrantfile: vagrantfile,
CustomVagrantfile: customVagrantfile,
})
f.Close()
if err != nil {
return nil, false, err
}
// Create the box
2013-12-19 17:44:15 -05:00
if err := DirToBox(outputPath, dir, ui, config.CompressionLevel); err != nil {
return nil, false, err
}
return NewArtifact(name, outputPath), provider.KeepInputArtifact(), nil
}
func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
name, ok := builtins[artifact.BuilderId()]
if !ok {
return nil, false, fmt.Errorf(
"Unknown artifact type, can't build box: %s", artifact.BuilderId())
}
provider := providerForName(name)
if provider == nil {
// This shouldn't happen since we hard code all of these ourselves
panic(fmt.Sprintf("bad provider name: %s", name))
}
return p.PostProcessProvider(name, provider, ui, artifact)
}
2015-05-27 17:36:15 -04:00
func (p *PostProcessor) configureSingle(c *Config, raws ...interface{}) error {
var md mapstructure.Metadata
err := config.Decode(c, &config.DecodeOpts{
Metadata: &md,
Interpolate: true,
InterpolateContext: &c.ctx,
2015-05-27 17:36:15 -04:00
InterpolateFilter: &interpolate.RenderFilter{
Exclude: []string{
"output",
},
},
}, raws...)
2013-12-19 17:44:15 -05:00
if err != nil {
return err
}
// Defaults
2015-05-27 17:36:15 -04:00
if c.OutputPath == "" {
c.OutputPath = "packer_{{ .BuildName }}_{{.Provider}}.box"
2013-12-19 17:44:15 -05:00
}
found := false
for _, k := range md.Keys {
if k == "compression_level" {
found = true
break
}
}
if !found {
2015-05-27 17:36:15 -04:00
c.CompressionLevel = flate.DefaultCompression
2013-12-19 17:44:15 -05:00
}
2015-05-27 17:36:15 -04:00
var errs *packer.MultiError
if c.VagrantfileTemplate != "" {
_, err := os.Stat(c.VagrantfileTemplate)
if err != nil {
2015-05-27 17:36:15 -04:00
errs = packer.MultiErrorAppend(errs, fmt.Errorf(
"vagrantfile_template '%s' does not exist", c.VagrantfileTemplate))
2013-12-19 17:44:15 -05:00
}
}
if errs != nil && len(errs.Errors) > 0 {
return errs
}
return nil
}
func providerForName(name string) Provider {
switch name {
case "aws":
return new(AWSProvider)
2017-04-06 05:19:17 -04:00
case "scaleway":
return new(ScalewayProvider)
case "digitalocean":
return new(DigitalOceanProvider)
case "virtualbox":
return new(VBoxProvider)
case "vmware":
return new(VMwareProvider)
case "parallels":
return new(ParallelsProvider)
2014-06-23 14:19:06 -04:00
case "hyperv":
return new(HypervProvider)
case "libvirt":
return new(LibVirtProvider)
case "google":
return new(GoogleProvider)
2018-03-06 15:02:19 -05:00
case "lxc":
return new(LXCProvider)
default:
return nil
}
}
2018-03-13 03:13:24 -04:00
// OutputPathTemplate is the structure that is available within the
// OutputPath variables.
type outputPathTemplate struct {
ArtifactId string
BuildName string
Provider string
}
type vagrantfileTemplate struct {
ProviderVagrantfile string
CustomVagrantfile string
}
const boxVagrantfileContents string = `
# The contents below were provided by the Packer Vagrant post-processor
{{ .ProviderVagrantfile }}
# The contents below (if any) are custom contents provided by the
# Packer template during image build.
{{ .CustomVagrantfile }}
`