v0.1.2

.gitignore

@@ -1,6 +1,5 @@
 /bin
 /local
 /pkg
-/src
 /website/.sass-cache
 /website/build

.travis.yml

@@ -1,22 +0,0 @@
-language: go
-
-go:
-    - 1.1
-    - tip
-
-install: make deps
-script: make test
-
-notifications:
-    flowdock:
-        secure: fZrcf9rlh2IrQrlch1sHkn3YI7SKvjGnAl/zyV5D6NROe1Bbr6d3QRMuCXWWdhJHzjKmXk5rIzbqJhUc0PNF7YjxGNKSzqWMQ56KcvN1k8DzlqxpqkcA3Jbs6fXCWo2fssRtZ7hj/wOP1f5n6cc7kzHDt9dgaYJ6nO2fqNPJiTc=
-
-    irc:
-        channels:
-            - "chat.freenode.net#packer-tool"
-        on_success: change
-        on_failure: always
-
-matrix:
-    allow_failures:
-        - go: tip

CHANGELOG.md

@@ -1,302 +1,3 @@
-## 0.3.2 (August 18, 2013)
-
-FEATURES:
-
-* New command: `packer inspect`. This command tells you the components of
-  a template. It respects the `-machine-readable` flag as well so you can
-  parse out components of a template.
-* Packer will detect its own crashes (always a bug) and save a "crash.log"
-  file.
-* builder/virtualbox: You may now specify multiple URLs for an ISO
-  using "iso_url" in a template. The URLs will be tried in order.
-* builder/vmware: You may now specify multiple URLs for an ISO
-  using "iso_url" in a template. The URLs will be tried in order.
-
-IMPROVEMENTS:
-
-* core: built with Go 1.1.2
-* core: packer help output now loads much faster.
-* builder/virtualbox: guest_additions_url can now use the `Version`
-  variable to get the VirtualBox version. [GH-272]
-* builder/virtualbox: Do not check for VirtualBox as part of template
-  validation; only check at execution.
-* builder/vmware: Do not check for VMware as part of template validation;
-  only check at execution.
-* command/build: A path of "-" will read the template from stdin.
-* builder/amazon: add block device mappings [GH-90]
-
-BUG FIXES:
-
-* windows: file URLs are easier to get right as Packer
-  has better parsing and error handling for Windows file paths. [GH-284]
-* builder/amazon/all: Modifying more than one AMI attribute type no longer
-  crashes.
-* builder/amazon-instance: send IAM instance profile data. [GH-294]
-* builder/digitalocean: API request parameters are properly URL
-  encoded. [GH-281]
-* builder/virtualbox: dowload progress won't be shown until download
-  actually starts. [GH-288]
-* builder/virtualbox: floppy files names of 13 characters are now properly
-  written to the FAT12 filesystem. [GH-285]
-* builder/vmware: dowload progress won't be shown until download
-  actually starts. [GH-288]
-* builder/vmware: interrupt works while typing commands over VNC.
-* builder/virtualbox: floppy files names of 13 characters are now properly
-  written to the FAT12 filesystem. [GH-285]
-* post-processor/vagrant: Process user variables. [GH-295]
-
-## 0.3.1 (August 12, 2013)
-
-IMPROVEMENTS:
-
-* provisioner/shell: New setting `start_retry_timeout` which is the timeout
-  for the provisioner to attempt to _start_ the remote process. This allows
-  the shell provisioner to work properly with reboots. [GH-260]
-
-BUG FIXES:
-
-* core: Remote command output containing '\r' now looks much better
-  within the Packer output.
-* builder/vmware: Fix issue with finding driver files. [GH-279]
-* provisioner/salt-masterless: Uploads work properly from Windows. [GH-276]
-
-## 0.3.0 (August 12, 2013)
-
-BACKWARDS INCOMPATIBILITIES:
-
-* All `{{.CreateTime}}` variables within templates (such as for AMI names)
-  are now replaced with `{{timestamp}}`. Run `packer fix` to fix your
-  templates.
-
-FEATURES:
-
-* **User Variables** allow you to specify variables within your templates
-  that can be replaced using the command-line, files, or environmental
-  variables. This dramatically improves the portability of packer templates.
-  See the documentation for more information.
-* **Machine-readable output** can be enabled by passing the
-  `-machine-readable` flag to _any_ Packer command.
-* All strings in a template are now processed for variables/functions,
-  so things like `{{timestamp}}` can be used everywhere. More features will
-  be added in the future.
-* The `amazon` builders (all of them) can now have attributes of their
-  resulting AMIs modified, such as access permissions and product codes.
-
-IMPROVEMENTS:
-
-* builder/amazon/all: User data can be passed to start the instances. [GH-253]
-* provisioner/salt-masterless: `local_state_tree` is no longer required,
-  allowing you to use shell provisioner (or others) to bring this down.
-  [GH-269]
-
-BUG FIXES:
-
-* builder/amazon/ebs,instance: Retry deleing security group a few times.
-  [GH-278]
-* builder/vmware: Workstation works on Windows XP now. [GH-238]
-* builder/vmware: Look for files on Windows in multiple locations
-  using multiple environmental variables. [GH-263]
-* provisioner/salt-masterless: states aren't deleted after the run
-  anymore. [GH-265]
-* provisioner/salt-masterless: error if any commands exit with a non-zero
-  exit status. [GH-266]
-
-## 0.2.3 (August 7, 2013)
-
-IMPROVEMENTS:
-
-* builder/amazon/all: Added Amazon AMI tag support [GH-233]
-
-BUG FIXES:
-
-* core: Absolute/relative filepaths on Windows now work for iso_url
-  and other settings. [GH-240]
-* builder/amazon/all: instance info is refreshed while waiting for SSH,
-  allowing Packer to see updated IP/DNS info. [GH-243]
-
-## 0.2.2 (August 1, 2013)
-
-FEATURES:
-
-* New builder: `amazon-chroot` can create EBS-backed AMIs without launching
-  a new EC2 instance. This can shave minutes off of the AMI creation process.
-  See the docs for more info.
-* New provisioner: `salt-masterless` will provision the node using Salt
-  without a master.
-* The `vmware` builder now works with Workstation 9 on Windows. [GH-222]
-* The `vmware` builder now works with Player 5 on Linux. [GH-190]
-
-IMPROVEMENTS:
-
-* core: Colors won't be outputted on Windows unless in Cygwin.
-* builder/amazon/all: Added `iam_instance_profile` to launch the source
-  image with a given IAM profile. [GH-226]
-
-BUG FIXES:
-
-* builder/virtualbox,vmware: relative paths work properly as URL
-  configurations. [GH-215]
-* builder/virtualbox,vmware: fix race condition in deleting the output
-  directory on Windows by retrying.
-
-## 0.2.1 (July 26, 2013)
-
-FEATURES:
-
-* New builder: `amazon-instance` can create instance-storage backed
-  AMIs.
-* VMware builder now works with Workstation 9 on Linux.
-
-IMPROVEMENTS:
-
-* builder/amazon/all: Ctrl-C while waiting for state change works
-* builder/amazon/ebs: Can now launch instances into a VPC for added protection [GH-210]
-* builder/virtualbox,vmware: Add backspace, delete, and F1-F12 keys to the boot
-  command.
-* builder/virtualbox: massive performance improvements with big ISO files because
-  an expensive copy is avoided. [GH-202]
-* builder/vmware: CD is removed prior to exporting final machine. [GH-198]
-
-BUG FIXES:
-
-* builder/amazon/all: Gracefully handle when AMI appears to not exist
-  while AWS state is propogating. [GH-207]
-* builder/virtualbox: Trim carriage returns for Windows to properly
-  detect VM state on Windows. [GH-218]
-* core: build names no longer cause invalid config errors. [GH-197]
-* command/build: If any builds fail, exit with non-zero exit status.
-* communicator/ssh: SCP exit codes are tested and errors are reported. [GH-195]
-* communicator/ssh: Properly change slash direction for Windows hosts. [GH-218]
-
-## 0.2.0 (July 16, 2013)
-
-BACKWARDS INCOMPATIBILITIES:
-
-* "iso_md5" in the virtualbox and vmware builders is replaced with
-  "iso_checksum" and "iso_checksum_type" (with the latter set to "md5").
-  See the announce below on `packer fix` to automatically fix your templates.
-
-FEATURES:
-
-* **NEW COMMAND:** `packer fix` will attempt to fix templates from older
-  versions of Packer that are now broken due to backwards incompatibilities.
-  This command will fix the backwards incompatibilities introduced in this
-  version.
-* Amazon EBS builder can now optionally use a pre-made security group
-  instead of randomly generating one.
-* DigitalOcean API key and client IDs can now be passed in as
-  environmental variables. See the documentatin for more details.
-* VirtualBox and VMware can now have `floppy_files` specified to attach
-  floppy disks when booting. This allows for unattended Windows installs.
-* `packer build` has a new `-force` flag that forces the removal of
-  existing artifacts if they exist. [GH-173]
-* You can now log to a file (instead of just stderr) by setting the
-  `PACKER_LOG_FILE` environmental variable. [GH-168]
-* Checksums other than MD5 can now be used. SHA1 and SHA256 can also
-  be used. See the documentation on `iso_checksum_type` for more info. [GH-175]
-
-IMPROVEMENTS:
-
-* core: invalid keys in configuration are now considered validation
-  errors. [GH-104]
-* core: all builders now share a common SSH connection core, improving
-  SSH reliability over all the builders.
-* amazon-ebs: Credentials will come from IAM role if available. [GH-160]
-* amazon-ebs: Verify the source AMI is EBS-backed before launching. [GH-169]
-* shell provisioner: the build name and builder type are available in
-  the `PACKER_BUILD_NAME` and `PACKER_BUILDER_TYPE` env vars by default,
-  respectively. [GH-154]
-* vmware: error if shutdown command has non-zero exit status.
-
-BUG FIXES:
-
-* core: UI messages are now properly prefixed with spaces again.
-* core: If SSH connection ends, re-connection attempts will take
-  place. [GH-152]
-* virtualbox: "paused" doesn't mean the VM is stopped, improving
-  shutdown detection.
-* vmware: error if guest IP could not be detected. [GH-189]
-
-## 0.1.5 (July 7, 2013)
-
-FEATURES:
-
-* "file" uploader will upload files from the machine running Packer to the
-  remote machine.
-* VirtualBox guest additions URL and checksum can now be specified, allowing
-  the VirtualBox builder to have the ability to be used completely offline.
-
-IMPROVEMENTS:
-
-* core: If SCP is not available, a more descriptive error message
-  is shown telling the user. [GH-127]
-* shell: Scripts are now executed by default according to their shebang,
-  not with `/bin/sh`. [GH-105]
-* shell: You can specify what interpreter you want inline scripts to
-  run with `inline_shebang`.
-* virtualbox: Delete the packer-made SSH port forwarding prior to
-  exporting the VM.
-
-BUG FIXES:
-
-* core: Non-200 response codes on downloads now show proper errors.
-  [GH-141]
-* amazon-ebs: SSH handshake is retried. [GH-130]
-* vagrant: The `BuildName` template propery works properly in
-  the output path.
-* vagrant: Properly configure the provider-specific post-processors so
-  things like `vagrantfile_template` work. [GH-129]
-* vagrant: Close filehandles when copying files so Windows can
-  rename files. [GH-100]
-
-## 0.1.4 (July 2, 2013)
-
-FEATURES:
-
-* virtualbox: Can now be built headless with the "Headless" option. [GH-99]
-* virtualbox: <wait5> and <wait10> codes for waiting 5 and 10 seconds
-  during the boot sequence, respectively. [GH-97]
-* vmware: Can now be built headless with the "Headless" option. [GH-99]
-* vmware: <wait5> and <wait10> codes for waiting 5 and 10 seconds
-  during the boot sequence, respectively. [GH-97]
-* vmware: Disks are defragmented and compacted at the end of the build.
-  This can be disabled using "skip_compaction"
-
-IMPROVEMENTS:
-
-* core: Template syntax errors now show line and character number. [GH-56]
-* amazon-ebs: Access key and secret access key default to
-  environmental variables. [GH-40]
-* virtualbox: Send password for keyboard-interactive auth [GH-121]
-* vmware: Send password for keyboard-interactive auth [GH-121]
-
-BUG FIXES:
-
-* vmware: Wait until shut down cleans up properly to avoid corrupt
-  disk files [GH-111]
-
-## 0.1.3 (July 1, 2013)
-
-FEATURES:
-
-* The VMware builder can now upload the VMware tools for you into
-  the VM. This is opt-in, you must specify the `tools_upload_flavor`
-  option. See the website for more documentation.
-
-IMPROVEMENTS:
-
-* digitalocean: Errors contain human-friendly error messages. [GH-85]
-
-BUG FIXES:
-
-* core: More plugin server fixes that avoid hangs on OS X 10.7 [GH-87]
-* vagrant: AWS boxes will keep the AMI artifact around [GH-55]
-* virtualbox: More robust version parsing for uploading guest additions. [GH-69]
-* virtualbox: Output dir and VM name defaults depend on build name,
-  avoiding collisions. [GH-91]
-* vmware: Output dir and VM name defaults depend on build name,
-  avoiding collisions. [GH-91]
-
 ## 0.1.2 (June 29, 2013)
 
 IMPROVEMENTS:

CONTRIBUTING.md

@@ -1,67 +0,0 @@
-# Contributing to Packer
-
-**First:** if you're unsure or afraid of _anything_, just ask
-or submit the issue or pull request anyways. You won't be yelled at for
-giving your best effort. The worst that can happen is that you'll be
-politely asked to change something. We appreciate any sort of contributions,
-and don't want a wall of rules to get in the way of that.
-
-However, for those individuals who want a bit more guidance on the
-best way to contribute to the project, read on. This document will cover
-what we're looking for. By addressing all the points we're looking for,
-it raises the chances we can quickly merge or address your contributions.
-
-## Issues
-
-### Reporting an Issue
-
-* Make sure you test against the latest released version. It is possible
-  we already fixed the bug you're experiencing.
-
-* 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.
-
-* Respond promptly to any questions made by the Packer team to your issue.
-  Stale issues will be closed.
-
-### Issue Lifecycle
-
-1. The issue is reported.
-
-2. The issue is verified and categorized by a Packer collaborator.
-   Categorization is done via tags. For example, bugs are marked as "bugs"
-   and easy fixes are marked as "easy".
-
-3. Unless it is critical, the issue is left for a period of time (sometimes
-   many weeks), giving outside contributors a chance to address the issue.
-
-4. The issue is addressed in a pull request or commit. The issue will be
-   referenced in the commit message so that the code that fixes it is clearly
-   linked.
-
-5. The issue is closed.
-
-## Setting up Go to work on Packer
-
-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`.
-
-2. Set and export the `GOPATH` environment variable. For example, you can
-   add `export GOPATH=$HOME/Documents/golang` to your `.bash_profile`.
-
-3. Download the Packer source (and its dependencies) by running
-   `go get github.com/mitchellh/packer`. This will download the Packer
-   source to `$GOPATH/src/github.com/mitchellh/packer`.
-
-4. Make your changes to the Packer source. You can run `make` from the main
-   source directory to recompile all the binaries. Any compilation errors
-   will be shown when the binaries are rebuilding.
-
-5. Test your changes by running `make test` and then running
-   `$GOPATH/src/github.com/mitchellh/packer/bin/packer` to build a machine.
-
-6. If everything works well and the tests pass, run `go fmt` on your code
-   before submitting a pull request.

Makefile

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

README.md

@@ -11,7 +11,7 @@ Packer is lightweight, runs on every major operating system, and is highly
 performant, creating machine images for multiple platforms in parallel.
 Packer comes out of the box with support for creating AMIs (EC2), VMware
 images, and VirtualBox images. Support for more platforms can be added via
-plugins.
+plugins. 
 
 The images that Packer creates can easily be turned into
 [Vagrant](http://www.vagrantup.com) boxes.
@@ -43,7 +43,7 @@ own.
     "source_ami": "ami-de0d9eb7",
     "instance_type": "t1.micro",
     "ssh_username": "ubuntu",
-    "ami_name": "packer-example {{timestamp}}"
+    "ami_name": "packer-example {{.CreateTime}}"
   }]
 }
 ```
@@ -70,15 +70,8 @@ http://www.packer.io/docs
 ## Developing Packer
 
 If you wish to work on Packer itself, you'll first need [Go](http://golang.org)
-installed (version 1.1+ is _required_). Make sure you have Go properly installed,
-including setting up your [GOPATH](http://golang.org/doc/code.html#GOPATH).
-
-For some additional dependencies, Go needs [Mercurial](http://mercurial.selenic.com/)
-to be installed. Packer itself doesn't require this but a dependency of a
-dependency does.
-
-Next, clone this repository into `$GOPATH/src/github.com/mitchellh/packer` and
-then just type `make`. In a few moments, you'll have a working `packer` executable:
+installed (version 1.1+ is _required_). Next, clone this repository then just type `make`.
+In a few moments, you'll have a working `packer` executable:
 
 ```
 $ make
@@ -87,6 +80,6 @@ $ bin/packer
 ...
 ```
 
-You can run tests by typing `make test`.
+You can run tests by typing `make test`. 
 
 This will run tests for Packer core along with all the core builders and commands and such that come with Packer.

TODO.md

@@ -0,0 +1,7 @@
+* builder/amazonebs: Copy AMI to multiple regions
+* builder/vmware: VMX templates
+* communicator/ssh: Ability to re-establish connection
+* communicator/ssh: Download()
+* packer: Communicator should have Close() method
+* packer/plugin: Better error messages/detection if plugin crashes
+* provisioner/shell: Arguments

builder/amazon/chroot/builder.go

@@ -1,236 +0,0 @@
-// The chroot package is able to create an Amazon AMI without requiring
-// the launch of a new instance for every build. It does this by attaching
-// and mounting the root volume of another AMI and chrooting into that
-// directory. It then creates an AMI from that attached drive.
-package chroot
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"runtime"
-)
-
-// The unique ID for this builder
-const BuilderId = "mitchellh.amazon.chroot"
-
-// Config is the configuration that is chained through the steps and
-// settable from the template.
-type Config struct {
-	common.PackerConfig    `mapstructure:",squash"`
-	awscommon.AccessConfig `mapstructure:",squash"`
-	awscommon.AMIConfig    `mapstructure:",squash"`
-
-	ChrootMounts   [][]string `mapstructure:"chroot_mounts"`
-	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 Builder struct {
-	config Config
-	runner multistep.Runner
-}
-
-func (b *Builder) Prepare(raws ...interface{}) error {
-	md, err := common.DecodeConfig(&b.config, raws...)
-	if err != nil {
-		return err
-	}
-
-	b.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return err
-	}
-	b.config.tpl.UserVars = b.config.PackerUserVars
-
-	// Defaults
-	if b.config.ChrootMounts == nil {
-		b.config.ChrootMounts = make([][]string, 0)
-	}
-
-	if b.config.CopyFiles == nil {
-		b.config.CopyFiles = make([]string, 0)
-	}
-
-	if len(b.config.ChrootMounts) == 0 {
-		b.config.ChrootMounts = [][]string{
-			[]string{"proc", "proc", "/proc"},
-			[]string{"sysfs", "sysfs", "/sys"},
-			[]string{"bind", "/dev", "/dev"},
-			[]string{"devpts", "devpts", "/dev/pts"},
-			[]string{"binfmt_misc", "binfmt_misc", "/proc/sys/fs/binfmt_misc"},
-		}
-	}
-
-	if len(b.config.CopyFiles) == 0 {
-		b.config.CopyFiles = []string{"/etc/resolv.conf"}
-	}
-
-	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)...)
-	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...)
-
-	for i, mounts := range b.config.ChrootMounts {
-		if len(mounts) != 3 {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("Each chroot_mounts entry should be three elements."))
-			break
-		}
-
-		for j, entry := range mounts {
-			b.config.ChrootMounts[i][j], err = b.config.tpl.Process(entry, nil)
-			if err != nil {
-				errs = packer.MultiErrorAppend(errs,
-					fmt.Errorf("Error processing chroot_mounts[%d][%d]: %s",
-						i, j, err))
-			}
-		}
-	}
-
-	for i, file := range b.config.CopyFiles {
-		var err error
-		b.config.CopyFiles[i], err = b.config.tpl.Process(file, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing copy_files[%d]: %s",
-					i, err))
-		}
-	}
-
-	if b.config.SourceAmi == "" {
-		errs = packer.MultiErrorAppend(errs, errors.New("source_ami is required."))
-	}
-
-	templates := map[string]*string{
-		"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 {
-		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))
-		}
-	}
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
-	}
-
-	log.Printf("Config: %+v", b.config)
-	return nil
-}
-
-func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-	if runtime.GOOS != "linux" {
-		return nil, errors.New("The amazon-chroot builder only works on Linux environments.")
-	}
-
-	region, err := b.config.Region()
-	if err != nil {
-		return nil, err
-	}
-
-	auth, err := b.config.AccessConfig.Auth()
-	if err != nil {
-		return nil, err
-	}
-
-	ec2conn := ec2.New(auth, region)
-
-	// Setup the state bag and initial state for the steps
-	state := make(map[string]interface{})
-	state["config"] = &b.config
-	state["ec2"] = ec2conn
-	state["hook"] = hook
-	state["ui"] = ui
-
-	// Build the steps
-	steps := []multistep.Step{
-		&StepInstanceInfo{},
-		&StepSourceAMIInfo{},
-		&StepFlock{},
-		&StepPrepareDevice{},
-		&StepCreateVolume{},
-		&StepAttachVolume{},
-		&StepEarlyUnflock{},
-		&StepMountDevice{},
-		&StepMountExtra{},
-		&StepCopyFiles{},
-		&StepChrootProvision{},
-		&StepEarlyCleanup{},
-		&StepSnapshot{},
-		&StepRegisterAMI{},
-		&awscommon.StepModifyAMIAttributes{
-			Description: b.config.AMIDescription,
-			Users:       b.config.AMIUsers,
-			Groups:      b.config.AMIGroups,
-		},
-	}
-
-	// 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["error"]; ok {
-		return nil, rawErr.(error)
-	}
-
-	// If there are no AMIs, then just return
-	if _, ok := state["amis"]; !ok {
-		return nil, nil
-	}
-
-	// Build the artifact and return it
-	artifact := &awscommon.Artifact{
-		Amis:           state["amis"].(map[string]string),
-		BuilderIdValue: BuilderId,
-		Conn:           ec2conn,
-	}
-
-	return artifact, nil
-}
-
-func (b *Builder) Cancel() {
-	if b.runner != nil {
-		log.Println("Cancelling the step runner...")
-		b.runner.Cancel()
-	}
-}

builder/amazon/chroot/builder_test.go

@@ -1,84 +0,0 @@
-package chroot
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func testConfig() map[string]interface{} {
-	return map[string]interface{}{
-		"ami_name":   "foo",
-		"source_ami": "foo",
-	}
-}
-
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	var raw interface{}
-	raw = &Builder{}
-	if _, ok := raw.(packer.Builder); !ok {
-		t.Fatalf("Builder should be a builder")
-	}
-}
-
-func TestBuilderPrepare_AMIName(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test good
-	config["ami_name"] = "foo"
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	// Test bad
-	config["ami_name"] = "foo {{"
-	b = Builder{}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test bad
-	delete(config, "ami_name")
-	b = Builder{}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_ChrootMounts(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["chroot_mounts"] = nil
-	err := b.Prepare(config)
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-
-	config["chroot_mounts"] = [][]string{
-		[]string{"bad"},
-	}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-func TestBuilderPrepare_SourceAmi(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["source_ami"] = ""
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	config["source_ami"] = "foo"
-	err = b.Prepare(config)
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-}

builder/amazon/chroot/cleanup.go

@@ -1,6 +0,0 @@
-package chroot
-
-// Cleanup is an interface that some steps implement for early cleanup.
-type Cleanup interface {
-	CleanupFunc(map[string]interface{}) error
-}

builder/amazon/chroot/communicator.go

@@ -1,87 +0,0 @@
-package chroot
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"syscall"
-)
-
-// Communicator is a special communicator that works by executing
-// commands locally but within a chroot.
-type Communicator struct {
-	Chroot string
-}
-
-func (c *Communicator) Start(cmd *packer.RemoteCmd) error {
-	chrootCmdPath, err := exec.LookPath("chroot")
-	if err != nil {
-		return err
-	}
-
-	localCmd := exec.Command(chrootCmdPath, c.Chroot, "/bin/sh", "-c", cmd.Command)
-	localCmd.Stdin = cmd.Stdin
-	localCmd.Stdout = cmd.Stdout
-	localCmd.Stderr = cmd.Stderr
-	log.Printf("Executing: %s %#v", localCmd.Path, localCmd.Args)
-	if err := localCmd.Start(); err != nil {
-		return err
-	}
-
-	go func() {
-		exitStatus := 0
-		if err := localCmd.Wait(); err != nil {
-			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()
-				}
-			}
-		}
-
-		log.Printf(
-			"Chroot executation ended with '%d': '%s'",
-			exitStatus, cmd.Command)
-		cmd.SetExited(exitStatus)
-	}()
-
-	return nil
-}
-
-func (c *Communicator) Upload(dst string, r io.Reader) error {
-	dst = filepath.Join(c.Chroot, dst)
-	log.Printf("Uploading to chroot dir: %s", dst)
-	f, err := os.Create(dst)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	if _, err := io.Copy(f, r); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (c *Communicator) Download(src string, w io.Writer) error {
-	src = filepath.Join(c.Chroot, src)
-	log.Printf("Downloading from chroot dir: %s", src)
-	f, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	if _, err := io.Copy(w, f); err != nil {
-		return err
-	}
-
-	return nil
-}

builder/amazon/chroot/communicator_test.go

@@ -1,14 +0,0 @@
-package chroot
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func TestCommunicator_ImplementsCommunicator(t *testing.T) {
-	var raw interface{}
-	raw = &Communicator{}
-	if _, ok := raw.(packer.Communicator); !ok {
-		t.Fatalf("Communicator should be a communicator")
-	}
-}

builder/amazon/chroot/device.go

@@ -1,61 +0,0 @@
-package chroot
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// AvailableDevice finds an available device and returns it. Note that
-// you should externally hold a flock or something in order to guarantee
-// that this device is available across processes.
-func AvailableDevice() (string, error) {
-	prefix, err := devicePrefix()
-	if err != nil {
-		return "", err
-	}
-
-	letters := "fghijklmnop"
-	for _, letter := range letters {
-		for i := 1; i < 16; i++ {
-			device := fmt.Sprintf("/dev/%s%c%d", prefix, letter, i)
-			if _, err := os.Stat(device); err != nil {
-				return device, nil
-			}
-		}
-	}
-
-	return "", errors.New("available device could not be found")
-}
-
-// devicePrefix returns the prefix ("sd" or "xvd" or so on) of the devices
-// on the system.
-func devicePrefix() (string, error) {
-	available := []string{"sd", "xvd"}
-
-	f, err := os.Open("/sys/block")
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	dirs, err := f.Readdirnames(-1)
-	if dirs != nil && len(dirs) > 0 {
-		for _, dir := range dirs {
-			dirBase := filepath.Base(dir)
-			for _, prefix := range available {
-				if strings.HasPrefix(dirBase, prefix) {
-					return prefix, nil
-				}
-			}
-		}
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	return "", errors.New("device prefix could not be detected")
-}

builder/amazon/chroot/lockfile.go

@@ -1,16 +0,0 @@
-// +build windows
-
-package chroot
-
-import (
-	"errors"
-	"os"
-)
-
-func lockFile(*os.File) error {
-	return errors.New("not supported on Windows")
-}
-
-func unlockFile(f *os.File) error {
-	return nil
-}

builder/amazon/chroot/lockfile_unix.go

@@ -1,32 +0,0 @@
-// +build !windows
-
-package chroot
-
-import (
-	"errors"
-	"os"
-	"syscall"
-)
-
-// See: http://linux.die.net/include/sys/file.h
-const LOCK_EX = 2
-const LOCK_NB = 4
-const LOCK_UN = 8
-
-func lockFile(f *os.File) error {
-	err := syscall.Flock(int(f.Fd()), LOCK_EX|LOCK_NB)
-	if err != nil {
-		errno, ok := err.(syscall.Errno)
-		if ok && errno == syscall.EWOULDBLOCK {
-			return errors.New("file already locked")
-		}
-
-		return err
-	}
-
-	return nil
-}
-
-func unlockFile(f *os.File) error {
-	return syscall.Flock(int(f.Fd()), LOCK_UN)
-}

builder/amazon/chroot/step_attach_volume.go

@@ -1,129 +0,0 @@
-package chroot
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/packer"
-	"strings"
-)
-
-// StepAttachVolume attaches the previously created volume to an
-// available device location.
-//
-// Produces:
-//   device string - The location where the volume was attached.
-//   attach_cleanup CleanupFunc
-type StepAttachVolume struct {
-	attached bool
-	volumeId string
-}
-
-func (s *StepAttachVolume) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	device := state["device"].(string)
-	instance := state["instance"].(*ec2.Instance)
-	ui := state["ui"].(packer.Ui)
-	volumeId := state["volume_id"].(string)
-
-	// For the API call, it expects "sd" prefixed devices.
-	attachVolume := strings.Replace(device, "/xvd", "/sd", 1)
-
-	ui.Say(fmt.Sprintf("Attaching the root volume to %s", attachVolume))
-	_, err := ec2conn.AttachVolume(volumeId, instance.InstanceId, attachVolume)
-	if err != nil {
-		err := fmt.Errorf("Error attaching volume: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Mark that we attached it so we can detach it later
-	s.attached = true
-	s.volumeId = volumeId
-
-	// Wait for the volume to become attached
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"attaching"},
-		StepState: state,
-		Target:    "attached",
-		Refresh: func() (interface{}, string, error) {
-			resp, err := ec2conn.Volumes([]string{volumeId}, ec2.NewFilter())
-			if err != nil {
-				return nil, "", err
-			}
-
-			if len(resp.Volumes[0].Attachments) == 0 {
-				return nil, "", errors.New("No attachments on volume.")
-			}
-
-			return nil, resp.Volumes[0].Attachments[0].Status, nil
-		},
-	}
-
-	_, err = awscommon.WaitForState(&stateChange)
-	if err != nil {
-		err := fmt.Errorf("Error waiting for volume: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state["attach_cleanup"] = s
-	return multistep.ActionContinue
-}
-
-func (s *StepAttachVolume) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
-	if err := s.CleanupFunc(state); err != nil {
-		ui.Error(err.Error())
-	}
-}
-
-func (s *StepAttachVolume) CleanupFunc(state map[string]interface{}) error {
-	if !s.attached {
-		return nil
-	}
-
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-
-	ui.Say("Detaching EBS volume...")
-	_, err := ec2conn.DetachVolume(s.volumeId)
-	if err != nil {
-		return fmt.Errorf("Error detaching EBS volume: %s", err)
-	}
-
-	s.attached = false
-
-	// Wait for the volume to detach
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"attaching", "attached", "detaching"},
-		StepState: state,
-		Target:    "detached",
-		Refresh: func() (interface{}, string, error) {
-			resp, err := ec2conn.Volumes([]string{s.volumeId}, ec2.NewFilter())
-			if err != nil {
-				return nil, "", err
-			}
-
-			state := "detached"
-			if len(resp.Volumes[0].Attachments) > 0 {
-				state = resp.Volumes[0].Attachments[0].Status
-			}
-
-			return nil, state, nil
-		},
-	}
-
-	_, err = awscommon.WaitForState(&stateChange)
-	if err != nil {
-		return fmt.Errorf("Error waiting for volume: %s", err)
-	}
-
-	return nil
-}

