v0.3.7

.gitignore

@@ -4,5 +4,3 @@
 /src
 /website/.sass-cache
 /website/build
-.vagrant
-Vagrantfile

CHANGELOG.md

@@ -1,168 +1,3 @@
-## 0.4.0 (November 19, 2013)
-
-FEATURES:
-
-* Docker builder: build and export Docker containers, easily provisioned
-  with any of the Packer built-in provisioners.
-* QEMU builder: builds a new VM compatible with KVM or Xen using QEMU.
-* Remote ESXi builder: builds a VMware VM using ESXi remotely using only
-  SSH to an ESXi machine directly.
-* vSphere post-processor: Can upload VMware artifacts to vSphere
-* Vagrant post-processor can now make DigitalOcean provider boxes. [GH-504]
-
-IMPROVEMENTS:
-
-* builder/amazon/all: Can now specify a list of multiple security group
-  IDs to apply. [GH-499]
-* builder/amazon/all: AWS API requests are now retried when a temporary
-  network error occurs as well as 500 errors. [GH-559]
-* builder/virtualbox: Use VBOX\_INSTALL\_PATH env var on Windows to find
-  VBoxManage. [GH-628]
-* post-processor/vagrant: skips gzip compression when compression_level=0
-* provisioner/chef-solo: Encrypted data bag support [GH-625]
-
-BUG FIXES:
-
-* builder/amazon/chroot: Copying empty directories works. [GH-588]
-* builder/amazon/chroot: Chroot commands work with shell provisioners. [GH-581]
-* builder/amazon/chroot: Don't choose a mount point that is a partition of
-  an already mounted device. [GH-635]
-* builder/virtualbox: Ctrl-C interrupts during waiting for boot. [GH-618]
-* builder/vmware: VMX modifications are now case-insensitive. [GH-608]
-* builder/vmware: VMware Fusion won't ask for VM upgrade.
-* builder/vmware: Ctrl-C interrupts during waiting for boot. [GH-618]
-* provisioner/chef-solo: Output is slightly prettier and more informative.
-
-## 0.3.11 (November 4, 2013)
-
-FEATURES:
-
-* builder/amazon/ebs: Ability to specify which availability zone to create
-  instance in. [GH-536]
-
-IMPROVEMENTS:
-
-* core: builders can now give warnings during validation. warnings won't
-  fail the build but may hint at potential future problems.
-* builder/digitalocean: Can now specify a droplet name
-* builder/virtualbox: Can now disable guest addition download entirely
-  by setting "guest_additions_mode" to "disable" [GH-580]
-* builder/virtualbox,vmware: ISO urls can now be https [GH-587]
-* builder/virtualbox,vmware: Warning if shutdown command is not specified,
-  since it is a common case of data loss.
-
-BUG FIXES:
-
-* core: Won't panic when writing to a bad pipe. [GH-560]
-* builder/amazon/all: Properly scrub access key and secret key from logs.
-  [GH-554]
-* builder/openstack: Properly scrub password from logs [GH-554]
-* builder/virtualbox: No panic if SSH host port min/max is the same. [GH-594]
-* builder/vmware: checks if `ifconfig` is in `/sbin` [GH-591]
-* builder/vmware: Host IP lookup works for non-C locales. [GH-592]
-* common/uuid: Use cryptographically secure PRNG when generating
-  UUIDs. [GH-552]
-* communicator/ssh: File uploads that exceed the size of memory no longer
-  cause crashes. [GH-561]
-
-## 0.3.10 (October 20, 2013)
-
-FEATURES:
-
-* Ansible provisioner
-
-IMPROVEMENTS:
-
-* post-processor/vagrant: support instance-store AMIs built by Packer. [GH-502]
-* post-processor/vagrant: can now specify compression level to use
-  when creating the box. [GH-506]
-
-BUG FIXES:
-
-* builder/all: timeout waiting for SSH connection is a failure. [GH-491]
-* builder/amazon: Scrub sensitive data from the logs. [GH-521]
-* builder/amazon: Handle the situation where an EC2 instance might not
-  be immediately available. [GH-522]
-* builder/amazon/chroot: Files copied into the chroot remove destination
-  before copy, fixing issues with dangling symlinks. [GH-500]
-* builder/digitalocean: don't panic if erroneous API response doesn't
-  contain error message. [GH-492]
-* builder/digitalocean: scrub API keys from config debug output [GH-516]
-* builder/virtualbox: error if VirtualBox version cant be detected. [GH-488]
-* builder/virtualbox: detect if vboxdrv isn't properly setup. [GH-488]
-* builder/virtualbox: sleep a bit before export to ensure the sesssion
-  is unlocked. [GH-512]
-* builder/virtualbox: create SATA drives properly on VirtualBox 4.3 [GH-547]
-* builder/virtualbox: support user templates in SSH key path. [GH-539]
-* builder/vmware: support user templates in SSH key path. [GH-539]
-* communicator/ssh: Fix issue where a panic could arise from a nil
-  dereference. [GH-525]
-* post-processor/vagrant: Fix issue with VirtualBox OVA. [GH-548]
-* provisioner/salt: Move salt states to correct remote directory. [GH-513]
-* provisioner/shell: Won't block on certain scripts on Windows anymore.
-  [GH-507]
-
-## 0.3.9 (October 2, 2013)
-
-FEATURES:
-
-* The Amazon chroot builder is now able to run without any `sudo` privileges
-  by using the "command_wrapper" configuration. [GH-430]
-* Chef provisioner supports environments. [GH-483]
-
-BUG FIXES:
-
-* core: default user variable values don't need to be strings. [GH-456]
-* builder/amazon-chroot: Fix errors with waitin for state change. [GH-459]
-* builder/digitalocean: Use proper error message JSON key (DO API change).
-* communicator/ssh: SCP uploads now work properly when directories
-  contain symlinks. [GH-449]
-* provisioner/chef-solo: Data bags and roles path are now properly
-  populated when set. [GH-470]
-* provisioner/shell: Windows line endings are actually properly changed
-  to Unix line endings. [GH-477]
-
-## 0.3.8 (September 22, 2013)
-
-FEATURES:
-
-* core: You can now specify `only` and `except` configurations on any
-  provisioner or post-processor to specify a list of builds that they
-  are valid for. [GH-438]
-* builders/virtualbox: Guest additions can be attached rather than uploaded,
-  easier to handle for Windows guests. [GH-405]
-* provisioner/chef-solo: Ability to specify a custom Chef configuration
-  template.
-* provisioner/chef-solo: Roles and data bags support. [GH-348]
-
-IMPROVEMENTS:
-
-* core: User variables can now be used for integer, boolean, etc.
-  values. [GH-418]
-* core: Plugins made with incompatible versions will no longer load.
-* builder/amazon/all: Interrupts work while waiting for AMI to be ready.
-* provisioner/shell: Script line-endings are automatically converted to
-  Unix-style line-endings. Can be disabled by setting "binary" to "true".
-  [GH-277]
-
-BUG FIXES:
-
-* core: Set TCP KeepAlives on internally created RPC connections so that
-  they don't die. [GH-416]
-* builder/amazon/all: While waiting for AMI, will detect "failed" state.
-* builder/amazon/all: Waiting for state will detect if the resource (AMI,
-  instance, etc.) disappears from under it.
-* builder/amazon/instance: Exclude only contents of /tmp, not /tmp
-  itself. [GH-437]
-* builder/amazon/instance: Make AccessKey/SecretKey available to bundle
-  command even when they come from the environment. [GH-434]
-* builder/virtualbox: F1-F12 and delete scancodes now work. [GH-425]
-* post-processor/vagrant: Override configurations properly work. [GH-426]
-* provisioner/puppet-masterless: Fix failure case when both facter vars
-  are used and prevent_sudo. [GH-415]
-* provisioner/puppet-masterless: User variables now work properly in
-  manifest file and hiera path. [GH-448]
-
 ## 0.3.7 (September 9, 2013)
 
 BACKWARDS INCOMPATIBILITIES:

CONTRIBUTING.md

@@ -18,12 +18,6 @@ it raises the chances we can quickly merge or address your contributions.
 * Make sure you test against the latest released version. It is possible
   we already fixed the bug you're experiencing.
 
