post-processor/vagrant: vmware

post-processor/vagrant/vmware.go

 package vagrant
 
 import (
-	"compress/flate"
 	"fmt"
-	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
-	"io/ioutil"
-	"os"
 	"path/filepath"
-	"strconv"
 )
 
-type VMwareBoxConfig struct {
-	common.PackerConfig `mapstructure:",squash"`
+type VMwareProvider struct{}
 
-	OutputPath          string `mapstructure:"output"`
-	VagrantfileTemplate string `mapstructure:"vagrantfile_template"`
-	CompressionLevel    string `mapstructure:"compression_level"`
-
-	tpl *packer.ConfigTemplate
-}
-
-type VMwareBoxPostProcessor struct {
-	config VMwareBoxConfig
-}
-
-func (p *VMwareBoxPostProcessor) Configure(raws ...interface{}) error {
-	md, err := common.DecodeConfig(&p.config, raws...)
-	if err != nil {
-		return err
-	}
-
-	p.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return err
-	}
-	p.config.tpl.UserVars = p.config.PackerUserVars
-
-	// Accumulate any errors
-	errs := common.CheckUnusedConfig(md)
-
-	validates := map[string]*string{
-		"output":               &p.config.OutputPath,
-		"vagrantfile_template": &p.config.VagrantfileTemplate,
-		"compression_level":    &p.config.CompressionLevel,
-	}
-
-	for n, ptr := range validates {
-		if err := p.config.tpl.Validate(*ptr); err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error parsing %s: %s", n, err))
-		}
-	}
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
-	}
-
-	return nil
-}
-
-func (p *VMwareBoxPostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
-	// Compile the output path
-	outputPath, err := p.config.tpl.Process(p.config.OutputPath, &OutputPathTemplate{
-		ArtifactId: artifact.Id(),
-		BuildName:  p.config.PackerBuildName,
-		Provider:   "vmware",
-	})
-	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)
+func (p *VMwareProvider) Process(ui packer.Ui, artifact packer.Artifact, dir string) (vagrantfile string, metadata map[string]interface{}, err error) {
+	// Create the metadata
+	metadata = map[string]interface{}{"provider": "vmware_desktop"}
 
 	// Copy all of the original contents into the temporary directory
 	for _, path := range artifact.Files() {
 		ui.Message(fmt.Sprintf("Copying: %s", path))
 
 		dstPath := filepath.Join(dir, filepath.Base(path))
-		if err := CopyContents(dstPath, path); err != nil {
-			return nil, false, err
-		}
-	}
-
-	if p.config.VagrantfileTemplate != "" {
-		f, err := os.Open(p.config.VagrantfileTemplate)
-		if err != nil {
-			return nil, false, err
-		}
-		defer f.Close()
-
-		contents, err := ioutil.ReadAll(f)
-		if err != nil {
-			return nil, false, err
-		}
-
-		// Create the Vagrantfile from the template
-		vf, err := os.Create(filepath.Join(dir, "Vagrantfile"))
-		if err != nil {
-			return nil, false, err
+		if err = CopyContents(dstPath, path); err != nil {
+			return
 		}
-		defer vf.Close()
-
-		vagrantfileContents, err := p.config.tpl.Process(string(contents), nil)
-		if err != nil {
-			return nil, false, fmt.Errorf("Error writing Vagrantfile: %s", err)
-		}
-		vf.Write([]byte(vagrantfileContents))
-		vf.Close()
-	}
-
-	var level int = flate.DefaultCompression
-	if p.config.CompressionLevel != "" {
-		level, err = strconv.Atoi(p.config.CompressionLevel)
-		if err != nil {
-			return nil, false, err
-		}
-	}
-
-	// Create the metadata
-	metadata := map[string]string{"provider": "vmware_desktop"}
-	if err := WriteMetadata(dir, metadata); err != nil {
-		return nil, false, err
-	}
-
-	// Compress the directory to the given output path
-	ui.Message(fmt.Sprintf("Compressing box..."))
-	if err := DirToBox(outputPath, dir, ui, level); err != nil {
-		return nil, false, err
 	}
 
-	return NewArtifact("vmware", outputPath), false, nil
+	return
 }

post-processor/vagrant/vmware_test.go

 package vagrant
 
 import (
-	"github.com/mitchellh/packer/packer"
 	"testing"
 )
 
-func TestVMwareBoxPostProcessor_ImplementsPostProcessor(t *testing.T) {
-	var raw interface{}
-	raw = &VMwareBoxPostProcessor{}
-	if _, ok := raw.(packer.PostProcessor); !ok {
-		t.Fatalf("VMware PostProcessor should be a PostProcessor")
-	}
+func TestVMwareProvider_impl(t *testing.T) {
+	var _ Provider = new(VMwareProvider)
 }