builder/amazon/chroot/step_attach_volume_test.go

@@ -1,11 +0,0 @@
-package chroot
-
-import "testing"
-
-func TestAttachVolumeCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
-	var raw interface{}
-	raw = new(StepAttachVolume)
-	if _, ok := raw.(Cleanup); !ok {
-		t.Fatalf("cleanup func should be a CleanupFunc")
-	}
-}

builder/amazon/chroot/step_chroot_provision.go

@@ -1,34 +0,0 @@
-package chroot
-
-import (
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-// StepChrootProvision provisions the instance within a chroot.
-type StepChrootProvision struct {
-	mounts []string
-}
-
-func (s *StepChrootProvision) Run(state map[string]interface{}) multistep.StepAction {
-	hook := state["hook"].(packer.Hook)
-	mountPath := state["mount_path"].(string)
-	ui := state["ui"].(packer.Ui)
-
-	// Create our communicator
-	comm := &Communicator{
-		Chroot: mountPath,
-	}
-
-	// Provision
-	log.Println("Running the provision hook")
-	if err := hook.Run(packer.HookProvision, ui, comm, nil); err != nil {
-		state["error"] = err
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepChrootProvision) Cleanup(state map[string]interface{}) {}

builder/amazon/chroot/step_copy_files.go

@@ -1,107 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-)
-
-// StepCopyFiles copies some files from the host into the chroot environment.
-//
-// Produces:
-//   copy_files_cleanup CleanupFunc - A function to clean up the copied files
-//   early.
-type StepCopyFiles struct {
-	files []string
-}
-
-func (s *StepCopyFiles) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	mountPath := state["mount_path"].(string)
-	ui := state["ui"].(packer.Ui)
-
-	s.files = make([]string, 0, len(config.CopyFiles))
-	if len(config.CopyFiles) > 0 {
-		ui.Say("Copying files from host to chroot...")
-		for _, path := range config.CopyFiles {
-			ui.Message(path)
-			chrootPath := filepath.Join(mountPath, path)
-			log.Printf("Copying '%s' to '%s'", path, chrootPath)
-
-			if err := s.copySingle(chrootPath, path); err != nil {
-				err := fmt.Errorf("Error copying file: %s", err)
-				state["error"] = err
-				ui.Error(err.Error())
-				return multistep.ActionHalt
-			}
-
-			s.files = append(s.files, chrootPath)
-		}
-	}
-
-	state["copy_files_cleanup"] = s
-	return multistep.ActionContinue
-}
-
-func (s *StepCopyFiles) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
-	if err := s.CleanupFunc(state); err != nil {
-		ui.Error(err.Error())
-	}
-}
-
-func (s *StepCopyFiles) CleanupFunc(map[string]interface{}) error {
-	if s.files != nil {
-		for _, file := range s.files {
-			log.Printf("Removing: %s", file)
-			if err := os.Remove(file); err != nil {
-				return err
-			}
-		}
-	}
-
-	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_copy_files_test.go

@@ -1,11 +0,0 @@
-package chroot
-
-import "testing"
-
-func TestCopyFilesCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
-	var raw interface{}
-	raw = new(StepCopyFiles)
-	if _, ok := raw.(Cleanup); !ok {
-		t.Fatalf("cleanup func should be a CleanupFunc")
-	}
-}

builder/amazon/chroot/step_create_volume.go