-* Run the command with debug ouput with the environment variable
-  `PACKER_LOG`. For example: `PACKER_LOG=1 packer build template.json`. Take
-  the *entire* output and create a [gist](https://gist.github.com) for linking
-  to in your issue. Packer should strip sensitive keys from the output,
-  but take a look through just in case.
-
 * Provide a reproducible test case. If a contributor can't reproduce an
   issue, then it dramatically lowers the chances it'll get fixed. And in
   some cases, the issue will eventually be closed.
@@ -53,9 +47,7 @@ it raises the chances we can quickly merge or address your contributions.
 If you have never worked with Go before, you will have to complete the
 following steps in order to be able to compile and test Packer.
 
-1. Install Go. On a Mac, you can `brew install go`. Make sure the Go
-   version is at least Go 1.1. Packer will not work with anything less than
-   Go 1.1.
+1. Install Go. On a Mac, you can `brew install go`.
 
 2. Set and export the `GOPATH` environment variable. For example, you can
    add `export GOPATH=$HOME/Documents/golang` to your `.bash_profile`.

Makefile

@@ -2,22 +2,16 @@ NO_COLOR=\033[0m
 OK_COLOR=\033[32;01m
 ERROR_COLOR=\033[31;01m
 WARN_COLOR=\033[33;01m
-DEPS = $(go list -f '{{range .TestImports}}{{.}} {{end}}' ./...)
 
 all: deps
 	@mkdir -p bin/
 	@echo "$(OK_COLOR)==> Building$(NO_COLOR)"
-	@bash --norc -i ./scripts/devcompile.sh
+	@./scripts/build.sh
 
 deps:
 	@echo "$(OK_COLOR)==> Installing dependencies$(NO_COLOR)"
 	@go get -d -v ./...
-	@echo $(DEPS) | xargs -n1 go get -d
-
-updatedeps:
-	@echo "$(OK_COLOR)==> Updating all dependencies$(NO_COLOR)"
-	@go get -d -v -u ./...
-	@echo $(DEPS) | xargs -n1 go get -d -u
+	@go list -f '{{range .TestImports}}{{.}} {{end}}' ./... | xargs -n1 go get -d
 
 clean:
 	@rm -rf bin/ local/ pkg/ src/ website/.sass-cache website/build
@@ -29,4 +23,4 @@ test: deps
 	@echo "$(OK_COLOR)==> Testing Packer...$(NO_COLOR)"
 	go test ./...
 
-.PHONY: all clean deps format test updatedeps
+.PHONY: all deps format test

README.md

@@ -93,6 +93,3 @@ This will run tests for Packer core along with all the core builders and command
 
 If you make any changes to the code, run `make format` in order to automatically
 format the code according to Go standards.
-
-When new dependencies are added to packer you can use `make updatedeps` to
-get the latest and subsequently use `make` to compile and generate the `packer` binary.

builder/amazon/chroot/builder.go

@@ -27,33 +27,30 @@ type Config struct {
 	awscommon.AMIConfig    `mapstructure:",squash"`
 
 	ChrootMounts   [][]string `mapstructure:"chroot_mounts"`
-	CommandWrapper string     `mapstructure:"command_wrapper"`
 	CopyFiles      []string   `mapstructure:"copy_files"`
 	DevicePath     string     `mapstructure:"device_path"`
+	MountCommand   string     `mapstructure:"mount_command"`
 	MountPath      string     `mapstructure:"mount_path"`
 	SourceAmi      string     `mapstructure:"source_ami"`
+	UnmountCommand string     `mapstructure:"unmount_command"`
 
 	tpl *packer.ConfigTemplate
 }
 
-type wrappedCommandTemplate struct {
-	Command string
-}
-
 type Builder struct {
 	config Config
 	runner multistep.Runner
 }
 
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+func (b *Builder) Prepare(raws ...interface{}) error {
 	md, err := common.DecodeConfig(&b.config, raws...)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	b.config.tpl, err = packer.NewConfigTemplate()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	b.config.tpl.UserVars = b.config.PackerUserVars
 	b.config.tpl.Funcs(awscommon.TemplateFuncs)
@@ -81,14 +78,18 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.CopyFiles = []string{"/etc/resolv.conf"}
 	}
 
-	if b.config.CommandWrapper == "" {
-		b.config.CommandWrapper = "{{.Command}}"
+	if b.config.MountCommand == "" {
+		b.config.MountCommand = "mount"
 	}
 
 	if b.config.MountPath == "" {
 		b.config.MountPath = "packer-amazon-chroot-volumes/{{.Device}}"
 	}
 
+	if b.config.UnmountCommand == "" {
+		b.config.UnmountCommand = "umount"
+	}
+
 	// Accumulate any errors
 	errs := common.CheckUnusedConfig(md)
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...)
@@ -126,8 +127,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	templates := map[string]*string{
-		"device_path": &b.config.DevicePath,
-		"source_ami":  &b.config.SourceAmi,
+		"device_path":     &b.config.DevicePath,
+		"mount_command":   &b.config.MountCommand,
+		"source_ami":      &b.config.SourceAmi,
+		"unmount_command": &b.config.UnmountCommand,
 	}
 
 	for n, ptr := range templates {
@@ -140,11 +143,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
+		return errs
 	}
 
-	log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey))
-	return nil, nil
+	log.Printf("Config: %+v", b.config)
+	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
@@ -164,20 +167,12 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 
 	ec2conn := ec2.New(auth, region)
 
-	wrappedCommand := func(command string) (string, error) {
-		return b.config.tpl.Process(
-			b.config.CommandWrapper, &wrappedCommandTemplate{
-				Command: command,
-			})
-	}
-
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
 	state.Put("ec2", ec2conn)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
-	state.Put("wrappedCommand", CommandWrapper(wrappedCommand))
 
 	// Build the steps
 	steps := []multistep.Step{

builder/amazon/chroot/builder_test.go

@@ -26,10 +26,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 
 	// Test good
 	config["ami_name"] = "foo"
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -37,10 +34,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 	// Test bad
 	config["ami_name"] = "foo {{"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -48,10 +42,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 	// Test bad
 	delete(config, "ami_name")
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -62,10 +53,7 @@ func TestBuilderPrepare_ChrootMounts(t *testing.T) {
 	config := testConfig()
 
 	config["chroot_mounts"] = nil
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Errorf("err: %s", err)
 	}
@@ -73,10 +61,7 @@ func TestBuilderPrepare_ChrootMounts(t *testing.T) {
 	config["chroot_mounts"] = [][]string{
 		[]string{"bad"},
 	}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -86,33 +71,13 @@ func TestBuilderPrepare_SourceAmi(t *testing.T) {
 	config := testConfig()
 
 	config["source_ami"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	config["source_ami"] = "foo"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-}
-
-func TestBuilderPrepare_CommandWrapper(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["command_wrapper"] = "echo hi; {{.Command}}"
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Errorf("err: %s", err)
 	}

builder/amazon/chroot/command.go

@@ -1,15 +0,0 @@
-package chroot
-
-import (
-	"os/exec"
-)
-
-// CommandWrapper is a type that given a command, will possibly modify that
-// command in-flight. This might return an error.
-type CommandWrapper func(string) (string, error)
-
-// ShellCommand takes a command string and returns an *exec.Cmd to execute
-// it within the context of a shell (/bin/sh).
-func ShellCommand(command string) *exec.Cmd {
-	return exec.Command("/bin/sh", "-c", command)
-}

builder/amazon/chroot/communicator.go

@@ -1,34 +1,28 @@
 package chroot
 
 import (
-	"bytes"
-	"fmt"
 	"github.com/mitchellh/packer/packer"
 	"io"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"strings"
 	"syscall"
 )
 
 // Communicator is a special communicator that works by executing
 // commands locally but within a chroot.
 type Communicator struct {
-	Chroot     string
-	CmdWrapper CommandWrapper
+	Chroot string
 }
 
 func (c *Communicator) Start(cmd *packer.RemoteCmd) error {
-	command, err := c.CmdWrapper(
-		fmt.Sprintf("chroot %s /bin/sh -c \"%s\"", c.Chroot, cmd.Command))
+	chrootCmdPath, err := exec.LookPath("chroot")
 	if err != nil {
 		return err
 	}
 
-	localCmd := ShellCommand(command)
+	localCmd := exec.Command(chrootCmdPath, c.Chroot, "/bin/sh", "-c", cmd.Command)
 	localCmd.Stdin = cmd.Stdin
 	localCmd.Stdout = cmd.Stdout
 	localCmd.Stderr = cmd.Stderr
@@ -52,7 +46,7 @@ func (c *Communicator) Start(cmd *packer.RemoteCmd) error {
 		}
 
 		log.Printf(
-			"Chroot execution exited with '%d': '%s'",
+			"Chroot executation ended with '%d': '%s'",
 			exitStatus, cmd.Command)
 		cmd.SetExited(exitStatus)
 	}()
@@ -63,46 +57,49 @@ func (c *Communicator) Start(cmd *packer.RemoteCmd) error {
 func (c *Communicator) Upload(dst string, r io.Reader) error {
 	dst = filepath.Join(c.Chroot, dst)
 	log.Printf("Uploading to chroot dir: %s", dst)
-	tf, err := ioutil.TempFile("", "packer-amazon-chroot")
-	if err != nil {
-		return fmt.Errorf("Error preparing shell script: %s", err)
-	}
-	defer os.Remove(tf.Name())
-	io.Copy(tf, r)
-
-	cpCmd, err := c.CmdWrapper(fmt.Sprintf("cp %s %s", tf.Name(), dst))
+	f, err := os.Create(dst)
 	if err != nil {
 		return err
 	}
+	defer f.Close()
 
-	return ShellCommand(cpCmd).Run()
+	if _, err := io.Copy(f, r); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (c *Communicator) UploadDir(dst string, src string, exclude []string) error {
-	// TODO: remove any file copied if it appears in `exclude`
-	chrootDest := filepath.Join(c.Chroot, dst)
-	log.Printf("Uploading directory '%s' to '%s'", src, chrootDest)
-	cpCmd, err := c.CmdWrapper(fmt.Sprintf("cp -R %s* %s", src, chrootDest))
-	if err != nil {
-		return err
+	walkFn := func(fullPath string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		path, err := filepath.Rel(src, fullPath)
+		if err != nil {
+			return err
+		}
+
+		for _, e := range exclude {
+			if e == path {
+				log.Printf("Skipping excluded file: %s", path)
+				return nil
+			}
+		}
+
+		dstPath := filepath.Join(dst, path)
+		f, err := os.Open(fullPath)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+
+		return c.Upload(dstPath, f)
 	}
 
-	var stderr bytes.Buffer
-	cmd := ShellCommand(cpCmd)
-	cmd.Env = append(cmd.Env, os.Environ()...)
-	cmd.Env = append(cmd.Env, "LANG=C")
-	cmd.Stderr = &stderr
-	err = cmd.Run()
-	if err == nil {
-		return err
-	}
-
-	if strings.Contains(stderr.String(), "No such file") {
-		// This just means that the directory was empty. Just ignore it.
-		return nil
-	}
-
-	return err
+	log.Printf("Uploading directory '%s' to '%s'", src, dst)
+	return filepath.Walk(src, walkFn)
 }
 
 func (c *Communicator) Download(src string, w io.Writer) error {

builder/amazon/chroot/copy_files.go

@@ -1 +0,0 @@
-package chroot

builder/amazon/chroot/copy_files_test.go

@@ -1,44 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-func TestCopyFile(t *testing.T) {
-	first, err := ioutil.TempFile("", "copy_files_test")
-	if err != nil {
-		t.Fatalf("couldn't create temp file.")
-	}
-	defer os.Remove(first.Name())
-	newName := first.Name() + "-new"
-
-	payload := "copy_files_test.go payload"
-	if _, err = first.WriteString(payload); err != nil {
-		t.Fatalf("Couldn't write payload to first file.")
-	}
-	first.Sync()
-
-	cmd := ShellCommand(fmt.Sprintf("cp %s %s", first.Name(), newName))
-	if err := cmd.Run(); err != nil {
-		t.Fatalf("Couldn't copy file")
-	}
-	defer os.Remove(newName)
-
-	second, err := os.Open(newName)
-	if err != nil {
-		t.Fatalf("Couldn't open copied file.")
-	}
-	defer second.Close()
-
-	var copiedPayload = make([]byte, len(payload))
-	if _, err := second.Read(copiedPayload); err != nil {
-		t.Fatalf("Couldn't open copied file for reading.")
-	}
-
-	if string(copiedPayload) != payload {
-		t.Fatalf("payload not copied.")
-	}
-}

builder/amazon/chroot/device.go

@@ -19,14 +19,6 @@ func AvailableDevice() (string, error) {
 
 	letters := "fghijklmnop"
 	for _, letter := range letters {
-		device := fmt.Sprintf("/dev/%s%c", prefix, letter)
-
-		// If the block device itself, i.e. /dev/sf, exists, then we
-		// can't use any of the numbers either.
-		if _, err := os.Stat(device); err == nil {
-			continue
-		}
-
 		for i := 1; i < 16; i++ {
 			device := fmt.Sprintf("/dev/%s%c%d", prefix, letter, i)
 			if _, err := os.Stat(device); err != nil {

builder/amazon/chroot/step_attach_volume.go

@@ -60,8 +60,7 @@ func (s *StepAttachVolume) Run(state multistep.StateBag) multistep.StepAction {
 				return nil, "", errors.New("No attachments on volume.")
 			}
 
-			a := resp.Volumes[0].Attachments[0]
-			return a, a.Status, nil
+			return nil, resp.Volumes[0].Attachments[0].Status, nil
 		},
 	}
 
@@ -112,12 +111,12 @@ func (s *StepAttachVolume) CleanupFunc(state multistep.StateBag) error {
 				return nil, "", err
 			}
 
-			v := resp.Volumes[0]
-			if len(v.Attachments) > 0 {
-				return v, v.Attachments[0].Status, nil
-			} else {
-				return v, "detached", nil
+			state := "detached"
+			if len(resp.Volumes[0].Attachments) > 0 {
+				state = resp.Volumes[0].Attachments[0].Status
 			}
+
+			return nil, state, nil
 		},
 	}
 

builder/amazon/chroot/step_chroot_provision.go

@@ -15,12 +15,10 @@ func (s *StepChrootProvision) Run(state multistep.StateBag) multistep.StepAction
 	hook := state.Get("hook").(packer.Hook)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
 	// Create our communicator
 	comm := &Communicator{
-		Chroot:     mountPath,
-		CmdWrapper: wrappedCommand,
+		Chroot: mountPath,
 	}
 
 	// Provision

builder/amazon/chroot/step_copy_files.go

@@ -1,11 +1,12 @@
 package chroot
 
 import (
-	"bytes"
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
+	"io"
 	"log"
+	"os"
 	"path/filepath"
 )
 
@@ -22,8 +23,6 @@ func (s *StepCopyFiles) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
-	stderr := new(bytes.Buffer)
 
 	s.files = make([]string, 0, len(config.CopyFiles))
 	if len(config.CopyFiles) > 0 {
@@ -33,20 +32,8 @@ func (s *StepCopyFiles) Run(state multistep.StateBag) multistep.StepAction {
 			chrootPath := filepath.Join(mountPath, path)
 			log.Printf("Copying '%s' to '%s'", path, chrootPath)
 
-			cmdText, err := wrappedCommand(fmt.Sprintf("cp --remove-destination %s %s", path, chrootPath))
-			if err != nil {
-				err := fmt.Errorf("Error building copy command: %s", err)
-				state.Put("error", err)
-				ui.Error(err.Error())
-				return multistep.ActionHalt
-			}
-
-			stderr.Reset()
-			cmd := ShellCommand(cmdText)
-			cmd.Stderr = stderr
-			if err := cmd.Run(); err != nil {
-				err := fmt.Errorf(
-					"Error copying file: %s\nnStderr: %s", err, stderr.String())
+			if err := s.copySingle(chrootPath, path); err != nil {
+				err := fmt.Errorf("Error copying file: %s", err)
 				state.Put("error", err)
 				ui.Error(err.Error())
 				return multistep.ActionHalt
@@ -67,18 +54,11 @@ func (s *StepCopyFiles) Cleanup(state multistep.StateBag) {
 	}
 }
 
-func (s *StepCopyFiles) CleanupFunc(state multistep.StateBag) error {
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
+func (s *StepCopyFiles) CleanupFunc(multistep.StateBag) error {
 	if s.files != nil {
 		for _, file := range s.files {
 			log.Printf("Removing: %s", file)
-			localCmdText, err := wrappedCommand(fmt.Sprintf("rm -f %s", file))
-			if err != nil {
-				return err
-			}
-
-			localCmd := ShellCommand(localCmdText)
-			if err := localCmd.Run(); err != nil {
+			if err := os.Remove(file); err != nil {
 				return err
 			}
 		}
@@ -87,3 +67,41 @@ func (s *StepCopyFiles) CleanupFunc(state multistep.StateBag) error {
 	s.files = nil
 	return nil
 }
+
+func (s *StepCopyFiles) copySingle(dst, src string) error {
+	// Stat the src file so we can copy the mode later
+	srcInfo, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+
+	// Remove any existing destination file
+	if err := os.Remove(dst); err != nil {
+		return err
+	}
+
+	// Copy the files
+	srcF, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer srcF.Close()
+
+	dstF, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer dstF.Close()
+
+	if _, err := io.Copy(dstF, srcF); err != nil {
+		return err
+	}
+	dstF.Close()
+
+	// Match the mode
+	if err := os.Chmod(dst, srcInfo.Mode()); err != nil {
+		return err
+	}
+
+	return nil
+}

builder/amazon/chroot/step_create_volume.go

@@ -75,8 +75,7 @@ func (s *StepCreateVolume) Run(state multistep.StateBag) multistep.StepAction {
 				return nil, "", err
 			}
 
-			v := resp.Volumes[0]
-			return v, v.Status, nil
+			return nil, resp.Volumes[0].Status, nil
 		},
 	}
 

builder/amazon/chroot/step_mount_device.go

@@ -7,6 +7,7 @@ import (
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
 )
 
@@ -27,7 +28,6 @@ func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
 	device := state.Get("device").(string)
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
 	mountPath, err := config.tpl.Process(config.MountPath, &mountPathData{
 		Device: filepath.Base(device),
@@ -59,16 +59,8 @@ func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 
 	ui.Say("Mounting the root device...")
 	stderr := new(bytes.Buffer)
-	mountCommand, err := wrappedCommand(
-		fmt.Sprintf("mount %s %s", device, mountPath))
-	if err != nil {
-		err := fmt.Errorf("Error creating mount command: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	cmd := ShellCommand(mountCommand)
+	mountCommand := fmt.Sprintf("%s %s %s", config.MountCommand, device, mountPath)
+	cmd := exec.Command("/bin/sh", "-c", mountCommand)
 	cmd.Stderr = stderr
 	if err := cmd.Run(); err != nil {
 		err := fmt.Errorf(
@@ -98,16 +90,12 @@ func (s *StepMountDevice) CleanupFunc(state multistep.StateBag) error {
 		return nil
 	}
 
+	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
-
 	ui.Say("Unmounting the root device...")
-	unmountCommand, err := wrappedCommand(fmt.Sprintf("umount %s", s.mountPath))
-	if err != nil {
-		return fmt.Errorf("Error creating unmount command: %s", err)
-	}
 
-	cmd := ShellCommand(unmountCommand)
+	unmountCommand := fmt.Sprintf("%s %s", config.UnmountCommand, s.mountPath)
+	cmd := exec.Command("/bin/sh", "-c", unmountCommand)
 	if err := cmd.Run(); err != nil {
 		return fmt.Errorf("Error unmounting root device: %s", err)
 	}

builder/amazon/chroot/step_mount_extra.go

@@ -6,6 +6,7 @@ import (
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 	"os"
+	"os/exec"
 )
 
 // StepMountExtra mounts the attached device.
@@ -20,7 +21,6 @@ func (s *StepMountExtra) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
 	s.mounts = make([]string, 0, len(config.ChrootMounts))
 
@@ -42,19 +42,13 @@ func (s *StepMountExtra) Run(state multistep.StateBag) multistep.StepAction {
 
 		ui.Message(fmt.Sprintf("Mounting: %s", mountInfo[2]))
 		stderr := new(bytes.Buffer)
-		mountCommand, err := wrappedCommand(fmt.Sprintf(
-			"mount %s %s %s",
+		mountCommand := fmt.Sprintf(
+			"%s %s %s %s",
+			config.MountCommand,
 			flags,
 			mountInfo[1],
-			innerPath))
-		if err != nil {
-			err := fmt.Errorf("Error creating mount command: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		cmd := ShellCommand(mountCommand)
+			innerPath)
+		cmd := exec.Command("/bin/sh", "-c", mountCommand)
 		cmd.Stderr = stderr
 		if err := cmd.Run(); err != nil {
 			err := fmt.Errorf(
@@ -85,18 +79,15 @@ func (s *StepMountExtra) CleanupFunc(state multistep.StateBag) error {
 		return nil
 	}
 
-	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
+	config := state.Get("config").(*Config)
 	for len(s.mounts) > 0 {
 		var path string
 		lastIndex := len(s.mounts) - 1
 		path, s.mounts = s.mounts[lastIndex], s.mounts[:lastIndex]
-		unmountCommand, err := wrappedCommand(fmt.Sprintf("umount %s", path))
-		if err != nil {
-			return fmt.Errorf("Error creating unmount command: %s", err)
-		}
+		unmountCommand := fmt.Sprintf("%s %s", config.UnmountCommand, path)
 
 		stderr := new(bytes.Buffer)
-		cmd := ShellCommand(unmountCommand)
+		cmd := exec.Command("/bin/sh", "-c", unmountCommand)
 		cmd.Stderr = stderr
 		if err := cmd.Run(); err != nil {
 			return fmt.Errorf(

builder/amazon/chroot/step_register_ami.go

@@ -52,16 +52,8 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 	state.Put("amis", amis)
 
 	// Wait for the image to become ready
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"pending"},
-		Target:    "available",
-		Refresh:   awscommon.AMIStateRefreshFunc(ec2conn, registerResp.ImageId),
-		StepState: state,
-	}
-
 	ui.Say("Waiting for AMI to become ready...")
-	if _, err := awscommon.WaitForState(&stateChange); err != nil {
+	if err := awscommon.WaitForAMI(ec2conn, registerResp.ImageId); err != nil {
 		err := fmt.Errorf("Error waiting for AMI: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())

builder/amazon/chroot/step_snapshot.go

@@ -51,8 +51,7 @@ func (s *StepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 				return nil, "", errors.New("No snapshots found.")
 			}
 
-			s := resp.Snapshots[0]
-			return s, s.Status, nil
+			return nil, resp.Snapshots[0].Status, nil
 		},
 	}
 

builder/amazon/common/access_config.go

@@ -18,14 +18,7 @@ type AccessConfig struct {
 // Auth returns a valid aws.Auth object for access to AWS services, or
 // an error if the authentication couldn't be resolved.
 func (c *AccessConfig) Auth() (aws.Auth, error) {
-	auth, err := aws.GetAuth(c.AccessKey, c.SecretKey)
-	if err == nil {
-		// Store the accesskey and secret that we got...
-		c.AccessKey = auth.AccessKey
-		c.SecretKey = auth.SecretKey
-	}
-
-	return auth, err
+	return aws.GetAuth(c.AccessKey, c.SecretKey)
 }
 
 // Region returns the aws.Region object for access to AWS services, requesting

builder/amazon/common/ami.go

@@ -0,0 +1,30 @@
+package common
+
+import (
+	"github.com/mitchellh/goamz/ec2"
+	"log"
+	"time"
+)
+
+// WaitForAMI waits for the given AMI ID to become ready.
+func WaitForAMI(c *ec2.EC2, imageId string) error {
+	for {
+		imageResp, err := c.Images([]string{imageId}, ec2.NewFilter())
+		if err != nil {
+			if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidAMIID.NotFound" {
+				log.Println("AMI not found, probably state issues on AWS side. Trying again.")
+				continue
+			}
+
+			return err
+		}
+
+		if imageResp.Images[0].State == "available" {
+			return nil
+		}
+
+		log.Printf("Image in state %s, sleeping 2s before checking again",
+			imageResp.Images[0].State)
+		time.Sleep(2 * time.Second)
+	}
+}

builder/amazon/common/artifact_test.go

@@ -1,15 +1,21 @@
 package common
 
 import (
+	"cgl.tideland.biz/asserts"
 	"github.com/mitchellh/packer/packer"
 	"testing"
 )
 
 func TestArtifact_Impl(t *testing.T) {
-	var _ packer.Artifact = new(Artifact)
+	assert := asserts.NewTestingAsserts(t, true)
+
+	var actual packer.Artifact
+	assert.Implementor(&Artifact{}, &actual, "should be an Artifact")
 }
 
 func TestArtifactId(t *testing.T) {
+	assert := asserts.NewTestingAsserts(t, true)
+
 	expected := `east:foo,west:bar`
 
 	amis := make(map[string]string)
@@ -21,12 +27,12 @@ func TestArtifactId(t *testing.T) {
 	}
 
 	result := a.Id()
-	if result != expected {
-		t.Fatalf("bad: %s", result)
-	}
+	assert.Equal(result, expected, "should match output")
 }
 
 func TestArtifactString(t *testing.T) {
+	assert := asserts.NewTestingAsserts(t, true)
+
 	expected := `AMIs were created:
 
 east: foo
@@ -38,7 +44,5 @@ west: bar`
 
 	a := &Artifact{Amis: amis}
 	result := a.String()
-	if result != expected {
-		t.Fatalf("bad: %s", result)
-	}
+	assert.Equal(result, expected, "should match output")
 }

builder/amazon/common/block_device_test.go

@@ -1,12 +1,14 @@
 package common
 
 import (
+	"cgl.tideland.biz/asserts"
 	"github.com/mitchellh/goamz/ec2"
-	"reflect"
 	"testing"
 )
 
 func TestBlockDevice(t *testing.T) {
+	assert := asserts.NewTestingAsserts(t, true)
+
 	ec2Mapping := []ec2.BlockDeviceMapping{
 		ec2.BlockDeviceMapping{
 			DeviceName:          "/dev/sdb",
@@ -34,11 +36,6 @@ func TestBlockDevice(t *testing.T) {
 		LaunchMappings: []BlockDevice{blockDevice},
 	}
 
-	if !reflect.DeepEqual(ec2Mapping, blockDevices.BuildAMIDevices()) {
-		t.Fatalf("bad: %#v", ec2Mapping)
-	}
-
-	if !reflect.DeepEqual(ec2Mapping, blockDevices.BuildLaunchDevices()) {
-		t.Fatalf("bad: %#v", ec2Mapping)
-	}
+	assert.Equal(ec2Mapping, blockDevices.BuildAMIDevices(), "should match output")
+	assert.Equal(ec2Mapping, blockDevices.BuildLaunchDevices(), "should match output")
 }

builder/amazon/common/instance.go

@@ -30,48 +30,17 @@ type StateChangeConf struct {
 	Target    string
 }
 
-// AMIStateRefreshFunc returns a StateRefreshFunc that is used to watch
-// an AMI for state changes.
-func AMIStateRefreshFunc(conn *ec2.EC2, imageId string) StateRefreshFunc {
-	return func() (interface{}, string, error) {
-		resp, err := conn.Images([]string{imageId}, ec2.NewFilter())
-		if err != nil {
-			if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidAMIID.NotFound" {
-				// Set this to nil as if we didn't find anything.
-				resp = nil
-			} else {
-				log.Printf("Error on AMIStateRefresh: %s", err)
-				return nil, "", err
-			}
-		}
-
-		if resp == nil || len(resp.Images) == 0 {
-			// Sometimes AWS has consistency issues and doesn't see the
-			// AMI. Return an empty state.
-			return nil, "", nil
-		}
-
-		i := resp.Images[0]
-		return i, i.State, nil
-	}
-}
-
 // InstanceStateRefreshFunc returns a StateRefreshFunc that is used to watch
 // an EC2 instance.
 func InstanceStateRefreshFunc(conn *ec2.EC2, i *ec2.Instance) StateRefreshFunc {
 	return func() (interface{}, string, error) {
 		resp, err := conn.Instances([]string{i.InstanceId}, ec2.NewFilter())
 		if err != nil {
-			if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidInstanceID.NotFound" {
-				// Set this to nil as if we didn't find anything.
-				resp = nil
-			} else {
-				log.Printf("Error on InstanceStateRefresh: %s", err)
-				return nil, "", err
-			}
+			log.Printf("Error on InstanceStateRefresh: %s", err)
+			return nil, "", err
 		}
 
-		if resp == nil || len(resp.Reservations) == 0 || len(resp.Reservations[0].Instances) == 0 {
+		if len(resp.Reservations) == 0 || len(resp.Reservations[0].Instances) == 0 {
 			// Sometimes AWS just has consistency issues and doesn't see
 			// our instance yet. Return an empty state.
 			return nil, "", nil
@@ -87,8 +56,6 @@ func InstanceStateRefreshFunc(conn *ec2.EC2, i *ec2.Instance) StateRefreshFunc {
 func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 	log.Printf("Waiting for state to become: %s", conf.Target)
 
-	notfoundTick := 0
-
 	for {
 		var currentState string
 		i, currentState, err = conf.Refresh()
@@ -96,17 +63,9 @@ func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 			return
 		}
 
-		if i == nil {
-			// If we didn't find the resource, check if we have been
-			// not finding it for awhile, and if so, report an error.
-			notfoundTick += 1
-			if notfoundTick > 20 {
-				return nil, errors.New("couldn't find resource")
-			}
-		} else {
-			// Reset the counter for when a resource isn't found
-			notfoundTick = 0
-
+		// Check states only if we were able to refresh to an instance
+		// that exists.
+		if i != nil {
 			if currentState == conf.Target {
 				return
 			}

builder/amazon/common/run_config.go

@@ -11,20 +11,18 @@ import (
 // RunConfig contains configuration for running an instance from a source
 // AMI and details on how to access that launched image.
 type RunConfig struct {
-	SourceAmi            string   `mapstructure:"source_ami"`
-	IamInstanceProfile   string   `mapstructure:"iam_instance_profile"`
-	InstanceType         string   `mapstructure:"instance_type"`
-	UserData             string   `mapstructure:"user_data"`
-	UserDataFile         string   `mapstructure:"user_data_file"`
-	RawSSHTimeout        string   `mapstructure:"ssh_timeout"`
-	SSHUsername          string   `mapstructure:"ssh_username"`
-	SSHPort              int      `mapstructure:"ssh_port"`
-	SecurityGroupId      string   `mapstructure:"security_group_id"`
-	SecurityGroupIds     []string `mapstructure:"security_group_ids"`
-	SubnetId             string   `mapstructure:"subnet_id"`
-	TemporaryKeyPairName string   `mapstructure:"temporary_key_pair_name"`
-	VpcId                string   `mapstructure:"vpc_id"`
-	AvailabilityZone     string   `mapstructure:"availability_zone"`
+	SourceAmi            string `mapstructure:"source_ami"`
+	IamInstanceProfile   string `mapstructure:"iam_instance_profile"`
+	InstanceType         string `mapstructure:"instance_type"`
+	UserData             string `mapstructure:"user_data"`
+	UserDataFile         string `mapstructure:"user_data_file"`
+	RawSSHTimeout        string `mapstructure:"ssh_timeout"`
+	SSHUsername          string `mapstructure:"ssh_username"`
+	SSHPort              int    `mapstructure:"ssh_port"`
+	SecurityGroupId      string `mapstructure:"security_group_id"`
+	SubnetId             string `mapstructure:"subnet_id"`
+	TemporaryKeyPairName string `mapstructure:"temporary_key_pair_name"`
+	VpcId                string `mapstructure:"vpc_id"`
 
 	// Unexported fields that are calculated from others
 	sshTimeout time.Duration
@@ -75,25 +73,16 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		}
 	}
 
-	if c.SecurityGroupId != "" {
-		if len(c.SecurityGroupIds) > 0 {
-			errs = append(errs, fmt.Errorf("Only one of security_group_id or security_group_ids can be specified."))
-		} else {
-			c.SecurityGroupIds = []string{c.SecurityGroupId}
-			c.SecurityGroupId = ""
-		}
-	}
-
 	templates := map[string]*string{
 		"iam_instance_profile":    &c.IamInstanceProfile,
 		"instance_type":           &c.InstanceType,
 		"ssh_timeout":             &c.RawSSHTimeout,
+		"security_group_id":       &c.SecurityGroupId,
 		"ssh_username":            &c.SSHUsername,
 		"source_ami":              &c.SourceAmi,
 		"subnet_id":               &c.SubnetId,
 		"temporary_key_pair_name": &c.TemporaryKeyPairName,
 		"vpc_id":                  &c.VpcId,
-		"availability_zone":       &c.AvailabilityZone,
 	}
 
 	for n, ptr := range templates {
@@ -105,21 +94,6 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		}
 	}
 
-	sliceTemplates := map[string][]string{
-		"security_group_ids": c.SecurityGroupIds,
-	}
-
-	for n, slice := range sliceTemplates {
-		for i, elem := range slice {
-			var err error
-			slice[i], err = t.Process(elem, nil)
-			if err != nil {
-				errs = append(
-					errs, fmt.Errorf("Error processing %s[%d]: %s", n, i, err))
-			}
-		}
-	}
-
 	c.sshTimeout, err = time.ParseDuration(c.RawSSHTimeout)
 	if err != nil {
 		errs = append(errs, fmt.Errorf("Failed parsing ssh_timeout: %s", err))

builder/amazon/common/step_ami_region_copy.go

@@ -40,17 +40,8 @@ func (s *StepAMIRegionCopy) Run(state multistep.StateBag) multistep.StepAction {
 			return multistep.ActionHalt
 		}
 
-		stateChange := StateChangeConf{
-			Conn:      regionconn,
-			Pending:   []string{"pending"},
-			Target:    "available",
-			Refresh:   AMIStateRefreshFunc(regionconn, resp.ImageId),
-			StepState: state,
-		}
-
-		ui.Say(fmt.Sprintf("Waiting for AMI (%s) in region (%s) to become ready...",
-			resp.ImageId, region))
-		if _, err := WaitForState(&stateChange); err != nil {
+		ui.Say(fmt.Sprintf("Waiting for AMI (%s) in region (%s) to become ready...", resp.ImageId, region))
+		if err := WaitForAMI(regionconn, resp.ImageId); err != nil {
 			err := fmt.Errorf("Error waiting for AMI (%s) in region (%s): %s", resp.ImageId, region, err)
 			state.Put("error", err)
 			ui.Error(err.Error())

builder/amazon/common/step_run_source_instance.go

@@ -18,7 +18,6 @@ type StepRunSourceInstance struct {
 	SourceAMI          string
 	IamInstanceProfile string
 	SubnetId           string
-	AvailabilityZone   string
 	BlockDevices       BlockDevices
 
 	instance *ec2.Instance
@@ -27,7 +26,7 @@ type StepRunSourceInstance struct {
 func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	keyName := state.Get("keyPair").(string)
-	securityGroupIds := state.Get("securityGroupIds").([]string)
+	securityGroupId := state.Get("securityGroupId").(string)
 	ui := state.Get("ui").(packer.Ui)
 
 	userData := s.UserData
@@ -41,11 +40,6 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 		userData = string(contents)
 	}
 
-	securityGroups := make([]ec2.SecurityGroup, len(securityGroupIds))
-	for n, securityGroupId := range securityGroupIds {
-		securityGroups[n] = ec2.SecurityGroup{Id: securityGroupId}
-	}
-
 	runOpts := &ec2.RunInstances{
 		KeyName:            keyName,
 		ImageId:            s.SourceAMI,
@@ -53,11 +47,10 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 		UserData:           []byte(userData),
 		MinCount:           0,
 		MaxCount:           0,
-		SecurityGroups:     securityGroups,
+		SecurityGroups:     []ec2.SecurityGroup{ec2.SecurityGroup{Id: securityGroupId}},
 		IamInstanceProfile: s.IamInstanceProfile,
 		SubnetId:           s.SubnetId,
 		BlockDevices:       s.BlockDevices.BuildLaunchDevices(),
-		AvailZone:          s.AvailabilityZone,
 	}
 
 	ui.Say("Launching a source AWS instance...")

builder/amazon/common/step_security_group.go

@@ -1,19 +1,20 @@
 package common
 
 import (
+	"cgl.tideland.biz/identifier"
+	"encoding/hex"
 	"fmt"
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"time"
 )
 
 type StepSecurityGroup struct {
-	SecurityGroupIds []string
-	SSHPort          int
-	VpcId            string
+	SecurityGroupId string
+	SSHPort         int
+	VpcId           string
 
 	createdGroupId string
 }
@@ -22,9 +23,9 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
-	if len(s.SecurityGroupIds) > 0 {
-		log.Printf("Using specified security groups: %v", s.SecurityGroupIds)
-		state.Put("securityGroupIds", s.SecurityGroupIds)
+	if s.SecurityGroupId != "" {
+		log.Printf("Using specified security group: %s", s.SecurityGroupId)
+		state.Put("securityGroupId", s.SecurityGroupId)
 		return multistep.ActionContinue
 	}
 
@@ -34,7 +35,7 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Create the group
 	ui.Say("Creating temporary security group for this instance...")
-	groupName := fmt.Sprintf("packer %s", uuid.TimeOrderedUUID())
+	groupName := fmt.Sprintf("packer %s", hex.EncodeToString(identifier.NewUUID().Raw()))
 	log.Printf("Temporary group name: %s", groupName)
 	group := ec2.SecurityGroup{
 		Name:        groupName,
@@ -69,7 +70,7 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	// Set some state data for use in future steps
-	state.Put("securityGroupIds", []string{s.createdGroupId})
+	state.Put("securityGroupId", s.createdGroupId)
 
 	return multistep.ActionContinue
 }

builder/amazon/ebs/builder.go

@@ -33,15 +33,15 @@ type Builder struct {
 	runner multistep.Runner
 }
 
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+func (b *Builder) Prepare(raws ...interface{}) error {
 	md, err := common.DecodeConfig(&b.config, raws...)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	b.config.tpl, err = packer.NewConfigTemplate()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	b.config.tpl.UserVars = b.config.PackerUserVars
 	b.config.tpl.Funcs(awscommon.TemplateFuncs)
@@ -53,11 +53,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
 
 	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
+		return errs
 	}
 
-	log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey))
-	return nil, nil
+	log.Printf("Config: %+v", b.config)
+	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
@@ -88,9 +88,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			KeyPairName:  b.config.TemporaryKeyPairName,
 		},
 		&awscommon.StepSecurityGroup{
-			SecurityGroupIds: b.config.SecurityGroupIds,
-			SSHPort:          b.config.SSHPort,
-			VpcId:            b.config.VpcId,
+			SecurityGroupId: b.config.SecurityGroupId,
+			SSHPort:         b.config.SSHPort,
+			VpcId:           b.config.VpcId,
 		},
 		&awscommon.StepRunSourceInstance{
 			Debug:              b.config.PackerDebug,
@@ -101,7 +101,6 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			SourceAMI:          b.config.SourceAmi,
 			IamInstanceProfile: b.config.IamInstanceProfile,
 			SubnetId:           b.config.SubnetId,
-			AvailabilityZone:   b.config.AvailabilityZone,
 			BlockDevices:       b.config.BlockDevices,
 		},
 		&common.StepConnectSSH{

builder/amazon/ebs/builder_test.go

@@ -31,10 +31,7 @@ func TestBuilder_Prepare_BadType(t *testing.T) {
 		"access_key": []string{},
 	}
 
-	warnings, err := b.Prepare(c)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(c)
 	if err == nil {
 		t.Fatalf("prepare should fail")
 	}
@@ -46,10 +43,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 
 	// Test good
 	config["ami_name"] = "foo"
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -57,10 +51,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 	// Test bad
 	config["ami_name"] = "foo {{"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -68,10 +59,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 	// Test bad
 	delete(config, "ami_name")
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -83,10 +71,7 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 
 	// Add a random key
 	config["i_should_not_be_valid"] = true
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}

builder/amazon/ebs/step_create_ami.go

@@ -39,16 +39,8 @@ func (s *stepCreateAMI) Run(state multistep.StateBag) multistep.StepAction {
 	state.Put("amis", amis)
 
 	// Wait for the image to become ready
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"pending"},
-		Target:    "available",
-		Refresh:   awscommon.AMIStateRefreshFunc(ec2conn, createResp.ImageId),
-		StepState: state,
-	}
-
 	ui.Say("Waiting for AMI to become ready...")
-	if _, err := awscommon.WaitForState(&stateChange); err != nil {
+	if err := awscommon.WaitForAMI(ec2conn, createResp.ImageId); err != nil {
 		err := fmt.Errorf("Error waiting for AMI: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())

builder/amazon/instance/builder.go

@@ -45,15 +45,15 @@ type Builder struct {
 	runner multistep.Runner
 }
 
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+func (b *Builder) Prepare(raws ...interface{}) error {
 	md, err := common.DecodeConfig(&b.config, raws...)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	b.config.tpl, err = packer.NewConfigTemplate()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	b.config.tpl.UserVars = b.config.PackerUserVars
 	b.config.tpl.Funcs(awscommon.TemplateFuncs)
@@ -83,7 +83,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			"-u {{.AccountId}} " +
 			"-c {{.CertPath}} " +
 			"-r {{.Architecture}} " +
-			"-e {{.PrivatePath}}/* " +
+			"-e {{.PrivatePath}} " +
 			"-d {{.Destination}} " +
 			"-p {{.Prefix}} " +
 			"--batch"
@@ -156,11 +156,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
+		return errs
 	}
 
-	log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey))
-	return nil, nil
+	log.Printf("Config: %+v", b.config)
+	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
@@ -191,9 +191,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			KeyPairName:  b.config.TemporaryKeyPairName,
 		},
 		&awscommon.StepSecurityGroup{
-			SecurityGroupIds: b.config.SecurityGroupIds,
-			SSHPort:          b.config.SSHPort,
-			VpcId:            b.config.VpcId,
+			SecurityGroupId: b.config.SecurityGroupId,
+			SSHPort:         b.config.SSHPort,
+			VpcId:           b.config.VpcId,
 		},
 		&awscommon.StepRunSourceInstance{
 			Debug:              b.config.PackerDebug,
@@ -204,7 +204,6 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			UserDataFile:       b.config.UserDataFile,
 			SourceAMI:          b.config.SourceAmi,
 			SubnetId:           b.config.SubnetId,
-			AvailabilityZone:   b.config.AvailabilityZone,
 			BlockDevices:       b.config.BlockDevices,
 		},
 		&common.StepConnectSSH{

builder/amazon/instance/builder_test.go

@@ -40,28 +40,19 @@ func TestBuilderPrepare_AccountId(t *testing.T) {
 	config := testConfig()
 
 	config["account_id"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	config["account_id"] = "foo"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Errorf("err: %s", err)
 	}
 
 	config["account_id"] = "0123-0456-7890"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -77,10 +68,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 
 	// Test good
 	config["ami_name"] = "foo"
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -88,10 +76,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 	// Test bad
 	config["ami_name"] = "foo {{"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -99,10 +84,7 @@ func TestBuilderPrepare_AMIName(t *testing.T) {
 	// Test bad
 	delete(config, "ami_name")
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -113,10 +95,7 @@ func TestBuilderPrepare_BundleDestination(t *testing.T) {
 	config := testConfig()
 
 	config["bundle_destination"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -131,10 +110,7 @@ func TestBuilderPrepare_BundlePrefix(t *testing.T) {
 	config := testConfig()
 
 	config["bundle_prefix"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -150,10 +126,7 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 
 	// Add a random key
 	config["i_should_not_be_valid"] = true
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -164,19 +137,13 @@ func TestBuilderPrepare_S3Bucket(t *testing.T) {
 	config := testConfig()
 
 	config["s3_bucket"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	config["s3_bucket"] = "foo"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Errorf("err: %s", err)
 	}
@@ -187,19 +154,13 @@ func TestBuilderPrepare_X509CertPath(t *testing.T) {
 	config := testConfig()
 
 	config["x509_cert_path"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	config["x509_cert_path"] = "i/am/a/file/that/doesnt/exist"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Error("should have error")
 	}
@@ -211,10 +172,7 @@ func TestBuilderPrepare_X509CertPath(t *testing.T) {
 	defer os.Remove(tf.Name())
 
 	config["x509_cert_path"] = tf.Name()
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -225,19 +183,13 @@ func TestBuilderPrepare_X509KeyPath(t *testing.T) {
 	config := testConfig()
 
 	config["x509_key_path"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	config["x509_key_path"] = "i/am/a/file/that/doesnt/exist"
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Error("should have error")
 	}
@@ -249,10 +201,7 @@ func TestBuilderPrepare_X509KeyPath(t *testing.T) {
 	defer os.Remove(tf.Name())
 
 	config["x509_key_path"] = tf.Name()
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -263,10 +212,7 @@ func TestBuilderPrepare_X509UploadPath(t *testing.T) {
 	config := testConfig()
 
 	config["x509_upload_path"] = ""
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}

builder/amazon/instance/step_register_ami.go

@@ -37,16 +37,8 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 	state.Put("amis", amis)
 
 	// Wait for the image to become ready
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"pending"},
-		Target:    "available",
-		Refresh:   awscommon.AMIStateRefreshFunc(ec2conn, registerResp.ImageId),
-		StepState: state,
-	}
-
 	ui.Say("Waiting for AMI to become ready...")
-	if _, err := awscommon.WaitForState(&stateChange); err != nil {
+	if err := awscommon.WaitForAMI(ec2conn, registerResp.ImageId); err != nil {
 		err := fmt.Errorf("Error waiting for AMI: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())

builder/digitalocean/api.go

@@ -29,15 +29,6 @@ type ImagesResp struct {
 	Images []Image
 }
 
-type Region struct {
-	Id   uint
-	Name string
-}
-
-type RegionsResp struct {
-	Regions []Region
-}
-
 type DigitalOceanClient struct {
 	// The http client for communicating
 	client *http.Client
@@ -236,13 +227,7 @@ func NewRequest(d DigitalOceanClient, path string, params url.Values) (map[strin
 		}
 
 		if status == "ERROR" {
-			statusRaw, ok := decodedResponse["error_message"]
-			if ok {
-				status = statusRaw.(string)
-			} else {
-				status = fmt.Sprintf(
-					"Unknown error. Full response body: %s", body)
-			}
+			status = decodedResponse["error_message"].(string)
 		}
 
 		lastErr = errors.New(fmt.Sprintf("Received error from DigitalOcean (%d): %s",
@@ -261,35 +246,3 @@ func NewRequest(d DigitalOceanClient, path string, params url.Values) (map[strin
 
 	return nil, lastErr
 }
-
-// Returns all available regions.
-func (d DigitalOceanClient) Regions() ([]Region, error) {
-	resp, err := NewRequest(d, "regions", url.Values{})
-	if err != nil {
-		return nil, err
-	}
-
-	var result RegionsResp
-	if err := mapstructure.Decode(resp, &result); err != nil {
-		return nil, err
-	}
-
-	return result.Regions, nil
-}
-
-func (d DigitalOceanClient) RegionName(region_id uint) (string, error) {
-	regions, err := d.Regions()
-	if err != nil {
-		return "", err
-	}
-
-	for _, region := range regions {
-		if region.Id == region_id {
-			return region.Name, nil
-		}
-	}
-
-	err = errors.New(fmt.Sprintf("Unknown region id %v", region_id))
-
-	return "", err
-}

builder/digitalocean/artifact.go

@@ -12,12 +12,6 @@ type Artifact struct {
 	// The ID of the image
 	snapshotId uint
 
-	// The name of the region
-	regionName string
-
-	// The ID of the region
-	regionId uint
-
 	// The client for making API calls
 	client *DigitalOceanClient
 }
@@ -32,15 +26,14 @@ func (*Artifact) Files() []string {
 }
 
 func (a *Artifact) Id() string {
-	// mimicing the aws builder
-	return fmt.Sprintf("%s:%s", a.regionName, a.snapshotName)
+	return a.snapshotName
 }
 
 func (a *Artifact) String() string {
-	return fmt.Sprintf("A snapshot was created: '%v' in region '%v'", a.snapshotName, a.regionName)
+	return fmt.Sprintf("A snapshot was created: %v", a.snapshotName)
 }
 
 func (a *Artifact) Destroy() error {
-	log.Printf("Destroying image: %d (%s)", a.snapshotId, a.snapshotName)
+	log.Printf("Destroying image: %d", a.snapshotId)
 	return a.client.DestroyImage(a.snapshotId)
 }

builder/digitalocean/artifact_test.go

@@ -14,8 +14,8 @@ func TestArtifact_Impl(t *testing.T) {
 }
 
 func TestArtifactString(t *testing.T) {
-	a := &Artifact{"packer-foobar", 42, "San Francisco", 3, nil}
-	expected := "A snapshot was created: 'packer-foobar' in region 'San Francisco'"
+	a := &Artifact{"packer-foobar", 42, nil}
+	expected := "A snapshot was created: packer-foobar"
 
 	if a.String() != expected {
 		t.Fatalf("artifact string should match: %v", expected)

builder/digitalocean/builder.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
@@ -31,7 +30,6 @@ type config struct {
 	ImageID  uint   `mapstructure:"image_id"`
 
 	SnapshotName string `mapstructure:"snapshot_name"`
-	DropletName  string `mapstructure:"droplet_name"`
 	SSHUsername  string `mapstructure:"ssh_username"`
 	SSHPort      uint   `mapstructure:"ssh_port"`
 
@@ -51,15 +49,15 @@ type Builder struct {
 	runner multistep.Runner
 }
 
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+func (b *Builder) Prepare(raws ...interface{}) error {
 	md, err := common.DecodeConfig(&b.config, raws...)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	b.config.tpl, err = packer.NewConfigTemplate()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	b.config.tpl.UserVars = b.config.PackerUserVars
 
@@ -97,11 +95,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.SnapshotName = "packer-{{timestamp}}"
 	}
 
-	if b.config.DropletName == "" {
-		// Default to packer-[time-ordered-uuid]
-		b.config.DropletName = fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID())
-	}
-
 	if b.config.SSHUsername == "" {
 		// Default to "root". You can override this if your
 		// SourceImage has a different user account then the DO default
@@ -128,7 +121,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		"client_id":     &b.config.ClientID,
 		"api_key":       &b.config.APIKey,
 		"snapshot_name": &b.config.SnapshotName,
-		"droplet_name":  &b.config.DropletName,
 		"ssh_username":  &b.config.SSHUsername,
 		"ssh_timeout":   &b.config.RawSSHTimeout,
 		"state_timeout": &b.config.RawStateTimeout,
@@ -169,11 +161,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	b.config.stateTimeout = stateTimeout
 
 	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
+		return errs
 	}
 
-	common.ScrubConfig(b.config, b.config.ClientID, b.config.APIKey)
-	return nil, nil
+	log.Printf("Config: %+v", b.config)
+	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
@@ -225,18 +217,9 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		return nil, nil
 	}
 
-	region_id := state.Get("region_id").(uint)
-
-	regionName, err := client.RegionName(region_id)
-	if err != nil {
-		return nil, err
-	}
-
 	artifact := &Artifact{
 		snapshotName: state.Get("snapshot_name").(string),
 		snapshotId:   state.Get("snapshot_image_id").(uint),
-		regionId:     region_id,
-		regionName:   regionName,
 		client:       client,
 	}
 

builder/digitalocean/builder_test.go

@@ -34,10 +34,7 @@ func TestBuilder_Prepare_BadType(t *testing.T) {
 		"api_key": []string{},
 	}
 
-	warnings, err := b.Prepare(c)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(c)
 	if err == nil {
 		t.Fatalf("prepare should fail")
 	}
@@ -49,10 +46,7 @@ func TestBuilderPrepare_APIKey(t *testing.T) {
 
 	// Test good
 	config["api_key"] = "foo"
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -64,10 +58,7 @@ func TestBuilderPrepare_APIKey(t *testing.T) {
 	// Test bad
 	delete(config, "api_key")
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -76,10 +67,7 @@ func TestBuilderPrepare_APIKey(t *testing.T) {
 	delete(config, "api_key")
 	os.Setenv("DIGITALOCEAN_API_KEY", "foo")
 	defer os.Setenv("DIGITALOCEAN_API_KEY", "")
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -91,10 +79,7 @@ func TestBuilderPrepare_ClientID(t *testing.T) {
 
 	// Test good
 	config["client_id"] = "foo"
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -106,10 +91,7 @@ func TestBuilderPrepare_ClientID(t *testing.T) {
 	// Test bad
 	delete(config, "client_id")
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -118,10 +100,7 @@ func TestBuilderPrepare_ClientID(t *testing.T) {
 	delete(config, "client_id")
 	os.Setenv("DIGITALOCEAN_CLIENT_ID", "foo")
 	defer os.Setenv("DIGITALOCEAN_CLIENT_ID", "")
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -133,10 +112,7 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 
 	// Add a random key
 	config["i_should_not_be_valid"] = true
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -147,10 +123,7 @@ func TestBuilderPrepare_RegionID(t *testing.T) {
 	config := testConfig()
 
 	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -162,10 +135,7 @@ func TestBuilderPrepare_RegionID(t *testing.T) {
 	// Test set
 	config["region_id"] = 2
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -180,10 +150,7 @@ func TestBuilderPrepare_SizeID(t *testing.T) {
 	config := testConfig()
 
 	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -195,10 +162,7 @@ func TestBuilderPrepare_SizeID(t *testing.T) {
 	// Test set
 	config["size_id"] = 67
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -213,10 +177,7 @@ func TestBuilderPrepare_ImageID(t *testing.T) {
 	config := testConfig()
 
 	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -228,10 +189,7 @@ func TestBuilderPrepare_ImageID(t *testing.T) {
 	// Test set
 	config["size_id"] = 2
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -246,10 +204,7 @@ func TestBuilderPrepare_SSHUsername(t *testing.T) {
 	config := testConfig()
 
 	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -261,10 +216,7 @@ func TestBuilderPrepare_SSHUsername(t *testing.T) {
 	// Test set
 	config["ssh_username"] = "foo"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -279,10 +231,7 @@ func TestBuilderPrepare_SSHTimeout(t *testing.T) {
 	config := testConfig()
 
 	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -294,10 +243,7 @@ func TestBuilderPrepare_SSHTimeout(t *testing.T) {
 	// Test set
 	config["ssh_timeout"] = "30s"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -305,10 +251,7 @@ func TestBuilderPrepare_SSHTimeout(t *testing.T) {
 	// Test bad
 	config["ssh_timeout"] = "tubes"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -320,10 +263,7 @@ func TestBuilderPrepare_StateTimeout(t *testing.T) {
 	config := testConfig()
 
 	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -335,10 +275,7 @@ func TestBuilderPrepare_StateTimeout(t *testing.T) {
 	// Test set
 	config["state_timeout"] = "5m"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -346,10 +283,7 @@ func TestBuilderPrepare_StateTimeout(t *testing.T) {
 	// Test bad
 	config["state_timeout"] = "tubes"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -361,10 +295,7 @@ func TestBuilderPrepare_SnapshotName(t *testing.T) {
 	config := testConfig()
 
 	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -376,10 +307,7 @@ func TestBuilderPrepare_SnapshotName(t *testing.T) {
 	// Test set
 	config["snapshot_name"] = "foobarbaz"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -387,10 +315,7 @@ func TestBuilderPrepare_SnapshotName(t *testing.T) {
 	// Test set with template
 	config["snapshot_name"] = "{{timestamp}}"
 	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -401,55 +326,3 @@ func TestBuilderPrepare_SnapshotName(t *testing.T) {
 	}
 
 }
-
-func TestBuilderPrepare_DropletName(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test default
-	warnings, err := b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.DropletName == "" {
-		t.Errorf("invalid: %s", b.config.DropletName)
-	}
-
-	// Test normal set
-	config["droplet_name"] = "foobar"
-	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	// Test with template
-	config["droplet_name"] = "foobar-{{timestamp}}"
-	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	// Test with bad template
-	config["droplet_name"] = "foobar-{{"
-	b = Builder{}
-	warnings, err = b.Prepare(config)
-	if len(warnings) > 0 {
-		t.Fatalf("bad: %#v", warnings)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-}

builder/digitalocean/step_create_droplet.go

@@ -1,6 +1,8 @@
 package digitalocean
 
 import (
+	"cgl.tideland.biz/identifier"
+	"encoding/hex"
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
@@ -18,9 +20,11 @@ func (s *stepCreateDroplet) Run(state multistep.StateBag) multistep.StepAction {
 
 	ui.Say("Creating droplet...")
 
-	// Create the droplet based on configuration
-	dropletId, err := client.CreateDroplet(c.DropletName, c.SizeID, c.ImageID, c.RegionID, sshKeyId)
+	// Some random droplet name as it's temporary
+	name := fmt.Sprintf("packer-%s", hex.EncodeToString(identifier.NewUUID().Raw()))
 
+	// Create the droplet based on configuration
+	dropletId, err := client.CreateDroplet(name, c.SizeID, c.ImageID, c.RegionID, sshKeyId)
 	if err != nil {
 		err := fmt.Errorf("Error creating droplet: %s", err)
 		state.Put("error", err)

builder/digitalocean/step_create_ssh_key.go

@@ -1,14 +1,15 @@
 package digitalocean
 
 import (
+	"cgl.tideland.biz/identifier"
 	"code.google.com/p/go.crypto/ssh"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/x509"
+	"encoding/hex"
 	"encoding/pem"
 	"fmt"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
 	"log"
 )
@@ -37,12 +38,11 @@ func (s *stepCreateSSHKey) Run(state multistep.StateBag) multistep.StepAction {
 	state.Put("privateKey", string(pem.EncodeToMemory(&priv_blk)))
 
 	// Marshal the public key into SSH compatible format
-	// TODO properly handle the public key error
-	pub, _ := ssh.NewPublicKey(&priv.PublicKey)
-	pub_sshformat := string(ssh.MarshalAuthorizedKey(pub))
+	pub := priv.PublicKey
+	pub_sshformat := string(ssh.MarshalAuthorizedKey(&pub))
 
 	// The name of the public key on DO
-	name := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID())
+	name := fmt.Sprintf("packer-%s", hex.EncodeToString(identifier.NewUUID().Raw()))
 
 	// Create the key!
 	keyId, err := client.CreateKey(name, pub_sshformat)

builder/digitalocean/step_snapshot.go

@@ -62,7 +62,6 @@ func (s *stepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 
 	state.Put("snapshot_image_id", imageId)
 	state.Put("snapshot_name", c.SnapshotName)
-	state.Put("region_id", c.RegionID)
 
 	return multistep.ActionContinue
 }

builder/digitalocean/wait.go

@@ -44,7 +44,7 @@ func waitForDropletState(desiredState string, dropletId uint, client *DigitalOce
 		}
 	}()
 
-	log.Printf("Waiting for up to %d seconds for droplet to become %s", timeout/time.Second, desiredState)
+	log.Printf("Waiting for up to %d seconds for droplet to become %s", timeout, desiredState)
 	select {
 	case err := <-result:
 		return err

builder/docker/artifact_export.go

@@ -1,32 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"os"
-)
-
-// ExportArtifact is an Artifact implementation for when a container is
-// exported from docker into a single flat file.
-type ExportArtifact struct {
-	path string
-}
-
-func (*ExportArtifact) BuilderId() string {
-	return BuilderId
-}
-
-func (a *ExportArtifact) Files() []string {
-	return []string{a.path}
-}
-
-func (*ExportArtifact) Id() string {
-	return "Container"
-}
-
-func (a *ExportArtifact) String() string {
-	return fmt.Sprintf("Exported Docker file: %s", a.path)
-}
-
-func (a *ExportArtifact) Destroy() error {
-	return os.Remove(a.path)
-}

builder/docker/artifact_export_test.go

@@ -1,10 +0,0 @@
-package docker
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func TestExportArtifact_impl(t *testing.T) {
-	var _ packer.Artifact = new(ExportArtifact)
-}

builder/docker/builder.go

@@ -1,77 +0,0 @@
-package docker
-
-import (
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-const BuilderId = "packer.docker"
-
-type Builder struct {
-	config *Config
-	runner multistep.Runner
-}
-
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
-	c, warnings, errs := NewConfig(raws...)
-	if errs != nil {
-		return warnings, errs
-	}
-	b.config = c
-
-	return warnings, nil
-}
-
-func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-	driver := &DockerDriver{Ui: ui}
-	if err := driver.Verify(); err != nil {
-		return nil, err
-	}
-
-	steps := []multistep.Step{
-		&StepTempDir{},
-		&StepPull{},
-		&StepRun{},
-		&StepProvision{},
-		&StepExport{},
-	}
-
-	// Setup the state bag and initial state for the steps
-	state := new(multistep.BasicStateBag)
-	state.Put("config", b.config)
-	state.Put("hook", hook)
-	state.Put("ui", ui)
-
-	// Setup the driver that will talk to Docker
-	state.Put("driver", driver)
-
-	// Run!
-	if b.config.PackerDebug {
-		b.runner = &multistep.DebugRunner{
-			Steps:   steps,
-			PauseFn: common.MultistepDebugFn(ui),
-		}
-	} else {
-		b.runner = &multistep.BasicRunner{Steps: steps}
-	}
-
-	b.runner.Run(state)
-
-	// If there was an error, return that
-	if rawErr, ok := state.GetOk("error"); ok {
-		return nil, rawErr.(error)
-	}
-
-	// No errors, must've worked
-	artifact := &ExportArtifact{path: b.config.ExportPath}
-	return artifact, nil
-}
-
-func (b *Builder) Cancel() {
-	if b.runner != nil {
-		log.Println("Cancelling the step runner...")
-		b.runner.Cancel()
-	}
-}

builder/docker/builder_test.go

@@ -1,10 +0,0 @@
-package docker
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func TestBuilder_implBuilder(t *testing.T) {
-	var _ packer.Builder = new(Builder)
-}

builder/docker/communicator.go

@@ -1,290 +0,0 @@
-package docker
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/ActiveState/tail"
-	"github.com/mitchellh/packer/packer"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"sync"
-	"syscall"
-	"time"
-)
-
-type Communicator struct {
-	ContainerId  string
-	HostDir      string
-	ContainerDir string
-
-	lock sync.Mutex
-}
-
-func (c *Communicator) Start(remote *packer.RemoteCmd) error {
-	// Create a temporary file to store the output. Because of a bug in
-	// Docker, sometimes all the output doesn't properly show up. This
-	// file will capture ALL of the output, and we'll read that.
-	//
-	// https://github.com/dotcloud/docker/issues/2625
-	outputFile, err := ioutil.TempFile(c.HostDir, "cmd")
-	if err != nil {
-		return err
-	}
-	outputFile.Close()
-
-	// This file will store the exit code of the command once it is complete.
-	exitCodePath := outputFile.Name() + "-exit"
-
-	cmd := exec.Command("docker", "attach", c.ContainerId)
-	stdin_w, err := cmd.StdinPipe()
-	if err != nil {
-		// We have to do some cleanup since run was never called
-		os.Remove(outputFile.Name())
-		os.Remove(exitCodePath)
-
-		return err
-	}
-
-	// Run the actual command in a goroutine so that Start doesn't block
-	go c.run(cmd, remote, stdin_w, outputFile, exitCodePath)
-
-	return nil
-}
-
-func (c *Communicator) Upload(dst string, src io.Reader) error {
-	// Create a temporary file to store the upload
-	tempfile, err := ioutil.TempFile(c.HostDir, "upload")
-	if err != nil {
-		return err
-	}
-	defer os.Remove(tempfile.Name())
-
-	// Copy the contents to the temporary file
-	_, err = io.Copy(tempfile, src)
-	tempfile.Close()
-	if err != nil {
-		return err
-	}
-
-	// Copy the file into place by copying the temporary file we put
-	// into the shared folder into the proper location in the container
-	cmd := &packer.RemoteCmd{
-		Command: fmt.Sprintf("cp %s/%s %s", c.ContainerDir,
-			filepath.Base(tempfile.Name()), dst),
-	}
-
-	if err := c.Start(cmd); err != nil {
-		return err
-	}
-
-	// Wait for the copy to complete
-	cmd.Wait()
-	if cmd.ExitStatus != 0 {
-		return fmt.Errorf("Upload failed with non-zero exit status: %d", cmd.ExitStatus)
-	}
-
-	return nil
-}
-
-func (c *Communicator) UploadDir(dst string, src string, exclude []string) error {
-	// Create the temporary directory that will store the contents of "src"
-	// for copying into the container.
-	td, err := ioutil.TempDir(c.HostDir, "dirupload")
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(td)
-
-	walkFn := func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		relpath, err := filepath.Rel(src, path)
-		if err != nil {
-			return err
-		}
-		hostpath := filepath.Join(td, relpath)
-
-		// If it is a directory, just create it
-		if info.IsDir() {
-			return os.MkdirAll(hostpath, info.Mode())
-		}
-
-		// It is a file, copy it over, including mode.
-		src, err := os.Open(path)
-		if err != nil {
-			return err
-		}
-		defer src.Close()
-
-		dst, err := os.Create(hostpath)
-		if err != nil {
-			return err
-		}
-		defer dst.Close()
-
-		if _, err := io.Copy(dst, src); err != nil {
-			return err
-		}
-
-		si, err := src.Stat()
-		if err != nil {
-			return err
-		}
-
-		return dst.Chmod(si.Mode())
-	}
-
-	// Copy the entire directory tree to the temporary directory
-	if err := filepath.Walk(src, walkFn); err != nil {
-		return err
-	}
-
-	// Determine the destination directory
-	containerSrc := filepath.Join(c.ContainerDir, filepath.Base(td))
-	containerDst := dst
-	if src[len(src)-1] != '/' {
-		containerDst = filepath.Join(dst, filepath.Base(src))
-	}
-
-	// Make the directory, then copy into it
-	cmd := &packer.RemoteCmd{
-		Command: fmt.Sprintf("set -e; mkdir -p %s; cp -R %s/* %s",
-			containerDst, containerSrc, containerDst),
-	}
-	if err := c.Start(cmd); err != nil {
-		return err
-	}
-
-	// Wait for the copy to complete
-	cmd.Wait()
-	if cmd.ExitStatus != 0 {
-		return fmt.Errorf("Upload failed with non-zero exit status: %d", cmd.ExitStatus)
-	}
-
-	return nil
-}
-
-func (c *Communicator) Download(src string, dst io.Writer) error {
-	panic("not implemented")
-}
-
-// Runs the given command and blocks until completion
-func (c *Communicator) run(cmd *exec.Cmd, remote *packer.RemoteCmd, stdin_w io.WriteCloser, outputFile *os.File, exitCodePath string) {
-	// For Docker, remote communication must be serialized since it
-	// only supports single execution.
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	// Clean up after ourselves by removing our temporary files
-	defer os.Remove(outputFile.Name())
-	defer os.Remove(exitCodePath)
-
-	// Tail the output file and send the data to the stdout listener
-	tail, err := tail.TailFile(outputFile.Name(), tail.Config{
-		Poll:   true,
-		ReOpen: true,
-		Follow: true,
-	})
-	if err != nil {
-		log.Printf("Error tailing output file: %s", err)
-		remote.SetExited(254)
-		return
-	}
-	defer tail.Stop()
-
-	// Modify the remote command so that all the output of the commands
-	// go to a single file and so that the exit code is redirected to
-	// a single file. This lets us determine both when the command
-	// is truly complete (because the file will have data), what the
-	// exit status is (because Docker loses it because of the pty, not
-	// Docker's fault), and get the output (Docker bug).
-	remoteCmd := fmt.Sprintf("(%s) >%s 2>&1; echo $? >%s",
-		remote.Command,
-		filepath.Join(c.ContainerDir, filepath.Base(outputFile.Name())),
-		filepath.Join(c.ContainerDir, filepath.Base(exitCodePath)))
-
-	// Start the command
-	log.Printf("Executing in container %s: %#v", c.ContainerId, remoteCmd)
-	if err := cmd.Start(); err != nil {
-		log.Printf("Error executing: %s", err)
-		remote.SetExited(254)
-		return
-	}
-
-	go func() {
-		defer stdin_w.Close()
-
-		// This sleep needs to be here because of the issue linked to below.
-		// Basically, without it, Docker will hang on reading stdin forever,
-		// and won't see what we write, for some reason.
-		//
-		// https://github.com/dotcloud/docker/issues/2628
-		time.Sleep(2 * time.Second)
-
-		stdin_w.Write([]byte(remoteCmd + "\n"))
-	}()
-
-	// Start a goroutine to read all the lines out of the logs
-	go func() {
-		for line := range tail.Lines {
-			if remote.Stdout != nil {
-				remote.Stdout.Write([]byte(line.Text + "\n"))
-			} else {
-				log.Printf("Command stdout: %#v", line.Text)
-			}
-		}
-	}()
-
-	err = cmd.Wait()
-	if exitErr, ok := err.(*exec.ExitError); ok {
-		exitStatus := 1
-
-		// There is no process-independent way to get the REAL
-		// exit status so we just try to go deeper.
-		if status, ok := exitErr.Sys().(syscall.WaitStatus); ok {
-			exitStatus = status.ExitStatus()
-		}
-
-		// Say that we ended, since if Docker itself failed, then
-		// the command must've not run, or so we assume
-		remote.SetExited(exitStatus)
-		return
-	}
-
-	// Wait for the exit code to appear in our file...
-	log.Println("Waiting for exit code to appear for remote command...")
-	for {
-		fi, err := os.Stat(exitCodePath)
-		if err == nil && fi.Size() > 0 {
-			break
-		}
-
-		time.Sleep(1 * time.Second)
-	}
-
-	// Read the exit code
-	exitRaw, err := ioutil.ReadFile(exitCodePath)
-	if err != nil {
-		log.Printf("Error executing: %s", err)
-		remote.SetExited(254)
-		return
-	}
-
-	exitStatus, err := strconv.ParseInt(string(bytes.TrimSpace(exitRaw)), 10, 0)
-	if err != nil {
-		log.Printf("Error executing: %s", err)
-		remote.SetExited(254)
-		return
-	}
-	log.Printf("Executed command exit status: %d", exitStatus)
-
-	// Finally, we're done
-	remote.SetExited(int(exitStatus))
-}

builder/docker/communicator_test.go

@@ -1,10 +0,0 @@
-package docker
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func TestCommunicator_impl(t *testing.T) {
-	var _ packer.Communicator = new(Communicator)
-}

builder/docker/config.go

@@ -1,75 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-)
-
-type Config struct {
-	common.PackerConfig `mapstructure:",squash"`
-
-	ExportPath string `mapstructure:"export_path"`
-	Image      string
-	Pull       bool
-
-	tpl *packer.ConfigTemplate
-}
-
-func NewConfig(raws ...interface{}) (*Config, []string, error) {
-	c := new(Config)
-	md, err := common.DecodeConfig(c, raws...)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	c.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// Default Pull if it wasn't set
-	hasPull := false
-	for _, k := range md.Keys {
-		if k == "Pull" {
-			hasPull = true
-			break
-		}
-	}
-
-	if !hasPull {
-		c.Pull = true
-	}
-
-	errs := common.CheckUnusedConfig(md)
-
-	templates := map[string]*string{
-		"export_path": &c.ExportPath,
-		"image":       &c.Image,
-	}
-
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = c.tpl.Process(*ptr, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
-	if c.ExportPath == "" {
-		errs = packer.MultiErrorAppend(errs,
-			fmt.Errorf("export_path must be specified"))
-	}
-
-	if c.Image == "" {
-		errs = packer.MultiErrorAppend(errs,
-			fmt.Errorf("image must be specified"))
-	}
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return nil, nil, errs
-	}
-
-	return c, nil, nil
-}

builder/docker/config_test.go

@@ -1,90 +0,0 @@
-package docker
-
-import (
-	"testing"
-)
-
-func testConfig() map[string]interface{} {
-	return map[string]interface{}{
-		"export_path": "foo",
-		"image":       "bar",
-	}
-}
-
-func testConfigStruct(t *testing.T) *Config {
-	c, warns, errs := NewConfig(testConfig())
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", len(warns))
-	}
-	if errs != nil {
-		t.Fatalf("bad: %#v", errs)
-	}
-
-	return c
-}
-
-func testConfigErr(t *testing.T, warns []string, err error) {
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should error")
-	}
-}
-
-func testConfigOk(t *testing.T, warns []string, err error) {
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-}
-
-func TestConfigPrepare_exportPath(t *testing.T) {
-	raw := testConfig()
-
-	// No export path
-	delete(raw, "export_path")
-	_, warns, errs := NewConfig(raw)
-	testConfigErr(t, warns, errs)
-
-	// Good export path
-	raw["export_path"] = "good"
-	_, warns, errs = NewConfig(raw)
-	testConfigOk(t, warns, errs)
-}
-
-func TestConfigPrepare_image(t *testing.T) {
-	raw := testConfig()
-
-	// No image
-	delete(raw, "image")
-	_, warns, errs := NewConfig(raw)
-	testConfigErr(t, warns, errs)
-
-	// Good image
-	raw["image"] = "path"
-	_, warns, errs = NewConfig(raw)
-	testConfigOk(t, warns, errs)
-}
-
-func TestConfigPrepare_pull(t *testing.T) {
-	raw := testConfig()
-
-	// No pull set
-	delete(raw, "pull")
-	c, warns, errs := NewConfig(raw)
-	testConfigOk(t, warns, errs)
-	if !c.Pull {
-		t.Fatal("should pull by default")
-	}
-
-	// Pull set
-	raw["pull"] = false
-	c, warns, errs = NewConfig(raw)
-	testConfigOk(t, warns, errs)
-	if c.Pull {
-		t.Fatal("should not pull")
-	}
-}

builder/docker/driver.go

@@ -1,32 +0,0 @@
-package docker
-
-import (
-	"io"
-)
-
-// Driver is the interface that has to be implemented to communicate with
-// Docker. The Driver interface also allows the steps to be tested since
-// a mock driver can be shimmed in.
-type Driver interface {
-	// Export exports the container with the given ID to the given writer.
-	Export(id string, dst io.Writer) error
-
-	// Pull should pull down the given image.
-	Pull(image string) error
-
-	// StartContainer starts a container and returns the ID for that container,
-	// along with a potential error.
-	StartContainer(*ContainerConfig) (string, error)
-
-	// StopContainer forcibly stops a container.
-	StopContainer(id string) error
-
-	// Verify verifies that the driver can run
-	Verify() error
-}
-
-// ContainerConfig is the configuration used to start a container.
-type ContainerConfig struct {
-	Image   string
-	Volumes map[string]string
-}

builder/docker/driver_docker.go

@@ -1,92 +0,0 @@
-package docker
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/mitchellh/packer/packer"
-	"io"
-	"log"
-	"os/exec"
-	"strings"
-)
-
-type DockerDriver struct {
-	Ui packer.Ui
-}
-
-func (d *DockerDriver) Export(id string, dst io.Writer) error {
-	var stderr bytes.Buffer
-	cmd := exec.Command("docker", "export", id)
-	cmd.Stdout = dst
-	cmd.Stderr = &stderr
-
-	log.Printf("Exporting container: %s", id)
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	if err := cmd.Wait(); err != nil {
-		err = fmt.Errorf("Error exporting: %s\nStderr: %s",
-			err, stderr.String())
-		return err
-	}
-
-	return nil
-}
-
-func (d *DockerDriver) Pull(image string) error {
-	cmd := exec.Command("docker", "pull", image)
-	return runAndStream(cmd, d.Ui)
-}
-
-func (d *DockerDriver) StartContainer(config *ContainerConfig) (string, error) {
-	// Args that we're going to pass to Docker
-	args := []string{"run", "-d", "-i", "-t"}
-
-	if len(config.Volumes) > 0 {
-		volumes := make([]string, 0, len(config.Volumes))
-		for host, guest := range config.Volumes {
-			volumes = append(volumes, fmt.Sprintf("%s:%s", host, guest))
-		}
-
-		args = append(args, "-v", strings.Join(volumes, ","))
-	}
-
-	args = append(args, config.Image, "/bin/bash")
-
-	// Start the container
-	var stdout, stderr bytes.Buffer
-	cmd := exec.Command("docker", args...)
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	log.Printf("Starting container with args: %v", args)
-	if err := cmd.Start(); err != nil {
-		return "", err
-	}
-
-	log.Println("Waiting for container to finish starting")
-	if err := cmd.Wait(); err != nil {
-		if _, ok := err.(*exec.ExitError); ok {
-			err = fmt.Errorf("Docker exited with a non-zero exit status.\nStderr: %s",
-				stderr.String())
-		}
-
-		return "", err
-	}
-
-	// Capture the container ID, which is alone on stdout
-	return strings.TrimSpace(stdout.String()), nil
-}
-
-func (d *DockerDriver) StopContainer(id string) error {
-	return exec.Command("docker", "kill", id).Run()
-}
-
-func (d *DockerDriver) Verify() error {
-	if _, err := exec.LookPath("docker"); err != nil {
-		return err
-	}
-
-	return nil
-}

builder/docker/driver_mock.go

@@ -1,63 +0,0 @@
-package docker
-
-import (
-	"io"
-)
-
-// MockDriver is a driver implementation that can be used for tests.
-type MockDriver struct {
-	ExportReader io.Reader
-	ExportError  error
-	PullError    error
-	StartID      string
-	StartError   error
-	StopError    error
-	VerifyError  error
-
-	ExportCalled bool
-	ExportID     string
-	PullCalled   bool
-	PullImage    string
-	StartCalled  bool
-	StartConfig  *ContainerConfig
-	StopCalled   bool
-	StopID       string
-	VerifyCalled bool
-}
-
-func (d *MockDriver) Export(id string, dst io.Writer) error {
-	d.ExportCalled = true
-	d.ExportID = id
-
-	if d.ExportReader != nil {
-		_, err := io.Copy(dst, d.ExportReader)
-		if err != nil {
-			return err
-		}
-	}
-
-	return d.ExportError
-}
-
-func (d *MockDriver) Pull(image string) error {
-	d.PullCalled = true
-	d.PullImage = image
-	return d.PullError
-}
-
-func (d *MockDriver) StartContainer(config *ContainerConfig) (string, error) {
-	d.StartCalled = true
-	d.StartConfig = config
-	return d.StartID, d.StartError
-}
-
-func (d *MockDriver) StopContainer(id string) error {
-	d.StopCalled = true
-	d.StopID = id
-	return d.StopError
-}
-
-func (d *MockDriver) Verify() error {
-	d.VerifyCalled = true
-	return d.VerifyError
-}

builder/docker/driver_mock_test.go

@@ -1,7 +0,0 @@
-package docker
-
-import "testing"
-
-func TestMockDriver_impl(t *testing.T) {
-	var _ Driver = new(MockDriver)
-}

builder/docker/drover_docker_test.go

@@ -1,7 +0,0 @@
-package docker
-
-import "testing"
-
-func TestDockerDriver_impl(t *testing.T) {
-	var _ Driver = new(DockerDriver)
-}

builder/docker/exec.go

@@ -1,102 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"github.com/mitchellh/iochan"
-	"github.com/mitchellh/packer/packer"
-	"io"
-	"log"
-	"os/exec"
-	"regexp"
-	"strings"
-	"sync"
-	"syscall"
-)
-
-func runAndStream(cmd *exec.Cmd, ui packer.Ui) error {
-	stdout_r, stdout_w := io.Pipe()
-	stderr_r, stderr_w := io.Pipe()
-	defer stdout_w.Close()
-	defer stderr_w.Close()
-
-	log.Printf("Executing: %s %v", cmd.Path, cmd.Args[1:])
-	cmd.Stdout = stdout_w
-	cmd.Stderr = stderr_w
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	// Create the channels we'll use for data
-	exitCh := make(chan int, 1)
-	stdoutCh := iochan.DelimReader(stdout_r, '\n')
-	stderrCh := iochan.DelimReader(stderr_r, '\n')
-
-	// Start the goroutine to watch for the exit
-	go func() {
-		defer stdout_w.Close()
-		defer stderr_w.Close()
-		exitStatus := 0
-
-		err := cmd.Wait()
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			exitStatus = 1
-
-			// There is no process-independent way to get the REAL
-			// exit status so we just try to go deeper.
-			if status, ok := exitErr.Sys().(syscall.WaitStatus); ok {
-				exitStatus = status.ExitStatus()
-			}
-		}
-
-		exitCh <- exitStatus
-	}()
-
-	// This waitgroup waits for the streaming to end
-	var streamWg sync.WaitGroup
-	streamWg.Add(2)
-
-	streamFunc := func(ch <-chan string) {
-		defer streamWg.Done()
-
-		for data := range ch {
-			data = cleanOutputLine(data)
-			if data != "" {
-				ui.Message(data)
-			}
-		}
-	}
-
-	// Stream stderr/stdout
-	go streamFunc(stderrCh)
-	go streamFunc(stdoutCh)
-
-	// Wait for the process to end and then wait for the streaming to end
-	exitStatus := <-exitCh
-	streamWg.Wait()
-
-	if exitStatus != 0 {
-		return fmt.Errorf("Bad exit status: %d", exitStatus)
-	}
-
-	return nil
-}
-
-// cleanOutputLine cleans up a line so that '\r' don't muck up the
-// UI output when we're reading from a remote command.
-func cleanOutputLine(line string) string {
-	// Build a regular expression that will get rid of shell codes
-	re := regexp.MustCompile("(?i)\x1b\\[([0-9]{1,2}(;[0-9]{1,2})?)?[a|b|m|k]")
-	line = re.ReplaceAllString(line, "")
-
-	// Trim surrounding whitespace
-	line = strings.TrimSpace(line)
-
-	// Trim up to the first carriage return, since that text would be
-	// lost anyways.
-	idx := strings.LastIndex(line, "\r")
-	if idx > -1 {
-		line = line[idx+1:]
-	}
-
-	return line
-}

builder/docker/exec_test.go

@@ -1,24 +0,0 @@
-package docker
-
-import (
-	"testing"
-)
-
-func TestCleanLine(t *testing.T) {
-	cases := []struct {
-		input  string
-		output string
-	}{
-		{
-			"\x1b[0A\x1b[2K\r8dbd9e392a96: Pulling image (precise) from ubuntu\r\x1b[0B\x1b[1A\x1b[2K\r8dbd9e392a96: Pulling image (precise) from ubuntu, endpoint: https://cdn-registry-1.docker.io/v1/\r\x1b[1B",
-			"8dbd9e392a96: Pulling image (precise) from ubuntu, endpoint: https://cdn-registry-1.docker.io/v1/",
-		},
-	}
-
-	for _, tc := range cases {
-		actual := cleanOutputLine(tc.input)
-		if actual != tc.output {
-			t.Fatalf("bad: %#v %#v", tc.input, actual)
-		}
-	}
-}

builder/docker/step_export.go

@@ -1,42 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"os"
-)
-
-// StepExport exports the container to a flat tar file.
-type StepExport struct{}
-
-func (s *StepExport) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(Driver)
-	containerId := state.Get("container_id").(string)
-	ui := state.Get("ui").(packer.Ui)
-
-	// Open the file that we're going to write to
-	f, err := os.Create(config.ExportPath)
-	if err != nil {
-		err := fmt.Errorf("Error creating output file: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Say("Exporting the container")
-	if err := driver.Export(containerId, f); err != nil {
-		f.Close()
-		os.Remove(f.Name())
-
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	f.Close()
-	return multistep.ActionContinue
-}
-
-func (s *StepExport) Cleanup(state multistep.StateBag) {}

builder/docker/step_export_test.go

@@ -1,99 +0,0 @@
-package docker
-
-import (
-	"bytes"
-	"errors"
-	"github.com/mitchellh/multistep"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-func testStepExportState(t *testing.T) multistep.StateBag {
-	state := testState(t)
-	state.Put("container_id", "foo")
-	return state
-}
-
-func TestStepExport_impl(t *testing.T) {
-	var _ multistep.Step = new(StepExport)
-}
-
-func TestStepExport(t *testing.T) {
-	state := testStepExportState(t)
-	step := new(StepExport)
-	defer step.Cleanup(state)
-
-	// Create a tempfile for our output path
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	tf.Close()
-	defer os.Remove(tf.Name())
-
-	config := state.Get("config").(*Config)
-	config.ExportPath = tf.Name()
-	driver := state.Get("driver").(*MockDriver)
-	driver.ExportReader = bytes.NewReader([]byte("data!"))
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// verify we did the right thing
-	if !driver.ExportCalled {
-		t.Fatal("should've exported")
-	}
-	if driver.ExportID != "foo" {
-		t.Fatalf("bad: %#v", driver.ExportID)
-	}
-
-	// verify the data exported to the file
-	contents, err := ioutil.ReadFile(tf.Name())
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if string(contents) != "data!" {
-		t.Fatalf("bad: %#v", string(contents))
-	}
-}
-
-func TestStepExport_error(t *testing.T) {
-	state := testStepExportState(t)
-	step := new(StepExport)
-	defer step.Cleanup(state)
-
-	// Create a tempfile for our output path
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	tf.Close()
-
-	if err := os.Remove(tf.Name()); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	config := state.Get("config").(*Config)
-	config.ExportPath = tf.Name()
-	driver := state.Get("driver").(*MockDriver)
-	driver.ExportError = errors.New("foo")
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// verify we have an error
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-
-	// verify we didn't make that file
-	if _, err := os.Stat(tf.Name()); err == nil {
-		t.Fatal("export path shouldn't exist")
-	}
-}

builder/docker/step_provision.go

@@ -1,26 +0,0 @@
-package docker
-
-import (
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
-)
-
-type StepProvision struct{}
-
-func (s *StepProvision) Run(state multistep.StateBag) multistep.StepAction {
-	containerId := state.Get("container_id").(string)
-	tempDir := state.Get("temp_dir").(string)
-
-	// Create the communicator that talks to Docker via various
-	// os/exec tricks.
-	comm := &Communicator{
-		ContainerId:  containerId,
-		HostDir:      tempDir,
-		ContainerDir: "/packer-files",
-	}
-
-	prov := common.StepProvision{Comm: comm}
-	return prov.Run(state)
-}
-
-func (s *StepProvision) Cleanup(state multistep.StateBag) {}

builder/docker/step_pull.go

@@ -1,34 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-type StepPull struct{}
-
-func (s *StepPull) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	if !config.Pull {
-		log.Println("Pull disabled, won't docker pull")
-		return multistep.ActionContinue
-	}
-
-	ui.Say(fmt.Sprintf("Pulling Docker image: %s", config.Image))
-	if err := driver.Pull(config.Image); err != nil {
-		err := fmt.Errorf("Error pulling Docker image: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepPull) Cleanup(state multistep.StateBag) {
-}

builder/docker/step_pull_test.go

@@ -1,73 +0,0 @@
-package docker
-
-import (
-	"errors"
-	"github.com/mitchellh/multistep"
-	"testing"
-)
-
-func TestStepPull_impl(t *testing.T) {
-	var _ multistep.Step = new(StepPull)
-}
-
-func TestStepPull(t *testing.T) {
-	state := testState(t)
-	step := new(StepPull)
-	defer step.Cleanup(state)
-
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(*MockDriver)
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// verify we did the right thing
-	if !driver.PullCalled {
-		t.Fatal("should've pulled")
-	}
-	if driver.PullImage != config.Image {
-		t.Fatalf("bad: %#v", driver.PullImage)
-	}
-}
-
-func TestStepPull_error(t *testing.T) {
-	state := testState(t)
-	step := new(StepPull)
-	defer step.Cleanup(state)
-
-	driver := state.Get("driver").(*MockDriver)
-	driver.PullError = errors.New("foo")
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// verify we have an error
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-}
-
-func TestStepPull_noPull(t *testing.T) {
-	state := testState(t)
-	step := new(StepPull)
-	defer step.Cleanup(state)
-
-	config := state.Get("config").(*Config)
-	config.Pull = false
-
-	driver := state.Get("driver").(*MockDriver)
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// verify we did the right thing
-	if driver.PullCalled {
-		t.Fatal("shouldn't have pulled")
-	}
-}

builder/docker/step_run.go

@@ -1,58 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-type StepRun struct {
-	containerId string
-}
-
-func (s *StepRun) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(Driver)
-	tempDir := state.Get("temp_dir").(string)
-	ui := state.Get("ui").(packer.Ui)
-
-	runConfig := ContainerConfig{
-		Image: config.Image,
-		Volumes: map[string]string{
-			tempDir: "/packer-files",
-		},
-	}
-
-	ui.Say("Starting docker container with /bin/bash")
-	containerId, err := driver.StartContainer(&runConfig)
-	if err != nil {
-		err := fmt.Errorf("Error running container: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Save the container ID
-	s.containerId = containerId
-	state.Put("container_id", s.containerId)
-	ui.Message(fmt.Sprintf("Container ID: %s", s.containerId))
-	return multistep.ActionContinue
-}
-
-func (s *StepRun) Cleanup(state multistep.StateBag) {
-	if s.containerId == "" {
-		return
-	}
-
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	// Kill the container. We don't handle errors because errors usually
-	// just mean that the container doesn't exist anymore, which isn't a
-	// big deal.
-	ui.Say(fmt.Sprintf("Killing the container: %s", s.containerId))
-	driver.StopContainer(s.containerId)
-
-	// Reset the container ID so that we're idempotent
-	s.containerId = ""
-}

builder/docker/step_run_test.go

@@ -1,95 +0,0 @@
-package docker
-
-import (
-	"errors"
-	"github.com/mitchellh/multistep"
-	"testing"
-)
-
-func testStepRunState(t *testing.T) multistep.StateBag {
-	state := testState(t)
-	state.Put("temp_dir", "/foo")
-	return state
-}
-
-func TestStepRun_impl(t *testing.T) {
-	var _ multistep.Step = new(StepRun)
-}
-
-func TestStepRun(t *testing.T) {
-	state := testStepRunState(t)
-	step := new(StepRun)
-	defer step.Cleanup(state)
-
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(*MockDriver)
-	driver.StartID = "foo"
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// verify we did the right thing
-	if !driver.StartCalled {
-		t.Fatal("should've called")
-	}
-	if driver.StartConfig.Image != config.Image {
-		t.Fatalf("bad: %#v", driver.StartConfig.Image)
-	}
-
-	// verify the ID is saved
-	idRaw, ok := state.GetOk("container_id")
-	if !ok {
-		t.Fatal("should've saved ID")
-	}
-
-	id := idRaw.(string)
-	if id != "foo" {
-		t.Fatalf("bad: %#v", id)
-	}
-
-	// Verify we haven't called stop yet
-	if driver.StopCalled {
-		t.Fatal("should not have stopped")
-	}
-
-	// Cleanup
-	step.Cleanup(state)
-	if !driver.StopCalled {
-		t.Fatal("should've stopped")
-	}
-	if driver.StopID != id {
-		t.Fatalf("bad: %#v", driver.StopID)
-	}
-}
-
-func TestStepRun_error(t *testing.T) {
-	state := testStepRunState(t)
-	step := new(StepRun)
-	defer step.Cleanup(state)
-
-	driver := state.Get("driver").(*MockDriver)
-	driver.StartError = errors.New("foo")
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// verify the ID is not saved
-	if _, ok := state.GetOk("container_id"); ok {
-		t.Fatal("shouldn't save container ID")
-	}
-
-	// Verify we haven't called stop yet
-	if driver.StopCalled {
-		t.Fatal("should not have stopped")
-	}
-
-	// Cleanup
-	step.Cleanup(state)
-	if driver.StopCalled {
-		t.Fatal("should not have stopped")
-	}
-}

builder/docker/step_temp_dir.go

@@ -1,38 +0,0 @@
-package docker
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"io/ioutil"
-	"os"
-)
-
-// StepTempDir creates a temporary directory that we use in order to
-// share data with the docker container over the communicator.
-type StepTempDir struct {
-	tempDir string
-}
-
-func (s *StepTempDir) Run(state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Creating a temporary directory for sharing data...")
-	td, err := ioutil.TempDir("", "packer-docker")
-	if err != nil {
-		err := fmt.Errorf("Error making temp dir: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	s.tempDir = td
-	state.Put("temp_dir", s.tempDir)
-	return multistep.ActionContinue
-}
-
-func (s *StepTempDir) Cleanup(state multistep.StateBag) {
-	if s.tempDir != "" {
-		os.RemoveAll(s.tempDir)
-	}
-}

builder/docker/step_temp_dir_test.go

@@ -1,44 +0,0 @@
-package docker
-
-import (
-	"github.com/mitchellh/multistep"
-	"os"
-	"testing"
-)
-
-func TestStepTempDir_impl(t *testing.T) {
-	var _ multistep.Step = new(StepTempDir)
-}
-
-func TestStepTempDir(t *testing.T) {
-	state := testState(t)
-	step := new(StepTempDir)
-	defer step.Cleanup(state)
-
-	// sanity test
-	if _, ok := state.GetOk("temp_dir"); ok {
-		t.Fatalf("temp_dir should not be in state yet")
-	}
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify that we got the temp dir
-	dirRaw, ok := state.GetOk("temp_dir")
-	if !ok {
-		t.Fatalf("should've made temp_dir")
-	}
-	dir := dirRaw.(string)
-
-	if _, err := os.Stat(dir); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	// Cleanup
-	step.Cleanup(state)
-	if _, err := os.Stat(dir); err == nil {
-		t.Fatalf("dir should be gone")
-	}
-}

builder/docker/step_test.go

@@ -1,20 +0,0 @@
-package docker
-
-import (
-	"bytes"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func testState(t *testing.T) multistep.StateBag {
-	state := new(multistep.BasicStateBag)
-	state.Put("config", testConfigStruct(t))
-	state.Put("driver", &MockDriver{})
-	state.Put("hook", &packer.MockHook{})
-	state.Put("ui", &packer.BasicUi{
-		Reader: new(bytes.Buffer),
-		Writer: new(bytes.Buffer),
-	})
-	return state
-}

builder/openstack/artifact_test.go

@@ -1,15 +1,21 @@
 package openstack
 
 import (
+	"cgl.tideland.biz/asserts"
 	"github.com/mitchellh/packer/packer"
 	"testing"
 )
 
 func TestArtifact_Impl(t *testing.T) {
-	var _ packer.Artifact = new(Artifact)
+	assert := asserts.NewTestingAsserts(t, true)
+
+	var actual packer.Artifact
+	assert.Implementor(&Artifact{}, &actual, "should be an Artifact")
 }
 
 func TestArtifactId(t *testing.T) {
+	assert := asserts.NewTestingAsserts(t, true)
+
 	expected := `b8cdf55b-c916-40bd-b190-389ec144c4ed`
 
 	a := &Artifact{
@@ -17,19 +23,17 @@ func TestArtifactId(t *testing.T) {
 	}
 
 	result := a.Id()
-	if result != expected {
-		t.Fatalf("bad: %s", result)
-	}
+	assert.Equal(result, expected, "should match output")
 }
 
 func TestArtifactString(t *testing.T) {
+	assert := asserts.NewTestingAsserts(t, true)
+
 	expected := "An image was created: b8cdf55b-c916-40bd-b190-389ec144c4ed"
 
 	a := &Artifact{
 		ImageId: "b8cdf55b-c916-40bd-b190-389ec144c4ed",
 	}
 	result := a.String()
-	if result != expected {
-		t.Fatalf("bad: %s", result)
-	}
+	assert.Equal(result, expected, "should match output")
 }

builder/openstack/builder.go

@@ -29,15 +29,15 @@ type Builder struct {
 	runner multistep.Runner
 }
 
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+func (b *Builder) Prepare(raws ...interface{}) error {
 	md, err := common.DecodeConfig(&b.config, raws...)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	b.config.tpl, err = packer.NewConfigTemplate()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	b.config.tpl.UserVars = b.config.PackerUserVars
 
@@ -48,11 +48,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
 
 	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
+		return errs
 	}
 
-	log.Println(common.ScrubConfig(b.config, b.config.Password))
-	return nil, nil
+	log.Printf("Config: %+v", b.config)
+	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {

builder/openstack/builder_test.go

@@ -32,10 +32,7 @@ func TestBuilder_Prepare_BadType(t *testing.T) {
 		"password": []string{},
 	}
 
-	warns, err := b.Prepare(c)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(c)
 	if err == nil {
 		t.Fatalf("prepare should fail")
 	}
@@ -47,10 +44,7 @@ func TestBuilderPrepare_ImageName(t *testing.T) {
 
 	// Test good
 	config["image_name"] = "foo"
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -58,10 +52,7 @@ func TestBuilderPrepare_ImageName(t *testing.T) {
 	// Test bad
 	config["image_name"] = "foo {{"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -69,10 +60,7 @@ func TestBuilderPrepare_ImageName(t *testing.T) {
 	// Test bad
 	delete(config, "image_name")
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -84,10 +72,7 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 
 	// Add a random key
 	config["i_should_not_be_valid"] = true
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}

builder/openstack/step_key_pair.go

@@ -1,9 +1,10 @@
 package openstack
 
 import (
+	"cgl.tideland.biz/identifier"
+	"encoding/hex"
 	"fmt"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
 	"github.com/rackspace/gophercloud"
 	"log"
@@ -18,7 +19,7 @@ func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Creating temporary keypair for this instance...")
-	keyName := fmt.Sprintf("packer %s", uuid.TimeOrderedUUID())
+	keyName := fmt.Sprintf("packer %s", hex.EncodeToString(identifier.NewUUID().Raw()))
 	log.Printf("temporary keypair name: %s", keyName)
 	keyResp, err := csp.CreateKeyPair(gophercloud.NewKeyPair{Name: keyName})
 	if err != nil {

builder/qemu/artifact.go

@@ -1,33 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"os"
-)
-
-// Artifact is the result of running the Qemu builder, namely a set
-// of files associated with the resulting machine.
-type Artifact struct {
-	dir string
-	f   []string
-}
-
-func (*Artifact) BuilderId() string {
-	return BuilderId
-}
-
-func (a *Artifact) Files() []string {
-	return a.f
-}
-
-func (*Artifact) Id() string {
-	return "VM"
-}
-
-func (a *Artifact) String() string {
-	return fmt.Sprintf("VM files in directory: %s", a.dir)
-}
-
-func (a *Artifact) Destroy() error {
-	return os.RemoveAll(a.dir)
-}

builder/qemu/builder.go

@@ -1,482 +0,0 @@
-package qemu
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-const BuilderId = "transcend.qemu"
-
-var netDevice = map[string]bool{
-	"ne2k_pci":   true,
-	"i82551":     true,
-	"i82557b":    true,
-	"i82559er":   true,
-	"rtl8139":    true,
-	"e1000":      true,
-	"pcnet":      true,
-	"virtio":     true,
-	"virtio-net": true,
-	"usb-net":    true,
-	"i82559a":    true,
-	"i82559b":    true,
-	"i82559c":    true,
-	"i82550":     true,
-	"i82562":     true,
-	"i82557a":    true,
-	"i82557c":    true,
-	"i82801":     true,
-	"vmxnet3":    true,
-	"i82558a":    true,
-	"i82558b":    true,
-}
-
-var diskInterface = map[string]bool{
-	"ide":    true,
-	"scsi":   true,
-	"virtio": true,
-}
-
-type Builder struct {
-	config config
-	runner multistep.Runner
-}
-
-type config struct {
-	common.PackerConfig `mapstructure:",squash"`
-
-	Accelerator     string     `mapstructure:"accelerator"`
-	BootCommand     []string   `mapstructure:"boot_command"`
-	DiskInterface   string     `mapstructure:"disk_interface"`
-	DiskSize        uint       `mapstructure:"disk_size"`
-	Format          string     `mapstructure:"format"`
-	Headless        bool       `mapstructure:"headless"`
-	HTTPDir         string     `mapstructure:"http_directory"`
-	HTTPPortMin     uint       `mapstructure:"http_port_min"`
-	HTTPPortMax     uint       `mapstructure:"http_port_max"`
-	ISOChecksum     string     `mapstructure:"iso_checksum"`
-	ISOChecksumType string     `mapstructure:"iso_checksum_type"`
-	ISOUrls         []string   `mapstructure:"iso_urls"`
-	NetDevice       string     `mapstructure:"net_device"`
-	OutputDir       string     `mapstructure:"output_directory"`
-	QemuArgs        [][]string `mapstructure:"qemuargs"`
-	ShutdownCommand string     `mapstructure:"shutdown_command"`
-	SSHHostPortMin  uint       `mapstructure:"ssh_host_port_min"`
-	SSHHostPortMax  uint       `mapstructure:"ssh_host_port_max"`
-	SSHPassword     string     `mapstructure:"ssh_password"`
-	SSHPort         uint       `mapstructure:"ssh_port"`
-	SSHUser         string     `mapstructure:"ssh_username"`
-	SSHKeyPath      string     `mapstructure:"ssh_key_path"`
-	VNCPortMin      uint       `mapstructure:"vnc_port_min"`
-	VNCPortMax      uint       `mapstructure:"vnc_port_max"`
-	VMName          string     `mapstructure:"vm_name"`
-
-	RawBootWait        string `mapstructure:"boot_wait"`
-	RawSingleISOUrl    string `mapstructure:"iso_url"`
-	RawShutdownTimeout string `mapstructure:"shutdown_timeout"`
-	RawSSHWaitTimeout  string `mapstructure:"ssh_wait_timeout"`
-
-	bootWait        time.Duration ``
-	shutdownTimeout time.Duration ``
-	sshWaitTimeout  time.Duration ``
-	tpl             *packer.ConfigTemplate
-}
-
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
-	md, err := common.DecodeConfig(&b.config, raws...)
-	if err != nil {
-		return nil, err
-	}
-
-	b.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return nil, err
-	}
-	b.config.tpl.UserVars = b.config.PackerUserVars
-
-	// Accumulate any errors
-	errs := common.CheckUnusedConfig(md)
-
-	if b.config.DiskSize == 0 {
-		b.config.DiskSize = 40000
-	}
-
-	if b.config.Accelerator == "" {
-		b.config.Accelerator = "kvm"
-	}
-
-	if b.config.HTTPPortMin == 0 {
-		b.config.HTTPPortMin = 8000
-	}
-
-	if b.config.HTTPPortMax == 0 {
-		b.config.HTTPPortMax = 9000
-	}
-
-	if b.config.OutputDir == "" {
-		b.config.OutputDir = fmt.Sprintf("output-%s", b.config.PackerBuildName)
-	}
-
-	if b.config.RawBootWait == "" {
-		b.config.RawBootWait = "10s"
-	}
-
-	if b.config.SSHHostPortMin == 0 {
-		b.config.SSHHostPortMin = 2222
-	}
-
-	if b.config.SSHHostPortMax == 0 {
-		b.config.SSHHostPortMax = 4444
-	}
-
-	if b.config.SSHPort == 0 {
-		b.config.SSHPort = 22
-	}
-
-	if b.config.VNCPortMin == 0 {
-		b.config.VNCPortMin = 5900
-	}
-
-	if b.config.VNCPortMax == 0 {
-		b.config.VNCPortMax = 6000
-	}
-
-	if b.config.QemuArgs == nil {
-		b.config.QemuArgs = make([][]string, 0)
-	}
-
-	if b.config.VMName == "" {
-		b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName)
-	}
-
-	if b.config.Format == "" {
-		b.config.Format = "qcow2"
-	}
-
-	if b.config.NetDevice == "" {
-		b.config.NetDevice = "virtio-net"
-	}
-
-	if b.config.DiskInterface == "" {
-		b.config.DiskInterface = "virtio"
-	}
-
-	// Errors
-	templates := map[string]*string{
-		"http_directory":    &b.config.HTTPDir,
-		"iso_checksum":      &b.config.ISOChecksum,
-		"iso_checksum_type": &b.config.ISOChecksumType,
-		"iso_url":           &b.config.RawSingleISOUrl,
-		"output_directory":  &b.config.OutputDir,
-		"shutdown_command":  &b.config.ShutdownCommand,
-		"ssh_password":      &b.config.SSHPassword,
-		"ssh_username":      &b.config.SSHUser,
-		"vm_name":           &b.config.VMName,
-		"format":            &b.config.Format,
-		"boot_wait":         &b.config.RawBootWait,
-		"shutdown_timeout":  &b.config.RawShutdownTimeout,
-		"ssh_wait_timeout":  &b.config.RawSSHWaitTimeout,
-		"accelerator":       &b.config.Accelerator,
-		"net_device":        &b.config.NetDevice,
-		"disk_interface":    &b.config.DiskInterface,
-	}
-
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = b.config.tpl.Process(*ptr, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
-	for i, url := range b.config.ISOUrls {
-		var err error
-		b.config.ISOUrls[i], err = b.config.tpl.Process(url, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error processing iso_urls[%d]: %s", i, err))
-		}
-	}
-
-	for i, command := range b.config.BootCommand {
-		if err := b.config.tpl.Validate(command); err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing boot_command[%d]: %s", i, err))
-		}
-	}
-
-	if !(b.config.Format == "qcow2" || b.config.Format == "raw") {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("invalid format, only 'qcow2' or 'img' are allowed"))
-	}
-
-	if !(b.config.Accelerator == "kvm" || b.config.Accelerator == "xen") {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("invalid format, only 'kvm' or 'xen' are allowed"))
-	}
-
-	if _, ok := netDevice[b.config.NetDevice]; !ok {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("unrecognized network device type"))
-	}
-
-	if _, ok := diskInterface[b.config.DiskInterface]; !ok {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("unrecognized disk interface type"))
-	}
-
-	if b.config.HTTPPortMin > b.config.HTTPPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("http_port_min must be less than http_port_max"))
-	}
-
-	if b.config.ISOChecksum == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("Due to large file sizes, an iso_checksum is required"))
-	} else {
-		b.config.ISOChecksum = strings.ToLower(b.config.ISOChecksum)
-	}
-
-	if b.config.ISOChecksumType == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("The iso_checksum_type must be specified."))
-	} else {
-		b.config.ISOChecksumType = strings.ToLower(b.config.ISOChecksumType)
-		if h := common.HashForType(b.config.ISOChecksumType); h == nil {
-			errs = packer.MultiErrorAppend(
-				errs,
-				fmt.Errorf("Unsupported checksum type: %s", b.config.ISOChecksumType))
-		}
-	}
-
-	if b.config.RawSingleISOUrl == "" && len(b.config.ISOUrls) == 0 {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("One of iso_url or iso_urls must be specified."))
-	} else if b.config.RawSingleISOUrl != "" && len(b.config.ISOUrls) > 0 {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("Only one of iso_url or iso_urls may be specified."))
-	} else if b.config.RawSingleISOUrl != "" {
-		b.config.ISOUrls = []string{b.config.RawSingleISOUrl}
-	}
-
-	for i, url := range b.config.ISOUrls {
-		b.config.ISOUrls[i], err = common.DownloadableURL(url)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed to parse iso_url %d: %s", i+1, err))
-		}
-	}
-
-	if !b.config.PackerForce {
-		if _, err := os.Stat(b.config.OutputDir); err == nil {
-			errs = packer.MultiErrorAppend(
-				errs,
-				fmt.Errorf("Output directory '%s' already exists. It must not exist.", b.config.OutputDir))
-		}
-	}
-
-	b.config.bootWait, err = time.ParseDuration(b.config.RawBootWait)
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing boot_wait: %s", err))
-	}
-
-	if b.config.RawShutdownTimeout == "" {
-		b.config.RawShutdownTimeout = "5m"
-	}
-
-	if b.config.RawSSHWaitTimeout == "" {
-		b.config.RawSSHWaitTimeout = "20m"
-	}
-
-	b.config.shutdownTimeout, err = time.ParseDuration(b.config.RawShutdownTimeout)
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing shutdown_timeout: %s", err))
-	}
-
-	if b.config.SSHKeyPath != "" {
-		if _, err := os.Stat(b.config.SSHKeyPath); err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
-		} else if _, err := sshKeyToKeyring(b.config.SSHKeyPath); err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
-		}
-	}
-
-	if b.config.SSHHostPortMin > b.config.SSHHostPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("ssh_host_port_min must be less than ssh_host_port_max"))
-	}
-
-	if b.config.SSHUser == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("An ssh_username must be specified."))
-	}
-
-	b.config.sshWaitTimeout, err = time.ParseDuration(b.config.RawSSHWaitTimeout)
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing ssh_wait_timeout: %s", err))
-	}
-
-	if b.config.VNCPortMin > b.config.VNCPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("vnc_port_min must be less than vnc_port_max"))
-	}
-
-	for i, args := range b.config.QemuArgs {
-		for j, arg := range args {
-			if err := b.config.tpl.Validate(arg); err != nil {
-				errs = packer.MultiErrorAppend(errs,
-					fmt.Errorf("Error processing qemu-system_x86-64[%d][%d]: %s", i, j, err))
-			}
-		}
-	}
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
-	}
-
-	return nil, nil
-}
-
-func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-	// Create the driver that we'll use to communicate with Qemu
-	driver, err := b.newDriver()
-	if err != nil {
-		return nil, fmt.Errorf("Failed creating Qemu driver: %s", err)
-	}
-
-	steps := []multistep.Step{
-		&common.StepDownload{
-			Checksum:     b.config.ISOChecksum,
-			ChecksumType: b.config.ISOChecksumType,
-			Description:  "ISO",
-			ResultKey:    "iso_path",
-			Url:          b.config.ISOUrls,
-		},
-		new(stepPrepareOutputDir),
-		new(stepCreateDisk),
-		new(stepHTTPServer),
-		new(stepForwardSSH),
-		new(stepConfigureVNC),
-		&stepRun{
-			BootDrive: "d",
-			Message:   "Starting VM, booting from CD-ROM",
-		},
-		&stepBootWait{},
-		&stepTypeBootCommand{},
-		&stepWaitForShutdown{
-			Message: "Waiting for initial VM boot to shut down",
-		},
-		&stepRun{
-			BootDrive: "c",
-			Message:   "Starting VM, booting from hard disk",
-		},
-		&common.StepConnectSSH{
-			SSHAddress:     sshAddress,
-			SSHConfig:      sshConfig,
-			SSHWaitTimeout: b.config.sshWaitTimeout,
-		},
-		new(common.StepProvision),
-		new(stepShutdown),
-	}
-
-	// Setup the state bag
-	state := new(multistep.BasicStateBag)
-	state.Put("cache", cache)
-	state.Put("config", &b.config)
-	state.Put("driver", driver)
-	state.Put("hook", hook)
-	state.Put("ui", ui)
-
-	// Run
-	if b.config.PackerDebug {
-		b.runner = &multistep.DebugRunner{
-			Steps:   steps,
-			PauseFn: common.MultistepDebugFn(ui),
-		}
-	} else {
-		b.runner = &multistep.BasicRunner{Steps: steps}
-	}
-
-	b.runner.Run(state)
-
-	// If there was an error, return that
-	if rawErr, ok := state.GetOk("error"); ok {
-		return nil, rawErr.(error)
-	}
-
-	// If we were interrupted or cancelled, then just exit.
-	if _, ok := state.GetOk(multistep.StateCancelled); ok {
-		return nil, errors.New("Build was cancelled.")
-	}
-
-	if _, ok := state.GetOk(multistep.StateHalted); ok {
-		return nil, errors.New("Build was halted.")
-	}
-
-	// Compile the artifact list
-	files := make([]string, 0, 5)
-	visit := func(path string, info os.FileInfo, err error) error {
-		if !info.IsDir() {
-			files = append(files, path)
-		}
-
-		return err
-	}
-
-	if err := filepath.Walk(b.config.OutputDir, visit); err != nil {
-		return nil, err
-	}
-
-	artifact := &Artifact{
-		dir: b.config.OutputDir,
-		f:   files,
-	}
-
-	return artifact, nil
-}
-
-func (b *Builder) Cancel() {
-	if b.runner != nil {
-		log.Println("Cancelling the step runner...")
-		b.runner.Cancel()
-	}
-}
-
-func (b *Builder) newDriver() (Driver, error) {
-	qemuPath, err := exec.LookPath("qemu-system-x86_64")
-	if err != nil {
-		return nil, err
-	}
-
-	qemuImgPath, err := exec.LookPath("qemu-img")
-	if err != nil {
-		return nil, err
-	}
-
-	log.Printf("Qemu path: %s, Qemu Image page: %s", qemuPath, qemuImgPath)
-	driver := &QemuDriver{
-		QemuPath:    qemuPath,
-		QemuImgPath: qemuImgPath,
-	}
-
-	if err := driver.Verify(); err != nil {
-		return nil, err
-	}
-
-	return driver, nil
-}

builder/qemu/builder_test.go

@@ -1,664 +0,0 @@
-package qemu
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"io/ioutil"
-	"os"
-	"reflect"
-	"testing"
-)
-
-var testPem = `
------BEGIN RSA PRIVATE KEY-----
-MIIEpQIBAAKCAQEAxd4iamvrwRJvtNDGQSIbNvvIQN8imXTRWlRY62EvKov60vqu
-hh+rDzFYAIIzlmrJopvOe0clqmi3mIP9dtkjPFrYflq52a2CF5q+BdwsJXuRHbJW
-LmStZUwW1khSz93DhvhmK50nIaczW63u4EO/jJb3xj+wxR1Nkk9bxi3DDsYFt8SN
-AzYx9kjlEYQ/+sI4/ATfmdV9h78SVotjScupd9KFzzi76gWq9gwyCBLRynTUWlyD
-2UOfJRkOvhN6/jKzvYfVVwjPSfA9IMuooHdScmC4F6KBKJl/zf/zETM0XyzIDNmH
-uOPbCiljq2WoRM+rY6ET84EO0kVXbfx8uxUsqQIDAQABAoIBAQCkPj9TF0IagbM3
-5BSs/CKbAWS4dH/D4bPlxx4IRCNirc8GUg+MRb04Xz0tLuajdQDqeWpr6iLZ0RKV
-BvreLF+TOdV7DNQ4XE4gSdJyCtCaTHeort/aordL3l0WgfI7mVk0L/yfN1PEG4YG
-E9q1TYcyrB3/8d5JwIkjabxERLglCcP+geOEJp+QijbvFIaZR/n2irlKW4gSy6ko
-9B0fgUnhkHysSg49ChHQBPQ+o5BbpuLrPDFMiTPTPhdfsvGGcyCGeqfBA56oHcSF
-K02Fg8OM+Bd1lb48LAN9nWWY4WbwV+9bkN3Ym8hO4c3a/Dxf2N7LtAQqWZzFjvM3
-/AaDvAgBAoGBAPLD+Xn1IYQPMB2XXCXfOuJewRY7RzoVWvMffJPDfm16O7wOiW5+
-2FmvxUDayk4PZy6wQMzGeGKnhcMMZTyaq2g/QtGfrvy7q1Lw2fB1VFlVblvqhoJa
-nMJojjC4zgjBkXMHsRLeTmgUKyGs+fdFbfI6uejBnnf+eMVUMIdJ+6I9AoGBANCn
-kWO9640dttyXURxNJ3lBr2H3dJOkmD6XS+u+LWqCSKQe691Y/fZ/ZL0Oc4Mhy7I6
-hsy3kDQ5k2V0fkaNODQIFJvUqXw2pMewUk8hHc9403f4fe9cPrL12rQ8WlQw4yoC
-v2B61vNczCCUDtGxlAaw8jzSRaSI5s6ax3K7enbdAoGBAJB1WYDfA2CoAQO6y9Sl
-b07A/7kQ8SN5DbPaqrDrBdJziBQxukoMJQXJeGFNUFD/DXFU5Fp2R7C86vXT7HIR
-v6m66zH+CYzOx/YE6EsUJms6UP9VIVF0Rg/RU7teXQwM01ZV32LQ8mswhTH20o/3
-uqMHmxUMEhZpUMhrfq0isyApAoGAe1UxGTXfj9AqkIVYylPIq2HqGww7+jFmVEj1
-9Wi6S6Sq72ffnzzFEPkIQL/UA4TsdHMnzsYKFPSbbXLIWUeMGyVTmTDA5c0e5XIR
-lPhMOKCAzv8w4VUzMnEkTzkFY5JqFCD/ojW57KvDdNZPVB+VEcdxyAW6aKELXMAc
-eHLc1nkCgYEApm/motCTPN32nINZ+Vvywbv64ZD+gtpeMNP3CLrbe1X9O+H52AXa
-1jCoOldWR8i2bs2NVPcKZgdo6fFULqE4dBX7Te/uYEIuuZhYLNzRO1IKU/YaqsXG
-3bfQ8hKYcSnTfE0gPtLDnqCIxTocaGLSHeG3TH9fTw+dA8FvWpUztI4=
------END RSA PRIVATE KEY-----
-`
-
-func testConfig() map[string]interface{} {
-	return map[string]interface{}{
-		"iso_checksum":            "foo",
-		"iso_checksum_type":       "md5",
-		"iso_url":                 "http://www.google.com/",
-		"ssh_username":            "foo",
-		packer.BuildNameConfigKey: "foo",
-	}
-}
-
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	var raw interface{}
-	raw = &Builder{}
-	if _, ok := raw.(packer.Builder); !ok {
-		t.Error("Builder must implement builder.")
-	}
-}
-
-func TestBuilderPrepare_Defaults(t *testing.T) {
-	var b Builder
-	config := testConfig()
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.OutputDir != "output-foo" {
-		t.Errorf("bad output dir: %s", b.config.OutputDir)
-	}
-
-	if b.config.SSHHostPortMin != 2222 {
-		t.Errorf("bad min ssh host port: %d", b.config.SSHHostPortMin)
-	}
-
-	if b.config.SSHHostPortMax != 4444 {
-		t.Errorf("bad max ssh host port: %d", b.config.SSHHostPortMax)
-	}
-
-	if b.config.SSHPort != 22 {
-		t.Errorf("bad ssh port: %d", b.config.SSHPort)
-	}
-
-	if b.config.VMName != "packer-foo" {
-		t.Errorf("bad vm name: %s", b.config.VMName)
-	}
-
-	if b.config.Format != "qcow2" {
-		t.Errorf("bad format: %s", b.config.Format)
-	}
-}
-
-func TestBuilderPrepare_BootWait(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test a default boot_wait
-	delete(config, "boot_wait")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if b.config.RawBootWait != "10s" {
-		t.Fatalf("bad value: %s", b.config.RawBootWait)
-	}
-
-	// Test with a bad boot_wait
-	config["boot_wait"] = "this is not good"
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test with a good one
-	config["boot_wait"] = "5s"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_DiskSize(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	delete(config, "disk_size")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("bad err: %s", err)
-	}
-
-	if b.config.DiskSize != 40000 {
-		t.Fatalf("bad size: %d", b.config.DiskSize)
-	}
-
-	config["disk_size"] = 60000
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.DiskSize != 60000 {
-		t.Fatalf("bad size: %s", b.config.DiskSize)
-	}
-}
-
-func TestBuilderPrepare_HTTPPort(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["http_port_min"] = 1000
-	config["http_port_max"] = 500
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Bad
-	config["http_port_min"] = -500
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["http_port_min"] = 500
-	config["http_port_max"] = 1000
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_Format(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["format"] = "illegal value"
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["format"] = "qcow2"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	// Good
-	config["format"] = "raw"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_InvalidKey(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Add a random key
-	config["i_should_not_be_valid"] = true
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_ISOChecksum(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test bad
-	config["iso_checksum"] = ""
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test good
-	config["iso_checksum"] = "FOo"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.ISOChecksum != "foo" {
-		t.Fatalf("should've lowercased: %s", b.config.ISOChecksum)
-	}
-}
-
-func TestBuilderPrepare_ISOChecksumType(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test bad
-	config["iso_checksum_type"] = ""
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test good
-	config["iso_checksum_type"] = "mD5"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.ISOChecksumType != "md5" {
-		t.Fatalf("should've lowercased: %s", b.config.ISOChecksumType)
-	}
-
-	// Test unknown
-	config["iso_checksum_type"] = "fake"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_ISOUrl(t *testing.T) {
-	var b Builder
-	config := testConfig()
-	delete(config, "iso_url")
-	delete(config, "iso_urls")
-
-	// Test both epty
-	config["iso_url"] = ""
-	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test iso_url set
-	config["iso_url"] = "http://www.packer.io"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Errorf("should not have error: %s", err)
-	}
-
-	expected := []string{"http://www.packer.io"}
-	if !reflect.DeepEqual(b.config.ISOUrls, expected) {
-		t.Fatalf("bad: %#v", b.config.ISOUrls)
-	}
-
-	// Test both set
-	config["iso_url"] = "http://www.packer.io"
-	config["iso_urls"] = []string{"http://www.packer.io"}
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test just iso_urls set
-	delete(config, "iso_url")
-	config["iso_urls"] = []string{
-		"http://www.packer.io",
-		"http://www.hashicorp.com",
-	}
-
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Errorf("should not have error: %s", err)
-	}
-
-	expected = []string{
-		"http://www.packer.io",
-		"http://www.hashicorp.com",
-	}
-	if !reflect.DeepEqual(b.config.ISOUrls, expected) {
-		t.Fatalf("bad: %#v", b.config.ISOUrls)
-	}
-}
-
-func TestBuilderPrepare_OutputDir(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test with existing dir
-	dir, err := ioutil.TempDir("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer os.RemoveAll(dir)
-
-	config["output_directory"] = dir
-	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test with a good one
-	config["output_directory"] = "i-hope-i-dont-exist"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_ShutdownTimeout(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test with a bad value
-	config["shutdown_timeout"] = "this is not good"
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test with a good one
-	config["shutdown_timeout"] = "5s"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_SSHHostPort(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["ssh_host_port_min"] = 1000
-	config["ssh_host_port_max"] = 500
-	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Bad
-	config["ssh_host_port_min"] = -500
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["ssh_host_port_min"] = 500
-	config["ssh_host_port_max"] = 1000
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_sshKeyPath(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	config["ssh_key_path"] = ""
-	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	config["ssh_key_path"] = "/i/dont/exist"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test bad contents
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer os.Remove(tf.Name())
-	defer tf.Close()
-
-	if _, err := tf.Write([]byte("HELLO!")); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	config["ssh_key_path"] = tf.Name()
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test good contents
-	tf.Seek(0, 0)
-	tf.Truncate(0)
-	tf.Write([]byte(testPem))
-	config["ssh_key_path"] = tf.Name()
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestBuilderPrepare_SSHUser(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	config["ssh_username"] = ""
-	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	config["ssh_username"] = "exists"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_SSHWaitTimeout(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test a default boot_wait
-	delete(config, "ssh_wait_timeout")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if b.config.RawSSHWaitTimeout != "20m" {
-		t.Fatalf("bad value: %s", b.config.RawSSHWaitTimeout)
-	}
-
-	// Test with a bad value
-	config["ssh_wait_timeout"] = "this is not good"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test with a good one
-	config["ssh_wait_timeout"] = "5s"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_QemuArgs(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test with empty
-	delete(config, "qemuargs")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if !reflect.DeepEqual(b.config.QemuArgs, [][]string{}) {
-		t.Fatalf("bad: %#v", b.config.QemuArgs)
-	}
-
-	// Test with a good one
-	config["qemuargs"] = [][]interface{}{
-		[]interface{}{"foo", "bar", "baz"},
-	}
-
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	expected := [][]string{
-		[]string{"foo", "bar", "baz"},
-	}
-
-	if !reflect.DeepEqual(b.config.QemuArgs, expected) {
-		t.Fatalf("bad: %#v", b.config.QemuArgs)
-	}
-}

builder/qemu/driver.go

@@ -1,214 +0,0 @@
-package qemu
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"io"
-	"log"
-	"os/exec"
-	"regexp"
-	"strings"
-	"sync"
-	"syscall"
-	"time"
-	"unicode"
-)
-
-type DriverCancelCallback func(state multistep.StateBag) bool
-
-// A driver is able to talk to qemu-system-x86_64 and perform certain
-// operations with it.
-type Driver interface {
-	// Stop stops a running machine, forcefully.
-	Stop() error
-
-	// Qemu executes the given command via qemu-system-x86_64
-	Qemu(qemuArgs ...string) error
-
-	// wait on shutdown of the VM with option to cancel
-	WaitForShutdown(<-chan struct{}) bool
-
-	// Qemu executes the given command via qemu-img
-	QemuImg(...string) error
-
-	// Verify checks to make sure that this driver should function
-	// properly. If there is any indication the driver can't function,
-	// this will return an error.
-	Verify() error
-
-	// Version reads the version of Qemu that is installed.
-	Version() (string, error)
-}
-
-type QemuDriver struct {
-	QemuPath    string
-	QemuImgPath string
-
-	vmCmd   *exec.Cmd
-	vmEndCh <-chan int
-	lock    sync.Mutex
-}
-
-func (d *QemuDriver) Stop() error {
-	d.lock.Lock()
-	defer d.lock.Unlock()
-
-	if d.vmCmd != nil {
-		if err := d.vmCmd.Process.Kill(); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (d *QemuDriver) Qemu(qemuArgs ...string) error {
-	d.lock.Lock()
-	defer d.lock.Unlock()
-
-	if d.vmCmd != nil {
-		panic("Existing VM state found")
-	}
-
-	stdout_r, stdout_w := io.Pipe()
-	stderr_r, stderr_w := io.Pipe()
-
-	log.Printf("Executing %s: %#v", d.QemuPath, qemuArgs)
-	cmd := exec.Command(d.QemuPath, qemuArgs...)
-	cmd.Stdout = stdout_w
-	cmd.Stderr = stderr_w
-
-	err := cmd.Start()
-	if err != nil {
-		err = fmt.Errorf("Error starting VM: %s", err)
-		return err
-	}
-
-	go logReader("Qemu stdout", stdout_r)
-	go logReader("Qemu stderr", stderr_r)
-
-	log.Printf("Started Qemu. Pid: %d", cmd.Process.Pid)
-
-	// Wait for Qemu to complete in the background, and mark when its done
-	endCh := make(chan int, 1)
-	go func() {
-		defer stderr_w.Close()
-		defer stdout_w.Close()
-
-		var exitCode int = 0
-		if err := cmd.Wait(); err != nil {
-			if exiterr, ok := err.(*exec.ExitError); ok {
-				// The program has exited with an exit code != 0
-				if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
-					exitCode = status.ExitStatus()
-				} else {
-					exitCode = 254
-				}
-			}
-		}
-
-		endCh <- exitCode
-
-		d.lock.Lock()
-		defer d.lock.Unlock()
-		d.vmCmd = nil
-		d.vmEndCh = nil
-	}()
-
-	// Wait at least a couple seconds for an early fail from Qemu so
-	// we can report that.
-	select {
-	case exit := <-endCh:
-		if exit != 0 {
-			return fmt.Errorf("Qemu failed to start. Please run with logs to get more info.")
-		}
-	case <-time.After(2 * time.Second):
-	}
-
-	// Setup our state so we know we are running
-	d.vmCmd = cmd
-	d.vmEndCh = endCh
-
-	return nil
-}
-
-func (d *QemuDriver) WaitForShutdown(cancelCh <-chan struct{}) bool {
-	d.lock.Lock()
-	endCh := d.vmEndCh
-	d.lock.Unlock()
-
-	if endCh == nil {
-		return true
-	}
-
-	select {
-	case <-endCh:
-		return true
-	case <-cancelCh:
-		return false
-	}
-}
-
-func (d *QemuDriver) QemuImg(args ...string) error {
-	var stdout, stderr bytes.Buffer
-
-	log.Printf("Executing qemu-img: %#v", args)
-	cmd := exec.Command(d.QemuImgPath, args...)
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
-
-	stdoutString := strings.TrimSpace(stdout.String())
-	stderrString := strings.TrimSpace(stderr.String())
-
-	if _, ok := err.(*exec.ExitError); ok {
-		err = fmt.Errorf("QemuImg error: %s", stderrString)
-	}
-
-	log.Printf("stdout: %s", stdoutString)
-	log.Printf("stderr: %s", stderrString)
-
-	return err
-}
-
-func (d *QemuDriver) Verify() error {
-	return nil
-}
-
-func (d *QemuDriver) Version() (string, error) {
-	var stdout bytes.Buffer
-
-	cmd := exec.Command(d.QemuPath, "-version")
-	cmd.Stdout = &stdout
-	if err := cmd.Run(); err != nil {
-		return "", err
-	}
-
-	versionOutput := strings.TrimSpace(stdout.String())
-	log.Printf("Qemu --version output: %s", versionOutput)
-	versionRe := regexp.MustCompile("qemu-kvm-[0-9]\\.[0-9]")
-	matches := versionRe.Split(versionOutput, 2)
-	if len(matches) == 0 {
-		return "", fmt.Errorf("No version found: %s", versionOutput)
-	}
-
-	log.Printf("Qemu version: %s", matches[0])
-	return matches[0], nil
-}
-
-func logReader(name string, r io.Reader) {
-	bufR := bufio.NewReader(r)
-	for {
-		line, err := bufR.ReadString('\n')
-		if line != "" {
-			line = strings.TrimRightFunc(line, unicode.IsSpace)
-			log.Printf("%s: %s", name, line)
-		}
-
-		if err == io.EOF {
-			break
-		}
-	}
-}

builder/qemu/ssh.go

@@ -1,59 +0,0 @@
-package qemu
-
-import (
-	gossh "code.google.com/p/go.crypto/ssh"
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/communicator/ssh"
-	"io/ioutil"
-	"os"
-)
-
-func sshAddress(state multistep.StateBag) (string, error) {
-	sshHostPort := state.Get("sshHostPort").(uint)
-	return fmt.Sprintf("127.0.0.1:%d", sshHostPort), nil
-}
-
-func sshConfig(state multistep.StateBag) (*gossh.ClientConfig, error) {
-	config := state.Get("config").(*config)
-
-	auth := []gossh.ClientAuth{
-		gossh.ClientAuthPassword(ssh.Password(config.SSHPassword)),
-		gossh.ClientAuthKeyboardInteractive(
-			ssh.PasswordKeyboardInteractive(config.SSHPassword)),
-	}
-
-	if config.SSHKeyPath != "" {
-		keyring, err := sshKeyToKeyring(config.SSHKeyPath)
-		if err != nil {
-			return nil, err
-		}
-
-		auth = append(auth, gossh.ClientAuthKeyring(keyring))
-	}
-
-	return &gossh.ClientConfig{
-		User: config.SSHUser,
-		Auth: auth,
-	}, nil
-}
-
-func sshKeyToKeyring(path string) (gossh.ClientKeyring, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	keyBytes, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, err
-	}
-
-	keyring := new(ssh.SimpleKeychain)
-	if err := keyring.AddPEMKey(string(keyBytes)); err != nil {
-		return nil, err
-	}
-
-	return keyring, nil
-}

builder/qemu/step_boot_wait.go

@@ -1,25 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"time"
-)
-
-// stepBootWait waits the configured time period.
-type stepBootWait struct{}
-
-func (s *stepBootWait) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	ui := state.Get("ui").(packer.Ui)
-
-	if int64(config.bootWait) > 0 {
-		ui.Say(fmt.Sprintf("Waiting %s for boot...", config.bootWait))
-		time.Sleep(config.bootWait)
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *stepBootWait) Cleanup(state multistep.StateBag) {}

builder/qemu/step_configure_vnc.go

@@ -1,50 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"math/rand"
-	"net"
-)
-
-// This step configures the VM to enable the VNC server.
-//
-// Uses:
-//   config *config
-//   ui     packer.Ui
-//
-// Produces:
-//   vnc_port uint - The port that VNC is configured to listen on.
-type stepConfigureVNC struct{}
-
-func (stepConfigureVNC) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	ui := state.Get("ui").(packer.Ui)
-
-	// Find an open VNC port. Note that this can still fail later on
-	// because we have to release the port at some point. But this does its
-	// best.
-	msg := fmt.Sprintf("Looking for available port between %d and %d", config.VNCPortMin, config.VNCPortMax)
-	ui.Say(msg)
-	log.Printf(msg)
-	var vncPort uint
-	portRange := int(config.VNCPortMax - config.VNCPortMin)
-	for {
-		vncPort = uint(rand.Intn(portRange)) + config.VNCPortMin
-		log.Printf("Trying port: %d", vncPort)
-		l, err := net.Listen("tcp", fmt.Sprintf(":%d", vncPort))
-		if err == nil {
-			defer l.Close()
-			break
-		}
-	}
-
-	ui.Say(fmt.Sprintf("Found available VNC port: %d", vncPort))
-	state.Put("vnc_port", vncPort)
-
-	return multistep.ActionContinue
-}
-
-func (stepConfigureVNC) Cleanup(multistep.StateBag) {}

builder/qemu/step_create_disk.go

@@ -1,40 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"path/filepath"
-	"strings"
-)
-
-// This step creates the virtual disk that will be used as the
-// hard drive for the virtual machine.
-type stepCreateDisk struct{}
-
-func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-	path := filepath.Join(config.OutputDir, fmt.Sprintf("%s.%s", config.VMName,
-		strings.ToLower(config.Format)))
-
-	command := []string{
-		"create",
-		"-f", config.Format,
-		path,
-		fmt.Sprintf("%vM", config.DiskSize),
-	}
-
-	ui.Say("Creating hard drive...")
-	if err := driver.QemuImg(command...); err != nil {
-		err := fmt.Errorf("Error creating hard drive: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *stepCreateDisk) Cleanup(state multistep.StateBag) {}

builder/qemu/step_forward_ssh.go

@@ -1,44 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"math/rand"
-	"net"
-)
-
-// This step adds a NAT port forwarding definition so that SSH is available
-// on the guest machine.
-//
-// Uses:
-//
-// Produces:
-type stepForwardSSH struct{}
-
-func (s *stepForwardSSH) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	ui := state.Get("ui").(packer.Ui)
-
-	log.Printf("Looking for available SSH port between %d and %d", config.SSHHostPortMin, config.SSHHostPortMax)
-	var sshHostPort uint
-	portRange := int(config.SSHHostPortMax - config.SSHHostPortMin)
-	for {
-		sshHostPort = uint(rand.Intn(portRange)) + config.SSHHostPortMin
-		log.Printf("Trying port: %d", sshHostPort)
-		l, err := net.Listen("tcp", fmt.Sprintf(":%d", sshHostPort))
-		if err == nil {
-			defer l.Close()
-			break
-		}
-	}
-	ui.Say(fmt.Sprintf("Found port for SSH: %d.", sshHostPort))
-
-	// Save the port we're using so that future steps can use it
-	state.Put("sshHostPort", sshHostPort)
-
-	return multistep.ActionContinue
-}
-
-func (s *stepForwardSSH) Cleanup(state multistep.StateBag) {}

builder/qemu/step_http_server.go

@@ -1,75 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"math/rand"
-	"net"
-	"net/http"
-)
-
-// This step creates and runs the HTTP server that is serving the files
-// specified by the 'http_files` configuration parameter in the template.
-//
-// Uses:
-//   config *config
-//   ui     packer.Ui
-//
-// Produces:
-//   http_port int - The port the HTTP server started on.
-type stepHTTPServer struct {
-	l net.Listener
-}
-
-func (s *stepHTTPServer) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	ui := state.Get("ui").(packer.Ui)
-
-	var httpPort uint = 0
-	if config.HTTPDir == "" {
-		state.Put("http_port", httpPort)
-		return multistep.ActionContinue
-	}
-
-	// Find an available TCP port for our HTTP server
-	var httpAddr string
-	portRange := int(config.HTTPPortMax - config.HTTPPortMin)
-	for {
-		var err error
-		var offset uint = 0
-
-		if portRange > 0 {
-			// Intn will panic if portRange == 0, so we do a check.
-			offset = uint(rand.Intn(portRange))
-		}
-
-		httpPort = offset + config.HTTPPortMin
-		httpAddr = fmt.Sprintf(":%d", httpPort)
-		log.Printf("Trying port: %d", httpPort)
-		s.l, err = net.Listen("tcp", httpAddr)
-		if err == nil {
-			break
-		}
-	}
-
-	ui.Say(fmt.Sprintf("Starting HTTP server on port %d", httpPort))
-
-	// Start the HTTP server and run it in the background
-	fileServer := http.FileServer(http.Dir(config.HTTPDir))
-	server := &http.Server{Addr: httpAddr, Handler: fileServer}
-	go server.Serve(s.l)
-
-	// Save the address into the state so it can be accessed in the future
-	state.Put("http_port", httpPort)
-
-	return multistep.ActionContinue
-}
-
-func (s *stepHTTPServer) Cleanup(multistep.StateBag) {
-	if s.l != nil {
-		// Close the listener so that the HTTP server stops
-		s.l.Close()
-	}
-}

builder/qemu/step_prepare_output_dir.go

@@ -1,49 +0,0 @@
-package qemu
-
-import (
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-	"time"
-)
-
-type stepPrepareOutputDir struct{}
-
-func (stepPrepareOutputDir) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	ui := state.Get("ui").(packer.Ui)
-
-	if _, err := os.Stat(config.OutputDir); err == nil && config.PackerForce {
-		ui.Say("Deleting previous output directory...")
-		os.RemoveAll(config.OutputDir)
-	}
-
-	if err := os.MkdirAll(config.OutputDir, 0755); err != nil {
-		state.Put("error", err)
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (stepPrepareOutputDir) Cleanup(state multistep.StateBag) {
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-
-	if cancelled || halted {
-		config := state.Get("config").(*config)
-		ui := state.Get("ui").(packer.Ui)
-
-		ui.Say("Deleting output directory...")
-		for i := 0; i < 5; i++ {
-			err := os.RemoveAll(config.OutputDir)
-			if err == nil {
-				break
-			}
-
-			log.Printf("Error removing output dir: %s", err)
-			time.Sleep(2 * time.Second)
-		}
-	}
-}

builder/qemu/step_run.go

@@ -1,116 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"path/filepath"
-	"strings"
-)
-
-// stepRun runs the virtual machine
-type stepRun struct {
-	BootDrive string
-	Message   string
-}
-
-func (s *stepRun) Run(state multistep.StateBag) multistep.StepAction {
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say(s.Message)
-
-	command := getCommandArgs(s.BootDrive, state)
-	if err := driver.Qemu(command...); err != nil {
-		err := fmt.Errorf("Error launching VM: %s", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *stepRun) Cleanup(state multistep.StateBag) {
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	if err := driver.Stop(); err != nil {
-		ui.Error(fmt.Sprintf("Error shutting down VM: %s", err))
-	}
-}
-
-func getCommandArgs(bootDrive string, state multistep.StateBag) []string {
-	config := state.Get("config").(*config)
-	isoPath := state.Get("iso_path").(string)
-	vncPort := state.Get("vnc_port").(uint)
-	sshHostPort := state.Get("sshHostPort").(uint)
-	ui := state.Get("ui").(packer.Ui)
-
-	guiArgument := "sdl"
-	vnc := fmt.Sprintf("0.0.0.0:%d", vncPort-5900)
-	vmName := config.VMName
-	imgPath := filepath.Join(config.OutputDir,
-		fmt.Sprintf("%s.%s", vmName, strings.ToLower(config.Format)))
-
-	if config.Headless == true {
-		ui.Message("WARNING: The VM will be started in headless mode, as configured.\n" +
-			"In headless mode, errors during the boot sequence or OS setup\n" +
-			"won't be easily visible. Use at your own discretion.")
-		guiArgument = "none"
-	}
-
-	defaultArgs := make(map[string]string)
-	defaultArgs["-name"] = vmName
-	defaultArgs["-machine"] = fmt.Sprintf("type=pc-1.0,accel=%s", config.Accelerator)
-	defaultArgs["-display"] = guiArgument
-	defaultArgs["-netdev"] = "user,id=user.0"
-	defaultArgs["-device"] = fmt.Sprintf("%s,netdev=user.0", config.NetDevice)
-	defaultArgs["-drive"] = fmt.Sprintf("file=%s,if=%s", imgPath, config.DiskInterface)
-	defaultArgs["-cdrom"] = isoPath
-	defaultArgs["-boot"] = bootDrive
-	defaultArgs["-m"] = "512m"
-	defaultArgs["-redir"] = fmt.Sprintf("tcp:%v::22", sshHostPort)
-	defaultArgs["-vnc"] = vnc
-
-	inArgs := make(map[string][]string)
-	if len(config.QemuArgs) > 0 {
-		ui.Say("Overriding defaults Qemu arguments with QemuArgs...")
-
-		// becuase qemu supports multiple appearances of the same
-		// switch, just different values, each key in the args hash
-		// will have an array of string values
-		for _, qemuArgs := range config.QemuArgs {
-			key := qemuArgs[0]
-			val := strings.Join(qemuArgs[1:], "")
-			if _, ok := inArgs[key]; !ok {
-				inArgs[key] = make([]string, 0)
-			}
-			if len(val) > 0 {
-				inArgs[key] = append(inArgs[key], val)
-			}
-		}
-	}
-
-	// get any remaining missing default args from the default settings
-	for key := range defaultArgs {
-		if _, ok := inArgs[key]; !ok {
-			arg := make([]string, 1)
-			arg[0] = defaultArgs[key]
-			inArgs[key] = arg
-		}
-	}
-
-	// Flatten to array of strings
-	outArgs := make([]string, 0)
-	for key, values := range inArgs {
-		if len(values) > 0 {
-			for idx := range values {
-				outArgs = append(outArgs, key, values[idx])
-			}
-		} else {
-			outArgs = append(outArgs, key)
-		}
-	}
-
-	return outArgs
-}

builder/qemu/step_shutdown.go

@@ -1,70 +0,0 @@
-package qemu
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"time"
-)
-
-// This step shuts down the machine. It first attempts to do so gracefully,
-// but ultimately forcefully shuts it down if that fails.
-//
-// Uses:
-//   communicator packer.Communicator
-//   config *config
-//   driver Driver
-//   ui     packer.Ui
-//
-// Produces:
-//   <nothing>
-type stepShutdown struct{}
-
-func (s *stepShutdown) Run(state multistep.StateBag) multistep.StepAction {
-	comm := state.Get("communicator").(packer.Communicator)
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	if config.ShutdownCommand != "" {
-		ui.Say("Gracefully halting virtual machine...")
-		log.Printf("Executing shutdown command: %s", config.ShutdownCommand)
-		cmd := &packer.RemoteCmd{Command: config.ShutdownCommand}
-		if err := cmd.StartWithUi(comm, ui); err != nil {
-			err := fmt.Errorf("Failed to send shutdown command: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		// Start the goroutine that will time out our graceful attempt
-		cancelCh := make(chan struct{}, 1)
-		go func() {
-			defer close(cancelCh)
-			<-time.After(config.shutdownTimeout)
-		}()
-
-		log.Printf("Waiting max %s for shutdown to complete", config.shutdownTimeout)
-		if ok := driver.WaitForShutdown(cancelCh); !ok {
-			err := errors.New("Timeout while waiting for machine to shut down.")
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	} else {
-		ui.Say("Halting the virtual machine...")
-		if err := driver.Stop(); err != nil {
-			err := fmt.Errorf("Error stopping VM: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	}
-
-	log.Println("VM shut down.")
-	return multistep.ActionContinue
-}
-
-func (s *stepShutdown) Cleanup(state multistep.StateBag) {}

builder/qemu/step_type_boot_command.go

@@ -1,175 +0,0 @@
-package qemu
-
-import (
-	"fmt"
-	"github.com/mitchellh/go-vnc"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"net"
-	"strings"
-	"time"
-	"unicode"
-	"unicode/utf8"
-)
-
-const KeyLeftShift uint32 = 0xFFE1
-
-type bootCommandTemplateData struct {
-	HTTPIP   string
-	HTTPPort uint
-	Name     string
-}
-
-// This step "types" the boot command into the VM over VNC.
-//
-// Uses:
-//   config *config
-//   http_port int
-//   ui     packer.Ui
-//   vnc_port uint
-//
-// Produces:
-//   <nothing>
-type stepTypeBootCommand struct{}
-
-func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	httpPort := state.Get("http_port").(uint)
-	ui := state.Get("ui").(packer.Ui)
-	vncPort := state.Get("vnc_port").(uint)
-
-	// Connect to VNC
-	ui.Say("Connecting to VM via VNC")
-	nc, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", vncPort))
-	if err != nil {
-		err := fmt.Errorf("Error connecting to VNC: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	defer nc.Close()
-
-	c, err := vnc.Client(nc, &vnc.ClientConfig{Exclusive: true})
-	if err != nil {
-		err := fmt.Errorf("Error handshaking with VNC: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	defer c.Close()
-
-	log.Printf("Connected to VNC desktop: %s", c.DesktopName)
-
-	tplData := &bootCommandTemplateData{
-		"10.0.2.2",
-		httpPort,
-		config.VMName,
-	}
-
-	ui.Say("Typing the boot command over VNC...")
-	for _, command := range config.BootCommand {
-		command, err := config.tpl.Process(command, tplData)
-		if err != nil {
-			err := fmt.Errorf("Error preparing boot command: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		// Check for interrupts between typing things so we can cancel
-		// since this isn't the fastest thing.
-		if _, ok := state.GetOk(multistep.StateCancelled); ok {
-			return multistep.ActionHalt
-		}
-
-		vncSendString(c, command)
-	}
-
-	return multistep.ActionContinue
-}
-
-func (*stepTypeBootCommand) Cleanup(multistep.StateBag) {}
-
-func vncSendString(c *vnc.ClientConn, original string) {
-	special := make(map[string]uint32)
-	special["<bs>"] = 0xFF08
-	special["<del>"] = 0xFFFF
-	special["<enter>"] = 0xFF0D
-	special["<esc>"] = 0xFF1B
-	special["<f1>"] = 0xFFBE
-	special["<f2>"] = 0xFFBF
-	special["<f3>"] = 0xFFC0
-	special["<f4>"] = 0xFFC1
-	special["<f5>"] = 0xFFC2
-	special["<f6>"] = 0xFFC3
-	special["<f7>"] = 0xFFC4
-	special["<f8>"] = 0xFFC5
-	special["<f9>"] = 0xFFC6
-	special["<f10>"] = 0xFFC7
-	special["<f11>"] = 0xFFC8
-	special["<f12>"] = 0xFFC9
-	special["<return>"] = 0xFF0D
-	special["<tab>"] = 0xFF09
-
-	shiftedChars := "~!@#$%^&*()_+{}|:\"<>?"
-
-	// TODO(mitchellh): Ripe for optimizations of some point, perhaps.
-	for len(original) > 0 {
-		var keyCode uint32
-		keyShift := false
-
-		if strings.HasPrefix(original, "<wait>") {
-			log.Printf("Special code '<wait>' found, sleeping one second")
-			time.Sleep(1 * time.Second)
-			original = original[len("<wait>"):]
-			continue
-		}
-
-		if strings.HasPrefix(original, "<wait5>") {
-			log.Printf("Special code '<wait5>' found, sleeping 5 seconds")
-			time.Sleep(5 * time.Second)
-			original = original[len("<wait5>"):]
-			continue
-		}
-
-		if strings.HasPrefix(original, "<wait10>") {
-			log.Printf("Special code '<wait10>' found, sleeping 10 seconds")
-			time.Sleep(10 * time.Second)
-			original = original[len("<wait10>"):]
-			continue
-		}
-
-		for specialCode, specialValue := range special {
-			if strings.HasPrefix(original, specialCode) {
-				log.Printf("Special code '%s' found, replacing with: %d", specialCode, specialValue)
-				keyCode = specialValue
-				original = original[len(specialCode):]
-				break
-			}
-		}
-
-		if keyCode == 0 {
-			r, size := utf8.DecodeRuneInString(original)
-			original = original[size:]
-			keyCode = uint32(r)
-			keyShift = unicode.IsUpper(r) || strings.ContainsRune(shiftedChars, r)
-
-			log.Printf("Sending char '%c', code %d, shift %v", r, keyCode, keyShift)
-		}
-
-		if keyShift {
-			c.KeyEvent(KeyLeftShift, true)
-		}
-
-		c.KeyEvent(keyCode, true)
-		c.KeyEvent(keyCode, false)
-
-		if keyShift {
-			c.KeyEvent(KeyLeftShift, false)
-		}
-
-		// qemu is picky, so no matter what, wait a small period
-		time.Sleep(100 * time.Millisecond)
-	}
-}

builder/qemu/step_wait_for_shutdown.go

@@ -1,43 +0,0 @@
-package qemu
-
-import (
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"time"
-)
-
-// stepWaitForShutdown waits for the shutdown of the currently running
-// qemu VM.
-type stepWaitForShutdown struct {
-	Message string
-}
-
-func (s *stepWaitForShutdown) Run(state multistep.StateBag) multistep.StepAction {
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	stopCh := make(chan struct{})
-	defer close(stopCh)
-
-	cancelCh := make(chan struct{})
-	go func() {
-		for {
-			if _, ok := state.GetOk(multistep.StateCancelled); ok {
-				close(cancelCh)
-				return
-			}
-
-			select {
-			case <-stopCh:
-				return
-			case <-time.After(100 * time.Millisecond):
-			}
-		}
-	}()
-
-	ui.Say(s.Message)
-	driver.WaitForShutdown(cancelCh)
-	return multistep.ActionContinue
-}
-
-func (s *stepWaitForShutdown) Cleanup(state multistep.StateBag) {}

builder/virtualbox/builder.go

@@ -10,21 +10,12 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"time"
 )
 
 const BuilderId = "mitchellh.virtualbox"
 
-// These are the different valid mode values for "guest_additions_mode" which
-// determine how guest additions are delivered to the guest.
-const (
-	GuestAdditionsModeDisable string = "disable"
-	GuestAdditionsModeAttach         = "attach"
-	GuestAdditionsModeUpload         = "upload"
-)
-
 type Builder struct {
 	config config
 	runner multistep.Runner
@@ -37,7 +28,6 @@ type config struct {
 	DiskSize             uint       `mapstructure:"disk_size"`
 	FloppyFiles          []string   `mapstructure:"floppy_files"`
 	Format               string     `mapstructure:"format"`
-	GuestAdditionsMode   string     `mapstructure:"guest_additions_mode"`
 	GuestAdditionsPath   string     `mapstructure:"guest_additions_path"`
 	GuestAdditionsURL    string     `mapstructure:"guest_additions_url"`
 	GuestAdditionsSHA256 string     `mapstructure:"guest_additions_sha256"`
@@ -73,21 +63,20 @@ type config struct {
 	tpl             *packer.ConfigTemplate
 }
 
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+func (b *Builder) Prepare(raws ...interface{}) error {
 	md, err := common.DecodeConfig(&b.config, raws...)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	b.config.tpl, err = packer.NewConfigTemplate()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	b.config.tpl.UserVars = b.config.PackerUserVars
 
-	// Accumulate any errors and warnings
+	// Accumulate any errors
 	errs := common.CheckUnusedConfig(md)
-	warnings := make([]string, 0)
 
 	if b.config.DiskSize == 0 {
 		b.config.DiskSize = 40000
@@ -97,10 +86,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.FloppyFiles = make([]string, 0)
 	}
 
-	if b.config.GuestAdditionsMode == "" {
-		b.config.GuestAdditionsMode = "upload"
-	}
-
 	if b.config.GuestAdditionsPath == "" {
 		b.config.GuestAdditionsPath = "VBoxGuestAdditions.iso"
 	}
@@ -159,7 +144,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 	// Errors
 	templates := map[string]*string{
-		"guest_additions_mode":    &b.config.GuestAdditionsMode,
 		"guest_additions_sha256":  &b.config.GuestAdditionsSHA256,
 		"guest_os_type":           &b.config.GuestOSType,
 		"hard_drive_interface":    &b.config.HardDriveInterface,
@@ -169,7 +153,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		"iso_url":                 &b.config.RawSingleISOUrl,
 		"output_directory":        &b.config.OutputDir,
 		"shutdown_command":        &b.config.ShutdownCommand,
-		"ssh_key_path":            &b.config.SSHKeyPath,
 		"ssh_password":            &b.config.SSHPassword,
 		"ssh_username":            &b.config.SSHUser,
 		"virtualbox_version_file": &b.config.VBoxVersionFile,
@@ -279,25 +262,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	validMode := false
-	validModes := []string{
-		GuestAdditionsModeDisable,
-		GuestAdditionsModeAttach,
-		GuestAdditionsModeUpload,
-	}
-
-	for _, mode := range validModes {
-		if b.config.GuestAdditionsMode == mode {
-			validMode = true
-			break
-		}
-	}
-
-	if !validMode {
-		errs = packer.MultiErrorAppend(errs,
-			fmt.Errorf("guest_additions_mode is invalid. Must be one of: %v", validModes))
-	}
-
 	if b.config.GuestAdditionsSHA256 != "" {
 		b.config.GuestAdditionsSHA256 = strings.ToLower(b.config.GuestAdditionsSHA256)
 	}
@@ -365,18 +329,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	// Warnings
-	if b.config.ShutdownCommand == "" {
-		warnings = append(warnings,
-			"A shutdown_command was not specified. Without a shutdown command, Packer\n"+
-				"will forcibly halt the virtual machine, which may result in data loss.")
-	}
-
 	if errs != nil && len(errs.Errors) > 0 {
-		return warnings, errs
+		return errs
 	}
 
-	return warnings, nil
+	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
@@ -404,7 +361,6 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		new(stepCreateVM),
 		new(stepCreateDisk),
 		new(stepAttachISO),
-		new(stepAttachGuestAdditions),
 		new(stepAttachFloppy),
 		new(stepForwardSSH),
 		new(stepVBoxManage),
@@ -486,29 +442,9 @@ func (b *Builder) Cancel() {
 }
 
 func (b *Builder) newDriver() (Driver, error) {
-	var vboxmanagePath string
-
-	if runtime.GOOS == "windows" {
-		// On Windows, we check VBOX_INSTALL_PATH env var for the path
-		if installPath := os.Getenv("VBOX_INSTALL_PATH"); installPath != "" {
-			log.Printf("[DEBUG] builder/virtualbox: VBOX_INSTALL_PATH: %s",
-				installPath)
-			for _, path := range strings.Split(installPath, ";") {
-				path = filepath.Join(path, "VBoxManage.exe")
-				if _, err := os.Stat(path); err == nil {
-					vboxmanagePath = path
-					break
-				}
-			}
-		}
-	}
-
-	if vboxmanagePath == "" {
-		var err error
-		vboxmanagePath, err = exec.LookPath("VBoxManage")
-		if err != nil {
-			return nil, err
-		}
+	vboxmanagePath, err := exec.LookPath("VBoxManage")
+	if err != nil {
+		return nil, err
 	}
 
 	log.Printf("VBoxManage path: %s", vboxmanagePath)

builder/virtualbox/builder_test.go

@@ -43,7 +43,6 @@ func testConfig() map[string]interface{} {
 		"iso_checksum":      "foo",
 		"iso_checksum_type": "md5",
 		"iso_url":           "http://www.google.com/",
-		"shutdown_command":  "yes",
 		"ssh_username":      "foo",
 
 		packer.BuildNameConfigKey: "foo",
@@ -61,18 +60,11 @@ func TestBuilder_ImplementsBuilder(t *testing.T) {
 func TestBuilderPrepare_Defaults(t *testing.T) {
 	var b Builder
 	config := testConfig()
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.GuestAdditionsMode != GuestAdditionsModeUpload {
-		t.Errorf("bad guest additions mode: %s", b.config.GuestAdditionsMode)
-	}
-
 	if b.config.GuestOSType != "Other" {
 		t.Errorf("bad guest OS type: %s", b.config.GuestOSType)
 	}
@@ -108,10 +100,7 @@ func TestBuilderPrepare_BootWait(t *testing.T) {
 
 	// Test a default boot_wait
 	delete(config, "boot_wait")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -122,10 +111,7 @@ func TestBuilderPrepare_BootWait(t *testing.T) {
 
 	// Test with a bad boot_wait
 	config["boot_wait"] = "this is not good"
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -133,10 +119,7 @@ func TestBuilderPrepare_BootWait(t *testing.T) {
 	// Test with a good one
 	config["boot_wait"] = "5s"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -147,10 +130,7 @@ func TestBuilderPrepare_DiskSize(t *testing.T) {
 	config := testConfig()
 
 	delete(config, "disk_size")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("bad err: %s", err)
 	}
@@ -161,10 +141,7 @@ func TestBuilderPrepare_DiskSize(t *testing.T) {
 
 	config["disk_size"] = 60000
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -179,10 +156,7 @@ func TestBuilderPrepare_FloppyFiles(t *testing.T) {
 	config := testConfig()
 
 	delete(config, "floppy_files")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("bad err: %s", err)
 	}
@@ -193,10 +167,7 @@ func TestBuilderPrepare_FloppyFiles(t *testing.T) {
 
 	config["floppy_files"] = []string{"foo", "bar"}
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -207,56 +178,12 @@ func TestBuilderPrepare_FloppyFiles(t *testing.T) {
 	}
 }
 
-func TestBuilderPrepare_GuestAdditionsMode(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// test default mode
-	delete(config, "guest_additions_mode")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("bad err: %s", err)
-	}
-
-	// Test another mode
-	config["guest_additions_mode"] = "attach"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.GuestAdditionsMode != GuestAdditionsModeAttach {
-		t.Fatalf("bad: %s", b.config.GuestAdditionsMode)
-	}
-
-	// Test bad mode
-	config["guest_additions_mode"] = "teleport"
-	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should error")
-	}
-}
-
 func TestBuilderPrepare_GuestAdditionsPath(t *testing.T) {
 	var b Builder
 	config := testConfig()
 
 	delete(config, "guest_additions_path")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("bad err: %s", err)
 	}
@@ -267,10 +194,7 @@ func TestBuilderPrepare_GuestAdditionsPath(t *testing.T) {
 
 	config["guest_additions_path"] = "foo"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -285,10 +209,7 @@ func TestBuilderPrepare_GuestAdditionsSHA256(t *testing.T) {
 	config := testConfig()
 
 	delete(config, "guest_additions_sha256")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("bad err: %s", err)
 	}
@@ -299,10 +220,7 @@ func TestBuilderPrepare_GuestAdditionsSHA256(t *testing.T) {
 
 	config["guest_additions_sha256"] = "FOO"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -317,10 +235,7 @@ func TestBuilderPrepare_GuestAdditionsURL(t *testing.T) {
 	config := testConfig()
 
 	config["guest_additions_url"] = ""
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -331,10 +246,7 @@ func TestBuilderPrepare_GuestAdditionsURL(t *testing.T) {
 
 	config["guest_additions_url"] = "http://www.packer.io"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Errorf("should not have error: %s", err)
 	}
@@ -346,10 +258,7 @@ func TestBuilderPrepare_HardDriveInterface(t *testing.T) {
 
 	// Test a default boot_wait
 	delete(config, "hard_drive_interface")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -361,10 +270,7 @@ func TestBuilderPrepare_HardDriveInterface(t *testing.T) {
 	// Test with a bad
 	config["hard_drive_interface"] = "fake"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -372,10 +278,7 @@ func TestBuilderPrepare_HardDriveInterface(t *testing.T) {
 	// Test with a good
 	config["hard_drive_interface"] = "sata"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -388,10 +291,7 @@ func TestBuilderPrepare_HTTPPort(t *testing.T) {
 	// Bad
 	config["http_port_min"] = 1000
 	config["http_port_max"] = 500
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -399,10 +299,7 @@ func TestBuilderPrepare_HTTPPort(t *testing.T) {
 	// Bad
 	config["http_port_min"] = -500
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -411,10 +308,7 @@ func TestBuilderPrepare_HTTPPort(t *testing.T) {
 	config["http_port_min"] = 500
 	config["http_port_max"] = 1000
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -426,10 +320,7 @@ func TestBuilderPrepare_Format(t *testing.T) {
 
 	// Bad
 	config["format"] = "illegal value"
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -437,10 +328,7 @@ func TestBuilderPrepare_Format(t *testing.T) {
 	// Good
 	config["format"] = "ova"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -448,10 +336,7 @@ func TestBuilderPrepare_Format(t *testing.T) {
 	// Good
 	config["format"] = "ovf"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -463,10 +348,7 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 
 	// Add a random key
 	config["i_should_not_be_valid"] = true
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -478,10 +360,7 @@ func TestBuilderPrepare_ISOChecksum(t *testing.T) {
 
 	// Test bad
 	config["iso_checksum"] = ""
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -489,10 +368,7 @@ func TestBuilderPrepare_ISOChecksum(t *testing.T) {
 	// Test good
 	config["iso_checksum"] = "FOo"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -508,10 +384,7 @@ func TestBuilderPrepare_ISOChecksumType(t *testing.T) {
 
 	// Test bad
 	config["iso_checksum_type"] = ""
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -519,10 +392,7 @@ func TestBuilderPrepare_ISOChecksumType(t *testing.T) {
 	// Test good
 	config["iso_checksum_type"] = "mD5"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -534,10 +404,7 @@ func TestBuilderPrepare_ISOChecksumType(t *testing.T) {
 	// Test unknown
 	config["iso_checksum_type"] = "fake"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -552,10 +419,7 @@ func TestBuilderPrepare_ISOUrl(t *testing.T) {
 	// Test both epty
 	config["iso_url"] = ""
 	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -563,10 +427,7 @@ func TestBuilderPrepare_ISOUrl(t *testing.T) {
 	// Test iso_url set
 	config["iso_url"] = "http://www.packer.io"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Errorf("should not have error: %s", err)
 	}
@@ -580,10 +441,7 @@ func TestBuilderPrepare_ISOUrl(t *testing.T) {
 	config["iso_url"] = "http://www.packer.io"
 	config["iso_urls"] = []string{"http://www.packer.io"}
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -596,10 +454,7 @@ func TestBuilderPrepare_ISOUrl(t *testing.T) {
 	}
 
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Errorf("should not have error: %s", err)
 	}
@@ -626,10 +481,7 @@ func TestBuilderPrepare_OutputDir(t *testing.T) {
 
 	config["output_directory"] = dir
 	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -637,40 +489,19 @@ func TestBuilderPrepare_OutputDir(t *testing.T) {
 	// Test with a good one
 	config["output_directory"] = "i-hope-i-dont-exist"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
 }
 
-func TestBuilderPrepare_ShutdownCommand(t *testing.T) {
-	var b Builder
-	config := testConfig()
-	delete(config, "shutdown_command")
-
-	warns, err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-
-	if len(warns) != 1 {
-		t.Fatalf("bad: %#v", warns)
-	}
-}
-
 func TestBuilderPrepare_ShutdownTimeout(t *testing.T) {
 	var b Builder
 	config := testConfig()
 
 	// Test with a bad value
 	config["shutdown_timeout"] = "this is not good"
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -678,10 +509,7 @@ func TestBuilderPrepare_ShutdownTimeout(t *testing.T) {
 	// Test with a good one
 	config["shutdown_timeout"] = "5s"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -695,10 +523,7 @@ func TestBuilderPrepare_SSHHostPort(t *testing.T) {
 	config["ssh_host_port_min"] = 1000
 	config["ssh_host_port_max"] = 500
 	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -706,10 +531,7 @@ func TestBuilderPrepare_SSHHostPort(t *testing.T) {
 	// Bad
 	config["ssh_host_port_min"] = -500
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -718,10 +540,7 @@ func TestBuilderPrepare_SSHHostPort(t *testing.T) {
 	config["ssh_host_port_min"] = 500
 	config["ssh_host_port_max"] = 1000
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -733,20 +552,14 @@ func TestBuilderPrepare_sshKeyPath(t *testing.T) {
 
 	config["ssh_key_path"] = ""
 	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
 
 	config["ssh_key_path"] = "/i/dont/exist"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -765,10 +578,7 @@ func TestBuilderPrepare_sshKeyPath(t *testing.T) {
 
 	config["ssh_key_path"] = tf.Name()
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -779,10 +589,7 @@ func TestBuilderPrepare_sshKeyPath(t *testing.T) {
 	tf.Write([]byte(testPem))
 	config["ssh_key_path"] = tf.Name()
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -794,20 +601,14 @@ func TestBuilderPrepare_SSHUser(t *testing.T) {
 
 	config["ssh_username"] = ""
 	b = Builder{}
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	config["ssh_username"] = "exists"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -819,10 +620,7 @@ func TestBuilderPrepare_SSHWaitTimeout(t *testing.T) {
 
 	// Test a default boot_wait
 	delete(config, "ssh_wait_timeout")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -834,10 +632,7 @@ func TestBuilderPrepare_SSHWaitTimeout(t *testing.T) {
 	// Test with a bad value
 	config["ssh_wait_timeout"] = "this is not good"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
@@ -845,10 +640,7 @@ func TestBuilderPrepare_SSHWaitTimeout(t *testing.T) {
 	// Test with a good one
 	config["ssh_wait_timeout"] = "5s"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -860,10 +652,7 @@ func TestBuilderPrepare_VBoxManage(t *testing.T) {
 
 	// Test with empty
 	delete(config, "vboxmanage")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -878,10 +667,7 @@ func TestBuilderPrepare_VBoxManage(t *testing.T) {
 	}
 
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}
@@ -901,10 +687,7 @@ func TestBuilderPrepare_VBoxVersionFile(t *testing.T) {
 
 	// Test empty
 	delete(config, "virtualbox_version_file")
-	warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -916,10 +699,7 @@ func TestBuilderPrepare_VBoxVersionFile(t *testing.T) {
 	// Test with a good one
 	config["virtualbox_version_file"] = "foo"
 	b = Builder{}
-	warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
+	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
 	}

builder/virtualbox/driver.go

@@ -11,15 +11,8 @@ import (
 )
 
 // A driver is able to talk to VirtualBox and perform certain
-// operations with it. Some of the operations on here may seem overly
-// specific, but they were built specifically in mind to handle features
-// of the VirtualBox builder for Packer, and to abstract differences in
-// versions out of the builder steps, so sometimes the methods are
-// extremely specific.
+// operations with it.
 type Driver interface {
-	// Create a SATA controller.
-	CreateSATAController(vm string, controller string) error
-
 	// Checks if the VM with the given name is running.
 	IsRunning(string) (bool, error)
 
@@ -47,27 +40,6 @@ type VBox42Driver struct {
 	VBoxManagePath string
 }
 
-func (d *VBox42Driver) CreateSATAController(vmName string, name string) error {
-	version, err := d.Version()
-	if err != nil {
-		return err
-	}
-
-	portCountArg := "--sataportcount"
-	if strings.HasPrefix(version, "4.3") {
-		portCountArg = "--portcount"
-	}
-
-	command := []string{
-		"storagectl", vmName,
-		"--name", name,
-		"--add", "sata",
-		portCountArg, "1",
-	}
-
-	return d.VBoxManage(command...)
-}
-
 func (d *VBox42Driver) IsRunning(name string) (bool, error) {
 	var stdout bytes.Buffer
 
@@ -163,17 +135,9 @@ func (d *VBox42Driver) Version() (string, error) {
 
 	versionOutput := strings.TrimSpace(stdout.String())
 	log.Printf("VBoxManage --version output: %s", versionOutput)
-
-	// If the "--version" output contains vboxdrv, then this is indicative
-	// of problems with the VirtualBox setup and we shouldn't really continue,
-	// whether or not we can read the version.
-	if strings.Contains(versionOutput, "vboxdrv") {
-		return "", fmt.Errorf("VirtualBox is not properly setup: %s", versionOutput)
-	}
-
 	versionRe := regexp.MustCompile("[^.0-9]")
 	matches := versionRe.Split(versionOutput, 2)
-	if len(matches) == 0 || matches[0] == "" {
+	if len(matches) == 0 {
 		return "", fmt.Errorf("No version found: %s", versionOutput)
 	}
 

builder/virtualbox/step_attach_guest_additions.go

@@ -1,81 +0,0 @@
-package virtualbox
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-// This step attaches the VirtualBox guest additions as a inserted CD onto
-// the virtual machine.
-//
-// Uses:
-//   config *config
-//   driver Driver
-//   guest_additions_path string
-//   ui packer.Ui
-//   vmName string
-//
-// Produces:
-type stepAttachGuestAdditions struct {
-	attachedPath string
-}
-
-func (s *stepAttachGuestAdditions) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(Driver)
-	guestAdditionsPath := state.Get("guest_additions_path").(string)
-	ui := state.Get("ui").(packer.Ui)
-	vmName := state.Get("vmName").(string)
-
-	// If we're not attaching the guest additions then just return
-	if config.GuestAdditionsMode != GuestAdditionsModeAttach {
-		log.Println("Not attaching guest additions since we're uploading.")
-		return multistep.ActionContinue
-	}
-
-	// Attach the guest additions to the computer
-	log.Println("Attaching guest additions ISO onto IDE controller...")
-	command := []string{
-		"storageattach", vmName,
-		"--storagectl", "IDE Controller",
-		"--port", "1",
-		"--device", "0",
-		"--type", "dvddrive",
-		"--medium", guestAdditionsPath,
-	}
-	if err := driver.VBoxManage(command...); err != nil {
-		err := fmt.Errorf("Error attaching guest additions: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Track the path so that we can unregister it from VirtualBox later
-	s.attachedPath = guestAdditionsPath
-
-	return multistep.ActionContinue
-}
-
-func (s *stepAttachGuestAdditions) Cleanup(state multistep.StateBag) {
-	if s.attachedPath == "" {
-		return
-	}
-
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-	vmName := state.Get("vmName").(string)
-
-	command := []string{
-		"storageattach", vmName,
-		"--storagectl", "IDE Controller",
-		"--port", "1",
-		"--device", "0",
-		"--medium", "none",
-	}
-
-	if err := driver.VBoxManage(command...); err != nil {
-		ui.Error(fmt.Sprintf("Error unregistering guest additions: %s", err))
-	}
-}

builder/virtualbox/step_create_disk.go

@@ -56,7 +56,13 @@ func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
 	// that.
 	if config.HardDriveInterface == "sata" {
 		controllerName = "SATA Controller"
-		if err := driver.CreateSATAController(vmName, controllerName); err != nil {
+		command = []string{
+			"storagectl", vmName,
+			"--name", controllerName,
+			"--add", "sata",
+			"--sataportcount", "1",
+		}
+		if err := driver.VBoxManage(command...); err != nil {
 			err := fmt.Errorf("Error creating disk controller: %s", err)
 			state.Put("error", err)
 			ui.Error(err.Error())

builder/virtualbox/step_create_vm.go

@@ -43,7 +43,7 @@ func (s *stepCreateVM) Run(state multistep.StateBag) multistep.StepAction {
 			return multistep.ActionHalt
 		}
 
-		// Set the VM name property on the first command
+		// Set the VM name propery on the first command
 		if s.vmName == "" {
 			s.vmName = name
 		}

builder/virtualbox/step_export.go

@@ -4,9 +4,7 @@ import (
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"log"
 	"path/filepath"
-	"time"
 )
 
 // This step cleans up forwarded ports and exports the VM to an OVF.
@@ -23,10 +21,6 @@ func (s *stepExport) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 	vmName := state.Get("vmName").(string)
 
-	// Wait a second to ensure VM is really shutdown.
-	log.Println("1 second timeout to ensure VM is really shutdown")
-	time.Sleep(1 * time.Second)
-
 	// Clear out the Packer-created forwarding rule
 	ui.Say("Preparing to export machine...")
 	ui.Message(fmt.Sprintf("Deleting forwarded port mapping for SSH (host port %d)", state.Get("sshHostPort")))

builder/virtualbox/step_forward_ssh.go

@@ -25,16 +25,9 @@ func (s *stepForwardSSH) Run(state multistep.StateBag) multistep.StepAction {
 
 	log.Printf("Looking for available SSH port between %d and %d", config.SSHHostPortMin, config.SSHHostPortMax)
 	var sshHostPort uint
-	var offset uint = 0
-
 	portRange := int(config.SSHHostPortMax - config.SSHHostPortMin)
-	if portRange > 0 {
-		// Have to check if > 0 to avoid a panic
-		offset = uint(rand.Intn(portRange))
-	}
-
 	for {
-		sshHostPort = offset + config.SSHHostPortMin
+		sshHostPort = uint(rand.Intn(portRange)) + config.SSHHostPortMin
 		log.Printf("Trying port: %d", sshHostPort)
 		l, err := net.Listen("tcp", fmt.Sprintf(":%d", sshHostPort))
 		if err == nil {

builder/virtualbox/step_run.go

@@ -42,18 +42,7 @@ func (s *stepRun) Run(state multistep.StateBag) multistep.StepAction {
 
 	if int64(config.bootWait) > 0 {
 		ui.Say(fmt.Sprintf("Waiting %s for boot...", config.bootWait))
-		wait := time.After(config.bootWait)
-	WAITLOOP:
-		for {
-			select {
-			case <-wait:
-				break WAITLOOP
-			case <-time.After(1 * time.Second):
-				if _, ok := state.GetOk(multistep.StateCancelled); ok {
-					return multistep.ActionHalt
-				}
-			}
-		}
+		time.Sleep(config.bootWait)
 	}
 
 	return multistep.ActionContinue

builder/virtualbox/step_type_boot_command.go

@@ -92,34 +92,29 @@ func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction
 func (*stepTypeBootCommand) Cleanup(multistep.StateBag) {}
 
 func scancodes(message string) []string {
-	// Scancodes reference: http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
-	//
-	// Scancodes represent raw keyboard output and are fed to the VM by the
-	// VBoxManage controlvm keyboardputscancode program.
-	//
-	// Scancodes are recorded here in pairs. The first entry represents
-	// the key press and the second entry represents the key release and is
-	// derived from the first by the addition of 0x80.
 	special := make(map[string][]string)
-	special["<bs>"] = []string{"0e", "8e"}
-	special["<del>"] = []string{"53", "d3"}
+	special["<bs>"] = []string{"ff", "08"}
+	special["<del>"] = []string{"ff", "ff"}
 	special["<enter>"] = []string{"1c", "9c"}
 	special["<esc>"] = []string{"01", "81"}
-	special["<f1>"] = []string{"3b", "bb"}
-	special["<f2>"] = []string{"3c", "bc"}
-	special["<f3>"] = []string{"3d", "bd"}
-	special["<f4>"] = []string{"3e", "be"}
-	special["<f5>"] = []string{"3f", "bf"}
-	special["<f6>"] = []string{"40", "c0"}
-	special["<f7>"] = []string{"41", "c1"}
-	special["<f8>"] = []string{"42", "c2"}
-	special["<f9>"] = []string{"43", "c3"}
-	special["<f10>"] = []string{"44", "c4"}
+	special["<f1>"] = []string{"ff", "be"}
+	special["<f2>"] = []string{"ff", "bf"}
+	special["<f3>"] = []string{"ff", "c0"}
+	special["<f4>"] = []string{"ff", "c1"}
+	special["<f5>"] = []string{"ff", "c2"}
+	special["<f6>"] = []string{"ff", "c3"}
+	special["<f7>"] = []string{"ff", "c4"}
+	special["<f8>"] = []string{"ff", "c5"}
+	special["<f9>"] = []string{"ff", "c6"}
+	special["<f10>"] = []string{"ff", "c7"}
+	special["<f11>"] = []string{"ff", "c8"}
+	special["<f12>"] = []string{"ff", "c9"}
 	special["<return>"] = []string{"1c", "9c"}
 	special["<tab>"] = []string{"0f", "8f"}
 
 	shiftedChars := "~!@#$%^&*()_+{}|:\"<>?"
 
+	// Scancodes reference: http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
 	scancodeIndex := make(map[string]uint)
 	scancodeIndex["1234567890-="] = 0x02
 	scancodeIndex["!@#$%^&*()_+"] = 0x02

builder/virtualbox/step_upload_guest_additions.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"log"
 	"os"
 )
 
@@ -22,12 +21,6 @@ func (s *stepUploadGuestAdditions) Run(state multistep.StateBag) multistep.StepA
 	guestAdditionsPath := state.Get("guest_additions_path").(string)
 	ui := state.Get("ui").(packer.Ui)
 
-	// If we're attaching then don't do this, since we attached.
-	if config.GuestAdditionsMode != GuestAdditionsModeUpload {
-		log.Println("Not uploading guest additions since mode is not upload")
-		return multistep.ActionContinue
-	}
-
 	version, err := driver.Version()
 	if err != nil {
 		state.Put("error", fmt.Errorf("Error reading version for guest additions upload: %s", err))

builder/vmware/artifact.go

@@ -8,13 +8,12 @@ import (
 // Artifact is the result of running the VMware builder, namely a set
 // of files associated with the resulting machine.
 type Artifact struct {
-	builderId string
-	dir       string
-	f         []string
+	dir string
+	f   []string
 }
 
-func (a *Artifact) BuilderId() string {
-	return a.builderId
+func (*Artifact) BuilderId() string {
+	return BuilderId
 }
 
 func (a *Artifact) Files() []string {