v0.3.7

.gitignore

@@ -4,7 +4,3 @@
 /src
 /website/.sass-cache
 /website/build
-.DS_Store
-.vagrant
-Vagrantfile
-test/.env

.travis.yml

@@ -1,7 +1,7 @@
 language: go
 
 go:
-    - 1.2
+    - 1.1
     - tip
 
 install: make deps

CHANGELOG.md

@@ -1,285 +1,3 @@
-## 0.5.0 (12/30/2013)
-
-BACKWARDS INCOMPATIBILITIES:
-
-* "virtualbox" builder has been renamed to "virtualbox-iso". Running your
-   template through `packer fix` will resolve this.
-* "vmware" builder has been renamed to "vmware-iso". Running your template
-  through `packer fix` will resolve this.
-* post-processor/vagrant: Syntax for overriding by provider has changed.
-  See the documentation for more information. Running your template
-  through `packer fix` should resolve this.
-* post-processor/vsphere: Some available configuration options were
-  changed. Running your template through `packer fix` should resolve
-  this.
-* provisioner/puppet-masterless: The `execute_command` no longer has
-  the `Has*` variables, since the templating language now supports
-  comparison operations. See the Go documentation for more info:
-  http://golang.org/pkg/text/template/
-
-FEATURES:
-
-* **New builder:** Google Compute Engine. You can now build images for
-  use in Google Compute Engine. See the documentation for more information.
-  [GH-715]
-* **New builder:** "virtualbox-ovf" can build VirtualBox images from
-  an existing OVF or OVA. [GH-201]
-* **New builder:** "vmware-vmx" can build VMware images from an existing
-  VMX. [GH-201]
-* Environmental variables can now be accessed as default values for
-  user variables using the "env" function. See the documentation for more
-  information.
-* "description" field in templates: write a human-readable description
-  of what a template does. This will be shown in `packer inspect`.
-* Vagrant post-processor now accepts a list of files to include in the
-  box.
-* All provisioners can now have a "pause\_before" parameter to wait
-  some period of time before running that provisioner. This is useful
-  for reboots. [GH-737]
-
-IMPROVEMENTS:
-
-* core: Plugins communicate over a single TCP connection per plugin now,
-  instead of sometimes dozens. Performance around plugin communication
-  dramatically increased.
-* core: Build names are now template processed so you can use things
-  like user variables in them. [GH-744]
-* core: New "pwd" function available globally that returns the working
-  directory. [GH-762]
-* builder/amazon/all: Launched EC2 instances now have a name of
-  "Packer Builder" so that they are easily recognizable. [GH-642]
-* builder/amazon/all: Copying AMIs to multiple regions now happens
-  in parallel. [GH-495]
-* builder/amazon/all: Ability to specify "run\_tags" to tag the instance
-  while running. [GH-722]
-* builder/digitalocean: Private networking support. [GH-698]
-* builder/docker: A "run\_command" can be specified, configuring how
-  the container is started. [GH-648]
-* builder/openstack: In debug mode, the generated SSH keypair is saved
-  so you can SSH into the machine. [GH-746]
-* builder/qemu: Floppy files are supported. [GH-686]
-* builder/qemu: Next `run_once` option tells Qemu to run only once,
-  which is useful for Windows installs that handle reboots for you.
-  [GH-687]
-* builder/virtualbox: Nice errors if Packer can't write to
-  the output directory.
-* builder/virtualbox: ISO is ejected prior to export.
-* builder/virtualbox: Checksum type can be "none" [GH-471]
-* builder/vmware: Can now specify path to the Fusion application. [GH-677]
-* builder/vmware: Checksum type can be "none" [GH-471]
-* provisioner/puppet-masterless: Can now specify a `manifest_dir` to
-  upload manifests to the remote machine for imports. [GH-655]
-
-BUG FIXES:
-
-* core: No colored output in machine-readable output. [GH-684]
-* core: User variables can now be used for non-string fields. [GH-598]
-* core: Fix bad download paths if the download URL contained a "."
-  before a "/" [GH-716]
-* core: "{{timestamp}}" values will always be the same for the entire
-  duration of a build. [GH-744]
-* builder/amazon: Handle cases where security group isn't instantly
-  available. [GH-494]
-* builder/virtualbox: don't download guest additions if disabled. [GH-731]
-* post-processor/vsphere: Uploads VM properly. [GH-694]
-* post-processor/vsphere: Process user variables.
-* provisioner/ansible-local: all configurations are processed as templates
-  [GH-749]
-* provisioner/ansible-local: playbook paths are properly validated
-  as directories, not files. [GH-710]
-* provisioner/chef-solo: Environments are recognized. [GH-726]
-
-## 0.4.1 (December 7, 2013)
-
-IMPROVEMENTS:
-
-* builder/amazon/ebs: New option allows associating a public IP with
-  non-default VPC instances. [GH-660]
-* builder/openstack: A "proxy\_url" setting was added to define an HTTP
-  proxy to use when building with this builder. [GH-637]
-
-BUG FIXES:
-
-* core: Don't change background color on CLI anymore, making things look
-  a tad nicer in some terminals.
-* core: multiple ISO URLs works properly in all builders. [GH-683]
-* builder/amazon/chroot: Block when obtaining file lock to allow
-  parallel builds. [GH-689]
-* builder/amazon/instance: Add location flag to upload bundle command
-  so that building AMIs works out of us-east-1 [GH-679]
-* builder/qemu: Qemu arguments are templated. [GH-688]
-* builder/vmware: Cleanup of VMX keys works properly so cd-rom won't
-  get stuck with ISO. [GH-685]
-* builder/vmware: File cleanup is more resilient to file delete races
-  with the operating system. [GH-675]
-* provisioner/puppet-masterless: Check for hiera config path existence
-  properly. [GH-656]
-
-## 0.4.0 (November 19, 2013)
-
-FEATURES:
-
-* Docker builder: build and export Docker containers, easily provisioned
-  with any of the Packer built-in provisioners.
-* QEMU builder: builds a new VM compatible with KVM or Xen using QEMU.
-* Remote ESXi builder: builds a VMware VM using ESXi remotely using only
-  SSH to an ESXi machine directly.
-* vSphere post-processor: Can upload VMware artifacts to vSphere
-* Vagrant post-processor can now make DigitalOcean provider boxes. [GH-504]
-
-IMPROVEMENTS:
-
-* builder/amazon/all: Can now specify a list of multiple security group
-  IDs to apply. [GH-499]
-* builder/amazon/all: AWS API requests are now retried when a temporary
-  network error occurs as well as 500 errors. [GH-559]
-* builder/virtualbox: Use VBOX\_INSTALL\_PATH env var on Windows to find
-  VBoxManage. [GH-628]
-* post-processor/vagrant: skips gzip compression when compression_level=0
-* provisioner/chef-solo: Encrypted data bag support [GH-625]
-
-BUG FIXES:
-
-* builder/amazon/chroot: Copying empty directories works. [GH-588]
-* builder/amazon/chroot: Chroot commands work with shell provisioners. [GH-581]
-* builder/amazon/chroot: Don't choose a mount point that is a partition of
-  an already mounted device. [GH-635]
-* builder/virtualbox: Ctrl-C interrupts during waiting for boot. [GH-618]
-* builder/vmware: VMX modifications are now case-insensitive. [GH-608]
-* builder/vmware: VMware Fusion won't ask for VM upgrade.
-* builder/vmware: Ctrl-C interrupts during waiting for boot. [GH-618]
-* provisioner/chef-solo: Output is slightly prettier and more informative.
-
-## 0.3.11 (November 4, 2013)
-
-FEATURES:
-
-* builder/amazon/ebs: Ability to specify which availability zone to create
-  instance in. [GH-536]
-
-IMPROVEMENTS:
-
-* core: builders can now give warnings during validation. warnings won't
-  fail the build but may hint at potential future problems.
-* builder/digitalocean: Can now specify a droplet name
-* builder/virtualbox: Can now disable guest addition download entirely
-  by setting "guest_additions_mode" to "disable" [GH-580]
-* builder/virtualbox,vmware: ISO urls can now be https [GH-587]
-* builder/virtualbox,vmware: Warning if shutdown command is not specified,
-  since it is a common case of data loss.
-
-BUG FIXES:
-
-* core: Won't panic when writing to a bad pipe. [GH-560]
-* builder/amazon/all: Properly scrub access key and secret key from logs.
-  [GH-554]
-* builder/openstack: Properly scrub password from logs [GH-554]
-* builder/virtualbox: No panic if SSH host port min/max is the same. [GH-594]
-* builder/vmware: checks if `ifconfig` is in `/sbin` [GH-591]
-* builder/vmware: Host IP lookup works for non-C locales. [GH-592]
-* common/uuid: Use cryptographically secure PRNG when generating
-  UUIDs. [GH-552]
-* communicator/ssh: File uploads that exceed the size of memory no longer
-  cause crashes. [GH-561]
-
-## 0.3.10 (October 20, 2013)
-
-FEATURES:
-
-* Ansible provisioner
-
-IMPROVEMENTS:
-
-* post-processor/vagrant: support instance-store AMIs built by Packer. [GH-502]
-* post-processor/vagrant: can now specify compression level to use
-  when creating the box. [GH-506]
-
-BUG FIXES:
-
-* builder/all: timeout waiting for SSH connection is a failure. [GH-491]
-* builder/amazon: Scrub sensitive data from the logs. [GH-521]
-* builder/amazon: Handle the situation where an EC2 instance might not
-  be immediately available. [GH-522]
-* builder/amazon/chroot: Files copied into the chroot remove destination
-  before copy, fixing issues with dangling symlinks. [GH-500]
-* builder/digitalocean: don't panic if erroneous API response doesn't
-  contain error message. [GH-492]
-* builder/digitalocean: scrub API keys from config debug output [GH-516]
-* builder/virtualbox: error if VirtualBox version cant be detected. [GH-488]
-* builder/virtualbox: detect if vboxdrv isn't properly setup. [GH-488]
-* builder/virtualbox: sleep a bit before export to ensure the sesssion
-  is unlocked. [GH-512]
-* builder/virtualbox: create SATA drives properly on VirtualBox 4.3 [GH-547]
-* builder/virtualbox: support user templates in SSH key path. [GH-539]
-* builder/vmware: support user templates in SSH key path. [GH-539]
-* communicator/ssh: Fix issue where a panic could arise from a nil
-  dereference. [GH-525]
-* post-processor/vagrant: Fix issue with VirtualBox OVA. [GH-548]
-* provisioner/salt: Move salt states to correct remote directory. [GH-513]
-* provisioner/shell: Won't block on certain scripts on Windows anymore.
-  [GH-507]
-
-## 0.3.9 (October 2, 2013)
-
-FEATURES:
-
-* The Amazon chroot builder is now able to run without any `sudo` privileges
-  by using the "command_wrapper" configuration. [GH-430]
-* Chef provisioner supports environments. [GH-483]
-
-BUG FIXES:
-
-* core: default user variable values don't need to be strings. [GH-456]
-* builder/amazon-chroot: Fix errors with waitin for state change. [GH-459]
-* builder/digitalocean: Use proper error message JSON key (DO API change).
-* communicator/ssh: SCP uploads now work properly when directories
-  contain symlinks. [GH-449]
-* provisioner/chef-solo: Data bags and roles path are now properly
-  populated when set. [GH-470]
-* provisioner/shell: Windows line endings are actually properly changed
-  to Unix line endings. [GH-477]
-
-## 0.3.8 (September 22, 2013)
-
-FEATURES:
-
-* core: You can now specify `only` and `except` configurations on any
-  provisioner or post-processor to specify a list of builds that they
-  are valid for. [GH-438]
-* builders/virtualbox: Guest additions can be attached rather than uploaded,
-  easier to handle for Windows guests. [GH-405]
-* provisioner/chef-solo: Ability to specify a custom Chef configuration
-  template.
-* provisioner/chef-solo: Roles and data bags support. [GH-348]
-
-IMPROVEMENTS:
-
-* core: User variables can now be used for integer, boolean, etc.
-  values. [GH-418]
-* core: Plugins made with incompatible versions will no longer load.
-* builder/amazon/all: Interrupts work while waiting for AMI to be ready.
-* provisioner/shell: Script line-endings are automatically converted to
-  Unix-style line-endings. Can be disabled by setting "binary" to "true".
-  [GH-277]
-
-BUG FIXES:
-
-* core: Set TCP KeepAlives on internally created RPC connections so that
-  they don't die. [GH-416]
-* builder/amazon/all: While waiting for AMI, will detect "failed" state.
-* builder/amazon/all: Waiting for state will detect if the resource (AMI,
-  instance, etc.) disappears from under it.
-* builder/amazon/instance: Exclude only contents of /tmp, not /tmp
-  itself. [GH-437]
-* builder/amazon/instance: Make AccessKey/SecretKey available to bundle
-  command even when they come from the environment. [GH-434]
-* builder/virtualbox: F1-F12 and delete scancodes now work. [GH-425]
-* post-processor/vagrant: Override configurations properly work. [GH-426]
-* provisioner/puppet-masterless: Fix failure case when both facter vars
-  are used and prevent_sudo. [GH-415]
-* provisioner/puppet-masterless: User variables now work properly in
-  manifest file and hiera path. [GH-448]
-
 ## 0.3.7 (September 9, 2013)
 
 BACKWARDS INCOMPATIBILITIES:

CONTRIBUTING.md

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

Makefile

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

README.md

@@ -70,19 +70,12 @@ 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.2+ is _required_). Make sure you have Go properly installed,
+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/)
-and [Bazaar](http://bazaar.canonical.com/en/) to be installed.
-Packer itself doesn't require these, but a dependency of a dependency does.
-
-You'll also need [`gox`](https://github.com/mitchellh/gox)
-to compile packer. You can install that with:
-
-```
-$ go get -u github.com/mitchellh/gox
-```
+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:
@@ -100,6 +93,3 @@ This will run tests for Packer core along with all the core builders and command
 
 If you make any changes to the code, run `make format` in order to automatically
 format the code according to Go standards.
-
-When new dependencies are added to packer you can use `make updatedeps` to
-get the latest and subsequently use `make` to compile and generate the `packer` binary.

builder/amazon/chroot/builder.go

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

builder/amazon/chroot/builder_test.go

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

builder/amazon/chroot/command.go

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

builder/amazon/chroot/communicator.go

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

builder/amazon/chroot/copy_files.go

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

builder/amazon/chroot/copy_files_test.go

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

builder/amazon/chroot/device.go

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

builder/amazon/chroot/lockfile_unix.go

@@ -3,6 +3,7 @@
 package chroot
 
 import (
+	"errors"
 	"os"
 	"syscall"
 )
@@ -13,8 +14,13 @@ const LOCK_NB = 4
 const LOCK_UN = 8
 
 func lockFile(f *os.File) error {
-	err := syscall.Flock(int(f.Fd()), LOCK_EX)
+	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
 	}
 

builder/amazon/chroot/step_attach_volume.go

@@ -46,6 +46,7 @@ func (s *StepAttachVolume) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Wait for the volume to become attached
 	stateChange := awscommon.StateChangeConf{
+		Conn:      ec2conn,
 		Pending:   []string{"attaching"},
 		StepState: state,
 		Target:    "attached",
@@ -59,8 +60,7 @@ func (s *StepAttachVolume) Run(state multistep.StateBag) multistep.StepAction {
 				return nil, "", errors.New("No attachments on volume.")
 			}
 
-			a := resp.Volumes[0].Attachments[0]
-			return a, a.Status, nil
+			return nil, resp.Volumes[0].Attachments[0].Status, nil
 		},
 	}
 
@@ -101,6 +101,7 @@ func (s *StepAttachVolume) CleanupFunc(state multistep.StateBag) error {
 
 	// Wait for the volume to detach
 	stateChange := awscommon.StateChangeConf{
+		Conn:      ec2conn,
 		Pending:   []string{"attaching", "attached", "detaching"},
 		StepState: state,
 		Target:    "detached",
@@ -110,12 +111,12 @@ func (s *StepAttachVolume) CleanupFunc(state multistep.StateBag) error {
 				return nil, "", err
 			}
 
-			v := resp.Volumes[0]
-			if len(v.Attachments) > 0 {
-				return v, v.Attachments[0].Status, nil
-			} else {
-				return v, "detached", nil
+			state := "detached"
+			if len(resp.Volumes[0].Attachments) > 0 {
+				state = resp.Volumes[0].Attachments[0].Status
 			}
+
+			return nil, state, nil
 		},
 	}
 

builder/amazon/chroot/step_chroot_provision.go

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

builder/amazon/chroot/step_copy_files.go

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

builder/amazon/chroot/step_create_volume.go

@@ -65,6 +65,7 @@ func (s *StepCreateVolume) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Wait for the volume to become ready
 	stateChange := awscommon.StateChangeConf{
+		Conn:      ec2conn,
 		Pending:   []string{"creating"},
 		StepState: state,
 		Target:    "available",
@@ -74,8 +75,7 @@ func (s *StepCreateVolume) Run(state multistep.StateBag) multistep.StepAction {
 				return nil, "", err
 			}
 
-			v := resp.Volumes[0]
-			return v, v.Status, nil
+			return nil, resp.Volumes[0].Status, nil
 		},
 	}
 

builder/amazon/chroot/step_flock.go