@@ -1,107 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-// StepCreateVolume creates a new volume from the snapshot of the root
-// device of the AMI.
-//
-// Produces:
-//   volume_id string - The ID of the created volume
-type StepCreateVolume struct {
-	volumeId string
-}
-
-func (s *StepCreateVolume) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	image := state["source_image"].(*ec2.Image)
-	instance := state["instance"].(*ec2.Instance)
-	ui := state["ui"].(packer.Ui)
-
-	// Determine the root device snapshot
-	log.Printf("Searching for root device of the image (%s)", image.RootDeviceName)
-	var rootDevice *ec2.BlockDeviceMapping
-	for _, device := range image.BlockDevices {
-		if device.DeviceName == image.RootDeviceName {
-			rootDevice = &device
-			break
-		}
-	}
-
-	if rootDevice == nil {
-		err := fmt.Errorf("Couldn't find root device!")
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Say("Creating the root volume...")
-	createVolume := &ec2.CreateVolume{
-		AvailZone:  instance.AvailZone,
-		Size:       rootDevice.VolumeSize,
-		SnapshotId: rootDevice.SnapshotId,
-		VolumeType: rootDevice.VolumeType,
-		IOPS:       rootDevice.IOPS,
-	}
-	log.Printf("Create args: %#v", createVolume)
-
-	createVolumeResp, err := ec2conn.CreateVolume(createVolume)
-	if err != nil {
-		err := fmt.Errorf("Error creating root volume: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Set the volume ID so we remember to delete it later
-	s.volumeId = createVolumeResp.VolumeId
-	log.Printf("Volume ID: %s", s.volumeId)
-
-	// Wait for the volume to become ready
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"creating"},
-		StepState: state,
-		Target:    "available",
-		Refresh: func() (interface{}, string, error) {
-			resp, err := ec2conn.Volumes([]string{s.volumeId}, ec2.NewFilter())
-			if err != nil {
-				return nil, "", err
-			}
-
-			return nil, resp.Volumes[0].Status, nil
-		},
-	}
-
-	_, err = awscommon.WaitForState(&stateChange)
-	if err != nil {
-		err := fmt.Errorf("Error waiting for volume: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state["volume_id"] = s.volumeId
-	return multistep.ActionContinue
-}
-
-func (s *StepCreateVolume) Cleanup(state map[string]interface{}) {
-	if s.volumeId == "" {
-		return
-	}
-
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-
-	ui.Say("Deleting the created EBS volume...")
-	_, err := ec2conn.DeleteVolume(s.volumeId)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error deleting EBS volume: %s", err))
-	}
-}

builder/amazon/chroot/step_early_cleanup.go

@@ -1,37 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-// StepEarlyCleanup performs some of the cleanup steps early in order to
-// prepare for snapshotting and creating an AMI.
-type StepEarlyCleanup struct{}
-
-func (s *StepEarlyCleanup) Run(state map[string]interface{}) multistep.StepAction {
-	ui := state["ui"].(packer.Ui)
-	cleanupKeys := []string{
-		"copy_files_cleanup",
-		"mount_extra_cleanup",
-		"mount_device_cleanup",
-		"attach_cleanup",
-	}
-
-	for _, key := range cleanupKeys {
-		c := state[key].(Cleanup)
-		log.Printf("Running cleanup func: %s", key)
-		if err := c.CleanupFunc(state); err != nil {
-			err := fmt.Errorf("Error cleaning up: %s", err)
-			state["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepEarlyCleanup) Cleanup(state map[string]interface{}) {}

builder/amazon/chroot/step_early_unflock.go

@@ -1,28 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-// StepEarlyUnflock unlocks the flock.
-type StepEarlyUnflock struct{}
-
-func (s *StepEarlyUnflock) Run(state map[string]interface{}) multistep.StepAction {
-	cleanup := state["flock_cleanup"].(Cleanup)
-	ui := state["ui"].(packer.Ui)
-
-	log.Println("Unlocking file lock...")
-	if err := cleanup.CleanupFunc(state); err != nil {
-		err := fmt.Errorf("Error unlocking file lock: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepEarlyUnflock) Cleanup(state map[string]interface{}) {}

builder/amazon/chroot/step_flock.go

@@ -1,72 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-	"path/filepath"
-)
-
-// StepFlock provisions the instance within a chroot.
-//
-// Produces:
-//   flock_cleanup Cleanup - To perform early cleanup
-type StepFlock struct {
-	fh *os.File
-}
-
-func (s *StepFlock) Run(state map[string]interface{}) multistep.StepAction {
-	ui := state["ui"].(packer.Ui)
-
-	lockfile := "/var/lock/packer-chroot/lock"
-	if err := os.MkdirAll(filepath.Dir(lockfile), 0755); err != nil {
-		err := fmt.Errorf("Error creating lock: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	log.Printf("Obtaining lock: %s", lockfile)
-	f, err := os.Create(lockfile)
-	if err != nil {
-		err := fmt.Errorf("Error creating lock: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// LOCK!
-	if err := lockFile(f); err != nil {
-		err := fmt.Errorf("Error creating lock: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Set the file handle, we can't close it because we need to hold
-	// the lock.
-	s.fh = f
-
-	state["flock_cleanup"] = s
-	return multistep.ActionContinue
-}
-
-func (s *StepFlock) Cleanup(state map[string]interface{}) {
-	s.CleanupFunc(state)
-}
-
-func (s *StepFlock) CleanupFunc(state map[string]interface{}) error {
-	if s.fh == nil {
-		return nil
-	}
-
-	log.Printf("Unlocking: %s", s.fh.Name())
-	if err := unlockFile(s.fh); err != nil {
-		return err
-	}
-
-	s.fh = nil
-	return nil
-}

builder/amazon/chroot/step_flock_test.go

@@ -1,11 +0,0 @@
-package chroot
-
-import "testing"
-
-func TestFlockCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
-	var raw interface{}
-	raw = new(StepFlock)
-	if _, ok := raw.(Cleanup); !ok {
-		t.Fatalf("cleanup func should be a CleanupFunc")
-	}
-}

builder/amazon/chroot/step_instance_info.go

@@ -1,57 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/aws"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-// StepInstanceInfo verifies that this builder is running on an EC2 instance.
-type StepInstanceInfo struct{}
-
-func (s *StepInstanceInfo) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-
-	// Get our own instance ID
-	ui.Say("Gathering information about this EC2 instance...")
-	instanceIdBytes, err := aws.GetMetaData("instance-id")
-	if err != nil {
-		log.Printf("Error: %s", err)
-		err := fmt.Errorf(
-			"Error retrieving the ID of the instance Packer is running on.\n" +
-				"Please verify Packer is running on a proper AWS EC2 instance.")
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	instanceId := string(instanceIdBytes)
-	log.Printf("Instance ID: %s", instanceId)
-
-	// Query the entire instance metadata
-	instancesResp, err := ec2conn.Instances([]string{instanceId}, ec2.NewFilter())
-	if err != nil {
-		err := fmt.Errorf("Error getting instance data: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	if len(instancesResp.Reservations) == 0 {
-		err := fmt.Errorf("Error getting instance data: no instance found.")
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	instance := &instancesResp.Reservations[0].Instances[0]
-	state["instance"] = instance
-
-	return multistep.ActionContinue
-}
-
-func (s *StepInstanceInfo) Cleanup(map[string]interface{}) {}

builder/amazon/chroot/step_mount_device.go

@@ -1,105 +0,0 @@
-package chroot
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-)
-
-type mountPathData struct {
-	Device string
-}
-
-// StepMountDevice mounts the attached device.
-//
-// Produces:
-//   mount_path string - The location where the volume was mounted.
-//   mount_device_cleanup CleanupFunc - To perform early cleanup
-type StepMountDevice struct {
-	mountPath string
-}
-
-func (s *StepMountDevice) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ui := state["ui"].(packer.Ui)
-	device := state["device"].(string)
-
-	mountPath, err := config.tpl.Process(config.MountPath, &mountPathData{
-		Device: filepath.Base(device),
-	})
-
-	if err != nil {
-		err := fmt.Errorf("Error preparing mount directory: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	mountPath, err = filepath.Abs(mountPath)
-	if err != nil {
-		err := fmt.Errorf("Error preparing mount directory: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	log.Printf("Mount path: %s", mountPath)
-
-	if err := os.MkdirAll(mountPath, 0755); err != nil {
-		err := fmt.Errorf("Error creating mount directory: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Say("Mounting the root device...")
-	stderr := new(bytes.Buffer)
-	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(
-			"Error mounting root volume: %s\nStderr: %s", err, stderr.String())
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Set the mount path so we remember to unmount it later
-	s.mountPath = mountPath
-	state["mount_path"] = s.mountPath
-	state["mount_device_cleanup"] = s
-
-	return multistep.ActionContinue
-}
-
-func (s *StepMountDevice) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
-	if err := s.CleanupFunc(state); err != nil {
-		ui.Error(err.Error())
-	}
-}
-
-func (s *StepMountDevice) CleanupFunc(state map[string]interface{}) error {
-	if s.mountPath == "" {
-		return nil
-	}
-
-	config := state["config"].(*Config)
-	ui := state["ui"].(packer.Ui)
-	ui.Say("Unmounting the root device...")
-
-	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)
-	}
-
-	s.mountPath = ""
-	return nil
-}

builder/amazon/chroot/step_mount_device_test.go

@@ -1,11 +0,0 @@
-package chroot
-
-import "testing"
-
-func TestMountDeviceCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
-	var raw interface{}
-	raw = new(StepMountDevice)
-	if _, ok := raw.(Cleanup); !ok {
-		t.Fatalf("cleanup func should be a CleanupFunc")
-	}
-}

builder/amazon/chroot/step_mount_extra.go

@@ -1,100 +0,0 @@
-package chroot
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"os"
-	"os/exec"
-)
-
-// StepMountExtra mounts the attached device.
-//
-// Produces:
-//   mount_extra_cleanup CleanupFunc - To perform early cleanup
-type StepMountExtra struct {
-	mounts []string
-}
-
-func (s *StepMountExtra) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	mountPath := state["mount_path"].(string)
-	ui := state["ui"].(packer.Ui)
-
-	s.mounts = make([]string, 0, len(config.ChrootMounts))
-
-	ui.Say("Mounting additional paths within the chroot...")
-	for _, mountInfo := range config.ChrootMounts {
-		innerPath := mountPath + mountInfo[2]
-
-		if err := os.MkdirAll(innerPath, 0755); err != nil {
-			err := fmt.Errorf("Error creating mount directory: %s", err)
-			state["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		flags := "-t " + mountInfo[0]
-		if mountInfo[0] == "bind" {
-			flags = "--bind"
-		}
-
-		ui.Message(fmt.Sprintf("Mounting: %s", mountInfo[2]))
-		stderr := new(bytes.Buffer)
-		mountCommand := fmt.Sprintf(
-			"%s %s %s %s",
-			config.MountCommand,
-			flags,
-			mountInfo[1],
-			innerPath)
-		cmd := exec.Command("/bin/sh", "-c", mountCommand)
-		cmd.Stderr = stderr
-		if err := cmd.Run(); err != nil {
-			err := fmt.Errorf(
-				"Error mounting: %s\nStderr: %s", err, stderr.String())
-			state["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		s.mounts = append(s.mounts, innerPath)
-	}
-
-	state["mount_extra_cleanup"] = s
-	return multistep.ActionContinue
-}
-
-func (s *StepMountExtra) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
-
-	if err := s.CleanupFunc(state); err != nil {
-		ui.Error(err.Error())
-		return
-	}
-}
-
-func (s *StepMountExtra) CleanupFunc(state map[string]interface{}) error {
-	if s.mounts == nil {
-		return nil
-	}
-
-	config := state["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 := fmt.Sprintf("%s %s", config.UnmountCommand, path)
-
-		stderr := new(bytes.Buffer)
-		cmd := exec.Command("/bin/sh", "-c", unmountCommand)
-		cmd.Stderr = stderr
-		if err := cmd.Run(); err != nil {
-			return fmt.Errorf(
-				"Error unmounting device: %s\nStderr: %s", err, stderr.String())
-		}
-	}
-
-	s.mounts = nil
-	return nil
-}

builder/amazon/chroot/step_mount_extra_test.go

@@ -1,11 +0,0 @@
-package chroot
-
-import "testing"
-
-func TestMountExtraCleanupFunc_ImplementsCleanupFunc(t *testing.T) {
-	var raw interface{}
-	raw = new(StepMountExtra)
-	if _, ok := raw.(Cleanup); !ok {
-		t.Fatalf("cleanup func should be a CleanupFunc")
-	}
-}

builder/amazon/chroot/step_prepare_device.go

@@ -1,45 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-)
-
-// StepPrepareDevice finds an available device and sets it.
-type StepPrepareDevice struct {
-	mounts []string
-}
-
-func (s *StepPrepareDevice) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ui := state["ui"].(packer.Ui)
-
-	device := config.DevicePath
-	if device == "" {
-		var err error
-		log.Println("Device path not specified, searching for available device...")
-		device, err = AvailableDevice()
-		if err != nil {
-			err := fmt.Errorf("Error finding available device: %s", err)
-			state["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	}
-
-	if _, err := os.Stat(device); err == nil {
-		err := fmt.Errorf("Device is in use: %s", device)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	log.Printf("Device: %s", device)
-	state["device"] = device
-	return multistep.ActionContinue
-}
-
-func (s *StepPrepareDevice) Cleanup(state map[string]interface{}) {}

builder/amazon/chroot/step_register_ami.go

@@ -1,66 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/packer"
-)
-
-// StepRegisterAMI creates the AMI.
-type StepRegisterAMI struct{}
-
-func (s *StepRegisterAMI) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ec2conn := state["ec2"].(*ec2.EC2)
-	image := state["source_image"].(*ec2.Image)
-	snapshotId := state["snapshot_id"].(string)
-	ui := state["ui"].(packer.Ui)
-
-	ui.Say("Registering the AMI...")
-	blockDevices := make([]ec2.BlockDeviceMapping, len(image.BlockDevices))
-	for i, device := range image.BlockDevices {
-		newDevice := device
-		if newDevice.DeviceName == image.RootDeviceName {
-			newDevice.SnapshotId = snapshotId
-		}
-
-		blockDevices[i] = newDevice
-	}
-
-	registerOpts := &ec2.RegisterImage{
-		Name:           config.AMIName,
-		Architecture:   image.Architecture,
-		KernelId:       image.KernelId,
-		RamdiskId:      image.RamdiskId,
-		RootDeviceName: image.RootDeviceName,
-		BlockDevices:   blockDevices,
-	}
-
-	registerResp, err := ec2conn.RegisterImage(registerOpts)
-	if err != nil {
-		state["error"] = fmt.Errorf("Error registering AMI: %s", err)
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	// Set the AMI ID in the state
-	ui.Say(fmt.Sprintf("AMI: %s", registerResp.ImageId))
-	amis := make(map[string]string)
-	amis[ec2conn.Region.Name] = registerResp.ImageId
-	state["amis"] = amis
-
-	// Wait for the image to become ready
-	ui.Say("Waiting for AMI to become ready...")
-	if err := awscommon.WaitForAMI(ec2conn, registerResp.ImageId); err != nil {
-		err := fmt.Errorf("Error waiting for AMI: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepRegisterAMI) Cleanup(state map[string]interface{}) {}

builder/amazon/chroot/step_snapshot.go

@@ -1,87 +0,0 @@
-package chroot
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/packer"
-)
-
-// StepSnapshot creates a snapshot of the created volume.
-//
-// Produces:
-//   snapshot_id string - ID of the created snapshot
-type StepSnapshot struct {
-	snapshotId string
-}
-
-func (s *StepSnapshot) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-	volumeId := state["volume_id"].(string)
-
-	ui.Say("Creating snapshot...")
-	createSnapResp, err := ec2conn.CreateSnapshot(volumeId, "")
-	if err != nil {
-		err := fmt.Errorf("Error creating snapshot: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Set the snapshot ID so we can delete it later
-	s.snapshotId = createSnapResp.Id
-	ui.Message(fmt.Sprintf("Snapshot ID: %s", s.snapshotId))
-
-	// Wait for the snapshot to be ready
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"pending"},
-		StepState: state,
-		Target:    "completed",
-		Refresh: func() (interface{}, string, error) {
-			resp, err := ec2conn.Snapshots([]string{s.snapshotId}, ec2.NewFilter())
-			if err != nil {
-				return nil, "", err
-			}
-
-			if len(resp.Snapshots) == 0 {
-				return nil, "", errors.New("No snapshots found.")
-			}
-
-			return nil, resp.Snapshots[0].Status, nil
-		},
-	}
-
-	_, err = awscommon.WaitForState(&stateChange)
-	if err != nil {
-		err := fmt.Errorf("Error waiting for snapshot: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state["snapshot_id"] = s.snapshotId
-	return multistep.ActionContinue
-}
-
-func (s *StepSnapshot) Cleanup(state map[string]interface{}) {
-	if s.snapshotId == "" {
-		return
-	}
-
-	_, cancelled := state[multistep.StateCancelled]
-	_, halted := state[multistep.StateHalted]
-
-	if cancelled || halted {
-		ec2conn := state["ec2"].(*ec2.EC2)
-		ui := state["ui"].(packer.Ui)
-		ui.Say("Removing snapshot since we cancelled or halted...")
-		_, err := ec2conn.DeleteSnapshots([]string{s.snapshotId})
-		if err != nil {
-			ui.Error(fmt.Sprintf("Error: %s", err))
-		}
-	}
-}

builder/amazon/chroot/step_source_ami_info.go

@@ -1,52 +0,0 @@
-package chroot
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-// StepSourceAMIInfo extracts critical information from the source AMI
-// that is used throughout the AMI creation process.
-//
-// Produces:
-//   source_image *ec2.Image - the source AMI info
-type StepSourceAMIInfo struct{}
-
-func (s *StepSourceAMIInfo) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-
-	ui.Say("Inspecting the source AMI...")
-	imageResp, err := ec2conn.Images([]string{config.SourceAmi}, ec2.NewFilter())
-	if err != nil {
-		err := fmt.Errorf("Error querying AMI: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	if len(imageResp.Images) == 0 {
-		err := fmt.Errorf("Source AMI '%s' was not found!", config.SourceAmi)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	image := &imageResp.Images[0]
-
-	// It must be EBS-backed otherwise the build won't work
-	if image.RootDeviceType != "ebs" {
-		err := fmt.Errorf("The root device of the source AMI must be EBS-backed.")
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state["source_image"] = image
-	return multistep.ActionContinue
-}
-
-func (s *StepSourceAMIInfo) Cleanup(map[string]interface{}) {}

builder/amazon/common/access_config.go

@@ -1,76 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/aws"
-	"github.com/mitchellh/packer/packer"
-	"strings"
-	"unicode"
-)
-
-// AccessConfig is for common configuration related to AWS access
-type AccessConfig struct {
-	AccessKey string `mapstructure:"access_key"`
-	SecretKey string `mapstructure:"secret_key"`
-	RawRegion string `mapstructure:"region"`
-}
-
-// 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) {
-	return aws.GetAuth(c.AccessKey, c.SecretKey)
-}
-
-// Region returns the aws.Region object for access to AWS services, requesting
-// the region from the instance metadata if possible.
-func (c *AccessConfig) Region() (aws.Region, error) {
-	if c.RawRegion != "" {
-		return aws.Regions[c.RawRegion], nil
-	}
-
-	md, err := aws.GetMetaData("placement/availability-zone")
-	if err != nil {
-		return aws.Region{}, err
-	}
-
-	region := strings.TrimRightFunc(string(md), unicode.IsLetter)
-	return aws.Regions[region], nil
-}
-
-func (c *AccessConfig) Prepare(t *packer.ConfigTemplate) []error {
-	if t == nil {
-		var err error
-		t, err = packer.NewConfigTemplate()
-		if err != nil {
-			return []error{err}
-		}
-	}
-
-	templates := map[string]*string{
-		"access_key": &c.AccessKey,
-		"secret_key": &c.SecretKey,
-		"region":     &c.RawRegion,
-	}
-
-	errs := make([]error, 0)
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = t.Process(*ptr, nil)
-		if err != nil {
-			errs = append(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
-	if c.RawRegion != "" {
-		if _, ok := aws.Regions[c.RawRegion]; !ok {
-			errs = append(errs, fmt.Errorf("Unknown region: %s", c.RawRegion))
-		}
-	}
-
-	if len(errs) > 0 {
-		return errs
-	}
-
-	return nil
-}

builder/amazon/common/access_config_test.go

@@ -1,27 +0,0 @@
-package common
-
-import (
-	"testing"
-)
-
-func testAccessConfig() *AccessConfig {
-	return &AccessConfig{}
-}
-
-func TestAccessConfigPrepare_Region(t *testing.T) {
-	c := testAccessConfig()
-	c.RawRegion = ""
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	c.RawRegion = "us-east-12"
-	if err := c.Prepare(nil); err == nil {
-		t.Fatal("should have error")
-	}
-
-	c.RawRegion = "us-east-1"
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-}

builder/amazon/common/ami.go

@@ -1,30 +0,0 @@
-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/ami_config.go

@@ -1,67 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"github.com/mitchellh/packer/packer"
-)
-
-// AMIConfig is for common configuration related to creating AMIs.
-type AMIConfig struct {
-	AMIName         string   `mapstructure:"ami_name"`
-	AMIDescription  string   `mapstructure:"ami_description"`
-	AMIUsers        []string `mapstructure:"ami_users"`
-	AMIGroups       []string `mapstructure:"ami_groups"`
-	AMIProductCodes []string `mapstructure:"ami_product_codes"`
-}
-
-func (c *AMIConfig) Prepare(t *packer.ConfigTemplate) []error {
-	if t == nil {
-		var err error
-		t, err = packer.NewConfigTemplate()
-		if err != nil {
-			return []error{err}
-		}
-	}
-
-	templates := map[string]*string{
-		"ami_name":        &c.AMIName,
-		"ami_description": &c.AMIDescription,
-	}
-
-	errs := make([]error, 0)
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = t.Process(*ptr, nil)
-		if err != nil {
-			errs = append(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
-	sliceTemplates := map[string][]string{
-		"ami_users":         c.AMIUsers,
-		"ami_groups":        c.AMIGroups,
-		"ami_product_codes": c.AMIProductCodes,
-	}
-
-	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))
-			}
-		}
-	}
-
-	if c.AMIName == "" {
-		errs = append(errs, fmt.Errorf("ami_name must be specified"))
-	}
-
-	if len(errs) > 0 {
-		return errs
-	}
-
-	return nil
-}

builder/amazon/common/ami_config_test.go

@@ -1,23 +0,0 @@
-package common
-
-import (
-	"testing"
-)
-
-func testAMIConfig() *AMIConfig {
-	return &AMIConfig{
-		AMIName: "foo",
-	}
-}
-
-func TestAMIConfigPrepare_Region(t *testing.T) {
-	c := testAMIConfig()
-	if err := c.Prepare(nil); err != nil {
-		t.Fatalf("shouldn't have err: %s", err)
-	}
-
-	c.AMIName = ""
-	if err := c.Prepare(nil); err == nil {
-		t.Fatal("should have error")
-	}
-}

builder/amazon/common/block_device.go

@@ -1,46 +0,0 @@
-package common
-
-import (
-	"github.com/mitchellh/goamz/ec2"
-)
-
-// BlockDevice
-type BlockDevice struct {
-	DeviceName          string `mapstructure:"device_name"`
-	VirtualName         string `mapstructure:"virtual_name"`
-	SnapshotId          string `mapstructure:"snapshot_id"`
-	VolumeType          string `mapstructure:"volume_type"`
-	VolumeSize          int64  `mapstructure:"volume_size"`
-	DeleteOnTermination bool   `mapstructure:"delete_on_termination"`
-	IOPS                int64  `mapstructure:"iops"`
-}
-
-type BlockDevices struct {
-	AMIMappings    []BlockDevice `mapstructure:"ami_block_device_mappings,squash"`
-	LaunchMappings []BlockDevice `mapstructure:"launch_block_device_mappings,squash"`
-}
-
-func buildBlockDevices(b []BlockDevice) []ec2.BlockDeviceMapping {
-	var blockDevices []ec2.BlockDeviceMapping
-
-	for _, blockDevice := range b {
-		blockDevices = append(blockDevices, ec2.BlockDeviceMapping{
-			DeviceName:          blockDevice.DeviceName,
-			VirtualName:         blockDevice.VirtualName,
-			SnapshotId:          blockDevice.SnapshotId,
-			VolumeType:          blockDevice.VolumeType,
-			VolumeSize:          blockDevice.VolumeSize,
-			DeleteOnTermination: blockDevice.DeleteOnTermination,
-			IOPS:                blockDevice.IOPS,
-		})
-	}
-	return blockDevices
-}
-
-func (b *BlockDevices) BuildAMIDevices() []ec2.BlockDeviceMapping {
-	return buildBlockDevices(b.AMIMappings)
-}
-
-func (b *BlockDevices) BuildLaunchDevices() []ec2.BlockDeviceMapping {
-	return buildBlockDevices(b.LaunchMappings)
-}

builder/amazon/common/block_device_test.go

@@ -1,41 +0,0 @@
-package common
-
-import (
-	"cgl.tideland.biz/asserts"
-	"github.com/mitchellh/goamz/ec2"
-	"testing"
-)
-
-func TestBlockDevice(t *testing.T) {
-	assert := asserts.NewTestingAsserts(t, true)
-
-	ec2Mapping := []ec2.BlockDeviceMapping{
-		ec2.BlockDeviceMapping{
-			DeviceName:          "/dev/sdb",
-			VirtualName:         "ephemeral0",
-			SnapshotId:          "snap-1234",
-			VolumeType:          "standard",
-			VolumeSize:          8,
-			DeleteOnTermination: true,
-			IOPS:                1000,
-		},
-	}
-
-	blockDevice := BlockDevice{
-		DeviceName:          "/dev/sdb",
-		VirtualName:         "ephemeral0",
-		SnapshotId:          "snap-1234",
-		VolumeType:          "standard",
-		VolumeSize:          8,
-		DeleteOnTermination: true,
-		IOPS:                1000,
-	}
-
-	blockDevices := BlockDevices{
-		AMIMappings:    []BlockDevice{blockDevice},
-		LaunchMappings: []BlockDevice{blockDevice},
-	}
-
-	assert.Equal(ec2Mapping, blockDevices.BuildAMIDevices(), "should match output")
-	assert.Equal(ec2Mapping, blockDevices.BuildLaunchDevices(), "should match output")
-}

builder/amazon/common/instance.go

@@ -1,87 +0,0 @@
-package common
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	"log"
-	"time"
-)
-
-// StateRefreshFunc is a function type used for StateChangeConf that is
-// responsible for refreshing the item being watched for a state change.
-//
-// It returns three results. `result` is any object that will be returned
-// as the final object after waiting for state change. This allows you to
-// return the final updated object, for example an EC2 instance after refreshing
-// it.
-//
-// `state` is the latest state of that object. And `err` is any error that
-// may have happened while refreshing the state.
-type StateRefreshFunc func() (result interface{}, state string, err error)
-
-// StateChangeConf is the configuration struct used for `WaitForState`.
-type StateChangeConf struct {
-	Conn      *ec2.EC2
-	Pending   []string
-	Refresh   StateRefreshFunc
-	StepState map[string]interface{}
-	Target    string
-}
-
-// 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 {
-			log.Printf("Error on InstanceStateRefresh: %s", err)
-			return nil, "", err
-		}
-
-		i = &resp.Reservations[0].Instances[0]
-		return i, i.State.Name, nil
-	}
-}
-
-// WaitForState watches an object and waits for it to achieve a certain
-// state.
-func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
-	log.Printf("Waiting for state to become: %s", conf.Target)
-
-	for {
-		var currentState string
-		i, currentState, err = conf.Refresh()
-		if err != nil {
-			return
-		}
-
-		if currentState == conf.Target {
-			return
-		}
-
-		if conf.StepState != nil {
-			if _, ok := conf.StepState[multistep.StateCancelled]; ok {
-				return nil, errors.New("interrupted")
-			}
-		}
-
-		found := false
-		for _, allowed := range conf.Pending {
-			if currentState == allowed {
-				found = true
-				break
-			}
-		}
-
-		if !found {
-			fmt.Errorf("unexpected state '%s', wanted target '%s'", currentState, conf.Target)
-			return
-		}
-
-		time.Sleep(2 * time.Second)
-	}
-
-	return
-}

builder/amazon/common/run_config.go

@@ -1,101 +0,0 @@
-package common
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/packer/packer"
-	"os"
-	"time"
-)
-
-// 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"`
-	SubnetId           string `mapstructure:"subnet_id"`
-	VpcId              string `mapstructure:"vpc_id"`
-
-	// Unexported fields that are calculated from others
-	sshTimeout time.Duration
-}
-
-func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
-	if t == nil {
-		var err error
-		t, err = packer.NewConfigTemplate()
-		if err != nil {
-			return []error{err}
-		}
-	}
-
-	// Defaults
-	if c.SSHPort == 0 {
-		c.SSHPort = 22
-	}
-
-	if c.RawSSHTimeout == "" {
-		c.RawSSHTimeout = "1m"
-	}
-
-	// Validation
-	var err error
-	errs := make([]error, 0)
-	if c.SourceAmi == "" {
-		errs = append(errs, errors.New("A source_ami must be specified"))
-	}
-
-	if c.InstanceType == "" {
-		errs = append(errs, errors.New("An instance_type must be specified"))
-	}
-
-	if c.SSHUsername == "" {
-		errs = append(errs, errors.New("An ssh_username must be specified"))
-	}
-
-	if c.UserData != "" && c.UserDataFile != "" {
-		errs = append(errs, fmt.Errorf("Only one of user_data or user_data_file can be specified."))
-	} else if c.UserDataFile != "" {
-		if _, err := os.Stat(c.UserDataFile); err != nil {
-			errs = append(errs, fmt.Errorf("user_data_file not found: %s", c.UserDataFile))
-		}
-	}
-
-	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,
-		"vpc_id":               &c.VpcId,
-	}
-
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = t.Process(*ptr, nil)
-		if err != nil {
-			errs = append(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
-	c.sshTimeout, err = time.ParseDuration(c.RawSSHTimeout)
-	if err != nil {
-		errs = append(errs, fmt.Errorf("Failed parsing ssh_timeout: %s", err))
-	}
-
-	return errs
-}
-
-func (c *RunConfig) SSHTimeout() time.Duration {
-	return c.sshTimeout
-}

builder/amazon/common/run_config_test.go

@@ -1,128 +0,0 @@
-package common
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-func init() {
-	// Clear out the AWS access key env vars so they don't
-	// affect our tests.
-	os.Setenv("AWS_ACCESS_KEY_ID", "")
-	os.Setenv("AWS_ACCESS_KEY", "")
-	os.Setenv("AWS_SECRET_ACCESS_KEY", "")
-	os.Setenv("AWS_SECRET_KEY", "")
-}
-
-func testConfig() *RunConfig {
-	return &RunConfig{
-		SourceAmi:    "abcd",
-		InstanceType: "m1.small",
-		SSHUsername:  "root",
-	}
-}
-
-func TestRunConfigPrepare(t *testing.T) {
-	c := testConfig()
-	err := c.Prepare(nil)
-	if len(err) > 0 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_InstanceType(t *testing.T) {
-	c := testConfig()
-	c.InstanceType = ""
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_SourceAmi(t *testing.T) {
-	c := testConfig()
-	c.SourceAmi = ""
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_SSHPort(t *testing.T) {
-	c := testConfig()
-	c.SSHPort = 0
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	if c.SSHPort != 22 {
-		t.Fatalf("invalid value: %d", c.SSHPort)
-	}
-
-	c.SSHPort = 44
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	if c.SSHPort != 44 {
-		t.Fatalf("invalid value: %d", c.SSHPort)
-	}
-}
-
-func TestRunConfigPrepare_SSHTimeout(t *testing.T) {
-	c := testConfig()
-	c.RawSSHTimeout = ""
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	c.RawSSHTimeout = "bad"
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_SSHUsername(t *testing.T) {
-	c := testConfig()
-	c.SSHUsername = ""
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_UserData(t *testing.T) {
-	c := testConfig()
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer tf.Close()
-
-	c.UserData = "foo"
-	c.UserDataFile = tf.Name()
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestRunConfigPrepare_UserDataFile(t *testing.T) {
-	c := testConfig()
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-
-	c.UserDataFile = "idontexistidontthink"
-	if err := c.Prepare(nil); len(err) != 1 {
-		t.Fatalf("err: %s", err)
-	}
-
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer tf.Close()
-
-	c.UserDataFile = tf.Name()
-	if err := c.Prepare(nil); len(err) != 0 {
-		t.Fatalf("err: %s", err)
-	}
-}

builder/amazon/common/ssh.go

@@ -1,65 +0,0 @@
-package common
-
-import (
-	gossh "code.google.com/p/go.crypto/ssh"
-	"errors"
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/packer/communicator/ssh"
-	"time"
-)
-
-// SSHAddress returns a function that can be given to the SSH communicator
-// for determining the SSH address based on the instance DNS name.
-func SSHAddress(e *ec2.EC2, port int) func(map[string]interface{}) (string, error) {
-	return func(state map[string]interface{}) (string, error) {
-		for j := 0; j < 2; j++ {
-			var host string
-			i := state["instance"].(*ec2.Instance)
-			if i.DNSName != "" {
-				host = i.DNSName
-			} else if i.VpcId != "" {
-				host = i.PrivateIpAddress
-			}
-
-			if host != "" {
-				return fmt.Sprintf("%s:%d", host, port), nil
-			}
-
-			r, err := e.Instances([]string{i.InstanceId}, ec2.NewFilter())
-			if err != nil {
-				return "", err
-			}
-
-			if len(r.Reservations) == 0 || len(r.Reservations[0].Instances) == 0 {
-				return "", fmt.Errorf("instance not found: %s", i.InstanceId)
-			}
-
-			state["instance"] = &r.Reservations[0].Instances[0]
-			time.Sleep(1 * time.Second)
-		}
-
-		return "", errors.New("couldn't determine IP address for instance")
-	}
-}
-
-// SSHConfig returns a function that can be used for the SSH communicator
-// config for connecting to the instance created over SSH using the generated
-// private key.
-func SSHConfig(username string) func(map[string]interface{}) (*gossh.ClientConfig, error) {
-	return func(state map[string]interface{}) (*gossh.ClientConfig, error) {
-		privateKey := state["privateKey"].(string)
-
-		keyring := new(ssh.SimpleKeychain)
-		if err := keyring.AddPEMKey(privateKey); err != nil {
-			return nil, fmt.Errorf("Error setting up SSH config: %s", err)
-		}
-
-		return &gossh.ClientConfig{
-			User: username,
-			Auth: []gossh.ClientAuth{
-				gossh.ClientAuthKeyring(keyring),
-			},
-		}, nil
-	}
-}

builder/amazon/common/step_create_tags.go

@@ -1,43 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-type StepCreateTags struct {
-	Tags map[string]string
-}
-
-func (s *StepCreateTags) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-	amis := state["amis"].(map[string]string)
-	ami := amis[ec2conn.Region.Name]
-
-	if len(s.Tags) > 0 {
-		ui.Say(fmt.Sprintf("Adding tags to AMI (%s)...", ami))
-
-		var ec2Tags []ec2.Tag
-		for key, value := range s.Tags {
-			ui.Message(fmt.Sprintf("Adding tag: \"%s\": \"%s\"", key, value))
-			ec2Tags = append(ec2Tags, ec2.Tag{key, value})
-		}
-
-		_, err := ec2conn.CreateTags([]string{ami}, ec2Tags)
-		if err != nil {
-			err := fmt.Errorf("Error adding tags to AMI (%s): %s", ami, err)
-			state["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepCreateTags) Cleanup(state map[string]interface{}) {
-	// No cleanup...
-}

builder/amazon/common/step_modify_ami_attributes.go

@@ -1,79 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-type StepModifyAMIAttributes struct {
-	Users        []string
-	Groups       []string
-	ProductCodes []string
-	Description  string
-}
-
-func (s *StepModifyAMIAttributes) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-	amis := state["amis"].(map[string]string)
-	ami := amis[ec2conn.Region.Name]
-
-	// Determine if there is any work to do.
-	valid := false
-	valid = valid || s.Description != ""
-	valid = valid || (s.Users != nil && len(s.Users) > 0)
-	valid = valid || (s.Groups != nil && len(s.Groups) > 0)
-	valid = valid || (s.ProductCodes != nil && len(s.ProductCodes) > 0)
-
-	if !valid {
-		return multistep.ActionContinue
-	}
-
-	// Construct the modify image attribute requests we're going to make.
-	// We need to make each separately since the EC2 API only allows changing
-	// one type at a kind currently.
-	options := make(map[string]*ec2.ModifyImageAttribute)
-	if s.Description != "" {
-		options["description"] = &ec2.ModifyImageAttribute{
-			Description: s.Description,
-		}
-	}
-
-	if len(s.Groups) > 0 {
-		options["groups"] = &ec2.ModifyImageAttribute{
-			AddGroups: s.Groups,
-		}
-	}
-
-	if len(s.Users) > 0 {
-		options["users"] = &ec2.ModifyImageAttribute{
-			AddUsers: s.Users,
-		}
-	}
-
-	if len(s.ProductCodes) > 0 {
-		options["product codes"] = &ec2.ModifyImageAttribute{
-			ProductCodes: s.ProductCodes,
-		}
-	}
-
-	ui.Say("Modifying AMI attributes...")
-	for name, opts := range options {
-		ui.Message(fmt.Sprintf("Modifying: %s", name))
-		_, err := ec2conn.ModifyImageAttribute(ami, opts)
-		if err != nil {
-			err := fmt.Errorf("Error modify AMI attributes: %s", err)
-			state["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepModifyAMIAttributes) Cleanup(state map[string]interface{}) {
-	// No cleanup...
-}

builder/amazon/common/step_run_source_instance.go

@@ -1,130 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"io/ioutil"
-	"log"
-)
-
-type StepRunSourceInstance struct {
-	ExpectedRootDevice string
-	InstanceType       string
-	UserData           string
-	UserDataFile       string
-	SourceAMI          string
-	IamInstanceProfile string
-	SubnetId           string
-	BlockDevices       BlockDevices
-
-	instance *ec2.Instance
-}
-
-func (s *StepRunSourceInstance) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	keyName := state["keyPair"].(string)
-	securityGroupId := state["securityGroupId"].(string)
-	ui := state["ui"].(packer.Ui)
-
-	userData := s.UserData
-	if s.UserDataFile != "" {
-		contents, err := ioutil.ReadFile(s.UserDataFile)
-		if err != nil {
-			state["error"] = fmt.Errorf("Problem reading user data file: %s", err)
-			return multistep.ActionHalt
-		}
-
-		userData = string(contents)
-	}
-
-	runOpts := &ec2.RunInstances{
-		KeyName:            keyName,
-		ImageId:            s.SourceAMI,
-		InstanceType:       s.InstanceType,
-		UserData:           []byte(userData),
-		MinCount:           0,
-		MaxCount:           0,
-		SecurityGroups:     []ec2.SecurityGroup{ec2.SecurityGroup{Id: securityGroupId}},
-		IamInstanceProfile: s.IamInstanceProfile,
-		SubnetId:           s.SubnetId,
-		BlockDevices:       s.BlockDevices.BuildLaunchDevices(),
-	}
-
-	ui.Say("Launching a source AWS instance...")
-	imageResp, err := ec2conn.Images([]string{s.SourceAMI}, ec2.NewFilter())
-	if err != nil {
-		state["error"] = fmt.Errorf("There was a problem with the source AMI: %s", err)
-		return multistep.ActionHalt
-	}
-
-	if len(imageResp.Images) != 1 {
-		state["error"] = fmt.Errorf("The source AMI '%s' could not be found.", s.SourceAMI)
-		return multistep.ActionHalt
-	}
-
-	if s.ExpectedRootDevice != "" && imageResp.Images[0].RootDeviceType != s.ExpectedRootDevice {
-		state["error"] = fmt.Errorf(
-			"The provided source AMI has an invalid root device type.\n"+
-				"Expected '%s', got '%s'.",
-			s.ExpectedRootDevice, imageResp.Images[0].RootDeviceType)
-		return multistep.ActionHalt
-	}
-
-	runResp, err := ec2conn.RunInstances(runOpts)
-	if err != nil {
-		err := fmt.Errorf("Error launching source instance: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	s.instance = &runResp.Instances[0]
-	log.Printf("instance id: %s", s.instance.InstanceId)
-
-	ui.Say(fmt.Sprintf("Waiting for instance (%s) to become ready...", s.instance.InstanceId))
-	stateChange := StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"pending"},
-		Target:    "running",
-		Refresh:   InstanceStateRefreshFunc(ec2conn, s.instance),
-		StepState: state,
-	}
-	latestInstance, err := WaitForState(&stateChange)
-	if err != nil {
-		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", s.instance.InstanceId, err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	s.instance = latestInstance.(*ec2.Instance)
-	state["instance"] = s.instance
-
-	return multistep.ActionContinue
-}
-
-func (s *StepRunSourceInstance) Cleanup(state map[string]interface{}) {
-	if s.instance == nil {
-		return
-	}
-
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-
-	ui.Say("Terminating the source AWS instance...")
-	if _, err := ec2conn.TerminateInstances([]string{s.instance.InstanceId}); err != nil {
-		ui.Error(fmt.Sprintf("Error terminating instance, may still be around: %s", err))
-		return
-	}
-
-	stateChange := StateChangeConf{
-		Conn:    ec2conn,
-		Pending: []string{"pending", "running", "shutting-down", "stopped", "stopping"},
-		Refresh: InstanceStateRefreshFunc(ec2conn, s.instance),
-		Target:  "terminated",
-	}
-
-	WaitForState(&stateChange)
-}

builder/amazon/ebs/builder.go

@@ -1,178 +0,0 @@
-// The amazonebs package contains a packer.Builder implementation that
-// builds AMIs for Amazon EC2.
-//
-// In general, there are two types of AMIs that can be created: ebs-backed or
-// instance-store. This builder _only_ builds ebs-backed images.
-package ebs
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-// The unique ID for this builder
-const BuilderId = "mitchellh.amazonebs"
-
-type config struct {
-	common.PackerConfig    `mapstructure:",squash"`
-	awscommon.AccessConfig `mapstructure:",squash"`
-	awscommon.AMIConfig    `mapstructure:",squash"`
-	awscommon.BlockDevices `mapstructure:",squash"`
-	awscommon.RunConfig    `mapstructure:",squash"`
-
-	// Tags for the AMI
-	Tags map[string]string
-
-	tpl *packer.ConfigTemplate
-}
-
-type Builder struct {
-	config config
-	runner multistep.Runner
-}
-
-func (b *Builder) Prepare(raws ...interface{}) error {
-	md, err := common.DecodeConfig(&b.config, raws...)
-	if err != nil {
-		return err
-	}
-
-	b.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return err
-	}
-	b.config.tpl.UserVars = b.config.PackerUserVars
-
-	// Accumulate any errors
-	errs := common.CheckUnusedConfig(md)
-	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...)
-	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...)
-	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
-
-	// Accumulate any errors
-	newTags := make(map[string]string)
-	for k, v := range b.config.Tags {
-		k, err = b.config.tpl.Process(k, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing tag key %s: %s", k, err))
-			continue
-		}
-
-		v, err = b.config.tpl.Process(v, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing tag value '%s': %s", v, err))
-			continue
-		}
-
-		newTags[k] = v
-	}
-
-	b.config.Tags = newTags
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
-	}
-
-	log.Printf("Config: %+v", b.config)
-	return nil
-}
-
-func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-	region, err := b.config.Region()
-	if err != nil {
-		return nil, err
-	}
-
-	auth, err := b.config.AccessConfig.Auth()
-	if err != nil {
-		return nil, err
-	}
-
-	ec2conn := ec2.New(auth, region)
-
-	// Setup the state bag and initial state for the steps
-	state := make(map[string]interface{})
-	state["config"] = b.config
-	state["ec2"] = ec2conn
-	state["hook"] = hook
-	state["ui"] = ui
-
-	// Build the steps
-	steps := []multistep.Step{
-		&awscommon.StepKeyPair{},
-		&awscommon.StepSecurityGroup{
-			SecurityGroupId: b.config.SecurityGroupId,
-			SSHPort:         b.config.SSHPort,
-			VpcId:           b.config.VpcId,
-		},
-		&awscommon.StepRunSourceInstance{
-			ExpectedRootDevice: "ebs",
-			InstanceType:       b.config.InstanceType,
-			UserData:           b.config.UserData,
-			UserDataFile:       b.config.UserDataFile,
-			SourceAMI:          b.config.SourceAmi,
-			IamInstanceProfile: b.config.IamInstanceProfile,
-			SubnetId:           b.config.SubnetId,
-			BlockDevices:       b.config.BlockDevices,
-		},
-		&common.StepConnectSSH{
-			SSHAddress:     awscommon.SSHAddress(ec2conn, b.config.SSHPort),
-			SSHConfig:      awscommon.SSHConfig(b.config.SSHUsername),
-			SSHWaitTimeout: b.config.SSHTimeout(),
-		},
-		&common.StepProvision{},
-		&stepStopInstance{},
-		&stepCreateAMI{},
-		&awscommon.StepCreateTags{Tags: b.config.Tags},
-		&awscommon.StepModifyAMIAttributes{
-			Description: b.config.AMIDescription,
-			Users:       b.config.AMIUsers,
-			Groups:      b.config.AMIGroups,
-		},
-	}
-
-	// 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["error"]; ok {
-		return nil, rawErr.(error)
-	}
-
-	// If there are no AMIs, then just return
-	if _, ok := state["amis"]; !ok {
-		return nil, nil
-	}
-
-	// Build the artifact and return it
-	artifact := &awscommon.Artifact{
-		Amis:           state["amis"].(map[string]string),
-		BuilderIdValue: BuilderId,
-		Conn:           ec2conn,
-	}
-
-	return artifact, nil
-}
-
-func (b *Builder) Cancel() {
-	if b.runner != nil {
-		log.Println("Cancelling the step runner...")
-		b.runner.Cancel()
-	}
-}

builder/amazon/ebs/builder_test.go

@@ -1,78 +0,0 @@
-package ebs
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func testConfig() map[string]interface{} {
-	return map[string]interface{}{
-		"access_key":    "foo",
-		"secret_key":    "bar",
-		"source_ami":    "foo",
-		"instance_type": "foo",
-		"region":        "us-east-1",
-		"ssh_username":  "root",
-		"ami_name":      "foo",
-	}
-}
-
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	var raw interface{}
-	raw = &Builder{}
-	if _, ok := raw.(packer.Builder); !ok {
-		t.Fatalf("Builder should be a builder")
-	}
-}
-
-func TestBuilder_Prepare_BadType(t *testing.T) {
-	b := &Builder{}
-	c := map[string]interface{}{
-		"access_key": []string{},
-	}
-
-	err := b.Prepare(c)
-	if err == nil {
-		t.Fatalf("prepare should fail")
-	}
-}
-
-func TestBuilderPrepare_AMIName(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test good
-	config["ami_name"] = "foo"
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	// Test bad
-	config["ami_name"] = "foo {{"
-	b = Builder{}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test bad
-	delete(config, "ami_name")
-	b = Builder{}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_InvalidKey(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Add a random key
-	config["i_should_not_be_valid"] = true
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}

builder/amazon/instance/builder.go

@@ -1,260 +0,0 @@
-// The instance package contains a packer.Builder implementation that builds
-// AMIs for Amazon EC2 backed by instance storage, as opposed to EBS storage.
-package instance
-
-import (
-	"errors"
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-	"strings"
-)
-
-// The unique ID for this builder
-const BuilderId = "mitchellh.amazon.instance"
-
-// Config is the configuration that is chained through the steps and
-// settable from the template.
-type Config struct {
-	common.PackerConfig    `mapstructure:",squash"`
-	awscommon.AccessConfig `mapstructure:",squash"`
-	awscommon.AMIConfig    `mapstructure:",squash"`
-	awscommon.BlockDevices `mapstructure:",squash"`
-	awscommon.RunConfig    `mapstructure:",squash"`
-
-	AccountId           string `mapstructure:"account_id"`
-	BundleDestination   string `mapstructure:"bundle_destination"`
-	BundlePrefix        string `mapstructure:"bundle_prefix"`
-	BundleUploadCommand string `mapstructure:"bundle_upload_command"`
-	BundleVolCommand    string `mapstructure:"bundle_vol_command"`
-	S3Bucket            string `mapstructure:"s3_bucket"`
-	Tags                map[string]string
-	X509CertPath        string `mapstructure:"x509_cert_path"`
-	X509KeyPath         string `mapstructure:"x509_key_path"`
-	X509UploadPath      string `mapstructure:"x509_upload_path"`
-
-	tpl *packer.ConfigTemplate
-}
-
-type Builder struct {
-	config Config
-	runner multistep.Runner
-}
-
-func (b *Builder) Prepare(raws ...interface{}) error {
-	md, err := common.DecodeConfig(&b.config, raws...)
-	if err != nil {
-		return err
-	}
-
-	b.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return err
-	}
-	b.config.tpl.UserVars = b.config.PackerUserVars
-
-	if b.config.BundleDestination == "" {
-		b.config.BundleDestination = "/tmp"
-	}
-
-	if b.config.BundlePrefix == "" {
-		b.config.BundlePrefix = "image-{{timestamp}}"
-	}
-
-	if b.config.BundleUploadCommand == "" {
-		b.config.BundleUploadCommand = "sudo -n ec2-upload-bundle " +
-			"-b {{.BucketName}} " +
-			"-m {{.ManifestPath}} " +
-			"-a {{.AccessKey}} " +
-			"-s {{.SecretKey}} " +
-			"-d {{.BundleDirectory}} " +
-			"--batch " +
-			"--retry"
-	}
-
-	if b.config.BundleVolCommand == "" {
-		b.config.BundleVolCommand = "sudo -n ec2-bundle-vol " +
-			"-k {{.KeyPath}} " +
-			"-u {{.AccountId}} " +
-			"-c {{.CertPath}} " +
-			"-r {{.Architecture}} " +
-			"-e {{.PrivatePath}} " +
-			"-d {{.Destination}} " +
-			"-p {{.Prefix}} " +
-			"--batch"
-	}
-
-	if b.config.X509UploadPath == "" {
-		b.config.X509UploadPath = "/tmp"
-	}
-
-	// Accumulate any errors
-	errs := common.CheckUnusedConfig(md)
-	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...)
-	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...)
-	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
-
-	validates := map[string]*string{
-		"bundle_upload_command": &b.config.BundleUploadCommand,
-		"bundle_vol_command":    &b.config.BundleVolCommand,
-	}
-
-	for n, ptr := range validates {
-		if err := b.config.tpl.Validate(*ptr); err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error parsing %s: %s", n, err))
-		}
-	}
-
-	templates := map[string]*string{
-		"account_id":         &b.config.AccountId,
-		"ami_name":           &b.config.AMIName,
-		"bundle_destination": &b.config.BundleDestination,
-		"bundle_prefix":      &b.config.BundlePrefix,
-		"s3_bucket":          &b.config.S3Bucket,
-		"x509_cert_path":     &b.config.X509CertPath,
-		"x509_key_path":      &b.config.X509KeyPath,
-		"x509_upload_path":   &b.config.X509UploadPath,
-	}
-
-	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))
-		}
-	}
-
-	if b.config.AccountId == "" {
-		errs = packer.MultiErrorAppend(errs, errors.New("account_id is required"))
-	} else {
-		b.config.AccountId = strings.Replace(b.config.AccountId, "-", "", -1)
-	}
-
-	if b.config.S3Bucket == "" {
-		errs = packer.MultiErrorAppend(errs, errors.New("s3_bucket is required"))
-	}
-
-	if b.config.X509CertPath == "" {
-		errs = packer.MultiErrorAppend(errs, errors.New("x509_cert_path is required"))
-	} else if _, err := os.Stat(b.config.X509CertPath); err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("x509_cert_path points to bad file: %s", err))
-	}
-
-	if b.config.X509KeyPath == "" {
-		errs = packer.MultiErrorAppend(errs, errors.New("x509_key_path is required"))
-	} else if _, err := os.Stat(b.config.X509KeyPath); err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("x509_key_path points to bad file: %s", err))
-	}
-
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
-	}
-
-	log.Printf("Config: %+v", b.config)
-	return nil
-}
-
-func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-	region, err := b.config.Region()
-	if err != nil {
-		return nil, err
-	}
-
-	auth, err := b.config.AccessConfig.Auth()
-	if err != nil {
-		return nil, err
-	}
-
-	ec2conn := ec2.New(auth, region)
-
-	// Setup the state bag and initial state for the steps
-	state := make(map[string]interface{})
-	state["config"] = &b.config
-	state["ec2"] = ec2conn
-	state["hook"] = hook
-	state["ui"] = ui
-
-	// Build the steps
-	steps := []multistep.Step{
-		&awscommon.StepKeyPair{},
-		&awscommon.StepSecurityGroup{
-			SecurityGroupId: b.config.SecurityGroupId,
-			SSHPort:         b.config.SSHPort,
-			VpcId:           b.config.VpcId,
-		},
-		&awscommon.StepRunSourceInstance{
-			ExpectedRootDevice: "instance-store",
-			InstanceType:       b.config.InstanceType,
-			IamInstanceProfile: b.config.IamInstanceProfile,
-			UserData:           b.config.UserData,
-			UserDataFile:       b.config.UserDataFile,
-			SourceAMI:          b.config.SourceAmi,
-			SubnetId:           b.config.SubnetId,
-			BlockDevices:       b.config.BlockDevices,
-		},
-		&common.StepConnectSSH{
-			SSHAddress:     awscommon.SSHAddress(ec2conn, b.config.SSHPort),
-			SSHConfig:      awscommon.SSHConfig(b.config.SSHUsername),
-			SSHWaitTimeout: b.config.SSHTimeout(),
-		},
-		&common.StepProvision{},
-		&StepUploadX509Cert{},
-		&StepBundleVolume{},
-		&StepUploadBundle{},
-		&StepRegisterAMI{},
-		&awscommon.StepCreateTags{Tags: b.config.Tags},
-		&awscommon.StepModifyAMIAttributes{
-			Description:  b.config.AMIDescription,
-			Users:        b.config.AMIUsers,
-			Groups:       b.config.AMIGroups,
-			ProductCodes: b.config.AMIProductCodes,
-		},
-	}
-
-	// 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["error"]; ok {
-		return nil, rawErr.(error)
-	}
-
-	// If there are no AMIs, then just return
-	if _, ok := state["amis"]; !ok {
-		return nil, nil
-	}
-
-	// Build the artifact and return it
-	artifact := &awscommon.Artifact{
-		Amis:           state["amis"].(map[string]string),
-		BuilderIdValue: BuilderId,
-		Conn:           ec2conn,
-	}
-
-	return artifact, nil
-}
-
-func (b *Builder) Cancel() {
-	if b.runner != nil {
-		log.Println("Cancelling the step runner...")
-		b.runner.Cancel()
-	}
-}

builder/amazon/instance/builder_test.go

@@ -1,219 +0,0 @@
-package instance
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-func testConfig() map[string]interface{} {
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		panic(err)
-	}
-
-	return map[string]interface{}{
-		"account_id":       "foo",
-		"ami_name":         "foo",
-		"instance_type":    "m1.small",
-		"region":           "us-east-1",
-		"s3_bucket":        "foo",
-		"source_ami":       "foo",
-		"ssh_username":     "bob",
-		"x509_cert_path":   tf.Name(),
-		"x509_key_path":    tf.Name(),
-		"x509_upload_path": "/foo",
-	}
-}
-
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	var raw interface{}
-	raw = &Builder{}
-	if _, ok := raw.(packer.Builder); !ok {
-		t.Fatalf("Builder should be a builder")
-	}
-}
-
-func TestBuilderPrepare_AccountId(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["account_id"] = ""
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	config["account_id"] = "foo"
-	err = b.Prepare(config)
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-
-	config["account_id"] = "0123-0456-7890"
-	err = b.Prepare(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if b.config.AccountId != "012304567890" {
-		t.Errorf("should strip hyphens: %s", b.config.AccountId)
-	}
-}
-
-func TestBuilderPrepare_AMIName(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test good
-	config["ami_name"] = "foo"
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	// Test bad
-	config["ami_name"] = "foo {{"
-	b = Builder{}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test bad
-	delete(config, "ami_name")
-	b = Builder{}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_BundleDestination(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["bundle_destination"] = ""
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if b.config.BundleDestination != "/tmp" {
-		t.Fatalf("bad: %s", b.config.BundleDestination)
-	}
-}
-
-func TestBuilderPrepare_BundlePrefix(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["bundle_prefix"] = ""
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if b.config.BundlePrefix == "" {
-		t.Fatalf("bad: %s", b.config.BundlePrefix)
-	}
-}
-
-func TestBuilderPrepare_InvalidKey(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Add a random key
-	config["i_should_not_be_valid"] = true
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_S3Bucket(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["s3_bucket"] = ""
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	config["s3_bucket"] = "foo"
-	err = b.Prepare(config)
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-}
-
-func TestBuilderPrepare_X509CertPath(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["x509_cert_path"] = ""
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	config["x509_cert_path"] = "i/am/a/file/that/doesnt/exist"
-	err = b.Prepare(config)
-	if err == nil {
-		t.Error("should have error")
-	}
-
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("error tempfile: %s", err)
-	}
-	defer os.Remove(tf.Name())
-
-	config["x509_cert_path"] = tf.Name()
-	err = b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_X509KeyPath(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["x509_key_path"] = ""
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	config["x509_key_path"] = "i/am/a/file/that/doesnt/exist"
-	err = b.Prepare(config)
-	if err == nil {
-		t.Error("should have error")
-	}
-
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("error tempfile: %s", err)
-	}
-	defer os.Remove(tf.Name())
-
-	config["x509_key_path"] = tf.Name()
-	err = b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_X509UploadPath(t *testing.T) {
-	b := &Builder{}
-	config := testConfig()
-
-	config["x509_upload_path"] = ""
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}

builder/amazon/instance/step_bundle_volume.go

@@ -1,93 +0,0 @@
-package instance
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-type bundleCmdData struct {
-	AccountId    string
-	Architecture string
-	CertPath     string
-	Destination  string
-	KeyPath      string
-	Prefix       string
-	PrivatePath  string
-}
-
-type StepBundleVolume struct{}
-
-func (s *StepBundleVolume) Run(state map[string]interface{}) multistep.StepAction {
-	comm := state["communicator"].(packer.Communicator)
-	config := state["config"].(*Config)
-	instance := state["instance"].(*ec2.Instance)
-	ui := state["ui"].(packer.Ui)
-	x509RemoteCertPath := state["x509RemoteCertPath"].(string)
-	x509RemoteKeyPath := state["x509RemoteKeyPath"].(string)
-
-	// Verify the AMI tools are available
-	ui.Say("Checking for EC2 AMI tools...")
-	cmd := &packer.RemoteCmd{Command: "ec2-ami-tools-version"}
-	if err := comm.Start(cmd); err != nil {
-		state["error"] = fmt.Errorf("Error checking for AMI tools: %s", err)
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-	cmd.Wait()
-
-	if cmd.ExitStatus != 0 {
-		state["error"] = fmt.Errorf(
-			"The EC2 AMI tools could not be detected. These must be manually\n" +
-				"via a provisioner or some other means and are required for Packer\n" +
-				"to create an instance-store AMI.")
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	// Bundle the volume
-	var err error
-	config.BundleVolCommand, err = config.tpl.Process(config.BundleVolCommand, bundleCmdData{
-		AccountId:    config.AccountId,
-		Architecture: instance.Architecture,
-		CertPath:     x509RemoteCertPath,
-		Destination:  config.BundleDestination,
-		KeyPath:      x509RemoteKeyPath,
-		Prefix:       config.BundlePrefix,
-		PrivatePath:  config.X509UploadPath,
-	})
-	if err != nil {
-		err := fmt.Errorf("Error processing bundle volume command: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Say("Bundling the volume...")
-	cmd = new(packer.RemoteCmd)
-	cmd.Command = config.BundleVolCommand
-	if err := cmd.StartWithUi(comm, ui); err != nil {
-		state["error"] = fmt.Errorf("Error bundling volume: %s", err)
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	if cmd.ExitStatus != 0 {
-		state["error"] = fmt.Errorf(
-			"Volume bundling failed. Please see the output above for more\n" +
-				"details on what went wrong.")
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	// Store the manifest path
-	manifestName := config.BundlePrefix + ".manifest.xml"
-	state["manifest_name"] = manifestName
-	state["manifest_path"] = fmt.Sprintf(
-		"%s/%s", config.BundleDestination, manifestName)
-
-	return multistep.ActionContinue
-}
-
-func (s *StepBundleVolume) Cleanup(map[string]interface{}) {}

builder/amazon/instance/step_register_ami.go

@@ -1,51 +0,0 @@
-package instance
-
-import (
-	"fmt"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
-	"github.com/mitchellh/packer/packer"
-)
-
-type StepRegisterAMI struct{}
-
-func (s *StepRegisterAMI) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ec2conn := state["ec2"].(*ec2.EC2)
-	manifestPath := state["remote_manifest_path"].(string)
-	ui := state["ui"].(packer.Ui)
-
-	ui.Say("Registering the AMI...")
-	registerOpts := &ec2.RegisterImage{
-		ImageLocation: manifestPath,
-		Name:          config.AMIName,
-		BlockDevices:  config.BlockDevices.BuildAMIDevices(),
-	}
-
-	registerResp, err := ec2conn.RegisterImage(registerOpts)
-	if err != nil {
-		state["error"] = fmt.Errorf("Error registering AMI: %s", err)
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	// Set the AMI ID in the state
-	ui.Say(fmt.Sprintf("AMI: %s", registerResp.ImageId))
-	amis := make(map[string]string)
-	amis[ec2conn.Region.Name] = registerResp.ImageId
-	state["amis"] = amis
-
-	// Wait for the image to become ready
-	ui.Say("Waiting for AMI to become ready...")
-	if err := awscommon.WaitForAMI(ec2conn, registerResp.ImageId); err != nil {
-		err := fmt.Errorf("Error waiting for AMI: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (s *StepRegisterAMI) Cleanup(map[string]interface{}) {}

builder/amazon/instance/step_upload_bundle.go

@@ -1,63 +0,0 @@
-package instance
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-type uploadCmdData struct {
-	AccessKey       string
-	BucketName      string
-	BundleDirectory string
-	ManifestPath    string
-	SecretKey       string
-}
-
-type StepUploadBundle struct{}
-
-func (s *StepUploadBundle) Run(state map[string]interface{}) multistep.StepAction {
-	comm := state["communicator"].(packer.Communicator)
-	config := state["config"].(*Config)
-	manifestName := state["manifest_name"].(string)
-	manifestPath := state["manifest_path"].(string)
-	ui := state["ui"].(packer.Ui)
-
-	var err error
-	config.BundleUploadCommand, err = config.tpl.Process(config.BundleUploadCommand, uploadCmdData{
-		AccessKey:       config.AccessKey,
-		BucketName:      config.S3Bucket,
-		BundleDirectory: config.BundleDestination,
-		ManifestPath:    manifestPath,
-		SecretKey:       config.SecretKey,
-	})
-	if err != nil {
-		err := fmt.Errorf("Error processing bundle upload command: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Say("Uploading the bundle...")
-	cmd := &packer.RemoteCmd{Command: config.BundleUploadCommand}
-	if err := cmd.StartWithUi(comm, ui); err != nil {
-		state["error"] = fmt.Errorf("Error uploading volume: %s", err)
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	if cmd.ExitStatus != 0 {
-		state["error"] = fmt.Errorf(
-			"Bundle upload failed. Please see the output above for more\n" +
-				"details on what went wrong.")
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	state["remote_manifest_path"] = fmt.Sprintf(
-		"%s/%s", config.S3Bucket, manifestName)
-
-	return multistep.ActionContinue
-}
-
-func (s *StepUploadBundle) Cleanup(state map[string]interface{}) {}

builder/amazon/instance/step_upload_x509_cert.go

@@ -1,49 +0,0 @@
-package instance
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"os"
-)
-
-type StepUploadX509Cert struct{}
-
-func (s *StepUploadX509Cert) Run(state map[string]interface{}) multistep.StepAction {
-	comm := state["communicator"].(packer.Communicator)
-	config := state["config"].(*Config)
-	ui := state["ui"].(packer.Ui)
-
-	x509RemoteCertPath := config.X509UploadPath + "/cert.pem"
-	x509RemoteKeyPath := config.X509UploadPath + "/key.pem"
-
-	ui.Say("Uploading X509 Certificate...")
-	if err := s.uploadSingle(comm, x509RemoteCertPath, config.X509CertPath); err != nil {
-		state["error"] = fmt.Errorf("Error uploading X509 cert: %s", err)
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	if err := s.uploadSingle(comm, x509RemoteKeyPath, config.X509KeyPath); err != nil {
-		state["error"] = fmt.Errorf("Error uploading X509 cert: %s", err)
-		ui.Error(state["error"].(error).Error())
-		return multistep.ActionHalt
-	}
-
-	state["x509RemoteCertPath"] = x509RemoteCertPath
-	state["x509RemoteKeyPath"] = x509RemoteKeyPath
-
-	return multistep.ActionContinue
-}
-
-func (s *StepUploadX509Cert) Cleanup(map[string]interface{}) {}
-
-func (s *StepUploadX509Cert) uploadSingle(comm packer.Communicator, dst, src string) error {
-	f, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	return comm.Upload(dst, f)
-}

builder/amazonebs/artifact.go

@@ -1,4 +1,4 @@
-package common
+package amazonebs
 
 import (
 	"fmt"
@@ -8,39 +8,35 @@ import (
 	"strings"
 )
 
-// Artifact is an artifact implementation that contains built AMIs.
-type Artifact struct {
+type artifact struct {
 	// A map of regions to AMI IDs.
-	Amis map[string]string
-
-	// BuilderId is the unique ID for the builder that created this AMI
-	BuilderIdValue string
+	amis map[string]string
 
 	// EC2 connection for performing API stuff.
-	Conn *ec2.EC2
+	conn *ec2.EC2
 }
 
-func (a *Artifact) BuilderId() string {
-	return a.BuilderIdValue
+func (*artifact) BuilderId() string {
+	return BuilderId
 }
 
-func (*Artifact) Files() []string {
+func (*artifact) Files() []string {
 	// We have no files
 	return nil
 }
 
-func (a *Artifact) Id() string {
-	parts := make([]string, 0, len(a.Amis))
-	for region, amiId := range a.Amis {
+func (a *artifact) Id() string {
+	parts := make([]string, 0, len(a.amis))
+	for region, amiId := range a.amis {
 		parts = append(parts, fmt.Sprintf("%s:%s", region, amiId))
 	}
 
 	return strings.Join(parts, ",")
 }
 
-func (a *Artifact) String() string {
-	amiStrings := make([]string, 0, len(a.Amis))
-	for region, id := range a.Amis {
+func (a *artifact) String() string {
+	amiStrings := make([]string, 0, len(a.amis))
+	for region, id := range a.amis {
 		single := fmt.Sprintf("%s: %s", region, id)
 		amiStrings = append(amiStrings, single)
 	}
@@ -48,12 +44,12 @@ func (a *Artifact) String() string {
 	return fmt.Sprintf("AMIs were created:\n\n%s", strings.Join(amiStrings, "\n"))
 }
 
-func (a *Artifact) Destroy() error {
+func (a *artifact) Destroy() error {
 	errors := make([]error, 0)
 
-	for _, imageId := range a.Amis {
+	for _, imageId := range a.amis {
 		log.Printf("Deregistering image ID: %s", imageId)
-		if _, err := a.Conn.DeregisterImage(imageId); err != nil {
+		if _, err := a.conn.DeregisterImage(imageId); err != nil {
 			errors = append(errors, err)
 		}
 

builder/amazonebs/artifact_test.go

@@ -1,4 +1,4 @@
-package common
+package amazonebs
 
 import (
 	"cgl.tideland.biz/asserts"
@@ -10,7 +10,7 @@ func TestArtifact_Impl(t *testing.T) {
 	assert := asserts.NewTestingAsserts(t, true)
 
 	var actual packer.Artifact
-	assert.Implementor(&Artifact{}, &actual, "should be an Artifact")
+	assert.Implementor(&artifact{}, &actual, "should be an Artifact")
 }
 
 func TestArtifactId(t *testing.T) {
@@ -22,10 +22,7 @@ func TestArtifactId(t *testing.T) {
 	amis["east"] = "foo"
 	amis["west"] = "bar"
 
-	a := &Artifact{
-		Amis: amis,
-	}
-
+	a := &artifact{amis, nil}
 	result := a.Id()
 	assert.Equal(result, expected, "should match output")
 }
@@ -42,7 +39,7 @@ west: bar`
 	amis["east"] = "foo"
 	amis["west"] = "bar"
 
-	a := &Artifact{Amis: amis}
+	a := &artifact{amis, nil}
 	result := a.String()
 	assert.Equal(result, expected, "should match output")
 }

builder/amazonebs/builder.go

@@ -0,0 +1,182 @@
+// The amazonebs package contains a packer.Builder implementation that
+// builds AMIs for Amazon EC2.
+//
+// In general, there are two types of AMIs that can be created: ebs-backed or
+// instance-store. This builder _only_ builds ebs-backed images.
+package amazonebs
+
+import (
+	"errors"
+	"fmt"
+	"github.com/mitchellh/goamz/aws"
+	"github.com/mitchellh/goamz/ec2"
+	"github.com/mitchellh/mapstructure"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/builder/common"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"text/template"
+	"time"
+)
+
+// The unique ID for this builder
+const BuilderId = "mitchellh.amazonebs"
+
+type config struct {
+	// Access information
+	AccessKey string `mapstructure:"access_key"`
+	SecretKey string `mapstructure:"secret_key"`
+
+	// Information for the source instance
+	Region       string
+	SourceAmi    string `mapstructure:"source_ami"`
+	InstanceType string `mapstructure:"instance_type"`
+	SSHUsername  string `mapstructure:"ssh_username"`
+	SSHPort      int    `mapstructure:"ssh_port"`
+	SSHTimeout   time.Duration
+
+	// Configuration of the resulting AMI
+	AMIName string `mapstructure:"ami_name"`
+
+	PackerDebug   bool   `mapstructure:"packer_debug"`
+	RawSSHTimeout string `mapstructure:"ssh_timeout"`
+}
+
+type Builder struct {
+	config config
+	runner multistep.Runner
+}
+
+func (b *Builder) Prepare(raws ...interface{}) error {
+	var err error
+
+	for _, raw := range raws {
+		err := mapstructure.Decode(raw, &b.config)
+		if err != nil {
+			return err
+		}
+	}
+
+	if b.config.SSHPort == 0 {
+		b.config.SSHPort = 22
+	}
+
+	if b.config.RawSSHTimeout == "" {
+		b.config.RawSSHTimeout = "1m"
+	}
+
+	// Accumulate any errors
+	errs := make([]error, 0)
+
+	if b.config.AccessKey == "" {
+		errs = append(errs, errors.New("An access_key must be specified"))
+	}
+
+	if b.config.SecretKey == "" {
+		errs = append(errs, errors.New("A secret_key must be specified"))
+	}
+
+	if b.config.SourceAmi == "" {
+		errs = append(errs, errors.New("A source_ami must be specified"))
+	}
+
+	if b.config.InstanceType == "" {
+		errs = append(errs, errors.New("An instance_type must be specified"))
+	}
+
+	if b.config.Region == "" {
+		errs = append(errs, errors.New("A region must be specified"))
+	} else if _, ok := aws.Regions[b.config.Region]; !ok {
+		errs = append(errs, fmt.Errorf("Unknown region: %s", b.config.Region))
+	}
+
+	if b.config.SSHUsername == "" {
+		errs = append(errs, errors.New("An ssh_username must be specified"))
+	}
+
+	b.config.SSHTimeout, err = time.ParseDuration(b.config.RawSSHTimeout)
+	if err != nil {
+		errs = append(errs, fmt.Errorf("Failed parsing ssh_timeout: %s", err))
+	}
+
+	if b.config.AMIName == "" {
+		errs = append(errs, errors.New("ami_name must be specified"))
+	} else {
+		_, err = template.New("ami").Parse(b.config.AMIName)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Failed parsing ami_name: %s", err))
+		}
+	}
+
+	if len(errs) > 0 {
+		return &packer.MultiError{errs}
+	}
+
+	log.Printf("Config: %+v", b.config)
+	return nil
+}
+
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+	region, ok := aws.Regions[b.config.Region]
+	if !ok {
+		panic("region not found")
+	}
+
+	auth := aws.Auth{b.config.AccessKey, b.config.SecretKey}
+	ec2conn := ec2.New(auth, region)
+
+	// Setup the state bag and initial state for the steps
+	state := make(map[string]interface{})
+	state["config"] = b.config
+	state["ec2"] = ec2conn
+	state["hook"] = hook
+	state["ui"] = ui
+
+	// Build the steps
+	steps := []multistep.Step{
+		&stepKeyPair{},
+		&stepSecurityGroup{},
+		&stepRunSourceInstance{},
+		&stepConnectSSH{},
+		&stepProvision{},
+		&stepStopInstance{},
+		&stepCreateAMI{},
+	}
+
+	// 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["error"]; ok {
+		return nil, rawErr.(error)
+	}
+
+	// If there are no AMIs, then just return
+	if _, ok := state["amis"]; !ok {
+		return nil, nil
+	}
+
+	// Build the artifact and return it
+	artifact := &artifact{
+		amis: state["amis"].(map[string]string),
+		conn: ec2conn,
+	}
+
+	return artifact, nil
+}
+
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}

builder/amazonebs/builder_test.go

@@ -0,0 +1,264 @@
+package amazonebs
+
+import (
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func testConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"access_key":    "foo",
+		"secret_key":    "bar",
+		"source_ami":    "foo",
+		"instance_type": "foo",
+		"region":        "us-east-1",
+		"ssh_username":  "root",
+		"ami_name":      "foo",
+	}
+}
+
+func TestBuilder_ImplementsBuilder(t *testing.T) {
+	var raw interface{}
+	raw = &Builder{}
+	if _, ok := raw.(packer.Builder); !ok {
+		t.Fatalf("Builder should be a builder")
+	}
+}
+
+func TestBuilder_Prepare_BadType(t *testing.T) {
+	b := &Builder{}
+	c := map[string]interface{}{
+		"access_key": []string{},
+	}
+
+	err := b.Prepare(c)
+	if err == nil {
+		t.Fatalf("prepare should fail")
+	}
+}
+
+func TestBuilderPrepare_AccessKey(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["access_key"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.AccessKey != "foo" {
+		t.Errorf("access key invalid: %s", b.config.AccessKey)
+	}
+
+	// Test bad
+	delete(config, "access_key")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_AMIName(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["ami_name"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	// Test bad
+	config["ami_name"] = "foo {{"
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test bad
+	delete(config, "ami_name")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_InstanceType(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["instance_type"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.InstanceType != "foo" {
+		t.Errorf("invalid: %s", b.config.InstanceType)
+	}
+
+	// Test bad
+	delete(config, "instance_type")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_Region(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["region"] = "us-east-1"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.Region != "us-east-1" {
+		t.Errorf("invalid: %s", b.config.Region)
+	}
+
+	// Test bad
+	delete(config, "region")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test invalid
+	config["region"] = "i-am-not-real"
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_SecretKey(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["secret_key"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SecretKey != "foo" {
+		t.Errorf("secret key invalid: %s", b.config.SecretKey)
+	}
+
+	// Test bad
+	delete(config, "secret_key")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_SourceAmi(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["source_ami"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SourceAmi != "foo" {
+		t.Errorf("invalid: %s", b.config.SourceAmi)
+	}
+
+	// Test bad
+	delete(config, "source_ami")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_SSHPort(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test default
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SSHPort != 22 {
+		t.Errorf("invalid: %d", b.config.SSHPort)
+	}
+
+	// Test set
+	config["ssh_port"] = 35
+	b = Builder{}
+	err = b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SSHPort != 35 {
+		t.Errorf("invalid: %d", b.config.SSHPort)
+	}
+}
+
+func TestBuilderPrepare_SSHTimeout(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test with a bad value
+	config["ssh_timeout"] = "this is not good"
+	err := b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test with a good one
+	config["ssh_timeout"] = "5s"
+	err = b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+}
+
+func TestBuilderPrepare_SSHUsername(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test good
+	config["ssh_username"] = "foo"
+	err := b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.SSHUsername != "foo" {
+		t.Errorf("invalid: %s", b.config.SSHUsername)
+	}
+
+	// Test bad
+	delete(config, "ssh_username")
+	b = Builder{}
+	err = b.Prepare(config)
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}

builder/amazonebs/hook.go

@@ -1,4 +1,4 @@
-package ebs
+package amazonebs
 
 // This hook is fired prior to launching the EC2 instance.
 const HookPreLaunch = "amazonebs_pre_launch"

builder/amazonebs/instance.go

@@ -0,0 +1,39 @@
+package amazonebs
+
+import (
+	"fmt"
+	"github.com/mitchellh/goamz/ec2"
+	"log"
+	"time"
+)
+
+func waitForState(ec2conn *ec2.EC2, originalInstance *ec2.Instance, pending []string, target string) (i *ec2.Instance, err error) {
+	log.Printf("Waiting for instance state to become: %s", target)
+
+	i = originalInstance
+	for i.State.Name != target {
+		found := false
+		for _, allowed := range pending {
+			if i.State.Name == allowed {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			fmt.Errorf("unexpected state '%s', wanted target '%s'", i.State.Name, target)
+			return
+		}
+
+		var resp *ec2.InstancesResp
+		resp, err = ec2conn.Instances([]string{i.InstanceId}, ec2.NewFilter())
+		if err != nil {
+			return
+		}
+
+		i = &resp.Reservations[0].Instances[0]
+		time.Sleep(2 * time.Second)
+	}
+
+	return
+}

builder/amazonebs/step_connect_ssh.go

@@ -0,0 +1,125 @@
+package amazonebs
+
+import (
+	gossh "code.google.com/p/go.crypto/ssh"
+	"errors"
+	"fmt"
+	"github.com/mitchellh/goamz/ec2"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/communicator/ssh"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"net"
+	"time"
+)
+
+type stepConnectSSH struct {
+	conn net.Conn
+}
+
+func (s *stepConnectSSH) Run(state map[string]interface{}) multistep.StepAction {
+	config := state["config"].(config)
+	instance := state["instance"].(*ec2.Instance)
+	privateKey := state["privateKey"].(string)
+	ui := state["ui"].(packer.Ui)
+
+	// Build the keyring for authentication. This stores the private key
+	// we'll use to authenticate.
+	keyring := &ssh.SimpleKeychain{}
+	err := keyring.AddPEMKey(privateKey)
+	if err != nil {
+		err := fmt.Errorf("Error setting up SSH config: %s", err)
+		state["error"] = err
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Build the actual SSH client configuration
+	sshConfig := &gossh.ClientConfig{
+		User: config.SSHUsername,
+		Auth: []gossh.ClientAuth{
+			gossh.ClientAuthKeyring(keyring),
+		},
+	}
+
+	// Start trying to connect to SSH
+	connected := make(chan bool, 1)
+	connectQuit := make(chan bool, 1)
+	defer func() {
+		connectQuit <- true
+	}()
+
+	go func() {
+		var err error
+
+		ui.Say("Connecting to the instance via SSH...")
+		attempts := 0
+		for {
+			select {
+			case <-connectQuit:
+				return
+			default:
+			}
+
+			attempts += 1
+			log.Printf(
+				"Opening TCP conn for SSH to %s:%d (attempt %d)",
+				instance.DNSName, config.SSHPort, attempts)
+			s.conn, err = net.Dial("tcp", fmt.Sprintf("%s:%d", instance.DNSName, config.SSHPort))
+			if err == nil {
+				break
+			}
+
+			// A brief sleep so we're not being overly zealous attempting
+			// to connect to the instance.
+			time.Sleep(500 * time.Millisecond)
+		}
+
+		connected <- true
+	}()
+
+	log.Printf("Waiting up to %s for SSH connection", config.SSHTimeout)
+	timeout := time.After(config.SSHTimeout)
+
+ConnectWaitLoop:
+	for {
+		select {
+		case <-connected:
+			// We connected. Just break the loop.
+			break ConnectWaitLoop
+		case <-timeout:
+			err := errors.New("Timeout waiting for SSH to become available.")
+			state["error"] = err
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		case <-time.After(1 * time.Second):
+			if _, ok := state[multistep.StateCancelled]; ok {
+				log.Println("Interrupt detected, quitting waiting for SSH.")
+				return multistep.ActionHalt
+			}
+		}
+	}
+
+	var comm packer.Communicator
+	if err == nil {
+		comm, err = ssh.New(s.conn, sshConfig)
+	}
+
+	if err != nil {
+		err := fmt.Errorf("Error connecting to SSH: %s", err)
+		state["error"] = err
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Set the communicator on the state bag so it can be used later
+	state["communicator"] = comm
+
+	return multistep.ActionContinue
+}
+
+func (s *stepConnectSSH) Cleanup(map[string]interface{}) {
+	if s.conn != nil {
+		s.conn.Close()
+	}
+}

builder/amazonebs/step_create_ami.go

@@ -1,27 +1,44 @@
-package ebs
+package amazonebs
 
 import (
+	"bytes"
 	"fmt"
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
 	"github.com/mitchellh/packer/packer"
+	"log"
+	"strconv"
+	"text/template"
+	"time"
 )
 
 type stepCreateAMI struct{}
 
+type amiNameData struct {
+	CreateTime string
+}
+
 func (s *stepCreateAMI) Run(state map[string]interface{}) multistep.StepAction {
 	config := state["config"].(config)
 	ec2conn := state["ec2"].(*ec2.EC2)
 	instance := state["instance"].(*ec2.Instance)
 	ui := state["ui"].(packer.Ui)
 
+	// Parse the name of the AMI
+	amiNameBuf := new(bytes.Buffer)
+	tData := amiNameData{
+		strconv.FormatInt(time.Now().UTC().Unix(), 10),
+	}
+
+	t := template.Must(template.New("ami").Parse(config.AMIName))
+	t.Execute(amiNameBuf, tData)
+	amiName := amiNameBuf.String()
+
 	// Create the image
-	ui.Say(fmt.Sprintf("Creating the AMI: %s", config.AMIName))
+	ui.Say(fmt.Sprintf("Creating the AMI: %s", amiName))
 	createOpts := &ec2.CreateImage{
-		InstanceId:   instance.InstanceId,
-		Name:         config.AMIName,
-		BlockDevices: config.BlockDevices.BuildAMIDevices(),
+		InstanceId: instance.InstanceId,
+		Name:       amiName,
 	}
 
 	createResp, err := ec2conn.CreateImage(createOpts)
@@ -35,16 +52,28 @@ func (s *stepCreateAMI) Run(state map[string]interface{}) multistep.StepAction {
 	// Set the AMI ID in the state
 	ui.Say(fmt.Sprintf("AMI: %s", createResp.ImageId))
 	amis := make(map[string]string)
-	amis[ec2conn.Region.Name] = createResp.ImageId
+	amis[config.Region] = createResp.ImageId
 	state["amis"] = amis
 
 	// Wait for the image to become ready
 	ui.Say("Waiting for AMI to become ready...")
-	if err := awscommon.WaitForAMI(ec2conn, createResp.ImageId); err != nil {
-		err := fmt.Errorf("Error waiting for AMI: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+	for {
+		imageResp, err := ec2conn.Images([]string{createResp.ImageId}, ec2.NewFilter())
+		if err != nil {
+			err := fmt.Errorf("Error querying images: %s", err)
+			state["error"] = err
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		if imageResp.Images[0].State == "available" {
+			break
+		}
+
+		log.Printf("Image in state %s, sleeping 2s before checking again",
+			imageResp.Images[0].State)
+
+		time.Sleep(2 * time.Second)
 	}
 
 	return multistep.ActionContinue

builder/amazonebs/step_keypair.go

@@ -1,4 +1,4 @@
-package common
+package amazonebs
 
 import (
 	"cgl.tideland.biz/identifier"
@@ -10,11 +10,11 @@ import (
 	"log"
 )
 
-type StepKeyPair struct {
+type stepKeyPair struct {
 	keyName string
 }
 
-func (s *StepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
+func (s *stepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
 	ec2conn := state["ec2"].(*ec2.EC2)
 	ui := state["ui"].(packer.Ui)
 
@@ -23,7 +23,9 @@ func (s *StepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
 	log.Printf("temporary keypair name: %s", keyName)
 	keyResp, err := ec2conn.CreateKeyPair(keyName)
 	if err != nil {
-		state["error"] = fmt.Errorf("Error creating temporary keypair: %s", err)
+		err := fmt.Errorf("Error creating temporary keypair: %s", err)
+		state["error"] = err
+		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
@@ -37,7 +39,7 @@ func (s *StepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
 	return multistep.ActionContinue
 }
 
-func (s *StepKeyPair) Cleanup(state map[string]interface{}) {
+func (s *stepKeyPair) Cleanup(state map[string]interface{}) {
 	// If no key name is set, then we never created it, so just return
 	if s.keyName == "" {
 		return

builder/amazonebs/step_provision.go

@@ -1,4 +1,4 @@
-package common
+package amazonebs
 
 import (
 	"github.com/mitchellh/multistep"
@@ -6,18 +6,9 @@ import (
 	"log"
 )
 
-// StepProvision runs the provisioners.
-//
-// Uses:
-//   communicator packer.Communicator
-//   hook         packer.Hook
-//   ui           packer.Ui
-//
-// Produces:
-//   <nothing>
-type StepProvision struct{}
+type stepProvision struct{}
 
-func (*StepProvision) Run(state map[string]interface{}) multistep.StepAction {
+func (*stepProvision) Run(state map[string]interface{}) multistep.StepAction {
 	comm := state["communicator"].(packer.Communicator)
 	hook := state["hook"].(packer.Hook)
 	ui := state["ui"].(packer.Ui)
@@ -31,4 +22,4 @@ func (*StepProvision) Run(state map[string]interface{}) multistep.StepAction {
 	return multistep.ActionContinue
 }
 
-func (*StepProvision) Cleanup(map[string]interface{}) {}
+func (*stepProvision) Cleanup(map[string]interface{}) {}

builder/amazonebs/step_run_source_instance.go

@@ -0,0 +1,73 @@
+package amazonebs
+
+import (
+	"fmt"
+	"github.com/mitchellh/goamz/ec2"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+type stepRunSourceInstance struct {
+	instance *ec2.Instance
+}
+
+func (s *stepRunSourceInstance) Run(state map[string]interface{}) multistep.StepAction {
+	config := state["config"].(config)
+	ec2conn := state["ec2"].(*ec2.EC2)
+	keyName := state["keyPair"].(string)
+	securityGroupId := state["securityGroupId"].(string)
+	ui := state["ui"].(packer.Ui)
+
+	runOpts := &ec2.RunInstances{
+		KeyName:        keyName,
+		ImageId:        config.SourceAmi,
+		InstanceType:   config.InstanceType,
+		MinCount:       0,
+		MaxCount:       0,
+		SecurityGroups: []ec2.SecurityGroup{ec2.SecurityGroup{Id: securityGroupId}},
+	}
+
+	ui.Say("Launching a source AWS instance...")
+	runResp, err := ec2conn.RunInstances(runOpts)
+	if err != nil {
+		err := fmt.Errorf("Error launching source instance: %s", err)
+		state["error"] = err
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	s.instance = &runResp.Instances[0]
+	log.Printf("instance id: %s", s.instance.InstanceId)
+
+	ui.Say("Waiting for instance to become ready...")
+	s.instance, err = waitForState(ec2conn, s.instance, []string{"pending"}, "running")
+	if err != nil {
+		err := fmt.Errorf("Error waiting for instance to become ready: %s", err)
+		state["error"] = err
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	state["instance"] = s.instance
+
+	return multistep.ActionContinue
+}
+
+func (s *stepRunSourceInstance) Cleanup(state map[string]interface{}) {
+	if s.instance == nil {
+		return
+	}
+
+	ec2conn := state["ec2"].(*ec2.EC2)
+	ui := state["ui"].(packer.Ui)
+
+	ui.Say("Terminating the source AWS instance...")
+	if _, err := ec2conn.TerminateInstances([]string{s.instance.InstanceId}); err != nil {
+		ui.Error(fmt.Sprintf("Error terminating instance, may still be around: %s", err))
+		return
+	}
+
+	pending := []string{"pending", "running", "shutting-down", "stopped", "stopping"}
+	waitForState(ec2conn, s.instance, pending, "terminated")
+}

builder/amazonebs/step_security_group.go

@@ -1,4 +1,4 @@
-package common
+package amazonebs
 
 import (
 	"cgl.tideland.biz/identifier"
@@ -8,55 +8,36 @@ import (
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 	"log"
-	"time"
 )
 
-type StepSecurityGroup struct {
-	SecurityGroupId string
-	SSHPort         int
-	VpcId           string
-
-	createdGroupId string
+type stepSecurityGroup struct {
+	groupId string
 }
 
-func (s *StepSecurityGroup) Run(state map[string]interface{}) multistep.StepAction {
+func (s *stepSecurityGroup) Run(state map[string]interface{}) multistep.StepAction {
+	config := state["config"].(config)
 	ec2conn := state["ec2"].(*ec2.EC2)
 	ui := state["ui"].(packer.Ui)
 
-	if s.SecurityGroupId != "" {
-		log.Printf("Using specified security group: %s", s.SecurityGroupId)
-		state["securityGroupId"] = s.SecurityGroupId
-		return multistep.ActionContinue
-	}
-
-	if s.SSHPort == 0 {
-		panic("SSHPort must be set to a non-zero value.")
-	}
-
 	// Create the group
 	ui.Say("Creating temporary security group for this instance...")
 	groupName := fmt.Sprintf("packer %s", hex.EncodeToString(identifier.NewUUID().Raw()))
 	log.Printf("Temporary group name: %s", groupName)
-	group := ec2.SecurityGroup{
-		Name:        groupName,
-		Description: "Temporary group for Packer",
-		VpcId:       s.VpcId,
-	}
-	groupResp, err := ec2conn.CreateSecurityGroup(group)
+	groupResp, err := ec2conn.CreateSecurityGroup(groupName, "Temporary group for Packer")
 	if err != nil {
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	// Set the group ID so we can delete it later
-	s.createdGroupId = groupResp.Id
+	s.groupId = groupResp.Id
 
 	// Authorize the SSH access
 	perms := []ec2.IPPerm{
 		ec2.IPPerm{
 			Protocol:  "tcp",
-			FromPort:  s.SSHPort,
-			ToPort:    s.SSHPort,
+			FromPort:  config.SSHPort,
+			ToPort:    config.SSHPort,
 			SourceIPs: []string{"0.0.0.0/0"},
 		},
 	}
@@ -70,13 +51,13 @@ func (s *StepSecurityGroup) Run(state map[string]interface{}) multistep.StepActi
 	}
 
 	// Set some state data for use in future steps
-	state["securityGroupId"] = s.createdGroupId
+	state["securityGroupId"] = s.groupId
 
 	return multistep.ActionContinue
 }
 
-func (s *StepSecurityGroup) Cleanup(state map[string]interface{}) {
-	if s.createdGroupId == "" {
+func (s *stepSecurityGroup) Cleanup(state map[string]interface{}) {
+	if s.groupId == "" {
 		return
 	}
 
@@ -84,20 +65,10 @@ func (s *StepSecurityGroup) Cleanup(state map[string]interface{}) {
 	ui := state["ui"].(packer.Ui)
 
 	ui.Say("Deleting temporary security group...")
-
-	var err error
-	for i := 0; i < 5; i++ {
-		_, err = ec2conn.DeleteSecurityGroup(ec2.SecurityGroup{Id: s.createdGroupId})
-		if err == nil {
-			break
-		}
-
-		log.Printf("Error deleting security group: %s", err)
-		time.Sleep(5 * time.Second)
-	}
-
+	_, err := ec2conn.DeleteSecurityGroup(ec2.SecurityGroup{Id: s.groupId})
 	if err != nil {
+		log.Printf("Error deleting security group: %s", err)
 		ui.Error(fmt.Sprintf(
-			"Error cleaning up security group. Please delete the group manually: %s", s.createdGroupId))
+			"Error cleaning up security group. Please delete the group manually: %s", s.groupId))
 	}
 }

builder/amazonebs/step_stop_instance.go

@@ -1,10 +1,9 @@
-package ebs
+package amazonebs
 
 import (
 	"fmt"
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
-	awscommon "github.com/mitchellh/packer/builder/amazon/common"
 	"github.com/mitchellh/packer/packer"
 )
 
@@ -27,14 +26,7 @@ func (s *stepStopInstance) Run(state map[string]interface{}) multistep.StepActio
 
 	// Wait for the instance to actual stop
 	ui.Say("Waiting for the instance to stop...")
-	stateChange := awscommon.StateChangeConf{
-		Conn:      ec2conn,
-		Pending:   []string{"running", "stopping"},
-		Target:    "stopped",
-		Refresh:   awscommon.InstanceStateRefreshFunc(ec2conn, instance),
-		StepState: state,
-	}
-	_, err = awscommon.WaitForState(&stateChange)
+	instance, err = waitForState(ec2conn, instance, []string{"running", "stopping"}, "stopped")
 	if err != nil {
 		err := fmt.Errorf("Error waiting for instance to stop: %s", err)
 		state["error"] = err

builder/common/download.go

@@ -2,9 +2,6 @@ package common
 
 import (
 	"bytes"
-	"crypto/md5"
-	"crypto/sha1"
-	"crypto/sha256"
 	"encoding/hex"
 	"errors"
 	"fmt"
@@ -14,7 +11,6 @@ import (
 	"net/http"
 	"net/url"
 	"os"
-	"runtime"
 )
 
 // DownloadConfig is the configuration given to instantiate a new
@@ -50,21 +46,6 @@ type DownloadClient struct {
 	downloader Downloader
 }
 
-// HashForType returns the Hash implementation for the given string
-// type, or nil if the type is not supported.
-func HashForType(t string) hash.Hash {
-	switch t {
-	case "md5":
-		return md5.New()
-	case "sha1":
-		return sha1.New()
-	case "sha256":
-		return sha256.New()
-	default:
-		return nil
-	}
-}
-
 // NewDownloadClient returns a new DownloadClient for the given
 // configuration.
 func NewDownloadClient(c *DownloadConfig) *DownloadClient {
@@ -108,11 +89,6 @@ func (d *DownloadClient) Get() (string, error) {
 	var finalPath string
 	if url.Scheme == "file" && !d.config.CopyFile {
 		finalPath = url.Path
-
-		// Remove forward slash on absolute Windows file URLs before processing
-		if runtime.GOOS == "windows" && finalPath[0] == '/' {
-			finalPath = finalPath[1:len(finalPath)]
-		}
 	} else {
 		finalPath = d.config.TargetPath
 
@@ -131,9 +107,6 @@ func (d *DownloadClient) Get() (string, error) {
 
 		log.Printf("Downloading: %s", url.String())
 		err = d.downloader.Download(f, url)
-		if err != nil {
-			return "", err
-		}
 	}
 
 	if d.config.Hash != nil {
@@ -148,12 +121,12 @@ func (d *DownloadClient) Get() (string, error) {
 }
 
 // PercentProgress returns the download progress as a percentage.
-func (d *DownloadClient) PercentProgress() int {
+func (d *DownloadClient) PercentProgress() uint {
 	if d.downloader == nil {
-		return -1
+		return 0
 	}
 
-	return int((float64(d.downloader.Progress()) / float64(d.downloader.Total())) * 100)
+	return uint((float64(d.downloader.Progress()) / float64(d.downloader.Total())) * 100)
 }
 
 // VerifyChecksum tests that the path matches the checksum for the
@@ -187,22 +160,11 @@ func (*HTTPDownloader) Cancel() {
 }
 
 func (d *HTTPDownloader) Download(dst io.Writer, src *url.URL) error {
-	log.Printf("Starting download: %s", src.String())
 	resp, err := http.Get(src.String())
 	if err != nil {
 		return err
 	}
 
-	if resp.StatusCode != 200 {
-		log.Printf(
-			"Non-200 status code: %d. Getting error body.", resp.StatusCode)
-
-		errorBody := new(bytes.Buffer)
-		io.Copy(errorBody, resp.Body)
-		return fmt.Errorf("HTTP error '%d'! Remote side responded:\n%s",
-			resp.StatusCode, errorBody.String())
-	}
-
 	d.progress = 0
 	d.total = uint(resp.ContentLength)
 

builder/common/download_test.go

@@ -0,0 +1,42 @@
+package common
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TestDownloadClient_VerifyChecksum(t *testing.T) {
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("tempfile error: %s", err)
+	}
+	defer os.Remove(tf.Name())
+
+	// "foo"
+	checksum, err := hex.DecodeString("acbd18db4cc2f85cedef654fccc4a4d8")
+	if err != nil {
+		t.Fatalf("decode err: %s", err)
+	}
+
+	// Write the file
+	tf.Write([]byte("foo"))
+	tf.Close()
+
+	config := &DownloadConfig{
+		Hash:     md5.New(),
+		Checksum: checksum,
+	}
+
+	d := NewDownloadClient(config)
+	result, err := d.VerifyChecksum(tf.Name())
+	if err != nil {
+		t.Fatalf("Verify err: %s", err)
+	}
+
+	if !result {
+		t.Fatal("didn't verify")
+	}
+}

builder/digitalocean/api.go

@@ -53,9 +53,10 @@ func (d DigitalOceanClient) New(client string, key string) *DigitalOceanClient {
 
 // Creates an SSH Key and returns it's id
 func (d DigitalOceanClient) CreateKey(name string, pub string) (uint, error) {
-	params := url.Values{}
-	params.Set("name", name)
-	params.Set("ssh_pub_key", pub)
+	// Escape the public key
+	pub = url.QueryEscape(pub)
+
+	params := fmt.Sprintf("name=%v&ssh_pub_key=%v", name, pub)
 
 	body, err := NewRequest(d, "ssh_keys/new", params)
 	if err != nil {
@@ -71,18 +72,15 @@ func (d DigitalOceanClient) CreateKey(name string, pub string) (uint, error) {
 // Destroys an SSH key
 func (d DigitalOceanClient) DestroyKey(id uint) error {
 	path := fmt.Sprintf("ssh_keys/%v/destroy", id)
-	_, err := NewRequest(d, path, url.Values{})
+	_, err := NewRequest(d, path, "")
 	return err
 }
 
 // Creates a droplet and returns it's id
 func (d DigitalOceanClient) CreateDroplet(name string, size uint, image uint, region uint, keyId uint) (uint, error) {
-	params := url.Values{}
-	params.Set("name", name)
-	params.Set("size_id", fmt.Sprintf("%v", size))
-	params.Set("image_id", fmt.Sprintf("%v", image))
-	params.Set("region_id", fmt.Sprintf("%v", region))
-	params.Set("ssh_key_ids", fmt.Sprintf("%v", keyId))
+	params := fmt.Sprintf(
+		"name=%v&image_id=%v&size_id=%v&region_id=%v&ssh_key_ids=%v",
+		name, image, size, region, keyId)
 
 	body, err := NewRequest(d, "droplets/new", params)
 	if err != nil {
@@ -98,7 +96,7 @@ func (d DigitalOceanClient) CreateDroplet(name string, size uint, image uint, re
 // Destroys a droplet
 func (d DigitalOceanClient) DestroyDroplet(id uint) error {
 	path := fmt.Sprintf("droplets/%v/destroy", id)
-	_, err := NewRequest(d, path, url.Values{})
+	_, err := NewRequest(d, path, "")
 	return err
 }
 
@@ -106,7 +104,7 @@ func (d DigitalOceanClient) DestroyDroplet(id uint) error {
 func (d DigitalOceanClient) PowerOffDroplet(id uint) error {
 	path := fmt.Sprintf("droplets/%v/power_off", id)
 
-	_, err := NewRequest(d, path, url.Values{})
+	_, err := NewRequest(d, path, "")
 
 	return err
 }
@@ -114,9 +112,7 @@ func (d DigitalOceanClient) PowerOffDroplet(id uint) error {
 // Creates a snaphot of a droplet by it's ID
 func (d DigitalOceanClient) CreateSnapshot(id uint, name string) error {
 	path := fmt.Sprintf("droplets/%v/snapshot", id)
-
-	params := url.Values{}
-	params.Set("name", name)
+	params := fmt.Sprintf("name=%v", name)
 
 	_, err := NewRequest(d, path, params)
 
@@ -125,7 +121,7 @@ func (d DigitalOceanClient) CreateSnapshot(id uint, name string) error {
 
 // Returns all available images.
 func (d DigitalOceanClient) Images() ([]Image, error) {
-	resp, err := NewRequest(d, "images", url.Values{})
+	resp, err := NewRequest(d, "images", "")
 	if err != nil {
 		return nil, err
 	}
@@ -141,7 +137,7 @@ func (d DigitalOceanClient) Images() ([]Image, error) {
 // Destroys an image by its ID.
 func (d DigitalOceanClient) DestroyImage(id uint) error {
 	path := fmt.Sprintf("images/%d/destroy", id)
-	_, err := NewRequest(d, path, url.Values{})
+	_, err := NewRequest(d, path, "")
 	return err
 }
 
@@ -149,7 +145,7 @@ func (d DigitalOceanClient) DestroyImage(id uint) error {
 func (d DigitalOceanClient) DropletStatus(id uint) (string, string, error) {
 	path := fmt.Sprintf("droplets/%v", id)
 
-	body, err := NewRequest(d, path, url.Values{})
+	body, err := NewRequest(d, path, "")
 	if err != nil {
 		return "", "", err
 	}
@@ -169,14 +165,10 @@ func (d DigitalOceanClient) DropletStatus(id uint) (string, string, error) {
 
 // Sends an api request and returns a generic map[string]interface of
 // the response.
-func NewRequest(d DigitalOceanClient, path string, params url.Values) (map[string]interface{}, error) {
+func NewRequest(d DigitalOceanClient, path string, params string) (map[string]interface{}, error) {
 	client := d.client
-
-	// Add the authentication parameters
-	params.Set("client_id", d.ClientID)
-	params.Set("api_key", d.APIKey)
-
-	url := fmt.Sprintf("%s/%s?%s", DIGITALOCEAN_API_URL, path, params.Encode())
+	url := fmt.Sprintf("%s/%s?%s&client_id=%s&api_key=%s",
+		DIGITALOCEAN_API_URL, path, params, d.ClientID, d.APIKey)
 
 	var decodedResponse map[string]interface{}
 
@@ -197,25 +189,28 @@ func NewRequest(d DigitalOceanClient, path string, params url.Values) (map[strin
 		return decodedResponse, err
 	}
 
-	log.Printf("response from digitalocean: %s", body)
-
 	err = json.Unmarshal(body, &decodedResponse)
 
-	// Check for bad JSON
-	if err != nil {
-		err = errors.New(fmt.Sprintf("Failed to decode JSON response (HTTP %v) from DigitalOcean: %s",
-			resp.StatusCode, body))
+	log.Printf("response from digitalocean: %v", decodedResponse)
+
+	// Catch all non-200 status and return an error
+	if resp.StatusCode != 200 {
+		err = errors.New(fmt.Sprintf("Received non-200 HTTP status from DigitalOcean: %v", resp.StatusCode))
 		return decodedResponse, err
 	}
 
-	// Check for errors sent by digitalocean
+	if err != nil {
+		return decodedResponse, err
+	}
+
+	// Catch all non-OK statuses from DO and return an error
 	status := decodedResponse["status"]
 	if status != "OK" {
 		// Get the actual error message if there is one
 		if status == "ERROR" {
 			status = decodedResponse["error_message"]
 		}
-		err = errors.New(fmt.Sprintf("Received bad response (HTTP %v) from DigitalOcean: %s", resp.StatusCode, status))
+		err = errors.New(fmt.Sprintf("Received bad status from DigitalOcean: %v", status))
 		return decodedResponse, err
 	}
 

builder/digitalocean/builder.go

@@ -4,46 +4,49 @@
 package digitalocean
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
+	"github.com/mitchellh/mapstructure"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/builder/common"
 	"github.com/mitchellh/packer/packer"
 	"log"
-	"os"
+	"strconv"
+	"text/template"
 	"time"
 )
 
 // The unique id for the builder
 const BuilderId = "pearkes.digitalocean"
 
+type snapshotNameData struct {
+	CreateTime string
+}
+
 // Configuration tells the builder the credentials
 // to use while communicating with DO and describes the image
 // you are creating
 type config struct {
-	common.PackerConfig `mapstructure:",squash"`
-
 	ClientID string `mapstructure:"client_id"`
 	APIKey   string `mapstructure:"api_key"`
 	RegionID uint   `mapstructure:"region_id"`
 	SizeID   uint   `mapstructure:"size_id"`
 	ImageID  uint   `mapstructure:"image_id"`
 
-	SnapshotName string `mapstructure:"snapshot_name"`
+	SnapshotName string
 	SSHUsername  string `mapstructure:"ssh_username"`
 	SSHPort      uint   `mapstructure:"ssh_port"`
+	SSHTimeout   time.Duration
+	EventDelay   time.Duration
+	StateTimeout time.Duration
 
+	PackerDebug bool `mapstructure:"packer_debug"`
+
+	RawSnapshotName string `mapstructure:"snapshot_name"`
 	RawSSHTimeout   string `mapstructure:"ssh_timeout"`
 	RawEventDelay   string `mapstructure:"event_delay"`
 	RawStateTimeout string `mapstructure:"state_timeout"`
-
-	// These are unexported since they're set by other fields
-	// being set.
-	sshTimeout   time.Duration
-	eventDelay   time.Duration
-	stateTimeout time.Duration
-
-	tpl *packer.ConfigTemplate
 }
 
 type Builder struct {
@@ -52,31 +55,15 @@ type Builder struct {
 }
 
 func (b *Builder) Prepare(raws ...interface{}) error {
-	md, err := common.DecodeConfig(&b.config, raws...)
-	if err != nil {
-		return err
+	for _, raw := range raws {
+		err := mapstructure.Decode(raw, &b.config)
+		if err != nil {
+			return err
+		}
 	}
 
-	b.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return err
-	}
-	b.config.tpl.UserVars = b.config.PackerUserVars
-
-	// Accumulate any errors
-	errs := common.CheckUnusedConfig(md)
-
 	// Optional configuration with defaults
-	if b.config.APIKey == "" {
-		// Default to environment variable for api_key, if it exists
-		b.config.APIKey = os.Getenv("DIGITALOCEAN_API_KEY")
-	}
-
-	if b.config.ClientID == "" {
-		// Default to environment variable for client_id, if it exists
-		b.config.ClientID = os.Getenv("DIGITALOCEAN_CLIENT_ID")
-	}
-
+	//
 	if b.config.RegionID == 0 {
 		// Default to Region "New York"
 		b.config.RegionID = 1
@@ -92,11 +79,6 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 		b.config.ImageID = 284203
 	}
 
-	if b.config.SnapshotName == "" {
-		// Default to packer-{{ unix timestamp (utc) }}
-		b.config.SnapshotName = "packer-{{timestamp}}"
-	}
-
 	if b.config.SSHUsername == "" {
 		// Default to "root". You can override this if your
 		// SourceImage has a different user account then the DO default
@@ -108,6 +90,11 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 		b.config.SSHPort = 22
 	}
 
+	if b.config.RawSnapshotName == "" {
+		// Default to packer-{{ unix timestamp (utc) }}
+		b.config.RawSnapshotName = "packer-{{.CreateTime}}"
+	}
+
 	if b.config.RawSSHTimeout == "" {
 		// Default to 1 minute timeouts
 		b.config.RawSSHTimeout = "1m"
@@ -125,59 +112,52 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 		b.config.RawStateTimeout = "6m"
 	}
 
-	templates := map[string]*string{
-		"client_id":     &b.config.ClientID,
-		"api_key":       &b.config.APIKey,
-		"snapshot_name": &b.config.SnapshotName,
-		"ssh_username":  &b.config.SSHUsername,
-		"ssh_timeout":   &b.config.RawSSHTimeout,
-		"event_delay":   &b.config.RawEventDelay,
-		"state_timeout": &b.config.RawStateTimeout,
-	}
-
-	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))
-		}
-	}
+	// A list of errors on the configuration
+	errs := make([]error, 0)
 
 	// Required configurations that will display errors if not set
+	//
 	if b.config.ClientID == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a client_id must be specified"))
+		errs = append(errs, errors.New("a client_id must be specified"))
 	}
 
 	if b.config.APIKey == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("an api_key must be specified"))
+		errs = append(errs, errors.New("an api_key must be specified"))
 	}
 
 	sshTimeout, err := time.ParseDuration(b.config.RawSSHTimeout)
 	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing ssh_timeout: %s", err))
+		errs = append(errs, fmt.Errorf("Failed parsing ssh_timeout: %s", err))
 	}
-	b.config.sshTimeout = sshTimeout
+	b.config.SSHTimeout = sshTimeout
 
 	eventDelay, err := time.ParseDuration(b.config.RawEventDelay)
 	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing event_delay: %s", err))
+		errs = append(errs, fmt.Errorf("Failed parsing event_delay: %s", err))
 	}
-	b.config.eventDelay = eventDelay
+	b.config.EventDelay = eventDelay
 
 	stateTimeout, err := time.ParseDuration(b.config.RawStateTimeout)
 	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing state_timeout: %s", err))
+		errs = append(errs, fmt.Errorf("Failed parsing state_timeout: %s", err))
 	}
-	b.config.stateTimeout = stateTimeout
+	b.config.StateTimeout = stateTimeout
 
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
+	// Parse the name of the snapshot
+	snapNameBuf := new(bytes.Buffer)
+	tData := snapshotNameData{
+		strconv.FormatInt(time.Now().UTC().Unix(), 10),
+	}
+	t, err := template.New("snapshot").Parse(b.config.RawSnapshotName)
+	if err != nil {
+		errs = append(errs, fmt.Errorf("Failed parsing snapshot_name: %s", err))
+	} else {
+		t.Execute(snapNameBuf, tData)
+		b.config.SnapshotName = snapNameBuf.String()
+	}
+
+	if len(errs) > 0 {
+		return &packer.MultiError{errs}
 	}
 
 	log.Printf("Config: %+v", b.config)
@@ -200,12 +180,8 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		new(stepCreateSSHKey),
 		new(stepCreateDroplet),
 		new(stepDropletInfo),
-		&common.StepConnectSSH{
-			SSHAddress:     sshAddress,
-			SSHConfig:      sshConfig,
-			SSHWaitTimeout: 5 * time.Minute,
-		},
-		new(common.StepProvision),
+		new(stepConnectSSH),
+		new(stepProvision),
 		new(stepPowerOff),
 		new(stepSnapshot),
 	}

builder/digitalocean/builder_test.go

@@ -2,17 +2,10 @@ package digitalocean
 
 import (
 	"github.com/mitchellh/packer/packer"
-	"os"
 	"strconv"
 	"testing"
 )
 
-func init() {
-	// Clear out the credential env vars
-	os.Setenv("DIGITALOCEAN_API_KEY", "")
-	os.Setenv("DIGITALOCEAN_CLIENT_ID", "")
-}
-
 func testConfig() map[string]interface{} {
 	return map[string]interface{}{
 		"client_id": "foo",
@@ -62,15 +55,6 @@ func TestBuilderPrepare_APIKey(t *testing.T) {
 	if err == nil {
 		t.Fatal("should have error")
 	}
-
-	// Test env variable
-	delete(config, "api_key")
-	os.Setenv("DIGITALOCEAN_API_KEY", "foo")
-	defer os.Setenv("DIGITALOCEAN_API_KEY", "")
-	err = b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
 }
 
 func TestBuilderPrepare_ClientID(t *testing.T) {
@@ -95,27 +79,6 @@ func TestBuilderPrepare_ClientID(t *testing.T) {
 	if err == nil {
 		t.Fatal("should have error")
 	}
-
-	// Test env variable
-	delete(config, "client_id")
-	os.Setenv("DIGITALOCEAN_CLIENT_ID", "foo")
-	defer os.Setenv("DIGITALOCEAN_CLIENT_ID", "")
-	err = b.Prepare(config)
-	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
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
 }
 
 func TestBuilderPrepare_RegionID(t *testing.T) {
@@ -332,8 +295,8 @@ func TestBuilderPrepare_SnapshotName(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.SnapshotName == "" {
-		t.Errorf("invalid: %s", b.config.SnapshotName)
+	if b.config.RawSnapshotName != "packer-{{.CreateTime}}" {
+		t.Errorf("invalid: %d", b.config.RawSnapshotName)
 	}
 
 	// Test set
@@ -345,7 +308,7 @@ func TestBuilderPrepare_SnapshotName(t *testing.T) {
 	}
 
 	// Test set with template
-	config["snapshot_name"] = "{{timestamp}}"
+	config["snapshot_name"] = "{{.CreateTime}}"
 	b = Builder{}
 	err = b.Prepare(config)
 	if err != nil {

builder/digitalocean/ssh.go

@@ -1,30 +0,0 @@
-package digitalocean
-
-import (
-	gossh "code.google.com/p/go.crypto/ssh"
-	"fmt"
-	"github.com/mitchellh/packer/communicator/ssh"
-)
-
-func sshAddress(state map[string]interface{}) (string, error) {
-	config := state["config"].(config)
-	ipAddress := state["droplet_ip"].(string)
-	return fmt.Sprintf("%s:%d", ipAddress, config.SSHPort), nil
-}
-
-func sshConfig(state map[string]interface{}) (*gossh.ClientConfig, error) {
-	config := state["config"].(config)
-	privateKey := state["privateKey"].(string)
-
-	keyring := new(ssh.SimpleKeychain)
-	if err := keyring.AddPEMKey(privateKey); err != nil {
-		return nil, fmt.Errorf("Error setting up SSH config: %s", err)
-	}
-
-	return &gossh.ClientConfig{
-		User: config.SSHUsername,
-		Auth: []gossh.ClientAuth{
-			gossh.ClientAuthKeyring(keyring),
-		},
-	}, nil
-}

builder/digitalocean/step_connect_ssh.go

@@ -0,0 +1,137 @@
+package digitalocean
+
+import (
+	gossh "code.google.com/p/go.crypto/ssh"
+	"errors"
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/communicator/ssh"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"net"
+	"time"
+)
+
+type stepConnectSSH struct {
+	conn net.Conn
+}
+
+func (s *stepConnectSSH) Run(state map[string]interface{}) multistep.StepAction {
+	config := state["config"].(config)
+	privateKey := state["privateKey"].(string)
+	ui := state["ui"].(packer.Ui)
+	ipAddress := state["droplet_ip"]
+
+	// Build the keyring for authentication. This stores the private key
+	// we'll use to authenticate.
+	keyring := &ssh.SimpleKeychain{}
+	err := keyring.AddPEMKey(privateKey)
+	if err != nil {
+		err := fmt.Errorf("Error setting up SSH config: %s", err)
+		state["error"] = err
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Build the actual SSH client configuration
+	sshConfig := &gossh.ClientConfig{
+		User: config.SSHUsername,
+		Auth: []gossh.ClientAuth{
+			gossh.ClientAuthKeyring(keyring),
+		},
+	}
+
+	// Start trying to connect to SSH
+	connected := make(chan error, 1)
+	connectQuit := make(chan bool, 1)
+	defer func() {
+		connectQuit <- true
+	}()
+
+	var comm packer.Communicator
+	go func() {
+		var err error
+
+		ui.Say("Connecting to the droplet via SSH...")
+		attempts := 0
+		handshakeAttempts := 0
+		for {
+			select {
+			case <-connectQuit:
+				return
+			default:
+			}
+
+			attempts += 1
+			log.Printf(
+				"Opening TCP conn for SSH to %s:%d (attempt %d)",
+				ipAddress, config.SSHPort, attempts)
+			s.conn, err = net.DialTimeout(
+				"tcp",
+				fmt.Sprintf("%s:%d", ipAddress, config.SSHPort),
+				10*time.Second)
+			if err == nil {
+				log.Println("TCP connection made. Attempting SSH handshake.")
+				comm, err = ssh.New(s.conn, sshConfig)
+				if err == nil {
+					log.Println("Connected to SSH!")
+					break
+				}
+
+				handshakeAttempts += 1
+				log.Printf("SSH handshake error: %s", err)
+
+				if handshakeAttempts > 5 {
+					connected <- err
+					return
+				}
+			}
+
+			// A brief sleep so we're not being overly zealous attempting
+			// to connect to the instance.
+			time.Sleep(500 * time.Millisecond)
+		}
+
+		connected <- nil
+	}()
+
+	log.Printf("Waiting up to %s for SSH connection", config.SSHTimeout)
+	timeout := time.After(config.SSHTimeout)
+
+ConnectWaitLoop:
+	for {
+		select {
+		case err := <-connected:
+			if err != nil {
+				err := fmt.Errorf("Error connecting to SSH: %s", err)
+				state["error"] = err
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
+
+			// We connected. Just break the loop.
+			break ConnectWaitLoop
+		case <-timeout:
+			err := errors.New("Timeout waiting for SSH to become available.")
+			state["error"] = err
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		case <-time.After(1 * time.Second):
+			if _, ok := state[multistep.StateCancelled]; ok {
+				log.Println("Interrupt detected, quitting waiting for SSH.")
+				return multistep.ActionHalt
+			}
+		}
+	}
+
+	// Set the communicator on the state bag so it can be used later
+	state["communicator"] = comm
+
+	return multistep.ActionContinue
+}
+
+func (s *stepConnectSSH) Cleanup(map[string]interface{}) {
+	if s.conn != nil {
+		s.conn.Close()
+	}
+}

builder/digitalocean/step_create_droplet.go

@@ -60,7 +60,7 @@ func (s *stepCreateDroplet) Cleanup(state map[string]interface{}) {
 	// Otherwise we get "pending event" errors, even though there isn't
 	// one.
 	log.Printf("Sleeping for %v, event_delay", c.RawEventDelay)
-	time.Sleep(c.eventDelay)
+	time.Sleep(c.EventDelay)
 
 	err := client.DestroyDroplet(s.dropletId)
 

builder/digitalocean/step_power_off.go

@@ -20,7 +20,7 @@ func (s *stepPowerOff) Run(state map[string]interface{}) multistep.StepAction {
 	// Otherwise we get "pending event" errors, even though there isn't
 	// one.
 	log.Printf("Sleeping for %v, event_delay", c.RawEventDelay)
-	time.Sleep(c.eventDelay)
+	time.Sleep(c.EventDelay)
 
 	// Poweroff the droplet so it can be snapshot
 	err := client.PowerOffDroplet(dropletId)

builder/digitalocean/step_provision.go

@@ -0,0 +1,25 @@
+package digitalocean
+
+import (
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+type stepProvision struct{}
+
+func (*stepProvision) Run(state map[string]interface{}) multistep.StepAction {
+	comm := state["communicator"].(packer.Communicator)
+	hook := state["hook"].(packer.Hook)
+	ui := state["ui"].(packer.Ui)
+
+	log.Println("Running the provision hook")
+	if err := hook.Run(packer.HookProvision, ui, comm, nil); err != nil {
+		state["error"] = err
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (*stepProvision) Cleanup(map[string]interface{}) {}

builder/digitalocean/wait.go

@@ -17,7 +17,9 @@ func waitForDropletState(desiredState string, dropletId uint, client *DigitalOce
 			attempts += 1
 
 			log.Printf("Checking droplet status... (attempt: %d)", attempts)
+
 			_, status, err := client.DropletStatus(dropletId)
+
 			if err != nil {
 				log.Println(err)
 				break
@@ -35,7 +37,7 @@ func waitForDropletState(desiredState string, dropletId uint, client *DigitalOce
 	}()
 
 	log.Printf("Waiting for up to %s for droplet to become %s", c.RawStateTimeout, desiredState)
-	timeout := time.After(c.stateTimeout)
+	timeout := time.After(c.StateTimeout)
 
 ActiveWaitLoop:
 	for {

builder/virtualbox/builder.go

@@ -3,10 +3,12 @@ package virtualbox
 import (
 	"errors"
 	"fmt"
+	"github.com/mitchellh/mapstructure"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/builder/common"
 	"github.com/mitchellh/packer/packer"
 	"log"
+	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -18,71 +20,55 @@ const BuilderId = "mitchellh.virtualbox"
 
 type Builder struct {
 	config config
+	driver Driver
 	runner multistep.Runner
 }
 
 type config struct {
-	common.PackerConfig `mapstructure:",squash"`
+	BootCommand        []string      `mapstructure:"boot_command"`
+	BootWait           time.Duration ``
+	DiskSize           uint          `mapstructure:"disk_size"`
+	GuestAdditionsPath string        `mapstructure:"guest_additions_path"`
+	GuestOSType        string        `mapstructure:"guest_os_type"`
+	HTTPDir            string        `mapstructure:"http_directory"`
+	HTTPPortMin        uint          `mapstructure:"http_port_min"`
+	HTTPPortMax        uint          `mapstructure:"http_port_max"`
+	ISOMD5             string        `mapstructure:"iso_md5"`
+	ISOUrl             string        `mapstructure:"iso_url"`
+	OutputDir          string        `mapstructure:"output_directory"`
+	ShutdownCommand    string        `mapstructure:"shutdown_command"`
+	ShutdownTimeout    time.Duration ``
+	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"`
+	SSHWaitTimeout     time.Duration ``
+	VBoxVersionFile    string        `mapstructure:"virtualbox_version_file"`
+	VBoxManage         [][]string    `mapstructure:"vboxmanage"`
+	VMName             string        `mapstructure:"vm_name"`
 
-	BootCommand          []string   `mapstructure:"boot_command"`
-	DiskSize             uint       `mapstructure:"disk_size"`
-	FloppyFiles          []string   `mapstructure:"floppy_files"`
-	GuestAdditionsPath   string     `mapstructure:"guest_additions_path"`
-	GuestAdditionsURL    string     `mapstructure:"guest_additions_url"`
-	GuestAdditionsSHA256 string     `mapstructure:"guest_additions_sha256"`
-	GuestOSType          string     `mapstructure:"guest_os_type"`
-	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"`
-	OutputDir            string     `mapstructure:"output_directory"`
-	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"`
-	VBoxVersionFile      string     `mapstructure:"virtualbox_version_file"`
-	VBoxManage           [][]string `mapstructure:"vboxmanage"`
-	VMName               string     `mapstructure:"vm_name"`
+	PackerDebug bool `mapstructure:"packer_debug"`
 
 	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{}) error {
-	md, err := common.DecodeConfig(&b.config, raws...)
-	if err != nil {
-		return err
-	}
+	var err error
 
-	b.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return err
+	for _, raw := range raws {
+		err := mapstructure.Decode(raw, &b.config)
+		if err != nil {
+			return 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.FloppyFiles == nil {
-		b.config.FloppyFiles = make([]string, 0)
-	}
-
 	if b.config.GuestAdditionsPath == "" {
 		b.config.GuestAdditionsPath = "VBoxGuestAdditions.iso"
 	}
@@ -100,7 +86,7 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 	}
 
 	if b.config.OutputDir == "" {
-		b.config.OutputDir = fmt.Sprintf("output-%s", b.config.PackerBuildName)
+		b.config.OutputDir = "virtualbox"
 	}
 
 	if b.config.RawBootWait == "" {
@@ -128,133 +114,67 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 	}
 
 	if b.config.VMName == "" {
-		b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName)
+		b.config.VMName = "packer"
 	}
 
-	// Errors
-	templates := map[string]*string{
-		"guest_additions_sha256":  &b.config.GuestAdditionsSHA256,
-		"guest_os_type":           &b.config.GuestOSType,
-		"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,
-		"virtualbox_version_file": &b.config.VBoxVersionFile,
-		"vm_name":                 &b.config.VMName,
-		"boot_wait":               &b.config.RawBootWait,
-		"shutdown_timeout":        &b.config.RawShutdownTimeout,
-		"ssh_wait_timeout":        &b.config.RawSSHWaitTimeout,
-	}
-
-	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))
-		}
-	}
-
-	validates := map[string]*string{
-		"guest_additions_path": &b.config.GuestAdditionsPath,
-		"guest_additions_url":  &b.config.GuestAdditionsURL,
-	}
-
-	for n, ptr := range validates {
-		if err := b.config.tpl.Validate(*ptr); err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error parsing %s: %s", n, 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))
-		}
-	}
-
-	for i, file := range b.config.FloppyFiles {
-		var err error
-		b.config.FloppyFiles[i], err = b.config.tpl.Process(file, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing floppy_files[%d]: %s",
-					i, err))
-		}
-	}
+	errs := make([]error, 0)
 
 	if b.config.HTTPPortMin > b.config.HTTPPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("http_port_min must be less than http_port_max"))
+		errs = append(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"))
+	if b.config.ISOMD5 == "" {
+		errs = append(errs, errors.New("Due to large file sizes, an iso_md5 is required"))
 	} else {
-		b.config.ISOChecksum = strings.ToLower(b.config.ISOChecksum)
+		b.config.ISOMD5 = strings.ToLower(b.config.ISOMD5)
 	}
 
-	if b.config.ISOChecksumType == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("The iso_checksum_type must be specified."))
+	if b.config.ISOUrl == "" {
+		errs = append(errs, errors.New("An iso_url 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)
+		url, err := url.Parse(b.config.ISOUrl)
 		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed to parse iso_url %d: %s", i+1, err))
+			errs = append(errs, fmt.Errorf("iso_url is not a valid URL: %s", err))
+		} else {
+			if url.Scheme == "" {
+				url.Scheme = "file"
+			}
+
+			if url.Scheme == "file" {
+				if _, err := os.Stat(url.Path); err != nil {
+					errs = append(errs, fmt.Errorf("iso_url points to bad file: %s", err))
+				}
+			} else {
+				supportedSchemes := []string{"file", "http", "https"}
+				scheme := strings.ToLower(url.Scheme)
+
+				found := false
+				for _, supported := range supportedSchemes {
+					if scheme == supported {
+						found = true
+						break
+					}
+				}
+
+				if !found {
+					errs = append(errs, fmt.Errorf("Unsupported URL scheme in iso_url: %s", scheme))
+				}
+			}
+		}
+
+		if len(errs) == 0 {
+			// Put the URL back together since we may have modified it
+			b.config.ISOUrl = url.String()
 		}
 	}
 
-	if b.config.GuestAdditionsSHA256 != "" {
-		b.config.GuestAdditionsSHA256 = strings.ToLower(b.config.GuestAdditionsSHA256)
+	if _, err := os.Stat(b.config.OutputDir); err == nil {
+		errs = append(errs, errors.New("Output directory already exists. It must not exist."))
 	}
 
-	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)
+	b.config.BootWait, err = time.ParseDuration(b.config.RawBootWait)
 	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing boot_wait: %s", err))
+		errs = append(errs, fmt.Errorf("Failed parsing boot_wait: %s", err))
 	}
 
 	if b.config.RawShutdownTimeout == "" {
@@ -265,82 +185,54 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 		b.config.RawSSHWaitTimeout = "20m"
 	}
 
-	b.config.shutdownTimeout, err = time.ParseDuration(b.config.RawShutdownTimeout)
+	b.config.ShutdownTimeout, err = time.ParseDuration(b.config.RawShutdownTimeout)
 	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing shutdown_timeout: %s", err))
+		errs = append(errs, fmt.Errorf("Failed parsing shutdown_timeout: %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"))
+		errs = append(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."))
+		errs = append(errs, errors.New("An ssh_username must be specified."))
 	}
 
-	b.config.sshWaitTimeout, err = time.ParseDuration(b.config.RawSSHWaitTimeout)
+	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))
+		errs = append(errs, fmt.Errorf("Failed parsing ssh_wait_timeout: %s", err))
 	}
 
-	for i, args := range b.config.VBoxManage {
-		for j, arg := range args {
-			if err := b.config.tpl.Validate(arg); err != nil {
-				errs = packer.MultiErrorAppend(errs,
-					fmt.Errorf("Error processing vboxmanage[%d][%d]: %s", i, j, err))
-			}
-		}
+	b.driver, err = b.newDriver()
+	if err != nil {
+		errs = append(errs, fmt.Errorf("Failed creating VirtualBox driver: %s", err))
 	}
 
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
+	if len(errs) > 0 {
+		return &packer.MultiError{errs}
 	}
 
 	return 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 VirtualBox
-	driver, err := b.newDriver()
-	if err != nil {
-		return nil, fmt.Errorf("Failed creating VirtualBox driver: %s", err)
-	}
-
 	steps := []multistep.Step{
 		new(stepDownloadGuestAdditions),
-		&common.StepDownload{
-			Checksum:     b.config.ISOChecksum,
-			ChecksumType: b.config.ISOChecksumType,
-			Description:  "ISO",
-			ResultKey:    "iso_path",
-			Url:          b.config.ISOUrls,
-		},
+		new(stepDownloadISO),
 		new(stepPrepareOutputDir),
-		&common.StepCreateFloppy{
-			Files: b.config.FloppyFiles,
-		},
 		new(stepHTTPServer),
 		new(stepSuppressMessages),
 		new(stepCreateVM),
 		new(stepCreateDisk),
 		new(stepAttachISO),
-		new(stepAttachFloppy),
 		new(stepForwardSSH),
 		new(stepVBoxManage),
 		new(stepRun),
 		new(stepTypeBootCommand),
-		&common.StepConnectSSH{
-			SSHAddress:     sshAddress,
-			SSHConfig:      sshConfig,
-			SSHWaitTimeout: b.config.sshWaitTimeout,
-		},
+		new(stepWaitForSSH),
 		new(stepUploadVersion),
 		new(stepUploadGuestAdditions),
-		new(common.StepProvision),
+		new(stepProvision),
 		new(stepShutdown),
 		new(stepExport),
 	}
@@ -349,7 +241,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	state := make(map[string]interface{})
 	state["cache"] = cache
 	state["config"] = &b.config
-	state["driver"] = driver
+	state["driver"] = b.driver
 	state["hook"] = hook
 	state["ui"] = ui
 

builder/virtualbox/builder_test.go

@@ -10,12 +10,9 @@ import (
 
 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",
+		"iso_md5":      "foo",
+		"iso_url":      "http://www.google.com/",
+		"ssh_username": "foo",
 	}
 }
 
@@ -39,7 +36,7 @@ func TestBuilderPrepare_Defaults(t *testing.T) {
 		t.Errorf("bad guest OS type: %s", b.config.GuestOSType)
 	}
 
-	if b.config.OutputDir != "output-foo" {
+	if b.config.OutputDir != "virtualbox" {
 		t.Errorf("bad output dir: %s", b.config.OutputDir)
 	}
 
@@ -55,7 +52,7 @@ func TestBuilderPrepare_Defaults(t *testing.T) {
 		t.Errorf("bad ssh port: %d", b.config.SSHPort)
 	}
 
-	if b.config.VMName != "packer-foo" {
+	if b.config.VMName != "packer" {
 		t.Errorf("bad vm name: %s", b.config.VMName)
 	}
 }
@@ -84,7 +81,6 @@ func TestBuilderPrepare_BootWait(t *testing.T) {
 
 	// Test with a good one
 	config["boot_wait"] = "5s"
-	b = Builder{}
 	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
@@ -117,38 +113,11 @@ func TestBuilderPrepare_DiskSize(t *testing.T) {
 	}
 }
 
-func TestBuilderPrepare_FloppyFiles(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	delete(config, "floppy_files")
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("bad err: %s", err)
-	}
-
-	if len(b.config.FloppyFiles) != 0 {
-		t.Fatalf("bad: %#v", b.config.FloppyFiles)
-	}
-
-	config["floppy_files"] = []string{"foo", "bar"}
-	b = Builder{}
-	err = b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	expected := []string{"foo", "bar"}
-	if !reflect.DeepEqual(b.config.FloppyFiles, expected) {
-		t.Fatalf("bad: %#v", b.config.FloppyFiles)
-	}
-}
-
 func TestBuilderPrepare_GuestAdditionsPath(t *testing.T) {
 	var b Builder
 	config := testConfig()
 
-	delete(config, "guest_additions_path")
+	delete(config, "disk_size")
 	err := b.Prepare(config)
 	if err != nil {
 		t.Fatalf("bad err: %s", err)
@@ -170,54 +139,6 @@ func TestBuilderPrepare_GuestAdditionsPath(t *testing.T) {
 	}
 }
 
-func TestBuilderPrepare_GuestAdditionsSHA256(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	delete(config, "guest_additions_sha256")
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("bad err: %s", err)
-	}
-
-	if b.config.GuestAdditionsSHA256 != "" {
-		t.Fatalf("bad: %s", b.config.GuestAdditionsSHA256)
-	}
-
-	config["guest_additions_sha256"] = "FOO"
-	b = Builder{}
-	err = b.Prepare(config)
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.GuestAdditionsSHA256 != "foo" {
-		t.Fatalf("bad size: %s", b.config.GuestAdditionsSHA256)
-	}
-}
-
-func TestBuilderPrepare_GuestAdditionsURL(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	config["guest_additions_url"] = ""
-	err := b.Prepare(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if b.config.GuestAdditionsURL != "" {
-		t.Fatalf("should be empty: %s", b.config.GuestAdditionsURL)
-	}
-
-	config["guest_additions_url"] = "http://www.packer.io"
-	b = Builder{}
-	err = b.Prepare(config)
-	if err != nil {
-		t.Errorf("should not have error: %s", err)
-	}
-}
-
 func TestBuilderPrepare_HTTPPort(t *testing.T) {
 	var b Builder
 	config := testConfig()
@@ -232,7 +153,6 @@ func TestBuilderPrepare_HTTPPort(t *testing.T) {
 
 	// Bad
 	config["http_port_min"] = -500
-	b = Builder{}
 	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
@@ -241,136 +161,77 @@ func TestBuilderPrepare_HTTPPort(t *testing.T) {
 	// Good
 	config["http_port_min"] = 500
 	config["http_port_max"] = 1000
-	b = Builder{}
 	err = b.Prepare(config)
 	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
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_ISOChecksum(t *testing.T) {
+func TestBuilderPrepare_ISOMD5(t *testing.T) {
 	var b Builder
 	config := testConfig()
 
 	// Test bad
-	config["iso_checksum"] = ""
+	config["iso_md5"] = ""
 	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	// Test good
-	config["iso_checksum"] = "FOo"
-	b = Builder{}
+	config["iso_md5"] = "FOo"
 	err = b.Prepare(config)
 	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"] = ""
-	err := b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test good
-	config["iso_checksum_type"] = "mD5"
-	b = Builder{}
-	err = b.Prepare(config)
-	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{}
-	err = b.Prepare(config)
-	if err == nil {
-		t.Fatal("should have error")
+	if b.config.ISOMD5 != "foo" {
+		t.Fatalf("should've lowercased: %s", b.config.ISOMD5)
 	}
 }
 
 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{}
 	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
-	// Test iso_url set
-	config["iso_url"] = "http://www.packer.io"
-	b = Builder{}
-	err = b.Prepare(config)
-	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{}
+	config["iso_url"] = "i/am/a/file/that/doesnt/exist"
 	err = b.Prepare(config)
 	if err == nil {
-		t.Fatal("should have error")
+		t.Error("should have error")
 	}
 
-	// Test just iso_urls set
-	delete(config, "iso_url")
-	config["iso_urls"] = []string{
-		"http://www.packer.io",
-		"http://www.hashicorp.com",
+	config["iso_url"] = "file:i/am/a/file/that/doesnt/exist"
+	err = b.Prepare(config)
+	if err == nil {
+		t.Error("should have error")
 	}
 
-	b = Builder{}
+	config["iso_url"] = "http://www.packer.io"
 	err = b.Prepare(config)
 	if err != nil {
 		t.Errorf("should not have error: %s", err)
 	}
 
-	expected = []string{
-		"http://www.packer.io",
-		"http://www.hashicorp.com",
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("error tempfile: %s", err)
 	}
-	if !reflect.DeepEqual(b.config.ISOUrls, expected) {
-		t.Fatalf("bad: %#v", b.config.ISOUrls)
+	defer os.Remove(tf.Name())
+
+	config["iso_url"] = tf.Name()
+	err = b.Prepare(config)
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.ISOUrl != "file://"+tf.Name() {
+		t.Fatalf("iso_url should be modified: %s", b.config.ISOUrl)
 	}
 }
 
@@ -386,7 +247,6 @@ func TestBuilderPrepare_OutputDir(t *testing.T) {
 	defer os.RemoveAll(dir)
 
 	config["output_directory"] = dir
-	b = Builder{}
 	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
@@ -394,7 +254,6 @@ func TestBuilderPrepare_OutputDir(t *testing.T) {
 
 	// Test with a good one
 	config["output_directory"] = "i-hope-i-dont-exist"
-	b = Builder{}
 	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
@@ -414,7 +273,6 @@ func TestBuilderPrepare_ShutdownTimeout(t *testing.T) {
 
 	// Test with a good one
 	config["shutdown_timeout"] = "5s"
-	b = Builder{}
 	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
@@ -428,7 +286,6 @@ func TestBuilderPrepare_SSHHostPort(t *testing.T) {
 	// Bad
 	config["ssh_host_port_min"] = 1000
 	config["ssh_host_port_max"] = 500
-	b = Builder{}
 	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
@@ -436,7 +293,6 @@ func TestBuilderPrepare_SSHHostPort(t *testing.T) {
 
 	// Bad
 	config["ssh_host_port_min"] = -500
-	b = Builder{}
 	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
@@ -445,7 +301,6 @@ func TestBuilderPrepare_SSHHostPort(t *testing.T) {
 	// Good
 	config["ssh_host_port_min"] = 500
 	config["ssh_host_port_max"] = 1000
-	b = Builder{}
 	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
@@ -457,14 +312,12 @@ func TestBuilderPrepare_SSHUser(t *testing.T) {
 	config := testConfig()
 
 	config["ssh_username"] = ""
-	b = Builder{}
 	err := b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
 	}
 
 	config["ssh_username"] = "exists"
-	b = Builder{}
 	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)
@@ -488,7 +341,6 @@ func TestBuilderPrepare_SSHWaitTimeout(t *testing.T) {
 
 	// Test with a bad value
 	config["ssh_wait_timeout"] = "this is not good"
-	b = Builder{}
 	err = b.Prepare(config)
 	if err == nil {
 		t.Fatal("should have error")
@@ -496,7 +348,6 @@ func TestBuilderPrepare_SSHWaitTimeout(t *testing.T) {
 
 	// Test with a good one
 	config["ssh_wait_timeout"] = "5s"
-	b = Builder{}
 	err = b.Prepare(config)
 	if err != nil {
 		t.Fatalf("should not have error: %s", err)

builder/virtualbox/driver.go

@@ -50,9 +50,6 @@ func (d *VBox42Driver) IsRunning(name string) (bool, error) {
 	}
 
 	for _, line := range strings.Split(stdout.String(), "\n") {
-		// Need to trim off CR character when running in windows
-		line = strings.TrimRight(line, "\r")
-
 		if line == `VMState="running"` {
 			return true, nil
 		}
@@ -62,12 +59,6 @@ func (d *VBox42Driver) IsRunning(name string) (bool, error) {
 		if line == `VMState="stopping"` {
 			return true, nil
 		}
-
-		// We consider "paused" to still be running. We wait for it to
-		// be completely stopped or some other state.
-		if line == `VMState="paused"` {
-			return true, nil
-		}
 	}
 
 	return false, nil
@@ -133,12 +124,11 @@ func (d *VBox42Driver) Version() (string, error) {
 		return "", err
 	}
 
-	versionOutput := strings.TrimSpace(stdout.String())
-	log.Printf("VBoxManage --version output: %s", versionOutput)
+	log.Printf("VBoxManage --version output: %s", stdout.String())
 	versionRe := regexp.MustCompile("[^.0-9]")
-	matches := versionRe.Split(versionOutput, 2)
+	matches := versionRe.Split(stdout.String(), 2)
 	if len(matches) == 0 {
-		return "", fmt.Errorf("No version found: %s", versionOutput)
+		return "", fmt.Errorf("No version found: %s", stdout.String())
 	}
 
 	log.Printf("VirtualBox version: %s", matches[0])

builder/virtualbox/ssh.go

@@ -1,25 +0,0 @@
-package virtualbox
-
-import (
-	gossh "code.google.com/p/go.crypto/ssh"
-	"fmt"
-	"github.com/mitchellh/packer/communicator/ssh"
-)
-
-func sshAddress(state map[string]interface{}) (string, error) {
-	sshHostPort := state["sshHostPort"].(uint)
-	return fmt.Sprintf("127.0.0.1:%d", sshHostPort), nil
-}
-
-func sshConfig(state map[string]interface{}) (*gossh.ClientConfig, error) {
-	config := state["config"].(*config)
-
-	return &gossh.ClientConfig{
-		User: config.SSHUser,
-		Auth: []gossh.ClientAuth{
-			gossh.ClientAuthPassword(ssh.Password(config.SSHPassword)),
-			gossh.ClientAuthKeyboardInteractive(
-				ssh.PasswordKeyboardInteractive(config.SSHPassword)),
-		},
-	}, nil
-}

builder/virtualbox/step_attach_floppy.go

@@ -1,128 +0,0 @@
-package virtualbox
-
-import (
-	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-)
-
-// This step attaches the ISO to the virtual machine.
-//
-// Uses:
-//
-// Produces:
-type stepAttachFloppy struct {
-	floppyPath string
-}
-
-func (s *stepAttachFloppy) Run(state map[string]interface{}) multistep.StepAction {
-	// Determine if we even have a floppy disk to attach
-	var floppyPath string
-	if floppyPathRaw, ok := state["floppy_path"]; ok {
-		floppyPath = floppyPathRaw.(string)
-	} else {
-		log.Println("No floppy disk, not attaching.")
-		return multistep.ActionContinue
-	}
-
-	// VirtualBox is really dumb and can't figure out the format of the file
-	// without an extension, so we need to add the "vfd" extension to the
-	// floppy.
-	floppyPath, err := s.copyFloppy(floppyPath)
-	if err != nil {
-		state["error"] = fmt.Errorf("Error preparing floppy: %s", err)
-		return multistep.ActionHalt
-	}
-
-	driver := state["driver"].(Driver)
-	ui := state["ui"].(packer.Ui)
-	vmName := state["vmName"].(string)
-
-	ui.Say("Attaching floppy disk...")
-
-	// Create the floppy disk controller
-	command := []string{
-		"storagectl", vmName,
-		"--name", "Floppy Controller",
-		"--add", "floppy",
-	}
-	if err := driver.VBoxManage(command...); err != nil {
-		state["error"] = fmt.Errorf("Error creating floppy controller: %s", err)
-		return multistep.ActionHalt
-	}
-
-	// Attach the floppy to the controller
-	command = []string{
-		"storageattach", vmName,
-		"--storagectl", "Floppy Controller",
-		"--port", "0",
-		"--device", "0",
-		"--type", "fdd",
-		"--medium", floppyPath,
-	}
-	if err := driver.VBoxManage(command...); err != nil {
-		state["error"] = fmt.Errorf("Error attaching floppy: %s", err)
-		return multistep.ActionHalt
-	}
-
-	// Track the path so that we can unregister it from VirtualBox later
-	s.floppyPath = floppyPath
-
-	return multistep.ActionContinue
-}
-
-func (s *stepAttachFloppy) Cleanup(state map[string]interface{}) {
-	if s.floppyPath == "" {
-		return
-	}
-
-	// Delete the floppy disk
-	defer os.Remove(s.floppyPath)
-
-	driver := state["driver"].(Driver)
-	vmName := state["vmName"].(string)
-
-	command := []string{
-		"storageattach", vmName,
-		"--storagectl", "Floppy Controller",
-		"--port", "0",
-		"--device", "0",
-		"--medium", "none",
-	}
-
-	if err := driver.VBoxManage(command...); err != nil {
-		log.Printf("Error unregistering floppy: %s", err)
-	}
-}
-
-func (s *stepAttachFloppy) copyFloppy(path string) (string, error) {
-	tempdir, err := ioutil.TempDir("", "packer")
-	if err != nil {
-		return "", err
-	}
-
-	floppyPath := filepath.Join(tempdir, "floppy.vfd")
-	f, err := os.Create(floppyPath)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	sourceF, err := os.Open(path)
-	if err != nil {
-		return "", err
-	}
-	defer sourceF.Close()
-
-	log.Printf("Copying floppy to temp location: %s", floppyPath)
-	if _, err := io.Copy(f, sourceF); err != nil {
-		return "", err
-	}
-
-	return floppyPath, nil
-}

builder/virtualbox/step_create_vm.go

@@ -22,10 +22,7 @@ func (s *stepCreateVM) Run(state map[string]interface{}) multistep.StepAction {
 	name := config.VMName
 
 	commands := make([][]string, 4)
-	commands[0] = []string{
-		"createvm", "--name", name,
-		"--ostype", config.GuestOSType, "--register",
-	}
+	commands[0] = []string{"createvm", "--name", name, "--ostype", config.GuestOSType, "--register"}
 	commands[1] = []string{
 		"modifyvm", name,
 		"--boot1", "disk", "--boot2", "dvd", "--boot3", "none", "--boot4", "none",

builder/virtualbox/step_download_guest_additions.go

@@ -2,15 +2,18 @@ package virtualbox
 
 import (
 	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
 	"fmt"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/builder/common"
 	"github.com/mitchellh/packer/packer"
 	"io"
 	"io/ioutil"
 	"log"
 	"os"
 	"strings"
+	"time"
 )
 
 var additionsVersionMap = map[string]string{
@@ -18,10 +21,6 @@ var additionsVersionMap = map[string]string{
 	"4.1.23": "4.1.22",
 }
 
-type guestAdditionsUrlTemplate struct {
-	Version string
-}
-
 // This step uploads a file containing the VirtualBox version, which
 // can be useful for various provisioning reasons.
 //
@@ -31,11 +30,10 @@ type stepDownloadGuestAdditions struct{}
 
 func (s *stepDownloadGuestAdditions) Run(state map[string]interface{}) multistep.StepAction {
 	var action multistep.StepAction
+	cache := state["cache"].(packer.Cache)
 	driver := state["driver"].(Driver)
 	ui := state["ui"].(packer.Ui)
-	config := state["config"].(*config)
 
-	// Get VBox version
 	version, err := driver.Version()
 	if err != nil {
 		state["error"] = fmt.Errorf("Error reading version for guest additions download: %s", err)
@@ -47,99 +45,40 @@ func (s *stepDownloadGuestAdditions) Run(state map[string]interface{}) multistep
 		version = newVersion
 	}
 
-	additionsName := fmt.Sprintf("VBoxGuestAdditions_%s.iso", version)
-
-	// Use provided version or get it from virtualbox.org
-	var checksum string
-
-	if config.GuestAdditionsSHA256 != "" {
-		checksum = config.GuestAdditionsSHA256
-	} else {
-		checksum, action = s.downloadAdditionsSHA256(state, version, additionsName)
-		if action != multistep.ActionContinue {
-			return action
-		}
-	}
-
-	// Use the provided source (URL or file path) or generate it
-	url := config.GuestAdditionsURL
-	if url != "" {
-		tplData := &guestAdditionsUrlTemplate{
-			Version: version,
-		}
-
-		url, err = config.tpl.Process(url, tplData)
-		if err != nil {
-			err := fmt.Errorf("Error preparing guest additions url: %s", err)
-			state["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	} else {
-		url = fmt.Sprintf(
-			"http://download.virtualbox.org/virtualbox/%s/%s",
-			version,
-			additionsName)
-	}
-
-	url, err = common.DownloadableURL(url)
-	if err != nil {
-		err := fmt.Errorf("Error preparing guest additions url: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	log.Printf("Guest additions URL: %s", url)
-
-	downStep := &common.StepDownload{
-		Checksum:     checksum,
-		ChecksumType: "sha256",
-		Description:  "Guest additions",
-		ResultKey:    "guest_additions_path",
-		Url:          []string{url},
-	}
-
-	return downStep.Run(state)
-}
-
-func (s *stepDownloadGuestAdditions) Cleanup(state map[string]interface{}) {}
-
-func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state map[string]interface{}, additionsVersion string, additionsName string) (string, multistep.StepAction) {
 	// First things first, we get the list of checksums for the files available
 	// for this version.
-	checksumsUrl := fmt.Sprintf(
-		"http://download.virtualbox.org/virtualbox/%s/SHA256SUMS",
-		additionsVersion)
-
+	checksumsUrl := fmt.Sprintf("http://download.virtualbox.org/virtualbox/%s/SHA256SUMS", version)
 	checksumsFile, err := ioutil.TempFile("", "packer")
 	if err != nil {
 		state["error"] = fmt.Errorf(
 			"Failed creating temporary file to store guest addition checksums: %s",
 			err)
-		return "", multistep.ActionHalt
+		return multistep.ActionHalt
 	}
-	defer os.Remove(checksumsFile.Name())
 	checksumsFile.Close()
+	defer os.Remove(checksumsFile.Name())
 
-	downStep := &common.StepDownload{
-		Description: "Guest additions checksums",
-		ResultKey:   "guest_additions_checksums_path",
-		TargetPath:  checksumsFile.Name(),
-		Url:         []string{checksumsUrl},
+	downloadConfig := &common.DownloadConfig{
+		Url:        checksumsUrl,
+		TargetPath: checksumsFile.Name(),
+		Hash:       nil,
 	}
 
-	action := downStep.Run(state)
-	if action == multistep.ActionHalt {
-		return "", action
+	log.Printf("Downloading guest addition checksums: %s", checksumsUrl)
+	download := common.NewDownloadClient(downloadConfig)
+	checksumsPath, action := s.progressDownload(download, state)
+	if action != multistep.ActionContinue {
+		return action
 	}
 
+	additionsName := fmt.Sprintf("VBoxGuestAdditions_%s.iso", version)
+
 	// Next, we find the checksum for the file we're looking to download.
 	// It is an error if the checksum cannot be found.
-	checksumsF, err := os.Open(state["guest_additions_checksums_path"].(string))
+	checksumsF, err := os.Open(checksumsPath)
 	if err != nil {
 		state["error"] = fmt.Errorf("Error opening guest addition checksums: %s", err)
-		return "", multistep.ActionHalt
+		return multistep.ActionHalt
 	}
 	defer checksumsF.Close()
 
@@ -166,11 +105,77 @@ func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state map[string]in
 	}
 
 	if checksum == "" {
-		state["error"] = fmt.Errorf(
-			"The checksum for the file '%s' could not be found.", additionsName)
-		return "", multistep.ActionHalt
+		state["error"] = fmt.Errorf("The checksum for the file '%s' could not be found.", additionsName)
+		return multistep.ActionHalt
 	}
 
-	return checksum, multistep.ActionContinue
+	checksumBytes, err := hex.DecodeString(checksum)
+	if err != nil {
+		state["error"] = fmt.Errorf("Couldn't decode checksum into bytes: %s", checksum)
+		return multistep.ActionHalt
+	}
 
+	url := fmt.Sprintf(
+		"http://download.virtualbox.org/virtualbox/%s/%s",
+		version, additionsName)
+	log.Printf("Guest additions URL: %s", url)
+
+	log.Printf("Acquiring lock to download the guest additions ISO.")
+	cachePath := cache.Lock(url)
+	defer cache.Unlock(url)
+
+	downloadConfig = &common.DownloadConfig{
+		Url:        url,
+		TargetPath: cachePath,
+		Hash:       sha256.New(),
+		Checksum:   checksumBytes,
+	}
+
+	download = common.NewDownloadClient(downloadConfig)
+	ui.Say("Downloading VirtualBox guest additions. Progress will be shown periodically.")
+	state["guest_additions_path"], action = s.progressDownload(download, state)
+	return action
+}
+
+func (s *stepDownloadGuestAdditions) Cleanup(state map[string]interface{}) {}
+
+func (s *stepDownloadGuestAdditions) progressDownload(c *common.DownloadClient, state map[string]interface{}) (string, multistep.StepAction) {
+	ui := state["ui"].(packer.Ui)
+
+	var result string
+	downloadCompleteCh := make(chan error, 1)
+
+	// Start a goroutine to actually do the download...
+	go func() {
+		var err error
+		result, err = c.Get()
+		downloadCompleteCh <- err
+	}()
+
+	progressTicker := time.NewTicker(5 * time.Second)
+	defer progressTicker.Stop()
+
+	// A loop that handles showing progress as well as timing out and handling
+	// interrupts and all that.
+DownloadWaitLoop:
+	for {
+		select {
+		case err := <-downloadCompleteCh:
+			if err != nil {
+				state["error"] = fmt.Errorf("Error downloading: %s", err)
+				return "", multistep.ActionHalt
+			}
+
+			break DownloadWaitLoop
+		case <-progressTicker.C:
+			ui.Message(fmt.Sprintf("Download progress: %d%%", c.PercentProgress()))
+		case <-time.After(1 * time.Second):
+			if _, ok := state[multistep.StateCancelled]; ok {
+				ui.Say("Interrupt received. Cancelling download...")
+				return "", multistep.ActionHalt
+			}
+		}
+	}
+
+	return result, multistep.ActionContinue
 }

builder/virtualbox/step_download_iso.go

@@ -0,0 +1,128 @@
+package virtualbox
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/builder/common"
+	"github.com/mitchellh/packer/packer"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// This step downloads the ISO specified.
+//
+// Uses:
+//   cache packer.Cache
+//   config *config
+//   ui     packer.Ui
+//
+// Produces:
+//   iso_path string
+type stepDownloadISO struct {
+	isoCopyDir string
+}
+
+func (s *stepDownloadISO) Run(state map[string]interface{}) multistep.StepAction {
+	cache := state["cache"].(packer.Cache)
+	config := state["config"].(*config)
+	ui := state["ui"].(packer.Ui)
+
+	checksum, err := hex.DecodeString(config.ISOMD5)
+	if err != nil {
+		state["error"] = fmt.Errorf("Error parsing checksum: %s", err)
+		return multistep.ActionHalt
+	}
+
+	log.Printf("Acquiring lock to download the ISO.")
+	cachePath := cache.Lock(config.ISOUrl)
+	defer cache.Unlock(config.ISOUrl)
+
+	downloadConfig := &common.DownloadConfig{
+		Url:        config.ISOUrl,
+		TargetPath: cachePath,
+		CopyFile:   false,
+		Hash:       md5.New(),
+		Checksum:   checksum,
+	}
+
+	download := common.NewDownloadClient(downloadConfig)
+
+	downloadCompleteCh := make(chan error, 1)
+	go func() {
+		ui.Say("Copying or downloading ISO. Progress will be reported periodically.")
+		cachePath, err = download.Get()
+		downloadCompleteCh <- err
+	}()
+
+	progressTicker := time.NewTicker(5 * time.Second)
+	defer progressTicker.Stop()
+
+DownloadWaitLoop:
+	for {
+		select {
+		case err := <-downloadCompleteCh:
+			if err != nil {
+				err := fmt.Errorf("Error downloading ISO: %s", err)
+				state["error"] = err
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
+
+			break DownloadWaitLoop
+		case <-progressTicker.C:
+			ui.Message(fmt.Sprintf("Download progress: %d%%", download.PercentProgress()))
+		case <-time.After(1 * time.Second):
+			if _, ok := state[multistep.StateCancelled]; ok {
+				ui.Say("Interrupt received. Cancelling download...")
+				return multistep.ActionHalt
+			}
+		}
+	}
+
+	// VirtualBox is really dumb and can't figure out that the file is an
+	// ISO unless it has a ".iso" extension. We can't modify the cache
+	// filenames so we just do a copy.
+	tempdir, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		state["error"] = fmt.Errorf("Error copying ISO: %s", err)
+		return multistep.ActionHalt
+	}
+	s.isoCopyDir = tempdir
+
+	f, err := os.Create(filepath.Join(tempdir, "image.iso"))
+	if err != nil {
+		state["error"] = fmt.Errorf("Error copying ISO: %s", err)
+		return multistep.ActionHalt
+	}
+	defer f.Close()
+
+	sourceF, err := os.Open(cachePath)
+	if err != nil {
+		state["error"] = fmt.Errorf("Error copying ISO: %s", err)
+		return multistep.ActionHalt
+	}
+	defer sourceF.Close()
+
+	log.Printf("Copying ISO to temp location: %s", tempdir)
+	if _, err := io.Copy(f, sourceF); err != nil {
+		state["error"] = fmt.Errorf("Error copying ISO: %s", err)
+		return multistep.ActionHalt
+	}
+
+	log.Printf("Path to ISO on disk: %s", cachePath)
+	state["iso_path"] = f.Name()
+
+	return multistep.ActionContinue
+}
+
+func (s *stepDownloadISO) Cleanup(map[string]interface{}) {
+	if s.isoCopyDir != "" {
+		os.RemoveAll(s.isoCopyDir)
+	}
+}

builder/virtualbox/step_export.go

@@ -7,7 +7,8 @@ import (
 	"path/filepath"
 )
 
-// This step cleans up forwarded ports and exports the VM to an OVF.
+// This step creates the virtual disk that will be used as the
+// hard drive for the virtual machine.
 //
 // Uses:
 //
@@ -21,38 +22,9 @@ func (s *stepExport) Run(state map[string]interface{}) multistep.StepAction {
 	ui := state["ui"].(packer.Ui)
 	vmName := state["vmName"].(string)
 
-	// 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["sshHostPort"]))
-	command := []string{"modifyvm", vmName, "--natpf1", "delete", "packerssh"}
-	if err := driver.VBoxManage(command...); err != nil {
-		err := fmt.Errorf("Error deleting port forwarding rule: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Remove the attached floppy disk, if it exists
-	if _, ok := state["floppy_path"]; ok {
-		ui.Message("Removing floppy drive...")
-		command := []string{
-			"storageattach", vmName,
-			"--storagectl", "Floppy Controller",
-			"--port", "0",
-			"--device", "0",
-			"--medium", "none",
-		}
-		if err := driver.VBoxManage(command...); err != nil {
-			state["error"] = fmt.Errorf("Error removing floppy: %s", err)
-			return multistep.ActionHalt
-		}
-
-	}
-
-	// Export the VM to an OVF
 	outputPath := filepath.Join(config.OutputDir, "packer.ovf")
 
-	command = []string{
+	command := []string{
 		"export",
 		vmName,
 		"--output",

builder/virtualbox/step_forward_ssh.go

@@ -36,7 +36,7 @@ func (s *stepForwardSSH) Run(state map[string]interface{}) multistep.StepAction
 		}
 	}
 
-	// Create a forwarded port mapping to the VM
+	// Attach the disk to the controller
 	ui.Say(fmt.Sprintf("Creating forwarded port mapping for SSH (host port %d)", sshHostPort))
 	command := []string{
 		"modifyvm", vmName,

builder/virtualbox/step_prepare_output_dir.go

@@ -3,21 +3,13 @@ package virtualbox
 import (
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"log"
 	"os"
-	"time"
 )
 
 type stepPrepareOutputDir struct{}
 
 func (stepPrepareOutputDir) Run(state map[string]interface{}) multistep.StepAction {
 	config := state["config"].(*config)
-	ui := state["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["error"] = err
@@ -36,14 +28,6 @@ func (stepPrepareOutputDir) Cleanup(state map[string]interface{}) {
 		ui := state["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)
-		}
+		os.RemoveAll(config.OutputDir)
 	}
 }

builder/virtualbox/step_provision.go

@@ -0,0 +1,25 @@
+package virtualbox
+
+import (
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+type stepProvision struct{}
+
+func (*stepProvision) Run(state map[string]interface{}) multistep.StepAction {
+	comm := state["communicator"].(packer.Communicator)
+	hook := state["hook"].(packer.Hook)
+	ui := state["ui"].(packer.Ui)
+
+	log.Println("Running the provision hook")
+	if err := hook.Run(packer.HookProvision, ui, comm, nil); err != nil {
+		state["error"] = err
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (*stepProvision) Cleanup(map[string]interface{}) {}

builder/virtualbox/step_run.go

@@ -23,14 +23,7 @@ func (s *stepRun) Run(state map[string]interface{}) multistep.StepAction {
 	vmName := state["vmName"].(string)
 
 	ui.Say("Starting the virtual machine...")
-	guiArgument := "gui"
-	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 = "headless"
-	}
-	command := []string{"startvm", vmName, "--type", guiArgument}
+	command := []string{"startvm", vmName, "--type", "gui"}
 	if err := driver.VBoxManage(command...); err != nil {
 		err := fmt.Errorf("Error starting VM: %s", err)
 		state["error"] = err
@@ -40,9 +33,9 @@ func (s *stepRun) Run(state map[string]interface{}) multistep.StepAction {
 
 	s.vmName = vmName
 
-	if int64(config.bootWait) > 0 {
-		ui.Say(fmt.Sprintf("Waiting %s for boot...", config.bootWait))
-		time.Sleep(config.bootWait)
+	if int64(config.BootWait) > 0 {
+		ui.Say(fmt.Sprintf("Waiting %s for boot...", config.BootWait))
+		time.Sleep(config.BootWait)
 	}
 
 	return multistep.ActionContinue

builder/virtualbox/step_shutdown.go

@@ -34,16 +34,19 @@ func (s *stepShutdown) Run(state map[string]interface{}) multistep.StepAction {
 		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 {
+		if err := comm.Start(cmd); err != nil {
 			err := fmt.Errorf("Failed to send shutdown command: %s", err)
 			state["error"] = err
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
 
+		// Wait for the command to run
+		cmd.Wait()
+
 		// Wait for the machine to actually shut down
-		log.Printf("Waiting max %s for shutdown to complete", config.shutdownTimeout)
-		shutdownTimer := time.After(config.shutdownTimeout)
+		log.Printf("Waiting max %s for shutdown to complete", config.ShutdownTimeout)
+		shutdownTimer := time.After(config.ShutdownTimeout)
 		for {
 			running, _ := driver.IsRunning(vmName)
 			if !running {

builder/virtualbox/step_type_boot_command.go

@@ -1,11 +1,13 @@
 package virtualbox
 
 import (
+	"bytes"
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"strings"
+	"text/template"
 	"time"
 	"unicode"
 	"unicode/utf8"
@@ -47,30 +49,16 @@ func (s *stepTypeBootCommand) Run(state map[string]interface{}) multistep.StepAc
 
 	ui.Say("Typing the boot command...")
 	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["error"] = err
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
+		var buf bytes.Buffer
+		t := template.Must(template.New("boot").Parse(command))
+		t.Execute(&buf, tplData)
 
-		for _, code := range scancodes(command) {
+		for _, code := range scancodes(buf.String()) {
 			if code == "wait" {
 				time.Sleep(1 * time.Second)
 				continue
 			}
 
-			if code == "wait5" {
-				time.Sleep(5 * time.Second)
-				continue
-			}
-
-			if code == "wait10" {
-				time.Sleep(10 * time.Second)
-				continue
-			}
-
 			// Since typing is sometimes so slow, we check for an interrupt
 			// in between each character.
 			if _, ok := state[multistep.StateCancelled]; ok {
@@ -93,22 +81,8 @@ func (*stepTypeBootCommand) Cleanup(map[string]interface{}) {}
 
 func scancodes(message string) []string {
 	special := make(map[string][]string)
-	special["<bs>"] = []string{"ff", "08"}
-	special["<del>"] = []string{"ff", "ff"}
 	special["<enter>"] = []string{"1c", "9c"}
 	special["<esc>"] = []string{"01", "81"}
-	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"}
 
@@ -142,23 +116,11 @@ func scancodes(message string) []string {
 		var scancode []string
 
 		if strings.HasPrefix(message, "<wait>") {
-			log.Printf("Special code <wait> found, will sleep 1 second at this point.")
+			log.Printf("Special code <wait> found, will sleep at this point.")
 			scancode = []string{"wait"}
 			message = message[len("<wait>"):]
 		}
 
-		if strings.HasPrefix(message, "<wait5>") {
-			log.Printf("Special code <wait5> found, will sleep 5 seconds at this point.")
-			scancode = []string{"wait5"}
-			message = message[len("<wait5>"):]
-		}
-
-		if strings.HasPrefix(message, "<wait10>") {
-			log.Printf("Special code <wait10> found, will sleep 10 seconds at this point.")
-			scancode = []string{"wait10"}
-			message = message[len("<wait10>"):]
-		}
-
 		if scancode == nil {
 			for specialCode, specialValue := range special {
 				if strings.HasPrefix(message, specialCode) {

builder/virtualbox/step_upload_guest_additions.go

@@ -1,10 +1,12 @@
 package virtualbox
 
 import (
+	"bytes"
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 	"os"
+	"text/template"
 )
 
 type guestAdditionsPathTemplate struct {
@@ -37,16 +39,12 @@ func (s *stepUploadGuestAdditions) Run(state map[string]interface{}) multistep.S
 		Version: version,
 	}
 
-	config.GuestAdditionsPath, err = config.tpl.Process(config.GuestAdditionsPath, tplData)
-	if err != nil {
-		err := fmt.Errorf("Error preparing guest additions path: %s", err)
-		state["error"] = err
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
+	var processedPath bytes.Buffer
+	t := template.Must(template.New("path").Parse(config.GuestAdditionsPath))
+	t.Execute(&processedPath, tplData)
 
 	ui.Say("Uploading VirtualBox guest additions ISO...")
-	if err := comm.Upload(config.GuestAdditionsPath, f); err != nil {
+	if err := comm.Upload(processedPath.String(), f); err != nil {
 		state["error"] = fmt.Errorf("Error uploading guest additions: %s", err)
 		return multistep.ActionHalt
 	}

builder/virtualbox/step_vboxmanage.go

@@ -1,10 +1,12 @@
 package virtualbox
 
 import (
+	"bytes"
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 	"strings"
+	"text/template"
 )
 
 type commandTemplate struct {
@@ -38,14 +40,10 @@ func (s *stepVBoxManage) Run(state map[string]interface{}) multistep.StepAction
 		copy(command, originalCommand)
 
 		for i, arg := range command {
-			var err error
-			command[i], err = config.tpl.Process(arg, tplData)
-			if err != nil {
-				err := fmt.Errorf("Error preparing vboxmanage command: %s", err)
-				state["error"] = err
-				ui.Error(err.Error())
-				return multistep.ActionHalt
-			}
+			var buf bytes.Buffer
+			t := template.Must(template.New("arg").Parse(arg))
+			t.Execute(&buf, tplData)
+			command[i] = buf.String()
 		}
 
 		ui.Message(fmt.Sprintf("Executing: %s", strings.Join(command, " ")))

builder/virtualbox/step_wait_for_ssh.go

@@ -0,0 +1,147 @@
+package virtualbox
+
+import (
+	gossh "code.google.com/p/go.crypto/ssh"
+	"errors"
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/communicator/ssh"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"net"
+	"time"
+)
+
+// This step waits for SSH to become available and establishes an SSH
+// connection.
+//
+// Uses:
+//   config *config
+//   sshHostPort uint
+//   ui     packer.Ui
+//
+// Produces:
+//   communicator packer.Communicator
+type stepWaitForSSH struct {
+	cancel bool
+	conn   net.Conn
+}
+
+func (s *stepWaitForSSH) Run(state map[string]interface{}) multistep.StepAction {
+	config := state["config"].(*config)
+	ui := state["ui"].(packer.Ui)
+
+	var comm packer.Communicator
+	var err error
+
+	waitDone := make(chan bool, 1)
+	go func() {
+		comm, err = s.waitForSSH(state)
+		waitDone <- true
+	}()
+
+	log.Printf("Waiting for SSH, up to timeout: %s", config.SSHWaitTimeout.String())
+
+	timeout := time.After(config.SSHWaitTimeout)
+WaitLoop:
+	for {
+		// Wait for either SSH to become available, a timeout to occur,
+		// or an interrupt to come through.
+		select {
+		case <-waitDone:
+			if err != nil {
+				ui.Error(fmt.Sprintf("Error waiting for SSH: %s", err))
+				return multistep.ActionHalt
+			}
+
+			state["communicator"] = comm
+			break WaitLoop
+		case <-timeout:
+			ui.Error("Timeout waiting for SSH.")
+			s.cancel = true
+			return multistep.ActionHalt
+		case <-time.After(1 * time.Second):
+			if _, ok := state[multistep.StateCancelled]; ok {
+				log.Println("Interrupt detected, quitting waiting for SSH.")
+				return multistep.ActionHalt
+			}
+		}
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *stepWaitForSSH) Cleanup(map[string]interface{}) {
+	if s.conn != nil {
+		s.conn.Close()
+		s.conn = nil
+	}
+}
+
+// This blocks until SSH becomes available, and sends the communicator
+// on the given channel.
+func (s *stepWaitForSSH) waitForSSH(state map[string]interface{}) (packer.Communicator, error) {
+	config := state["config"].(*config)
+	ui := state["ui"].(packer.Ui)
+	sshHostPort := state["sshHostPort"].(uint)
+
+	ui.Say("Waiting for SSH to become available...")
+	var comm packer.Communicator
+	var nc net.Conn
+	for {
+		if nc != nil {
+			nc.Close()
+		}
+
+		time.Sleep(5 * time.Second)
+
+		if s.cancel {
+			log.Println("SSH wait cancelled. Exiting loop.")
+			return nil, errors.New("SSH wait cancelled")
+		}
+
+		// Attempt to connect to SSH port
+		nc, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", sshHostPort))
+		if err != nil {
+			log.Printf("TCP connection to SSH ip/port failed: %s", err)
+			continue
+		}
+
+		// Then we attempt to connect via SSH
+		sshConfig := &gossh.ClientConfig{
+			User: config.SSHUser,
+			Auth: []gossh.ClientAuth{
+				gossh.ClientAuthPassword(ssh.Password(config.SSHPassword)),
+			},
+		}
+
+		sshConnectSuccess := make(chan bool, 1)
+		go func() {
+			comm, err = ssh.New(nc, sshConfig)
+			if err != nil {
+				log.Printf("SSH connection fail: %s", err)
+				sshConnectSuccess <- false
+				return
+			}
+
+			sshConnectSuccess <- true
+		}()
+
+		select {
+		case success := <-sshConnectSuccess:
+			if !success {
+				continue
+			}
+		case <-time.After(5 * time.Second):
+			log.Printf("SSH handshake timeout. Trying again.")
+			continue
+		}
+
+		ui.Say("Connected via SSH!")
+		break
+	}
+
+	// Store the connection so we can close it later
+	s.conn = nc
+	return comm, nil
+}

builder/vmware/builder.go

@@ -3,15 +3,16 @@ package vmware
 import (
 	"errors"
 	"fmt"
+	"github.com/mitchellh/mapstructure"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/builder/common"
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"math/rand"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
-	"text/template"
 	"time"
 )
 
@@ -19,63 +20,48 @@ const BuilderId = "mitchellh.vmware"
 
 type Builder struct {
 	config config
+	driver Driver
 	runner multistep.Runner
 }
 
 type config struct {
-	common.PackerConfig `mapstructure:",squash"`
+	DiskName        string            `mapstructure:"vmdk_name"`
+	DiskSize        uint              `mapstructure:"disk_size"`
+	GuestOSType     string            `mapstructure:"guest_os_type"`
+	ISOMD5          string            `mapstructure:"iso_md5"`
+	ISOUrl          string            `mapstructure:"iso_url"`
+	VMName          string            `mapstructure:"vm_name"`
+	OutputDir       string            `mapstructure:"output_directory"`
+	HTTPDir         string            `mapstructure:"http_directory"`
+	HTTPPortMin     uint              `mapstructure:"http_port_min"`
+	HTTPPortMax     uint              `mapstructure:"http_port_max"`
+	BootCommand     []string          `mapstructure:"boot_command"`
+	BootWait        time.Duration     ``
+	ShutdownCommand string            `mapstructure:"shutdown_command"`
+	ShutdownTimeout time.Duration     ``
+	SSHUser         string            `mapstructure:"ssh_username"`
+	SSHPassword     string            `mapstructure:"ssh_password"`
+	SSHPort         uint              `mapstructure:"ssh_port"`
+	SSHWaitTimeout  time.Duration     ``
+	VMXData         map[string]string `mapstructure:"vmx_data"`
+	VNCPortMin      uint              `mapstructure:"vnc_port_min"`
+	VNCPortMax      uint              `mapstructure:"vnc_port_max"`
 
-	DiskName          string            `mapstructure:"vmdk_name"`
-	DiskSize          uint              `mapstructure:"disk_size"`
-	FloppyFiles       []string          `mapstructure:"floppy_files"`
-	GuestOSType       string            `mapstructure:"guest_os_type"`
-	ISOChecksum       string            `mapstructure:"iso_checksum"`
-	ISOChecksumType   string            `mapstructure:"iso_checksum_type"`
-	ISOUrls           []string          `mapstructure:"iso_urls"`
-	VMName            string            `mapstructure:"vm_name"`
-	OutputDir         string            `mapstructure:"output_directory"`
-	Headless          bool              `mapstructure:"headless"`
-	HTTPDir           string            `mapstructure:"http_directory"`
-	HTTPPortMin       uint              `mapstructure:"http_port_min"`
-	HTTPPortMax       uint              `mapstructure:"http_port_max"`
-	BootCommand       []string          `mapstructure:"boot_command"`
-	SkipCompaction    bool              `mapstructure:"skip_compaction"`
-	ShutdownCommand   string            `mapstructure:"shutdown_command"`
-	SSHUser           string            `mapstructure:"ssh_username"`
-	SSHPassword       string            `mapstructure:"ssh_password"`
-	SSHPort           uint              `mapstructure:"ssh_port"`
-	ToolsUploadFlavor string            `mapstructure:"tools_upload_flavor"`
-	ToolsUploadPath   string            `mapstructure:"tools_upload_path"`
-	VMXData           map[string]string `mapstructure:"vmx_data"`
-	VNCPortMin        uint              `mapstructure:"vnc_port_min"`
-	VNCPortMax        uint              `mapstructure:"vnc_port_max"`
+	PackerDebug bool `mapstructure:"packer_debug"`
 
 	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{}) error {
-	md, err := common.DecodeConfig(&b.config, raws...)
-	if err != nil {
-		return err
+	for _, raw := range raws {
+		err := mapstructure.Decode(raw, &b.config)
+		if err != nil {
+			return err
+		}
 	}
 
-	b.config.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return err
-	}
-	b.config.tpl.UserVars = b.config.PackerUserVars
-
-	// Accumulate any errors
-	errs := common.CheckUnusedConfig(md)
-
 	if b.config.DiskName == "" {
 		b.config.DiskName = "disk"
 	}
@@ -84,16 +70,12 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 		b.config.DiskSize = 40000
 	}
 
-	if b.config.FloppyFiles == nil {
-		b.config.FloppyFiles = make([]string, 0)
-	}
-
 	if b.config.GuestOSType == "" {
 		b.config.GuestOSType = "other"
 	}
 
 	if b.config.VMName == "" {
-		b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName)
+		b.config.VMName = "packer"
 	}
 
 	if b.config.HTTPPortMin == 0 {
@@ -117,152 +99,78 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 	}
 
 	if b.config.OutputDir == "" {
-		b.config.OutputDir = fmt.Sprintf("output-%s", b.config.PackerBuildName)
+		b.config.OutputDir = "vmware"
 	}
 
 	if b.config.SSHPort == 0 {
 		b.config.SSHPort = 22
 	}
 
-	if b.config.ToolsUploadPath == "" {
-		b.config.ToolsUploadPath = "{{ .Flavor }}.iso"
-	}
-
-	// Errors
-	templates := map[string]*string{
-		"disk_name":           &b.config.DiskName,
-		"guest_os_type":       &b.config.GuestOSType,
-		"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,
-		"tools_upload_flavor": &b.config.ToolsUploadFlavor,
-		"vm_name":             &b.config.VMName,
-		"boot_wait":           &b.config.RawBootWait,
-		"shutdown_timeout":    &b.config.RawShutdownTimeout,
-		"ssh_wait_timeout":    &b.config.RawSSHWaitTimeout,
-	}
-
-	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))
-		}
-	}
-
-	for i, file := range b.config.FloppyFiles {
-		var err error
-		b.config.FloppyFiles[i], err = b.config.tpl.Process(file, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing floppy_files[%d]: %s",
-					i, err))
-		}
-	}
-
-	newVMXData := make(map[string]string)
-	for k, v := range b.config.VMXData {
-		k, err = b.config.tpl.Process(k, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing VMX data key %s: %s", k, err))
-			continue
-		}
-
-		v, err = b.config.tpl.Process(v, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(errs,
-				fmt.Errorf("Error processing VMX data value '%s': %s", v, err))
-			continue
-		}
-
-		newVMXData[k] = v
-	}
-
-	b.config.VMXData = newVMXData
+	// Accumulate any errors
+	var err error
+	errs := make([]error, 0)
 
 	if b.config.HTTPPortMin > b.config.HTTPPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("http_port_min must be less than http_port_max"))
+		errs = append(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"))
+	if b.config.ISOMD5 == "" {
+		errs = append(errs, errors.New("Due to large file sizes, an iso_md5 is required"))
 	} else {
-		b.config.ISOChecksum = strings.ToLower(b.config.ISOChecksum)
+		b.config.ISOMD5 = strings.ToLower(b.config.ISOMD5)
 	}
 
-	if b.config.ISOChecksumType == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("The iso_checksum_type must be specified."))
+	if b.config.ISOUrl == "" {
+		errs = append(errs, errors.New("An iso_url 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)
+		url, err := url.Parse(b.config.ISOUrl)
 		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed to parse iso_url %d: %s", i+1, err))
+			errs = append(errs, fmt.Errorf("iso_url is not a valid URL: %s", err))
+		} else {
+			if url.Scheme == "" {
+				url.Scheme = "file"
+			}
+
+			if url.Scheme == "file" {
+				if _, err := os.Stat(url.Path); err != nil {
+					errs = append(errs, fmt.Errorf("iso_url points to bad file: %s", err))
+				}
+			} else {
+				supportedSchemes := []string{"file", "http", "https"}
+				scheme := strings.ToLower(url.Scheme)
+
+				found := false
+				for _, supported := range supportedSchemes {
+					if scheme == supported {
+						found = true
+						break
+					}
+				}
+
+				if !found {
+					errs = append(errs, fmt.Errorf("Unsupported URL scheme in iso_url: %s", scheme))
+				}
+			}
+		}
+
+		if len(errs) == 0 {
+			// Put the URL back together since we may have modified it
+			b.config.ISOUrl = url.String()
 		}
 	}
 
-	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))
-		}
+	if _, err := os.Stat(b.config.OutputDir); err == nil {
+		errs = append(errs, errors.New("Output directory already exists. It must not exist."))
 	}
 
 	if b.config.SSHUser == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("An ssh_username must be specified."))
+		errs = append(errs, errors.New("An ssh_username must be specified."))
 	}
 
 	if b.config.RawBootWait != "" {
-		b.config.bootWait, err = time.ParseDuration(b.config.RawBootWait)
+		b.config.BootWait, err = time.ParseDuration(b.config.RawBootWait)
 		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed parsing boot_wait: %s", err))
+			errs = append(errs, fmt.Errorf("Failed parsing boot_wait: %s", err))
 		}
 	}
 
@@ -270,86 +178,60 @@ func (b *Builder) Prepare(raws ...interface{}) error {
 		b.config.RawShutdownTimeout = "5m"
 	}
 
-	b.config.shutdownTimeout, err = time.ParseDuration(b.config.RawShutdownTimeout)
+	b.config.ShutdownTimeout, err = time.ParseDuration(b.config.RawShutdownTimeout)
 	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing shutdown_timeout: %s", err))
+		errs = append(errs, fmt.Errorf("Failed parsing shutdown_timeout: %s", err))
 	}
 
 	if b.config.RawSSHWaitTimeout == "" {
 		b.config.RawSSHWaitTimeout = "20m"
 	}
 
-	b.config.sshWaitTimeout, err = time.ParseDuration(b.config.RawSSHWaitTimeout)
+	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 _, err := template.New("path").Parse(b.config.ToolsUploadPath); err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("tools_upload_path invalid: %s", err))
+		errs = append(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"))
+		errs = append(errs, fmt.Errorf("vnc_port_min must be less than vnc_port_max"))
 	}
 
-	if errs != nil && len(errs.Errors) > 0 {
-		return errs
+	b.driver, err = b.newDriver()
+	if err != nil {
+		errs = append(errs, fmt.Errorf("Failed creating VMware driver: %s", err))
+	}
+
+	if len(errs) > 0 {
+		return &packer.MultiError{errs}
 	}
 
 	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-	// Initialize the driver that will handle our interaction with VMware
-	driver, err := NewDriver()
-	if err != nil {
-		return nil, fmt.Errorf("Failed creating VMware driver: %s", err)
-	}
-
 	// Seed the random number generator
 	rand.Seed(time.Now().UTC().UnixNano())
 
 	steps := []multistep.Step{
-		&stepPrepareTools{},
-		&common.StepDownload{
-			Checksum:     b.config.ISOChecksum,
-			ChecksumType: b.config.ISOChecksumType,
-			Description:  "ISO",
-			ResultKey:    "iso_path",
-			Url:          b.config.ISOUrls,
-		},
+		&stepDownloadISO{},
 		&stepPrepareOutputDir{},
-		&common.StepCreateFloppy{
-			Files: b.config.FloppyFiles,
-		},
 		&stepCreateDisk{},
 		&stepCreateVMX{},
 		&stepHTTPServer{},
 		&stepConfigureVNC{},
 		&stepRun{},
 		&stepTypeBootCommand{},
-		&common.StepConnectSSH{
-			SSHAddress:     sshAddress,
-			SSHConfig:      sshConfig,
-			SSHWaitTimeout: b.config.sshWaitTimeout,
-		},
-		&stepUploadTools{},
-		&common.StepProvision{},
+		&stepWaitForSSH{},
+		&stepProvision{},
 		&stepShutdown{},
 		&stepCleanFiles{},
-		&stepCleanVMX{},
-		&stepCompactDisk{},
 	}
 
 	// Setup the state bag
 	state := make(map[string]interface{})
 	state["cache"] = cache
 	state["config"] = &b.config
-	state["driver"] = driver
+	state["driver"] = b.driver
 	state["hook"] = hook
 	state["ui"] = ui
 
@@ -406,3 +288,13 @@ func (b *Builder) Cancel() {
 		b.runner.Cancel()
 	}
 }
+
+func (b *Builder) newDriver() (Driver, error) {
+	fusionAppPath := "/Applications/VMware Fusion.app"
+	driver := &Fusion5Driver{fusionAppPath}
+	if err := driver.Verify(); err != nil {
+		return nil, err
+	}
+
+	return driver, nil
+}