@@ -39,7 +39,7 @@ func (s *StepFlock) Run(state multistep.StateBag) multistep.StepAction {
 
 	// LOCK!
 	if err := lockFile(f); err != nil {
-		err := fmt.Errorf("Error obtaining lock: %s", err)
+		err := fmt.Errorf("Error creating lock: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt

builder/amazon/chroot/step_mount_device.go

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

builder/amazon/chroot/step_mount_extra.go

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

builder/amazon/chroot/step_register_ami.go

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

builder/amazon/chroot/step_snapshot.go

@@ -37,6 +37,7 @@ func (s *StepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Wait for the snapshot to be ready
 	stateChange := awscommon.StateChangeConf{
+		Conn:      ec2conn,
 		Pending:   []string{"pending"},
 		StepState: state,
 		Target:    "completed",
@@ -50,8 +51,7 @@ func (s *StepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 				return nil, "", errors.New("No snapshots found.")
 			}
 
-			s := resp.Snapshots[0]
-			return s, s.Status, nil
+			return nil, resp.Snapshots[0].Status, nil
 		},
 	}
 

builder/amazon/common/access_config.go

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

builder/amazon/common/ami.go

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

builder/amazon/common/artifact_test.go

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

builder/amazon/common/block_device_test.go

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

builder/amazon/common/instance.go

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

builder/amazon/common/run_config.go

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

builder/amazon/common/ssh.go

@@ -20,11 +20,7 @@ func SSHAddress(e *ec2.EC2, port int) func(multistep.StateBag) (string, error) {
 			if i.DNSName != "" {
 				host = i.DNSName
 			} else if i.VpcId != "" {
-				if i.PublicIpAddress != "" {
-					host = i.PublicIpAddress
-				} else {
-					host = i.PrivateIpAddress
-				}
+				host = i.PrivateIpAddress
 			}
 
 			if host != "" {

builder/amazon/common/step_ami_region_copy.go

@@ -6,7 +6,6 @@ import (
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"sync"
 )
 
 type StepAMIRegionCopy struct {
@@ -24,37 +23,32 @@ func (s *StepAMIRegionCopy) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	ui.Say(fmt.Sprintf("Copying AMI (%s) to other regions...", ami))
-
-	var lock sync.Mutex
-	var wg sync.WaitGroup
-	errs := new(packer.MultiError)
 	for _, region := range s.Regions {
-		wg.Add(1)
 		ui.Message(fmt.Sprintf("Copying to: %s", region))
 
-		go func(region string) {
-			defer wg.Done()
-			id, err := amiRegionCopy(state, ec2conn.Auth, ami,
-				aws.Regions[region], ec2conn.Region)
+		// Connect to the region where the AMI will be copied to
+		regionconn := ec2.New(ec2conn.Auth, aws.Regions[region])
+		resp, err := regionconn.CopyImage(&ec2.CopyImage{
+			SourceRegion:  ec2conn.Region.Name,
+			SourceImageId: ami,
+		})
 
-			lock.Lock()
-			defer lock.Unlock()
-			amis[region] = id
-			if err != nil {
-				errs = packer.MultiErrorAppend(errs, err)
-			}
-		}(region)
-	}
+		if err != nil {
+			err := fmt.Errorf("Error Copying AMI (%s) to region (%s): %s", ami, region, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
 
-	// TODO(mitchellh): Wait but also allow for cancels to go through...
-	ui.Message("Waiting for all copies to complete...")
-	wg.Wait()
+		ui.Say(fmt.Sprintf("Waiting for AMI (%s) in region (%s) to become ready...", resp.ImageId, region))
+		if err := WaitForAMI(regionconn, resp.ImageId); err != nil {
+			err := fmt.Errorf("Error waiting for AMI (%s) in region (%s): %s", resp.ImageId, region, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
 
-	// If there were errors, show them
-	if len(errs.Errors) > 0 {
-		state.Put("error", errs)
-		ui.Error(errs.Error())
-		return multistep.ActionHalt
+		amis[region] = resp.ImageId
 	}
 
 	state.Put("amis", amis)
@@ -64,35 +58,3 @@ func (s *StepAMIRegionCopy) Run(state multistep.StateBag) multistep.StepAction {
 func (s *StepAMIRegionCopy) Cleanup(state multistep.StateBag) {
 	// No cleanup...
 }
-
-// amiRegionCopy does a copy for the given AMI to the target region and
-// returns the resulting ID or error.
-func amiRegionCopy(state multistep.StateBag, auth aws.Auth, imageId string,
-	target aws.Region, source aws.Region) (string, error) {
-
-	// Connect to the region where the AMI will be copied to
-	regionconn := ec2.New(auth, target)
-	resp, err := regionconn.CopyImage(&ec2.CopyImage{
-		SourceRegion:  source.Name,
-		SourceImageId: imageId,
-	})
-
-	if err != nil {
-		return "", fmt.Errorf("Error Copying AMI (%s) to region (%s): %s",
-			imageId, target, err)
-	}
-
-	stateChange := StateChangeConf{
-		Pending:   []string{"pending"},
-		Target:    "available",
-		Refresh:   AMIStateRefreshFunc(regionconn, resp.ImageId),
-		StepState: state,
-	}
-
-	if _, err := WaitForState(&stateChange); err != nil {
-		return "", fmt.Errorf("Error waiting for AMI (%s) in region (%s): %s",
-			resp.ImageId, target, err)
-	}
-
-	return resp.ImageId, nil
-}

builder/amazon/common/step_run_source_instance.go

@@ -6,21 +6,19 @@ import (
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 	"io/ioutil"
+	"log"
 )
 
 type StepRunSourceInstance struct {
-	AssociatePublicIpAddress bool
-	AvailabilityZone         string
-	BlockDevices             BlockDevices
-	Debug                    bool
-	ExpectedRootDevice       string
-	InstanceType             string
-	IamInstanceProfile       string
-	SourceAMI                string
-	SubnetId                 string
-	Tags                     map[string]string
-	UserData                 string
-	UserDataFile             string
+	Debug              bool
+	ExpectedRootDevice string
+	InstanceType       string
+	UserData           string
+	UserDataFile       string
+	SourceAMI          string
+	IamInstanceProfile string
+	SubnetId           string
+	BlockDevices       BlockDevices
 
 	instance *ec2.Instance
 }
@@ -28,7 +26,7 @@ type StepRunSourceInstance struct {
 func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	keyName := state.Get("keyPair").(string)
-	securityGroupIds := state.Get("securityGroupIds").([]string)
+	securityGroupId := state.Get("securityGroupId").(string)
 	ui := state.Get("ui").(packer.Ui)
 
 	userData := s.UserData
@@ -42,24 +40,17 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 		userData = string(contents)
 	}
 
-	securityGroups := make([]ec2.SecurityGroup, len(securityGroupIds))
-	for n, securityGroupId := range securityGroupIds {
-		securityGroups[n] = ec2.SecurityGroup{Id: securityGroupId}
-	}
-
 	runOpts := &ec2.RunInstances{
-		KeyName:                  keyName,
-		ImageId:                  s.SourceAMI,
-		InstanceType:             s.InstanceType,
-		UserData:                 []byte(userData),
-		MinCount:                 0,
-		MaxCount:                 0,
-		SecurityGroups:           securityGroups,
-		IamInstanceProfile:       s.IamInstanceProfile,
-		SubnetId:                 s.SubnetId,
-		AssociatePublicIpAddress: s.AssociatePublicIpAddress,
-		BlockDevices:             s.BlockDevices.BuildLaunchDevices(),
-		AvailZone:                s.AvailabilityZone,
+		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...")
@@ -91,22 +82,11 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 	}
 
 	s.instance = &runResp.Instances[0]
-	ui.Message(fmt.Sprintf("Instance ID: %s", s.instance.InstanceId))
-
-	ec2Tags := make([]ec2.Tag, 1, len(s.Tags)+1)
-	ec2Tags[0] = ec2.Tag{"Name", "Packer Builder"}
-	for k, v := range s.Tags {
-		ec2Tags = append(ec2Tags, ec2.Tag{k, v})
-	}
-
-	_, err = ec2conn.CreateTags([]string{s.instance.InstanceId}, ec2Tags)
-	if err != nil {
-		ui.Message(
-			fmt.Sprintf("Failed to tag a Name on the builder instance: %s", err))
-	}
+	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),
@@ -127,10 +107,6 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 			ui.Message(fmt.Sprintf("Public DNS: %s", s.instance.DNSName))
 		}
 
-		if s.instance.PublicIpAddress != "" {
-			ui.Message(fmt.Sprintf("Public IP: %s", s.instance.PublicIpAddress))
-		}
-
 		if s.instance.PrivateIpAddress != "" {
 			ui.Message(fmt.Sprintf("Private IP: %s", s.instance.PrivateIpAddress))
 		}
@@ -156,6 +132,7 @@ func (s *StepRunSourceInstance) Cleanup(state multistep.StateBag) {
 	}
 
 	stateChange := StateChangeConf{
+		Conn:    ec2conn,
 		Pending: []string{"pending", "running", "shutting-down", "stopped", "stopping"},
 		Refresh: InstanceStateRefreshFunc(ec2conn, s.instance),
 		Target:  "terminated",

builder/amazon/common/step_security_group.go

@@ -1,19 +1,20 @@
 package common
 
 import (
+	"cgl.tideland.biz/identifier"
+	"encoding/hex"
 	"fmt"
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"time"
 )
 
 type StepSecurityGroup struct {
-	SecurityGroupIds []string
-	SSHPort          int
-	VpcId            string
+	SecurityGroupId string
+	SSHPort         int
+	VpcId           string
 
 	createdGroupId string
 }
@@ -22,9 +23,9 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
-	if len(s.SecurityGroupIds) > 0 {
-		log.Printf("Using specified security groups: %v", s.SecurityGroupIds)
-		state.Put("securityGroupIds", s.SecurityGroupIds)
+	if s.SecurityGroupId != "" {
+		log.Printf("Using specified security group: %s", s.SecurityGroupId)
+		state.Put("securityGroupId", s.SecurityGroupId)
 		return multistep.ActionContinue
 	}
 
@@ -34,7 +35,7 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Create the group
 	ui.Say("Creating temporary security group for this instance...")
-	groupName := fmt.Sprintf("packer %s", uuid.TimeOrderedUUID())
+	groupName := fmt.Sprintf("packer %s", hex.EncodeToString(identifier.NewUUID().Raw()))
 	log.Printf("Temporary group name: %s", groupName)
 	group := ec2.SecurityGroup{
 		Name:        groupName,
@@ -60,21 +61,8 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 		},
 	}
 
-	// We loop and retry this a few times because sometimes the security
-	// group isn't available immediately because AWS resources are eventaully
-	// consistent.
 	ui.Say("Authorizing SSH access on the temporary security group...")
-	for i := 0; i < 5; i++ {
-		_, err = ec2conn.AuthorizeSecurityGroup(groupResp.SecurityGroup, perms)
-		if err == nil {
-			break
-		}
-
-		log.Printf("Error authorizing. Will sleep and retry. %s", err)
-		time.Sleep((time.Duration(i) * time.Second) + 1)
-	}
-
-	if err != nil {
+	if _, err := ec2conn.AuthorizeSecurityGroup(groupResp.SecurityGroup, perms); err != nil {
 		err := fmt.Errorf("Error creating temporary security group: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
@@ -82,7 +70,7 @@ func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	// Set some state data for use in future steps
-	state.Put("securityGroupIds", []string{s.createdGroupId})
+	state.Put("securityGroupId", s.createdGroupId)
 
 	return multistep.ActionContinue
 }

builder/amazon/ebs/builder.go

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

builder/amazon/ebs/builder_test.go

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

builder/amazon/ebs/step_create_ami.go

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

builder/amazon/ebs/step_stop_instance.go

@@ -28,6 +28,7 @@ func (s *stepStopInstance) Run(state multistep.StateBag) multistep.StepAction {
 	// 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),

builder/amazon/instance/builder.go

@@ -45,15 +45,15 @@ type Builder struct {
 	runner multistep.Runner
 }
 
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+func (b *Builder) Prepare(raws ...interface{}) error {
 	md, err := common.DecodeConfig(&b.config, raws...)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	b.config.tpl, err = packer.NewConfigTemplate()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	b.config.tpl.UserVars = b.config.PackerUserVars
 	b.config.tpl.Funcs(awscommon.TemplateFuncs)
@@ -74,7 +74,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			"-s {{.SecretKey}} " +
 			"-d {{.BundleDirectory}} " +
 			"--batch " +
-			"--location {{.Region}} " +
 			"--retry"
 	}
 
@@ -84,7 +83,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			"-u {{.AccountId}} " +
 			"-c {{.CertPath}} " +
 			"-r {{.Architecture}} " +
-			"-e {{.PrivatePath}}/* " +
+			"-e {{.PrivatePath}} " +
 			"-d {{.Destination}} " +
 			"-p {{.Prefix}} " +
 			"--batch"
@@ -157,11 +156,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	if errs != nil && len(errs.Errors) > 0 {
-		return nil, errs
+		return errs
 	}
 
-	log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey))
-	return nil, nil
+	log.Printf("Config: %+v", b.config)
+	return nil
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
@@ -192,23 +191,20 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			KeyPairName:  b.config.TemporaryKeyPairName,
 		},
 		&awscommon.StepSecurityGroup{
-			SecurityGroupIds: b.config.SecurityGroupIds,
-			SSHPort:          b.config.SSHPort,
-			VpcId:            b.config.VpcId,
+			SecurityGroupId: b.config.SecurityGroupId,
+			SSHPort:         b.config.SSHPort,
+			VpcId:           b.config.VpcId,
 		},
 		&awscommon.StepRunSourceInstance{
-			Debug:                    b.config.PackerDebug,
-			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,
-			AssociatePublicIpAddress: b.config.AssociatePublicIpAddress,
-			AvailabilityZone:         b.config.AvailabilityZone,
-			BlockDevices:             b.config.BlockDevices,
-			Tags:                     b.config.RunTags,
+			Debug:              b.config.PackerDebug,
+			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),

builder/amazon/instance/builder_test.go

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

builder/amazon/instance/step_register_ami.go

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

builder/amazon/instance/step_upload_bundle.go

@@ -11,7 +11,6 @@ type uploadCmdData struct {
 	BucketName      string
 	BundleDirectory string
 	ManifestPath    string
-	Region          string
 	SecretKey       string
 }
 
@@ -24,26 +23,12 @@ func (s *StepUploadBundle) Run(state multistep.StateBag) multistep.StepAction {
 	manifestPath := state.Get("manifest_path").(string)
 	ui := state.Get("ui").(packer.Ui)
 
-	region, err := config.Region()
-	if err != nil {
-		err := fmt.Errorf("Error retrieving region: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// See GH-729 and http://goo.gl/rNZiCs
-	regionName := region.Name
-	if regionName == "us-east-1" {
-		regionName = "US"
-	}
-
+	var err error
 	config.BundleUploadCommand, err = config.tpl.Process(config.BundleUploadCommand, uploadCmdData{
 		AccessKey:       config.AccessKey,
 		BucketName:      config.S3Bucket,
 		BundleDirectory: config.BundleDestination,
 		ManifestPath:    manifestPath,
-		Region:          regionName,
 		SecretKey:       config.SecretKey,
 	})
 	if err != nil {

builder/digitalocean/api.go

@@ -29,15 +29,6 @@ type ImagesResp struct {
 	Images []Image
 }
 
-type Region struct {
-	Id   uint
-	Name string
-}
-
-type RegionsResp struct {
-	Regions []Region
-}
-
 type DigitalOceanClient struct {
 	// The http client for communicating
 	client *http.Client
@@ -90,14 +81,13 @@ func (d DigitalOceanClient) DestroyKey(id uint) error {
 }
 
 // Creates a droplet and returns it's id
-func (d DigitalOceanClient) CreateDroplet(name string, size uint, image uint, region uint, keyId uint, privateNetworking bool) (uint, error) {
+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.Set("private_networking", fmt.Sprintf("%v", privateNetworking))
 
 	body, err := NewRequest(d, "droplets/new", params)
 	if err != nil {
@@ -237,13 +227,7 @@ func NewRequest(d DigitalOceanClient, path string, params url.Values) (map[strin
 		}
 
 		if status == "ERROR" {
-			statusRaw, ok := decodedResponse["error_message"]
-			if ok {
-				status = statusRaw.(string)
-			} else {
-				status = fmt.Sprintf(
-					"Unknown error. Full response body: %s", body)
-			}
+			status = decodedResponse["error_message"].(string)
 		}
 
 		lastErr = errors.New(fmt.Sprintf("Received error from DigitalOcean (%d): %s",
@@ -262,35 +246,3 @@ func NewRequest(d DigitalOceanClient, path string, params url.Values) (map[strin
 
 	return nil, lastErr
 }
-
-// Returns all available regions.
-func (d DigitalOceanClient) Regions() ([]Region, error) {
-	resp, err := NewRequest(d, "regions", url.Values{})
-	if err != nil {
-		return nil, err
-	}
-
-	var result RegionsResp
-	if err := mapstructure.Decode(resp, &result); err != nil {
-		return nil, err
-	}
-
-	return result.Regions, nil
-}
-
-func (d DigitalOceanClient) RegionName(region_id uint) (string, error) {
-	regions, err := d.Regions()
-	if err != nil {
-		return "", err
-	}
-
-	for _, region := range regions {
-		if region.Id == region_id {
-			return region.Name, nil
-		}
-	}
-
-	err = errors.New(fmt.Sprintf("Unknown region id %v", region_id))
-
-	return "", err
-}

builder/digitalocean/artifact.go

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

builder/digitalocean/artifact_test.go

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

builder/digitalocean/builder.go

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

builder/digitalocean/builder_test.go

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

builder/digitalocean/step_create_droplet.go

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

builder/digitalocean/step_create_ssh_key.go

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

builder/digitalocean/step_snapshot.go

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

builder/digitalocean/wait.go

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

builder/docker/artifact_export.go

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

builder/docker/artifact_export_test.go

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

builder/docker/builder.go

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

builder/docker/builder_test.go

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

builder/docker/communicator.go

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

builder/docker/communicator_test.go

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

builder/docker/config.go

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

builder/docker/config_test.go

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

builder/docker/driver.go

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

builder/docker/driver_docker.go

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

builder/docker/driver_docker_test.go

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

builder/docker/driver_mock.go

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

builder/docker/driver_mock_test.go

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

builder/docker/exec.go

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

builder/docker/exec_test.go

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

builder/docker/step_export.go

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

builder/docker/step_export_test.go

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

builder/docker/step_provision.go

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

builder/docker/step_pull.go

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

builder/docker/step_pull_test.go

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

builder/docker/step_run.go

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

builder/docker/step_run_test.go

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

builder/docker/step_temp_dir.go

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

builder/docker/step_temp_dir_test.go

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

builder/docker/step_test.go

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

builder/googlecompute/artifact.go

@@ -1,39 +0,0 @@
-package googlecompute
-
-import (
-	"fmt"
-	"log"
-)
-
-// Artifact represents a GCE image as the result of a Packer build.
-type Artifact struct {
-	imageName string
-	driver    Driver
-}
-
-// BuilderId returns the builder Id.
-func (*Artifact) BuilderId() string {
-	return BuilderId
-}
-
-// Destroy destroys the GCE image represented by the artifact.
-func (a *Artifact) Destroy() error {
-	log.Printf("Destroying image: %s", a.imageName)
-	errCh := a.driver.DeleteImage(a.imageName)
-	return <-errCh
-}
-
-// Files returns the files represented by the artifact.
-func (*Artifact) Files() []string {
-	return nil
-}
-
-// Id returns the GCE image name.
-func (a *Artifact) Id() string {
-	return a.imageName
-}
-
-// String returns the string representation of the artifact.
-func (a *Artifact) String() string {
-	return fmt.Sprintf("A disk image was created: %v", a.imageName)
-}

builder/googlecompute/artifact_test.go

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

builder/googlecompute/builder.go

@@ -1,100 +0,0 @@
-// The googlecompute package contains a packer.Builder implementation that
-// builds images for Google Compute Engine.
-package googlecompute
-
-import (
-	"log"
-	"time"
-
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-)
-
-// The unique ID for this builder.
-const BuilderId = "packer.googlecompute"
-
-// Builder represents a Packer Builder.
-type Builder struct {
-	config *Config
-	runner multistep.Runner
-}
-
-// Prepare processes the build configuration parameters.
-func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
-	c, warnings, errs := NewConfig(raws...)
-	if errs != nil {
-		return warnings, errs
-	}
-	b.config = c
-
-	return warnings, nil
-}
-
-// Run executes a googlecompute Packer build and returns a packer.Artifact
-// representing a GCE machine image.
-func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
-	driver, err := NewDriverGCE(
-		ui, b.config.ProjectId, b.config.clientSecrets, b.config.privateKeyBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	// Set up the state.
-	state := new(multistep.BasicStateBag)
-	state.Put("config", b.config)
-	state.Put("driver", driver)
-	state.Put("hook", hook)
-	state.Put("ui", ui)
-
-	// Build the steps.
-	steps := []multistep.Step{
-		new(StepCreateSSHKey),
-		new(StepCreateInstance),
-		new(StepInstanceInfo),
-		&common.StepConnectSSH{
-			SSHAddress:     sshAddress,
-			SSHConfig:      sshConfig,
-			SSHWaitTimeout: 5 * time.Minute,
-		},
-		new(common.StepProvision),
-		new(StepUpdateGsutil),
-		new(StepCreateImage),
-		new(StepUploadImage),
-		new(StepRegisterImage),
-	}
-
-	// Run the steps.
-	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)
-
-	// Report any errors.
-	if rawErr, ok := state.GetOk("error"); ok {
-		return nil, rawErr.(error)
-	}
-	if _, ok := state.GetOk("image_name"); !ok {
-		log.Println("Failed to find image_name in state. Bug?")
-		return nil, nil
-	}
-
-	artifact := &Artifact{
-		imageName: state.Get("image_name").(string),
-		driver:    driver,
-	}
-	return artifact, nil
-}
-
-// Cancel.
-func (b *Builder) Cancel() {
-	if b.runner != nil {
-		log.Println("Cancelling the step runner...")
-		b.runner.Cancel()
-	}
-}

builder/googlecompute/builder_test.go

@@ -1 +0,0 @@
-package googlecompute

builder/googlecompute/client_secrets.go

@@ -1,32 +0,0 @@
-package googlecompute
-
-import (
-	"encoding/json"
-	"io/ioutil"
-)
-
-// clientSecrets represents the client secrets of a GCE service account.
-type clientSecrets struct {
-	Web struct {
-		AuthURI     string `json:"auth_uri"`
-		ClientEmail string `json:"client_email"`
-		ClientId    string `json:"client_id"`
-		TokenURI    string `json:"token_uri"`
-	}
-}
-
-// loadClientSecrets loads the GCE client secrets file identified by path.
-func loadClientSecrets(path string) (*clientSecrets, error) {
-	var cs *clientSecrets
-	secretBytes, err := ioutil.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	err = json.Unmarshal(secretBytes, &cs)
-	if err != nil {
-		return nil, err
-	}
-
-	return cs, nil
-}

builder/googlecompute/client_secrets_test.go

@@ -1,31 +0,0 @@
-package googlecompute
-
-import (
-	"io/ioutil"
-	"testing"
-)
-
-func testClientSecretsFile(t *testing.T) string {
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer tf.Close()
-
-	if _, err := tf.Write([]byte(testClientSecretsContent)); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	return tf.Name()
-}
-
-func TestLoadClientSecrets(t *testing.T) {
-	_, err := loadClientSecrets(testClientSecretsFile(t))
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-// This is just some dummy data that doesn't actually work (it was revoked
-// a long time ago).
-const testClientSecretsContent = `{"web":{"auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://accounts.google.com/o/oauth2/token","client_email":"774313886706-eorlsj0r4eqkh5e7nvea5fuf59ifr873@developer.gserviceaccount.com","client_x509_cert_url":"https://www.googleapis.com/robot/v1/metadata/x509/774313886706-eorlsj0r4eqkh5e7nvea5fuf59ifr873@developer.gserviceaccount.com","client_id":"774313886706-eorlsj0r4eqkh5e7nvea5fuf59ifr873.apps.googleusercontent.com","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs"}}`

builder/googlecompute/config.go

@@ -1,191 +0,0 @@
-package googlecompute
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
-)
-
-// Config is the configuration structure for the GCE builder. It stores
-// both the publicly settable state as well as the privately generated
-// state of the config object.
-type Config struct {
-	common.PackerConfig `mapstructure:",squash"`
-
-	BucketName        string            `mapstructure:"bucket_name"`
-	ClientSecretsFile string            `mapstructure:"client_secrets_file"`
-	ImageName         string            `mapstructure:"image_name"`
-	ImageDescription  string            `mapstructure:"image_description"`
-	MachineType       string            `mapstructure:"machine_type"`
-	Metadata          map[string]string `mapstructure:"metadata"`
-	Network           string            `mapstructure:"network"`
-	Passphrase        string            `mapstructure:"passphrase"`
-	PrivateKeyFile    string            `mapstructure:"private_key_file"`
-	ProjectId         string            `mapstructure:"project_id"`
-	SourceImage       string            `mapstructure:"source_image"`
-	SSHUsername       string            `mapstructure:"ssh_username"`
-	SSHPort           uint              `mapstructure:"ssh_port"`
-	RawSSHTimeout     string            `mapstructure:"ssh_timeout"`
-	RawStateTimeout   string            `mapstructure:"state_timeout"`
-	Tags              []string          `mapstructure:"tags"`
-	Zone              string            `mapstructure:"zone"`
-
-	clientSecrets   *clientSecrets
-	instanceName    string
-	privateKeyBytes []byte
-	sshTimeout      time.Duration
-	stateTimeout    time.Duration
-	tpl             *packer.ConfigTemplate
-}
-
-func NewConfig(raws ...interface{}) (*Config, []string, error) {
-	c := new(Config)
-	md, err := common.DecodeConfig(c, raws...)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	c.tpl, err = packer.NewConfigTemplate()
-	if err != nil {
-		return nil, nil, err
-	}
-	c.tpl.UserVars = c.PackerUserVars
-
-	// Prepare the errors
-	errs := common.CheckUnusedConfig(md)
-
-	// Set defaults.
-	if c.Network == "" {
-		c.Network = "default"
-	}
-
-	if c.ImageDescription == "" {
-		c.ImageDescription = "Created by Packer"
-	}
-
-	if c.ImageName == "" {
-		c.ImageName = "packer-{{timestamp}}"
-	}
-
-	if c.MachineType == "" {
-		c.MachineType = "n1-standard-1"
-	}
-
-	if c.RawSSHTimeout == "" {
-		c.RawSSHTimeout = "5m"
-	}
-
-	if c.RawStateTimeout == "" {
-		c.RawStateTimeout = "5m"
-	}
-
-	if c.SSHUsername == "" {
-		c.SSHUsername = "root"
-	}
-
-	if c.SSHPort == 0 {
-		c.SSHPort = 22
-	}
-
-	// Process Templates
-	templates := map[string]*string{
-		"bucket_name":         &c.BucketName,
-		"client_secrets_file": &c.ClientSecretsFile,
-		"image_name":          &c.ImageName,
-		"image_description":   &c.ImageDescription,
-		"machine_type":        &c.MachineType,
-		"network":             &c.Network,
-		"passphrase":          &c.Passphrase,
-		"private_key_file":    &c.PrivateKeyFile,
-		"project_id":          &c.ProjectId,
-		"source_image":        &c.SourceImage,
-		"ssh_username":        &c.SSHUsername,
-		"ssh_timeout":         &c.RawSSHTimeout,
-		"state_timeout":       &c.RawStateTimeout,
-		"zone":                &c.Zone,
-	}
-
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = c.tpl.Process(*ptr, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
-	// Process required parameters.
-	if c.BucketName == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a bucket_name must be specified"))
-	}
-
-	if c.ClientSecretsFile == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a client_secrets_file must be specified"))
-	}
-
-	if c.PrivateKeyFile == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a private_key_file must be specified"))
-	}
-
-	if c.ProjectId == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a project_id must be specified"))
-	}
-
-	if c.SourceImage == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a source_image must be specified"))
-	}
-
-	if c.Zone == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a zone must be specified"))
-	}
-
-	// Process timeout settings.
-	sshTimeout, err := time.ParseDuration(c.RawSSHTimeout)
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing ssh_timeout: %s", err))
-	}
-	c.sshTimeout = sshTimeout
-
-	stateTimeout, err := time.ParseDuration(c.RawStateTimeout)
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed parsing state_timeout: %s", err))
-	}
-	c.stateTimeout = stateTimeout
-
-	if c.ClientSecretsFile != "" {
-		// Load the client secrets file.
-		cs, err := loadClientSecrets(c.ClientSecretsFile)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed parsing client secrets file: %s", err))
-		}
-		c.clientSecrets = cs
-	}
-
-	if c.PrivateKeyFile != "" {
-		// Load the private key.
-		c.privateKeyBytes, err = processPrivateKeyFile(c.PrivateKeyFile, c.Passphrase)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed loading private key file: %s", err))
-		}
-	}
-
-	// Check for any errors.
-	if errs != nil && len(errs.Errors) > 0 {
-		return nil, nil, errs
-	}
-
-	return c, nil, nil
-}

builder/googlecompute/config_test.go

@@ -1,176 +0,0 @@
-package googlecompute
-
-import (
-	"testing"
-)
-
-func testConfig(t *testing.T) map[string]interface{} {
-	return map[string]interface{}{
-		"bucket_name":         "foo",
-		"client_secrets_file": testClientSecretsFile(t),
-		"private_key_file":    testPrivateKeyFile(t),
-		"project_id":          "hashicorp",
-		"source_image":        "foo",
-		"zone":                "us-east-1a",
-	}
-}
-
-func testConfigStruct(t *testing.T) *Config {
-	c, warns, errs := NewConfig(testConfig(t))
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", len(warns))
-	}
-	if errs != nil {
-		t.Fatalf("bad: %#v", errs)
-	}
-
-	return c
-}
-
-func testConfigErr(t *testing.T, warns []string, err error, extra string) {
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatalf("should error: %s", extra)
-	}
-}
-
-func testConfigOk(t *testing.T, warns []string, err error) {
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-}
-
-func TestConfigPrepare(t *testing.T) {
-	cases := []struct {
-		Key   string
-		Value interface{}
-		Err   bool
-	}{
-		{
-			"unknown_key",
-			"bad",
-			true,
-		},
-
-		{
-			"bucket_name",
-			nil,
-			true,
-		},
-		{
-			"bucket_name",
-			"good",
-			false,
-		},
-
-		{
-			"client_secrets_file",
-			nil,
-			true,
-		},
-		{
-			"client_secrets_file",
-			testClientSecretsFile(t),
-			false,
-		},
-		{
-			"client_secrets_file",
-			"/tmp/i/should/not/exist",
-			true,
-		},
-
-		{
-			"private_key_file",
-			nil,
-			true,
-		},
-		{
-			"private_key_file",
-			testPrivateKeyFile(t),
-			false,
-		},
-		{
-			"private_key_file",
-			"/tmp/i/should/not/exist",
-			true,
-		},
-
-		{
-			"project_id",
-			nil,
-			true,
-		},
-		{
-			"project_id",
-			"foo",
-			false,
-		},
-
-		{
-			"source_image",
-			nil,
-			true,
-		},
-		{
-			"source_image",
-			"foo",
-			false,
-		},
-
-		{
-			"zone",
-			nil,
-			true,
-		},
-		{
-			"zone",
-			"foo",
-			false,
-		},
-
-		{
-			"ssh_timeout",
-			"SO BAD",
-			true,
-		},
-		{
-			"ssh_timeout",
-			"5s",
-			false,
-		},
-
-		{
-			"state_timeout",
-			"SO BAD",
-			true,
-		},
-		{
-			"state_timeout",
-			"5s",
-			false,
-		},
-	}
-
-	for _, tc := range cases {
-		raw := testConfig(t)
-
-		if tc.Value == nil {
-			delete(raw, tc.Key)
-		} else {
-			raw[tc.Key] = tc.Value
-		}
-
-		_, warns, errs := NewConfig(raw)
-
-		if tc.Err {
-			testConfigErr(t, warns, errs, tc.Key)
-		} else {
-			testConfigOk(t, warns, errs)
-		}
-	}
-}

builder/googlecompute/driver.go

@@ -1,35 +0,0 @@
-package googlecompute
-
-// Driver is the interface that has to be implemented to communicate
-// with GCE. The Driver interface exists mostly to allow a mock implementation
-// to be used to test the steps.
-type Driver interface {
-	// CreateImage creates an image with the given URL in Google Storage.
-	CreateImage(name, description, url string) <-chan error
-
-	// DeleteImage deletes the image with the given name.
-	DeleteImage(name string) <-chan error
-
-	// DeleteInstance deletes the given instance.
-	DeleteInstance(zone, name string) (<-chan error, error)
-
-	// GetNatIP gets the NAT IP address for the instance.
-	GetNatIP(zone, name string) (string, error)
-
-	// RunInstance takes the given config and launches an instance.
-	RunInstance(*InstanceConfig) (<-chan error, error)
-
-	// WaitForInstance waits for an instance to reach the given state.
-	WaitForInstance(state, zone, name string) <-chan error
-}
-
-type InstanceConfig struct {
-	Description string
-	Image       string
-	MachineType string
-	Metadata    map[string]string
-	Name        string
-	Network     string
-	Tags        []string
-	Zone        string
-}

builder/googlecompute/driver_gce.go

@@ -1,309 +0,0 @@
-package googlecompute
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"time"
-
-	"code.google.com/p/goauth2/oauth"
-	"code.google.com/p/goauth2/oauth/jwt"
-	"code.google.com/p/google-api-go-client/compute/v1beta16"
-	"github.com/mitchellh/packer/packer"
-)
-
-// driverGCE is a Driver implementation that actually talks to GCE.
-// Create an instance using NewDriverGCE.
-type driverGCE struct {
-	projectId string
-	service   *compute.Service
-	ui        packer.Ui
-}
-
-const DriverScopes string = "https://www.googleapis.com/auth/compute " +
-	"https://www.googleapis.com/auth/devstorage.full_control"
-
-func NewDriverGCE(ui packer.Ui, projectId string, c *clientSecrets, key []byte) (Driver, error) {
-	log.Printf("[INFO] Requesting token...")
-	log.Printf("[INFO]   -- Email: %s", c.Web.ClientEmail)
-	log.Printf("[INFO]   -- Scopes: %s", DriverScopes)
-	log.Printf("[INFO]   -- Private Key Length: %d", len(key))
-	log.Printf("[INFO]   -- Token URL: %s", c.Web.TokenURI)
-	jwtTok := jwt.NewToken(c.Web.ClientEmail, DriverScopes, key)
-	jwtTok.ClaimSet.Aud = c.Web.TokenURI
-	token, err := jwtTok.Assert(new(http.Client))
-	if err != nil {
-		return nil, err
-	}
-
-	transport := &oauth.Transport{
-		Config: &oauth.Config{
-			ClientId: c.Web.ClientId,
-			Scope:    DriverScopes,
-			TokenURL: c.Web.TokenURI,
-			AuthURL:  c.Web.AuthURI,
-		},
-		Token: token,
-	}
-
-	log.Printf("[INFO] Instantiating client...")
-	service, err := compute.New(transport.Client())
-	if err != nil {
-		return nil, err
-	}
-
-	return &driverGCE{
-		projectId: projectId,
-		service:   service,
-		ui:        ui,
-	}, nil
-}
-
-func (d *driverGCE) CreateImage(name, description, url string) <-chan error {
-	image := &compute.Image{
-		Description: description,
-		Name:        name,
-		RawDisk: &compute.ImageRawDisk{
-			ContainerType: "TAR",
-			Source:        url,
-		},
-		SourceType: "RAW",
-	}
-
-	errCh := make(chan error, 1)
-	op, err := d.service.Images.Insert(d.projectId, image).Do()
-	if err != nil {
-		errCh <- err
-	} else {
-		go waitForState(errCh, "DONE", d.refreshGlobalOp(op))
-	}
-
-	return errCh
-}
-
-func (d *driverGCE) DeleteImage(name string) <-chan error {
-	errCh := make(chan error, 1)
-	op, err := d.service.Images.Delete(d.projectId, name).Do()
-	if err != nil {
-		errCh <- err
-	} else {
-		go waitForState(errCh, "DONE", d.refreshGlobalOp(op))
-	}
-
-	return errCh
-}
-
-func (d *driverGCE) DeleteInstance(zone, name string) (<-chan error, error) {
-	op, err := d.service.Instances.Delete(d.projectId, zone, name).Do()
-	if err != nil {
-		return nil, err
-	}
-
-	errCh := make(chan error, 1)
-	go waitForState(errCh, "DONE", d.refreshZoneOp(zone, op))
-	return errCh, nil
-}
-
-func (d *driverGCE) GetNatIP(zone, name string) (string, error) {
-	instance, err := d.service.Instances.Get(d.projectId, zone, name).Do()
-	if err != nil {
-		return "", err
-	}
-
-	for _, ni := range instance.NetworkInterfaces {
-		if ni.AccessConfigs == nil {
-			continue
-		}
-
-		for _, ac := range ni.AccessConfigs {
-			if ac.NatIP != "" {
-				return ac.NatIP, nil
-			}
-		}
-	}
-
-	return "", nil
-}
-
-func (d *driverGCE) RunInstance(c *InstanceConfig) (<-chan error, error) {
-	// Get the zone
-	d.ui.Message(fmt.Sprintf("Loading zone: %s", c.Zone))
-	zone, err := d.service.Zones.Get(d.projectId, c.Zone).Do()
-	if err != nil {
-		return nil, err
-	}
-
-	// Get the image
-	d.ui.Message(fmt.Sprintf("Loading image: %s", c.Image))
-	image, err := d.getImage(c.Image)
-	if err != nil {
-		return nil, err
-	}
-
-	// Get the machine type
-	d.ui.Message(fmt.Sprintf("Loading machine type: %s", c.MachineType))
-	machineType, err := d.service.MachineTypes.Get(
-		d.projectId, zone.Name, c.MachineType).Do()
-	if err != nil {
-		return nil, err
-	}
-	// TODO(mitchellh): deprecation warnings
-
-	// Get the network
-	d.ui.Message(fmt.Sprintf("Loading network: %s", c.Network))
-	network, err := d.service.Networks.Get(d.projectId, c.Network).Do()
-	if err != nil {
-		return nil, err
-	}
-
-	// Build up the metadata
-	metadata := make([]*compute.MetadataItems, len(c.Metadata))
-	for k, v := range c.Metadata {
-		metadata = append(metadata, &compute.MetadataItems{
-			Key:   k,
-			Value: v,
-		})
-	}
-
-	// Create the instance information
-	instance := compute.Instance{
-		Description: c.Description,
-		Image:       image.SelfLink,
-		MachineType: machineType.SelfLink,
-		Metadata: &compute.Metadata{
-			Items: metadata,
-		},
-		Name: c.Name,
-		NetworkInterfaces: []*compute.NetworkInterface{
-			&compute.NetworkInterface{
-				AccessConfigs: []*compute.AccessConfig{
-					&compute.AccessConfig{
-						Name: "AccessConfig created by Packer",
-						Type: "ONE_TO_ONE_NAT",
-					},
-				},
-				Network: network.SelfLink,
-			},
-		},
-		ServiceAccounts: []*compute.ServiceAccount{
-			&compute.ServiceAccount{
-				Email: "default",
-				Scopes: []string{
-					"https://www.googleapis.com/auth/userinfo.email",
-					"https://www.googleapis.com/auth/compute",
-					"https://www.googleapis.com/auth/devstorage.full_control",
-				},
-			},
-		},
-		Tags: &compute.Tags{
-			Items: c.Tags,
-		},
-	}
-
-	d.ui.Message("Requesting instance creation...")
-	op, err := d.service.Instances.Insert(d.projectId, zone.Name, &instance).Do()
-	if err != nil {
-		return nil, err
-	}
-
-	errCh := make(chan error, 1)
-	go waitForState(errCh, "DONE", d.refreshZoneOp(zone.Name, op))
-	return errCh, nil
-}
-
-func (d *driverGCE) WaitForInstance(state, zone, name string) <-chan error {
-	errCh := make(chan error, 1)
-	go waitForState(errCh, state, d.refreshInstanceState(zone, name))
-	return errCh
-}
-
-func (d *driverGCE) getImage(name string) (image *compute.Image, err error) {
-	projects := []string{d.projectId, "debian-cloud", "centos-cloud"}
-	for _, project := range projects {
-		image, err = d.service.Images.Get(project, name).Do()
-		if err == nil && image != nil && image.SelfLink != "" {
-			return
-		}
-		image = nil
-	}
-
-	if err == nil {
-		err = fmt.Errorf("Image could not be found: %s", name)
-	}
-
-	return
-}
-
-func (d *driverGCE) refreshInstanceState(zone, name string) stateRefreshFunc {
-	return func() (string, error) {
-		instance, err := d.service.Instances.Get(d.projectId, zone, name).Do()
-		if err != nil {
-			return "", err
-		}
-		return instance.Status, nil
-	}
-}
-
-func (d *driverGCE) refreshGlobalOp(op *compute.Operation) stateRefreshFunc {
-	return func() (string, error) {
-		newOp, err := d.service.GlobalOperations.Get(d.projectId, op.Name).Do()
-		if err != nil {
-			return "", err
-		}
-
-		// If the op is done, check for errors
-		err = nil
-		if newOp.Status == "DONE" {
-			if newOp.Error != nil {
-				for _, e := range newOp.Error.Errors {
-					err = packer.MultiErrorAppend(err, fmt.Errorf(e.Message))
-				}
-			}
-		}
-
-		return newOp.Status, err
-	}
-}
-
-func (d *driverGCE) refreshZoneOp(zone string, op *compute.Operation) stateRefreshFunc {
-	return func() (string, error) {
-		newOp, err := d.service.ZoneOperations.Get(d.projectId, zone, op.Name).Do()
-		if err != nil {
-			return "", err
-		}
-
-		// If the op is done, check for errors
-		err = nil
-		if newOp.Status == "DONE" {
-			if newOp.Error != nil {
-				for _, e := range newOp.Error.Errors {
-					err = packer.MultiErrorAppend(err, fmt.Errorf(e.Message))
-				}
-			}
-		}
-
-		return newOp.Status, err
-	}
-}
-
-// stateRefreshFunc is used to refresh the state of a thing and is
-// used in conjunction with waitForState.
-type stateRefreshFunc func() (string, error)
-
-// waitForState will spin in a loop forever waiting for state to
-// reach a certain target.
-func waitForState(errCh chan<- error, target string, refresh stateRefreshFunc) {
-	for {
-		state, err := refresh()
-		if err != nil {
-			errCh <- err
-			return
-		}
-		if state == target {
-			errCh <- nil
-			return
-		}
-
-		time.Sleep(2 * time.Second)
-	}
-}

builder/googlecompute/driver_mock.go

@@ -1,108 +0,0 @@
-package googlecompute
-
-// DriverMock is a Driver implementation that is a mocked out so that
-// it can be used for tests.
-type DriverMock struct {
-	CreateImageName  string
-	CreateImageDesc  string
-	CreateImageURL   string
-	CreateImageErrCh <-chan error
-
-	DeleteImageName  string
-	DeleteImageErrCh <-chan error
-
-	DeleteInstanceZone  string
-	DeleteInstanceName  string
-	DeleteInstanceErrCh <-chan error
-	DeleteInstanceErr   error
-
-	GetNatIPZone   string
-	GetNatIPName   string
-	GetNatIPResult string
-	GetNatIPErr    error
-
-	RunInstanceConfig *InstanceConfig
-	RunInstanceErrCh  <-chan error
-	RunInstanceErr    error
-
-	WaitForInstanceState string
-	WaitForInstanceZone  string
-	WaitForInstanceName  string
-	WaitForInstanceErrCh <-chan error
-}
-
-func (d *DriverMock) CreateImage(name, description, url string) <-chan error {
-	d.CreateImageName = name
-	d.CreateImageDesc = description
-	d.CreateImageURL = url
-
-	resultCh := d.CreateImageErrCh
-	if resultCh == nil {
-		ch := make(chan error)
-		close(ch)
-		resultCh = ch
-	}
-
-	return resultCh
-}
-
-func (d *DriverMock) DeleteImage(name string) <-chan error {
-	d.DeleteImageName = name
-
-	resultCh := d.DeleteImageErrCh
-	if resultCh == nil {
-		ch := make(chan error)
-		close(ch)
-		resultCh = ch
-	}
-
-	return resultCh
-}
-
-func (d *DriverMock) DeleteInstance(zone, name string) (<-chan error, error) {
-	d.DeleteInstanceZone = zone
-	d.DeleteInstanceName = name
-
-	resultCh := d.DeleteInstanceErrCh
-	if resultCh == nil {
-		ch := make(chan error)
-		close(ch)
-		resultCh = ch
-	}
-
-	return resultCh, d.DeleteInstanceErr
-}
-
-func (d *DriverMock) GetNatIP(zone, name string) (string, error) {
-	d.GetNatIPZone = zone
-	d.GetNatIPName = name
-	return d.GetNatIPResult, d.GetNatIPErr
-}
-
-func (d *DriverMock) RunInstance(c *InstanceConfig) (<-chan error, error) {
-	d.RunInstanceConfig = c
-
-	resultCh := d.RunInstanceErrCh
-	if resultCh == nil {
-		ch := make(chan error)
-		close(ch)
-		resultCh = ch
-	}
-
-	return resultCh, d.RunInstanceErr
-}
-
-func (d *DriverMock) WaitForInstance(state, zone, name string) <-chan error {
-	d.WaitForInstanceState = state
-	d.WaitForInstanceZone = zone
-	d.WaitForInstanceName = name
-
-	resultCh := d.WaitForInstanceErrCh
-	if resultCh == nil {
-		ch := make(chan error)
-		close(ch)
-		resultCh = ch
-	}
-
-	return resultCh
-}

builder/googlecompute/private_key.go

@@ -1,43 +0,0 @@
-package googlecompute
-
-import (
-	"crypto/x509"
-	"encoding/pem"
-	"errors"
-	"fmt"
-	"io/ioutil"
-)
-
-// processPrivateKeyFile takes a private key file and an optional passphrase
-// and decodes it to a byte slice.
-func processPrivateKeyFile(privateKeyFile, passphrase string) ([]byte, error) {
-	rawPrivateKeyBytes, err := ioutil.ReadFile(privateKeyFile)
-	if err != nil {
-		return nil, fmt.Errorf("Failed loading private key file: %s", err)
-	}
-
-	PEMBlock, _ := pem.Decode(rawPrivateKeyBytes)
-	if PEMBlock == nil {
-		return nil, fmt.Errorf(
-			"%s does not contain a vaild private key", privateKeyFile)
-	}
-
-	if x509.IsEncryptedPEMBlock(PEMBlock) {
-		if passphrase == "" {
-			return nil, errors.New("a passphrase must be specified when using an encrypted private key")
-		}
-
-		decryptedPrivateKeyBytes, err := x509.DecryptPEMBlock(PEMBlock, []byte(passphrase))
-		if err != nil {
-			return nil, fmt.Errorf("Failed decrypting private key: %s", err)
-		}
-
-		b := &pem.Block{
-			Type:  "RSA PRIVATE KEY",
-			Bytes: decryptedPrivateKeyBytes,
-		}
-		return pem.EncodeToMemory(b), nil
-	}
-
-	return rawPrivateKeyBytes, nil
-}

builder/googlecompute/private_key_test.go

@@ -1,78 +0,0 @@
-package googlecompute
-
-import (
-	"crypto/rand"
-	"crypto/x509"
-	"encoding/pem"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-func testPrivateKeyFile(t *testing.T) string {
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-	defer tf.Close()
-
-	b := &pem.Block{
-		Type:  "RSA PRIVATE KEY",
-		Bytes: []byte("what"),
-	}
-
-	if err := pem.Encode(tf, b); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	return tf.Name()
-}
-
-func TestProcesssPrivateKeyFile(t *testing.T) {
-	path := testPrivateKeyFile(t)
-	defer os.Remove(path)
-
-	data, err := processPrivateKeyFile(path, "")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if len(data) <= 0 {
-		t.Fatalf("bad: %#v", data)
-	}
-}
-
-func TestProcessPrivateKeyFile_encrypted(t *testing.T) {
-	// Encrypt the file
-	b, err := x509.EncryptPEMBlock(rand.Reader,
-		"RSA PRIVATE KEY",
-		[]byte("what"),
-		[]byte("password"),
-		x509.PEMCipherAES128)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-	defer os.Remove(tf.Name())
-
-	err = pem.Encode(tf, b)
-	tf.Close()
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	path := tf.Name()
-
-	// Should have an error with a bad password
-	if _, err := processPrivateKeyFile(path, "bad"); err == nil {
-		t.Fatal("should error")
-	}
-
-	if _, err := processPrivateKeyFile(path, "password"); err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-}

builder/googlecompute/ssh.go

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

builder/googlecompute/step_create_image.go

@@ -1,52 +0,0 @@
-package googlecompute
-
-import (
-	"fmt"
-	"path/filepath"
-
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-// StepCreateImage represents a Packer build step that creates GCE machine
-// images.
-type StepCreateImage int
-
-// Run executes the Packer build step that creates a GCE machine image.
-//
-// Currently the only way to create a GCE image is to run the gcimagebundle
-// command on the running GCE instance.
-func (s *StepCreateImage) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	comm := state.Get("communicator").(packer.Communicator)
-	ui := state.Get("ui").(packer.Ui)
-
-	sudoPrefix := ""
-	if config.SSHUsername != "root" {
-		sudoPrefix = "sudo "
-	}
-
-	imageFilename := fmt.Sprintf("%s.tar.gz", config.ImageName)
-	imageBundleCmd := "/usr/bin/gcimagebundle -d /dev/sda -o /tmp/"
-
-	ui.Say("Creating image...")
-	cmd := new(packer.RemoteCmd)
-	cmd.Command = fmt.Sprintf("%s%s --output_file_name %s",
-		sudoPrefix, imageBundleCmd, imageFilename)
-	err := cmd.StartWithUi(comm, ui)
-	if err == nil && cmd.ExitStatus != 0 {
-		err = fmt.Errorf(
-			"gcimagebundle exited with non-zero exit status: %d", cmd.ExitStatus)
-	}
-	if err != nil {
-		err := fmt.Errorf("Error creating image: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state.Put("image_file_name", filepath.Join("/tmp", imageFilename))
-	return multistep.ActionContinue
-}
-
-func (s *StepCreateImage) Cleanup(state multistep.StateBag) {}

builder/googlecompute/step_create_image_test.go

@@ -1,96 +0,0 @@
-package googlecompute
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-func TestStepCreateImage_impl(t *testing.T) {
-	var _ multistep.Step = new(StepCreateImage)
-}
-
-func TestStepCreateImage(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateImage)
-	defer step.Cleanup(state)
-
-	comm := new(packer.MockCommunicator)
-	state.Put("communicator", comm)
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify
-	if !comm.StartCalled {
-		t.Fatal("start should be called")
-	}
-	if strings.HasPrefix(comm.StartCmd.Command, "sudo") {
-		t.Fatal("should not sudo")
-	}
-	if !strings.Contains(comm.StartCmd.Command, "gcimagebundle") {
-		t.Fatalf("bad command: %#v", comm.StartCmd.Command)
-	}
-
-	if _, ok := state.GetOk("image_file_name"); !ok {
-		t.Fatal("should have image")
-	}
-}
-
-func TestStepCreateImage_badExitStatus(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateImage)
-	defer step.Cleanup(state)
-
-	comm := new(packer.MockCommunicator)
-	comm.StartExitStatus = 12
-	state.Put("communicator", comm)
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("image_file_name"); ok {
-		t.Fatal("should NOT have image")
-	}
-}
-
-func TestStepCreateImage_nonRoot(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateImage)
-	defer step.Cleanup(state)
-
-	comm := new(packer.MockCommunicator)
-	state.Put("communicator", comm)
-
-	config := state.Get("config").(*Config)
-	config.SSHUsername = "bob"
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify
-	if !comm.StartCalled {
-		t.Fatal("start should be called")
-	}
-	if !strings.HasPrefix(comm.StartCmd.Command, "sudo") {
-		t.Fatal("should sudo")
-	}
-	if !strings.Contains(comm.StartCmd.Command, "gcimagebundle") {
-		t.Fatalf("bad command: %#v", comm.StartCmd.Command)
-	}
-
-	if _, ok := state.GetOk("image_file_name"); !ok {
-		t.Fatal("should have image")
-	}
-}

builder/googlecompute/step_create_instance.go

@@ -1,95 +0,0 @@
-package googlecompute
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common/uuid"
-	"github.com/mitchellh/packer/packer"
-)
-
-// StepCreateInstance represents a Packer build step that creates GCE instances.
-type StepCreateInstance struct {
-	instanceName string
-}
-
-// Run executes the Packer build step that creates a GCE instance.
-func (s *StepCreateInstance) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(Driver)
-	sshPublicKey := state.Get("ssh_public_key").(string)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Creating instance...")
-	name := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID())
-
-	errCh, err := driver.RunInstance(&InstanceConfig{
-		Description: "New instance created by Packer",
-		Image:       config.SourceImage,
-		MachineType: config.MachineType,
-		Metadata: map[string]string{
-			"sshKeys": fmt.Sprintf("%s:%s", config.SSHUsername, sshPublicKey),
-		},
-		Name:    name,
-		Network: config.Network,
-		Tags:    config.Tags,
-		Zone:    config.Zone,
-	})
-
-	if err == nil {
-		ui.Message("Waiting for creation operation to complete...")
-		select {
-		case err = <-errCh:
-		case <-time.After(config.stateTimeout):
-			err = errors.New("time out while waiting for instance to create")
-		}
-	}
-
-	if err != nil {
-		err := fmt.Errorf("Error creating instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Message("Instance has been created!")
-
-	// Things succeeded, store the name so we can remove it later
-	state.Put("instance_name", name)
-	s.instanceName = name
-
-	return multistep.ActionContinue
-}
-
-// Cleanup destroys the GCE instance created during the image creation process.
-func (s *StepCreateInstance) Cleanup(state multistep.StateBag) {
-	if s.instanceName == "" {
-		return
-	}
-
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Deleting instance...")
-	errCh, err := driver.DeleteInstance(config.Zone, s.instanceName)
-	if err == nil {
-		select {
-		case err = <-errCh:
-		case <-time.After(config.stateTimeout):
-			err = errors.New("time out while waiting for instance to delete")
-		}
-	}
-
-	if err != nil {
-		ui.Error(fmt.Sprintf(
-			"Error deleting instance. Please delete it manually.\n\n"+
-				"Name: %s\n"+
-				"Error: %s", s.instanceName, err))
-	}
-
-	s.instanceName = ""
-	return
-}

builder/googlecompute/step_create_instance_test.go

@@ -1,128 +0,0 @@
-package googlecompute
-
-import (
-	"errors"
-	"github.com/mitchellh/multistep"
-	"testing"
-	"time"
-)
-
-func TestStepCreateInstance_impl(t *testing.T) {
-	var _ multistep.Step = new(StepCreateInstance)
-}
-
-func TestStepCreateInstance(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateInstance)
-	defer step.Cleanup(state)
-
-	state.Put("ssh_public_key", "key")
-
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(*DriverMock)
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	nameRaw, ok := state.GetOk("instance_name")
-	if !ok {
-		t.Fatal("should have instance name")
-	}
-
-	// cleanup
-	step.Cleanup(state)
-
-	if driver.DeleteInstanceName != nameRaw.(string) {
-		t.Fatal("should've deleted instance")
-	}
-	if driver.DeleteInstanceZone != config.Zone {
-		t.Fatal("bad zone: %#v", driver.DeleteInstanceZone)
-	}
-}
-
-func TestStepCreateInstance_error(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateInstance)
-	defer step.Cleanup(state)
-
-	state.Put("ssh_public_key", "key")
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.RunInstanceErr = errors.New("error")
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("instance_name"); ok {
-		t.Fatal("should NOT have instance name")
-	}
-}
-
-func TestStepCreateInstance_errorOnChannel(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateInstance)
-	defer step.Cleanup(state)
-
-	errCh := make(chan error, 1)
-	errCh <- errors.New("error")
-
-	state.Put("ssh_public_key", "key")
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.RunInstanceErrCh = errCh
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("instance_name"); ok {
-		t.Fatal("should NOT have instance name")
-	}
-}
-
-func TestStepCreateInstance_errorTimeout(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateInstance)
-	defer step.Cleanup(state)
-
-	errCh := make(chan error, 1)
-	go func() {
-		<-time.After(10 * time.Millisecond)
-		errCh <- nil
-	}()
-
-	state.Put("ssh_public_key", "key")
-
-	config := state.Get("config").(*Config)
-	config.stateTimeout = 1 * time.Microsecond
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.RunInstanceErrCh = errCh
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("instance_name"); ok {
-		t.Fatal("should NOT have instance name")
-	}
-}

builder/googlecompute/step_create_ssh_key.go

@@ -1,51 +0,0 @@
-package googlecompute
-
-import (
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"fmt"
-
-	"code.google.com/p/go.crypto/ssh"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-// StepCreateSSHKey represents a Packer build step that generates SSH key pairs.
-type StepCreateSSHKey int
-
-// Run executes the Packer build step that generates SSH key pairs.
-func (s *StepCreateSSHKey) Run(state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Creating temporary SSH key for instance...")
-	priv, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		err := fmt.Errorf("Error creating temporary ssh key: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	priv_blk := pem.Block{
-		Type:    "RSA PRIVATE KEY",
-		Headers: nil,
-		Bytes:   x509.MarshalPKCS1PrivateKey(priv),
-	}
-
-	pub, err := ssh.NewPublicKey(&priv.PublicKey)
-	if err != nil {
-		err := fmt.Errorf("Error creating temporary ssh key: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state.Put("ssh_private_key", string(pem.EncodeToMemory(&priv_blk)))
-	state.Put("ssh_public_key", string(ssh.MarshalAuthorizedKey(pub)))
-	return multistep.ActionContinue
-}
-
-// Nothing to clean up. SSH keys are associated with a single GCE instance.
-func (s *StepCreateSSHKey) Cleanup(state multistep.StateBag) {}

builder/googlecompute/step_create_ssh_key_test.go

@@ -1,29 +0,0 @@
-package googlecompute
-
-import (
-	"github.com/mitchellh/multistep"
-	"testing"
-)
-
-func TestStepCreateSSHKey_impl(t *testing.T) {
-	var _ multistep.Step = new(StepCreateSSHKey)
-}
-
-func TestStepCreateSSHKey(t *testing.T) {
-	state := testState(t)
-	step := new(StepCreateSSHKey)
-	defer step.Cleanup(state)
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify that we have a public/private key
-	if _, ok := state.GetOk("ssh_private_key"); !ok {
-		t.Fatal("should have key")
-	}
-	if _, ok := state.GetOk("ssh_public_key"); !ok {
-		t.Fatal("should have key")
-	}
-}

builder/googlecompute/step_instance_info.go

@@ -1,53 +0,0 @@
-package googlecompute
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-// stepInstanceInfo represents a Packer build step that gathers GCE instance info.
-type StepInstanceInfo int
-
-// Run executes the Packer build step that gathers GCE instance info.
-func (s *StepInstanceInfo) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	instanceName := state.Get("instance_name").(string)
-
-	ui.Say("Waiting for the instance to become running...")
-	errCh := driver.WaitForInstance("RUNNING", config.Zone, instanceName)
-	var err error
-	select {
-	case err = <-errCh:
-	case <-time.After(config.stateTimeout):
-		err = errors.New("time out while waiting for instance to become running")
-	}
-
-	if err != nil {
-		err := fmt.Errorf("Error waiting for instance: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ip, err := driver.GetNatIP(config.Zone, instanceName)
-	if err != nil {
-		err := fmt.Errorf("Error retrieving instance nat ip address: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Message(fmt.Sprintf("IP: %s", ip))
-	state.Put("instance_ip", ip)
-	return multistep.ActionContinue
-}
-
-// Cleanup.
-func (s *StepInstanceInfo) Cleanup(state multistep.StateBag) {}

builder/googlecompute/step_instance_info_test.go

@@ -1,134 +0,0 @@
-package googlecompute
-
-import (
-	"errors"
-	"github.com/mitchellh/multistep"
-	"testing"
-	"time"
-)
-
-func TestStepInstanceInfo_impl(t *testing.T) {
-	var _ multistep.Step = new(StepInstanceInfo)
-}
-
-func TestStepInstanceInfo(t *testing.T) {
-	state := testState(t)
-	step := new(StepInstanceInfo)
-	defer step.Cleanup(state)
-
-	state.Put("instance_name", "foo")
-
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(*DriverMock)
-	driver.GetNatIPResult = "1.2.3.4"
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if driver.WaitForInstanceState != "RUNNING" {
-		t.Fatalf("bad: %#v", driver.WaitForInstanceState)
-	}
-	if driver.WaitForInstanceZone != config.Zone {
-		t.Fatalf("bad: %#v", driver.WaitForInstanceZone)
-	}
-	if driver.WaitForInstanceName != "foo" {
-		t.Fatalf("bad: %#v", driver.WaitForInstanceName)
-	}
-
-	ipRaw, ok := state.GetOk("instance_ip")
-	if !ok {
-		t.Fatal("should have ip")
-	}
-	if ip, ok := ipRaw.(string); !ok {
-		t.Fatal("ip is not a string")
-	} else if ip != "1.2.3.4" {
-		t.Fatalf("bad ip: %s", ip)
-	}
-}
-
-func TestStepInstanceInfo_getNatIPError(t *testing.T) {
-	state := testState(t)
-	step := new(StepInstanceInfo)
-	defer step.Cleanup(state)
-
-	state.Put("instance_name", "foo")
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.GetNatIPErr = errors.New("error")
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("instance_ip"); ok {
-		t.Fatal("should NOT have instance IP")
-	}
-}
-
-func TestStepInstanceInfo_waitError(t *testing.T) {
-	state := testState(t)
-	step := new(StepInstanceInfo)
-	defer step.Cleanup(state)
-
-	state.Put("instance_name", "foo")
-
-	errCh := make(chan error, 1)
-	errCh <- errors.New("error")
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.WaitForInstanceErrCh = errCh
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("instance_ip"); ok {
-		t.Fatal("should NOT have instance IP")
-	}
-}
-
-func TestStepInstanceInfo_errorTimeout(t *testing.T) {
-	state := testState(t)
-	step := new(StepInstanceInfo)
-	defer step.Cleanup(state)
-
-	errCh := make(chan error, 1)
-	go func() {
-		<-time.After(10 * time.Millisecond)
-		errCh <- nil
-	}()
-
-	state.Put("instance_name", "foo")
-
-	config := state.Get("config").(*Config)
-	config.stateTimeout = 1 * time.Microsecond
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.WaitForInstanceErrCh = errCh
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("instance_ip"); ok {
-		t.Fatal("should NOT have instance IP")
-	}
-}

builder/googlecompute/step_register_image.go

@@ -1,46 +0,0 @@
-package googlecompute
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
-)
-
-// StepRegisterImage represents a Packer build step that registers GCE machine images.
-type StepRegisterImage int
-
-// Run executes the Packer build step that registers a GCE machine image.
-func (s *StepRegisterImage) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(Driver)
-	ui := state.Get("ui").(packer.Ui)
-
-	var err error
-	imageURL := fmt.Sprintf(
-		"https://storage.cloud.google.com/%s/%s.tar.gz",
-		config.BucketName, config.ImageName)
-
-	ui.Say("Registering image...")
-	errCh := driver.CreateImage(config.ImageName, config.ImageDescription, imageURL)
-	select {
-	case err = <-errCh:
-	case <-time.After(config.stateTimeout):
-		err = errors.New("time out while waiting for image to register")
-	}
-
-	if err != nil {
-		err := fmt.Errorf("Error waiting for image: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state.Put("image_name", config.ImageName)
-	return multistep.ActionContinue
-}
-
-// Cleanup.
-func (s *StepRegisterImage) Cleanup(state multistep.StateBag) {}

builder/googlecompute/step_register_image_test.go

@@ -1,100 +0,0 @@
-package googlecompute
-
-import (
-	"errors"
-	"github.com/mitchellh/multistep"
-	"testing"
-	"time"
-)
-
-func TestStepRegisterImage_impl(t *testing.T) {
-	var _ multistep.Step = new(StepRegisterImage)
-}
-
-func TestStepRegisterImage(t *testing.T) {
-	state := testState(t)
-	step := new(StepRegisterImage)
-	defer step.Cleanup(state)
-
-	config := state.Get("config").(*Config)
-	driver := state.Get("driver").(*DriverMock)
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionContinue {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if driver.CreateImageName != config.ImageName {
-		t.Fatalf("bad: %#v", driver.CreateImageName)
-	}
-	if driver.CreateImageDesc != config.ImageDescription {
-		t.Fatalf("bad: %#v", driver.CreateImageDesc)
-	}
-
-	nameRaw, ok := state.GetOk("image_name")
-	if !ok {
-		t.Fatal("should have name")
-	}
-	if name, ok := nameRaw.(string); !ok {
-		t.Fatal("name is not a string")
-	} else if name != config.ImageName {
-		t.Fatalf("bad name: %s", name)
-	}
-}
-
-func TestStepRegisterImage_waitError(t *testing.T) {
-	state := testState(t)
-	step := new(StepRegisterImage)
-	defer step.Cleanup(state)
-
-	errCh := make(chan error, 1)
-	errCh <- errors.New("error")
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.CreateImageErrCh = errCh
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("image_name"); ok {
-		t.Fatal("should NOT have image_name")
-	}
-}
-
-func TestStepRegisterImage_errorTimeout(t *testing.T) {
-	state := testState(t)
-	step := new(StepRegisterImage)
-	defer step.Cleanup(state)
-
-	errCh := make(chan error, 1)
-	go func() {
-		<-time.After(10 * time.Millisecond)
-		errCh <- nil
-	}()
-
-	config := state.Get("config").(*Config)
-	config.stateTimeout = 1 * time.Microsecond
-
-	driver := state.Get("driver").(*DriverMock)
-	driver.CreateImageErrCh = errCh
-
-	// run the step
-	if action := step.Run(state); action != multistep.ActionHalt {
-		t.Fatalf("bad action: %#v", action)
-	}
-
-	// Verify state
-	if _, ok := state.GetOk("error"); !ok {
-		t.Fatal("should have error")
-	}
-	if _, ok := state.GetOk("image_name"); ok {
-		t.Fatal("should NOT have image name")
-	}
-}

builder/googlecompute/step_test.go

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