builder/amazon/chroot: new multistep API

builder/amazon/chroot/builder.go

@@ -167,11 +167,11 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	ec2conn := ec2.New(auth, region)
 
 	// Setup the state bag and initial state for the steps
-	state := make(map[string]interface{})
-	state["config"] = &b.config
-	state["ec2"] = ec2conn
-	state["hook"] = hook
-	state["ui"] = ui
+	state := new(multistep.BasicStateBag)
+	state.Put("config", &b.config)
+	state.Put("ec2", ec2conn)
+	state.Put("hook", hook)
+	state.Put("ui", ui)
 
 	// Build the steps
 	steps := []multistep.Step{
@@ -216,18 +216,18 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	b.runner.Run(state)
 
 	// If there was an error, return that
-	if rawErr, ok := state["error"]; ok {
+	if rawErr, ok := state.GetOk("error"); ok {
 		return nil, rawErr.(error)
 	}
 
 	// If there are no AMIs, then just return
-	if _, ok := state["amis"]; !ok {
+	if _, ok := state.GetOk("amis"); !ok {
 		return nil, nil
 	}
 
 	// Build the artifact and return it
 	artifact := &awscommon.Artifact{
-		Amis:           state["amis"].(map[string]string),
+		Amis:           state.Get("amis").(map[string]string),
 		BuilderIdValue: BuilderId,
 		Conn:           ec2conn,
 	}

builder/amazon/chroot/cleanup.go

 package chroot
 
+import (
+	"github.com/mitchellh/multistep"
+)
+
 // Cleanup is an interface that some steps implement for early cleanup.
 type Cleanup interface {
-	CleanupFunc(map[string]interface{}) error
+	CleanupFunc(multistep.StateBag) error
 }

builder/amazon/chroot/step_attach_volume.go

@@ -21,12 +21,12 @@ type StepAttachVolume struct {
 	volumeId string
 }
 
-func (s *StepAttachVolume) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	device := state["device"].(string)
-	instance := state["instance"].(*ec2.Instance)
-	ui := state["ui"].(packer.Ui)
-	volumeId := state["volume_id"].(string)
+func (s *StepAttachVolume) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	device := state.Get("device").(string)
+	instance := state.Get("instance").(*ec2.Instance)
+	ui := state.Get("ui").(packer.Ui)
+	volumeId := state.Get("volume_id").(string)
 
 	// For the API call, it expects "sd" prefixed devices.
 	attachVolume := strings.Replace(device, "/xvd", "/sd", 1)
@@ -35,7 +35,7 @@ func (s *StepAttachVolume) Run(state map[string]interface{}) multistep.StepActio
 	_, err := ec2conn.AttachVolume(volumeId, instance.InstanceId, attachVolume)
 	if err != nil {
 		err := fmt.Errorf("Error attaching volume: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -67,29 +67,29 @@ func (s *StepAttachVolume) Run(state map[string]interface{}) multistep.StepActio
 	_, err = awscommon.WaitForState(&stateChange)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for volume: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	state["attach_cleanup"] = s
+	state.Put("attach_cleanup", s)
 	return multistep.ActionContinue
 }
 
-func (s *StepAttachVolume) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
+func (s *StepAttachVolume) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
 	if err := s.CleanupFunc(state); err != nil {
 		ui.Error(err.Error())
 	}
 }
 
-func (s *StepAttachVolume) CleanupFunc(state map[string]interface{}) error {
+func (s *StepAttachVolume) CleanupFunc(state multistep.StateBag) error {
 	if !s.attached {
 		return nil
 	}
 
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Detaching EBS volume...")
 	_, err := ec2conn.DetachVolume(s.volumeId)

builder/amazon/chroot/step_chroot_provision.go

@@ -11,10 +11,10 @@ type StepChrootProvision struct {
 	mounts []string
 }
 
-func (s *StepChrootProvision) Run(state map[string]interface{}) multistep.StepAction {
-	hook := state["hook"].(packer.Hook)
-	mountPath := state["mount_path"].(string)
-	ui := state["ui"].(packer.Ui)
+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)
 
 	// Create our communicator
 	comm := &Communicator{
@@ -24,11 +24,11 @@ func (s *StepChrootProvision) Run(state map[string]interface{}) multistep.StepAc
 	// Provision
 	log.Println("Running the provision hook")
 	if err := hook.Run(packer.HookProvision, ui, comm, nil); err != nil {
-		state["error"] = err
+		state.Put("error", err)
 		return multistep.ActionHalt
 	}
 
 	return multistep.ActionContinue
 }
 
-func (s *StepChrootProvision) Cleanup(state map[string]interface{}) {}
+func (s *StepChrootProvision) Cleanup(state multistep.StateBag) {}

builder/amazon/chroot/step_copy_files.go

@@ -19,10 +19,10 @@ type StepCopyFiles struct {
 	files []string
 }
 
-func (s *StepCopyFiles) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	mountPath := state["mount_path"].(string)
-	ui := state["ui"].(packer.Ui)
+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)
 
 	s.files = make([]string, 0, len(config.CopyFiles))
 	if len(config.CopyFiles) > 0 {
@@ -34,7 +34,7 @@ func (s *StepCopyFiles) Run(state map[string]interface{}) multistep.StepAction {
 
 			if err := s.copySingle(chrootPath, path); err != nil {
 				err := fmt.Errorf("Error copying file: %s", err)
-				state["error"] = err
+				state.Put("error", err)
 				ui.Error(err.Error())
 				return multistep.ActionHalt
 			}
@@ -43,18 +43,18 @@ func (s *StepCopyFiles) Run(state map[string]interface{}) multistep.StepAction {
 		}
 	}
 
-	state["copy_files_cleanup"] = s
+	state.Put("copy_files_cleanup", s)
 	return multistep.ActionContinue
 }
 
-func (s *StepCopyFiles) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
+func (s *StepCopyFiles) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
 	if err := s.CleanupFunc(state); err != nil {
 		ui.Error(err.Error())
 	}
 }
 
-func (s *StepCopyFiles) CleanupFunc(map[string]interface{}) error {
+func (s *StepCopyFiles) CleanupFunc(multistep.StateBag) error {
 	if s.files != nil {
 		for _, file := range s.files {
 			log.Printf("Removing: %s", file)

builder/amazon/chroot/step_create_volume.go

@@ -18,11 +18,11 @@ type StepCreateVolume struct {
 	volumeId string
 }
 
-func (s *StepCreateVolume) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	image := state["source_image"].(*ec2.Image)
-	instance := state["instance"].(*ec2.Instance)
-	ui := state["ui"].(packer.Ui)
+func (s *StepCreateVolume) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	image := state.Get("source_image").(*ec2.Image)
+	instance := state.Get("instance").(*ec2.Instance)
+	ui := state.Get("ui").(packer.Ui)
 
 	// Determine the root device snapshot
 	log.Printf("Searching for root device of the image (%s)", image.RootDeviceName)
@@ -36,7 +36,7 @@ func (s *StepCreateVolume) Run(state map[string]interface{}) multistep.StepActio
 
 	if rootDevice == nil {
 		err := fmt.Errorf("Couldn't find root device!")
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -54,7 +54,7 @@ func (s *StepCreateVolume) Run(state map[string]interface{}) multistep.StepActio
 	createVolumeResp, err := ec2conn.CreateVolume(createVolume)
 	if err != nil {
 		err := fmt.Errorf("Error creating root volume: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -82,22 +82,22 @@ func (s *StepCreateVolume) Run(state map[string]interface{}) multistep.StepActio
 	_, err = awscommon.WaitForState(&stateChange)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for volume: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	state["volume_id"] = s.volumeId
+	state.Put("volume_id", s.volumeId)
 	return multistep.ActionContinue
 }
 
-func (s *StepCreateVolume) Cleanup(state map[string]interface{}) {
+func (s *StepCreateVolume) Cleanup(state multistep.StateBag) {
 	if s.volumeId == "" {
 		return
 	}
 
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Deleting the created EBS volume...")
 	_, err := ec2conn.DeleteVolume(s.volumeId)

builder/amazon/chroot/step_early_cleanup.go

@@ -11,8 +11,8 @@ import (
 // prepare for snapshotting and creating an AMI.
 type StepEarlyCleanup struct{}
 
-func (s *StepEarlyCleanup) Run(state map[string]interface{}) multistep.StepAction {
-	ui := state["ui"].(packer.Ui)
+func (s *StepEarlyCleanup) Run(state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
 	cleanupKeys := []string{
 		"copy_files_cleanup",
 		"mount_extra_cleanup",
@@ -21,11 +21,11 @@ func (s *StepEarlyCleanup) Run(state map[string]interface{}) multistep.StepActio
 	}
 
 	for _, key := range cleanupKeys {
-		c := state[key].(Cleanup)
+		c := state.Get(key).(Cleanup)
 		log.Printf("Running cleanup func: %s", key)
 		if err := c.CleanupFunc(state); err != nil {
 			err := fmt.Errorf("Error cleaning up: %s", err)
-			state["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -34,4 +34,4 @@ func (s *StepEarlyCleanup) Run(state map[string]interface{}) multistep.StepActio
 	return multistep.ActionContinue
 }
 
-func (s *StepEarlyCleanup) Cleanup(state map[string]interface{}) {}
+func (s *StepEarlyCleanup) Cleanup(state multistep.StateBag) {}

builder/amazon/chroot/step_early_unflock.go

@@ -10,14 +10,14 @@ import (
 // StepEarlyUnflock unlocks the flock.
 type StepEarlyUnflock struct{}
 
-func (s *StepEarlyUnflock) Run(state map[string]interface{}) multistep.StepAction {
-	cleanup := state["flock_cleanup"].(Cleanup)
-	ui := state["ui"].(packer.Ui)
+func (s *StepEarlyUnflock) Run(state multistep.StateBag) multistep.StepAction {
+	cleanup := state.Get("flock_cleanup").(Cleanup)
+	ui := state.Get("ui").(packer.Ui)
 
 	log.Println("Unlocking file lock...")
 	if err := cleanup.CleanupFunc(state); err != nil {
 		err := fmt.Errorf("Error unlocking file lock: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -25,4 +25,4 @@ func (s *StepEarlyUnflock) Run(state map[string]interface{}) multistep.StepActio
 	return multistep.ActionContinue
 }
 
-func (s *StepEarlyUnflock) Cleanup(state map[string]interface{}) {}
+func (s *StepEarlyUnflock) Cleanup(state multistep.StateBag) {}

builder/amazon/chroot/step_flock.go

@@ -17,13 +17,13 @@ type StepFlock struct {
 	fh *os.File
 }
 
-func (s *StepFlock) Run(state map[string]interface{}) multistep.StepAction {
-	ui := state["ui"].(packer.Ui)
+func (s *StepFlock) Run(state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
 
 	lockfile := "/var/lock/packer-chroot/lock"
 	if err := os.MkdirAll(filepath.Dir(lockfile), 0755); err != nil {
 		err := fmt.Errorf("Error creating lock: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -32,7 +32,7 @@ func (s *StepFlock) Run(state map[string]interface{}) multistep.StepAction {
 	f, err := os.Create(lockfile)
 	if err != nil {
 		err := fmt.Errorf("Error creating lock: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -40,7 +40,7 @@ func (s *StepFlock) Run(state map[string]interface{}) multistep.StepAction {
 	// LOCK!
 	if err := lockFile(f); err != nil {
 		err := fmt.Errorf("Error creating lock: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -49,15 +49,15 @@ func (s *StepFlock) Run(state map[string]interface{}) multistep.StepAction {
 	// the lock.
 	s.fh = f
 
-	state["flock_cleanup"] = s
+	state.Put("flock_cleanup", s)
 	return multistep.ActionContinue
 }
 
-func (s *StepFlock) Cleanup(state map[string]interface{}) {
+func (s *StepFlock) Cleanup(state multistep.StateBag) {
 	s.CleanupFunc(state)
 }
 
-func (s *StepFlock) CleanupFunc(state map[string]interface{}) error {
+func (s *StepFlock) CleanupFunc(state multistep.StateBag) error {
 	if s.fh == nil {
 		return nil
 	}

builder/amazon/chroot/step_instance_info.go

@@ -12,9 +12,9 @@ import (
 // StepInstanceInfo verifies that this builder is running on an EC2 instance.
 type StepInstanceInfo struct{}
 
-func (s *StepInstanceInfo) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+func (s *StepInstanceInfo) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	// Get our own instance ID
 	ui.Say("Gathering information about this EC2 instance...")
@@ -24,7 +24,7 @@ func (s *StepInstanceInfo) Run(state map[string]interface{}) multistep.StepActio
 		err := fmt.Errorf(
 			"Error retrieving the ID of the instance Packer is running on.\n" +
 				"Please verify Packer is running on a proper AWS EC2 instance.")
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -36,22 +36,22 @@ func (s *StepInstanceInfo) Run(state map[string]interface{}) multistep.StepActio
 	instancesResp, err := ec2conn.Instances([]string{instanceId}, ec2.NewFilter())
 	if err != nil {
 		err := fmt.Errorf("Error getting instance data: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	if len(instancesResp.Reservations) == 0 {
 		err := fmt.Errorf("Error getting instance data: no instance found.")
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	instance := &instancesResp.Reservations[0].Instances[0]
-	state["instance"] = instance
+	state.Put("instance", instance)
 
 	return multistep.ActionContinue
 }
 
-func (s *StepInstanceInfo) Cleanup(map[string]interface{}) {}
+func (s *StepInstanceInfo) Cleanup(multistep.StateBag) {}

builder/amazon/chroot/step_mount_device.go

@@ -24,10 +24,10 @@ type StepMountDevice struct {
 	mountPath string
 }
 
-func (s *StepMountDevice) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ui := state["ui"].(packer.Ui)
-	device := state["device"].(string)
+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)
 
 	mountPath, err := config.tpl.Process(config.MountPath, &mountPathData{
 		Device: filepath.Base(device),
@@ -35,7 +35,7 @@ func (s *StepMountDevice) Run(state map[string]interface{}) multistep.StepAction
 
 	if err != nil {
 		err := fmt.Errorf("Error preparing mount directory: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -43,7 +43,7 @@ func (s *StepMountDevice) Run(state map[string]interface{}) multistep.StepAction
 	mountPath, err = filepath.Abs(mountPath)
 	if err != nil {
 		err := fmt.Errorf("Error preparing mount directory: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -52,7 +52,7 @@ func (s *StepMountDevice) Run(state map[string]interface{}) multistep.StepAction
 
 	if err := os.MkdirAll(mountPath, 0755); err != nil {
 		err := fmt.Errorf("Error creating mount directory: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -65,33 +65,33 @@ func (s *StepMountDevice) Run(state map[string]interface{}) multistep.StepAction
 	if err := cmd.Run(); err != nil {
 		err := fmt.Errorf(
 			"Error mounting root volume: %s\nStderr: %s", err, stderr.String())
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	// Set the mount path so we remember to unmount it later
 	s.mountPath = mountPath
-	state["mount_path"] = s.mountPath
-	state["mount_device_cleanup"] = s
+	state.Put("mount_path", s.mountPath)
+	state.Put("mount_device_cleanup", s)
 
 	return multistep.ActionContinue
 }
 
-func (s *StepMountDevice) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
+func (s *StepMountDevice) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
 	if err := s.CleanupFunc(state); err != nil {
 		ui.Error(err.Error())
 	}
 }
 
-func (s *StepMountDevice) CleanupFunc(state map[string]interface{}) error {
+func (s *StepMountDevice) CleanupFunc(state multistep.StateBag) error {
 	if s.mountPath == "" {
 		return nil
 	}
 
-	config := state["config"].(*Config)
-	ui := state["ui"].(packer.Ui)
+	config := state.Get("config").(*Config)
+	ui := state.Get("ui").(packer.Ui)
 	ui.Say("Unmounting the root device...")
 
 	unmountCommand := fmt.Sprintf("%s %s", config.UnmountCommand, s.mountPath)

builder/amazon/chroot/step_mount_extra.go

@@ -17,10 +17,10 @@ type StepMountExtra struct {
 	mounts []string
 }
 
-func (s *StepMountExtra) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	mountPath := state["mount_path"].(string)
-	ui := state["ui"].(packer.Ui)
+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)
 
 	s.mounts = make([]string, 0, len(config.ChrootMounts))
 
@@ -30,7 +30,7 @@ func (s *StepMountExtra) Run(state map[string]interface{}) multistep.StepAction
 
 		if err := os.MkdirAll(innerPath, 0755); err != nil {
 			err := fmt.Errorf("Error creating mount directory: %s", err)
-			state["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -53,7 +53,7 @@ func (s *StepMountExtra) Run(state map[string]interface{}) multistep.StepAction
 		if err := cmd.Run(); err != nil {
 			err := fmt.Errorf(
 				"Error mounting: %s\nStderr: %s", err, stderr.String())
-			state["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -61,12 +61,12 @@ func (s *StepMountExtra) Run(state map[string]interface{}) multistep.StepAction
 		s.mounts = append(s.mounts, innerPath)
 	}
 
-	state["mount_extra_cleanup"] = s
+	state.Put("mount_extra_cleanup", s)
 	return multistep.ActionContinue
 }
 
-func (s *StepMountExtra) Cleanup(state map[string]interface{}) {
-	ui := state["ui"].(packer.Ui)
+func (s *StepMountExtra) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
 
 	if err := s.CleanupFunc(state); err != nil {
 		ui.Error(err.Error())
@@ -74,12 +74,12 @@ func (s *StepMountExtra) Cleanup(state map[string]interface{}) {
 	}
 }
 
-func (s *StepMountExtra) CleanupFunc(state map[string]interface{}) error {
+func (s *StepMountExtra) CleanupFunc(state multistep.StateBag) error {
 	if s.mounts == nil {
 		return nil
 	}
 
-	config := state["config"].(*Config)
+	config := state.Get("config").(*Config)
 	for len(s.mounts) > 0 {
 		var path string
 		lastIndex := len(s.mounts) - 1

builder/amazon/chroot/step_prepare_device.go

@@ -13,9 +13,9 @@ type StepPrepareDevice struct {
 	mounts []string
 }
 
-func (s *StepPrepareDevice) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ui := state["ui"].(packer.Ui)
+func (s *StepPrepareDevice) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(*Config)
+	ui := state.Get("ui").(packer.Ui)
 
 	device := config.DevicePath
 	if device == "" {
@@ -24,7 +24,7 @@ func (s *StepPrepareDevice) Run(state map[string]interface{}) multistep.StepActi
 		device, err = AvailableDevice()
 		if err != nil {
 			err := fmt.Errorf("Error finding available device: %s", err)
-			state["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -32,14 +32,14 @@ func (s *StepPrepareDevice) Run(state map[string]interface{}) multistep.StepActi
 
 	if _, err := os.Stat(device); err == nil {
 		err := fmt.Errorf("Device is in use: %s", device)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	log.Printf("Device: %s", device)
-	state["device"] = device
+	state.Put("device", device)
 	return multistep.ActionContinue
 }
 
-func (s *StepPrepareDevice) Cleanup(state map[string]interface{}) {}
+func (s *StepPrepareDevice) Cleanup(state multistep.StateBag) {}

builder/amazon/chroot/step_register_ami.go

@@ -11,12 +11,12 @@ import (
 // StepRegisterAMI creates the AMI.
 type StepRegisterAMI struct{}
 
-func (s *StepRegisterAMI) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ec2conn := state["ec2"].(*ec2.EC2)
-	image := state["source_image"].(*ec2.Image)
-	snapshotId := state["snapshot_id"].(string)
-	ui := state["ui"].(packer.Ui)
+func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(*Config)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	image := state.Get("source_image").(*ec2.Image)
+	snapshotId := state.Get("snapshot_id").(string)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Registering the AMI...")
 	blockDevices := make([]ec2.BlockDeviceMapping, len(image.BlockDevices))
@@ -40,8 +40,8 @@ func (s *StepRegisterAMI) Run(state map[string]interface{}) multistep.StepAction
 
 	registerResp, err := ec2conn.RegisterImage(registerOpts)
 	if err != nil {
-		state["error"] = fmt.Errorf("Error registering AMI: %s", err)
-		ui.Error(state["error"].(error).Error())
+		state.Put("error", fmt.Errorf("Error registering AMI: %s", err))
+		ui.Error(state.Get("error").(error).Error())
 		return multistep.ActionHalt
 	}
 
@@ -49,13 +49,13 @@ func (s *StepRegisterAMI) Run(state map[string]interface{}) multistep.StepAction
 	ui.Say(fmt.Sprintf("AMI: %s", registerResp.ImageId))
 	amis := make(map[string]string)
 	amis[ec2conn.Region.Name] = registerResp.ImageId
-	state["amis"] = amis
+	state.Put("amis", amis)
 
 	// Wait for the image to become ready
 	ui.Say("Waiting for AMI to become ready...")
 	if err := awscommon.WaitForAMI(ec2conn, registerResp.ImageId); err != nil {
 		err := fmt.Errorf("Error waiting for AMI: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -63,4 +63,4 @@ func (s *StepRegisterAMI) Run(state map[string]interface{}) multistep.StepAction
 	return multistep.ActionContinue
 }
 
-func (s *StepRegisterAMI) Cleanup(state map[string]interface{}) {}
+func (s *StepRegisterAMI) Cleanup(state multistep.StateBag) {}

builder/amazon/chroot/step_snapshot.go

@@ -17,16 +17,16 @@ type StepSnapshot struct {
 	snapshotId string
 }
 
-func (s *StepSnapshot) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-	volumeId := state["volume_id"].(string)
+func (s *StepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
+	volumeId := state.Get("volume_id").(string)
 
 	ui.Say("Creating snapshot...")
 	createSnapResp, err := ec2conn.CreateSnapshot(volumeId, "")
 	if err != nil {
 		err := fmt.Errorf("Error creating snapshot: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -58,26 +58,26 @@ func (s *StepSnapshot) Run(state map[string]interface{}) multistep.StepAction {
 	_, err = awscommon.WaitForState(&stateChange)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for snapshot: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	state["snapshot_id"] = s.snapshotId
+	state.Put("snapshot_id", s.snapshotId)
 	return multistep.ActionContinue
 }
 
-func (s *StepSnapshot) Cleanup(state map[string]interface{}) {
+func (s *StepSnapshot) Cleanup(state multistep.StateBag) {
 	if s.snapshotId == "" {
 		return
 	}
 
-	_, cancelled := state[multistep.StateCancelled]
-	_, halted := state[multistep.StateHalted]
+	_, cancelled := state.GetOk(multistep.StateCancelled)
+	_, halted := state.GetOk(multistep.StateHalted)
 
 	if cancelled || halted {
-		ec2conn := state["ec2"].(*ec2.EC2)
-		ui := state["ui"].(packer.Ui)
+		ec2conn := state.Get("ec2").(*ec2.EC2)
+		ui := state.Get("ui").(packer.Ui)
 		ui.Say("Removing snapshot since we cancelled or halted...")
 		_, err := ec2conn.DeleteSnapshots([]string{s.snapshotId})
 		if err != nil {

builder/amazon/chroot/step_source_ami_info.go

@@ -14,23 +14,23 @@ import (
 //   source_image *ec2.Image - the source AMI info
 type StepSourceAMIInfo struct{}
 
-func (s *StepSourceAMIInfo) Run(state map[string]interface{}) multistep.StepAction {
-	config := state["config"].(*Config)
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(*Config)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Inspecting the source AMI...")
 	imageResp, err := ec2conn.Images([]string{config.SourceAmi}, ec2.NewFilter())
 	if err != nil {
 		err := fmt.Errorf("Error querying AMI: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	if len(imageResp.Images) == 0 {
 		err := fmt.Errorf("Source AMI '%s' was not found!", config.SourceAmi)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -40,13 +40,13 @@ func (s *StepSourceAMIInfo) Run(state map[string]interface{}) multistep.StepActi
 	// It must be EBS-backed otherwise the build won't work
 	if image.RootDeviceType != "ebs" {
 		err := fmt.Errorf("The root device of the source AMI must be EBS-backed.")
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
-	state["source_image"] = image
+	state.Put("source_image", image)
 	return multistep.ActionContinue
 }
 
-func (s *StepSourceAMIInfo) Cleanup(map[string]interface{}) {}
+func (s *StepSourceAMIInfo) Cleanup(multistep.StateBag) {}

builder/amazon/common/instance.go

@@ -26,7 +26,7 @@ type StateChangeConf struct {
 	Conn      *ec2.EC2
 	Pending   []string
 	Refresh   StateRefreshFunc
-	StepState map[string]interface{}
+	StepState multistep.StateBag
 	Target    string
 }
 
@@ -62,7 +62,7 @@ func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 		}
 
 		if conf.StepState != nil {
-			if _, ok := conf.StepState[multistep.StateCancelled]; ok {
+			if _, ok := conf.StepState.GetOk(multistep.StateCancelled); ok {
 				return nil, errors.New("interrupted")
 			}
 		}

builder/amazon/common/step_ami_region_copy.go

@@ -13,10 +13,10 @@ type StepAMIRegionCopy struct {
 	Tags    map[string]string
 }
 
-func (s *StepAMIRegionCopy) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-	amis := state["amis"].(map[string]string)
+func (s *StepAMIRegionCopy) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
+	amis := state.Get("amis").(map[string]string)
 	ami := amis[ec2conn.Region.Name]
 
 	if len(s.Regions) == 0 {
@@ -36,7 +36,7 @@ func (s *StepAMIRegionCopy) Run(state map[string]interface{}) multistep.StepActi
 
 		if err != nil {
 			err := fmt.Errorf("Error Copying AMI (%s) to region (%s): %s", ami, region, err)
-			state["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -44,7 +44,7 @@ func (s *StepAMIRegionCopy) Run(state map[string]interface{}) multistep.StepActi
 		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["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -62,7 +62,7 @@ func (s *StepAMIRegionCopy) Run(state map[string]interface{}) multistep.StepActi
 			_, err := regionconn.CreateTags([]string{resp.ImageId}, ec2Tags)
 			if err != nil {
 				err := fmt.Errorf("Error adding tags to AMI (%s): %s", resp.ImageId, err)
-				state["error"] = err
+				state.Put("error", err)
 				ui.Error(err.Error())
 				return multistep.ActionHalt
 			}
@@ -71,10 +71,10 @@ func (s *StepAMIRegionCopy) Run(state map[string]interface{}) multistep.StepActi
 		amis[region] = resp.ImageId
 	}
 
-	state["amis"] = amis
+	state.Put("amis", amis)
 	return multistep.ActionContinue
 }
 
-func (s *StepAMIRegionCopy) Cleanup(state map[string]interface{}) {
+func (s *StepAMIRegionCopy) Cleanup(state multistep.StateBag) {
 	// No cleanup...
 }

builder/amazon/common/step_create_tags.go

@@ -11,10 +11,10 @@ type StepCreateTags struct {
 	Tags map[string]string
 }
 
-func (s *StepCreateTags) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-	amis := state["amis"].(map[string]string)
+func (s *StepCreateTags) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
+	amis := state.Get("amis").(map[string]string)
 	ami := amis[ec2conn.Region.Name]
 
 	if len(s.Tags) > 0 {
@@ -29,7 +29,7 @@ func (s *StepCreateTags) Run(state map[string]interface{}) multistep.StepAction
 		_, err := ec2conn.CreateTags([]string{ami}, ec2Tags)
 		if err != nil {
 			err := fmt.Errorf("Error adding tags to AMI (%s): %s", ami, err)
-			state["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -38,6 +38,6 @@ func (s *StepCreateTags) Run(state map[string]interface{}) multistep.StepAction
 	return multistep.ActionContinue
 }
 
-func (s *StepCreateTags) Cleanup(state map[string]interface{}) {
+func (s *StepCreateTags) Cleanup(state multistep.StateBag) {
 	// No cleanup...
 }

builder/amazon/common/step_key_pair.go

@@ -19,16 +19,16 @@ type StepKeyPair struct {
 	keyName string
 }
 
-func (s *StepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Creating temporary keypair for this instance...")
 	keyName := fmt.Sprintf("packer %s", hex.EncodeToString(identifier.NewUUID().Raw()))
 	log.Printf("temporary keypair name: %s", keyName)
 	keyResp, err := ec2conn.CreateKeyPair(keyName)
 	if err != nil {
-		state["error"] = fmt.Errorf("Error creating temporary keypair: %s", err)
+		state.Put("error", fmt.Errorf("Error creating temporary keypair: %s", err))
 		return multistep.ActionHalt
 	}
 
@@ -36,8 +36,8 @@ func (s *StepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
 	s.keyName = keyName
 
 	// Set some state data for use in future steps
-	state["keyPair"] = keyName
-	state["privateKey"] = keyResp.KeyMaterial
+	state.Put("keyPair", keyName)
+	state.Put("privateKey", keyResp.KeyMaterial)
 
 	// If we're in debug mode, output the private key to the working
 	// directory.
@@ -45,21 +45,21 @@ func (s *StepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
 		ui.Message(fmt.Sprintf("Saving key for debug purposes: %s", s.DebugKeyPath))
 		f, err := os.Create(s.DebugKeyPath)
 		if err != nil {
-			state["error"] = fmt.Errorf("Error saving debug key: %s", err)
+			state.Put("error", fmt.Errorf("Error saving debug key: %s", err))
 			return multistep.ActionHalt
 		}
 		defer f.Close()
 
 		// Write the key out
 		if _, err := f.Write([]byte(keyResp.KeyMaterial)); err != nil {
-			state["error"] = fmt.Errorf("Error saving debug key: %s", err)
+			state.Put("error", fmt.Errorf("Error saving debug key: %s", err))
 			return multistep.ActionHalt
 		}
 
 		// Chmod it so that it is SSH ready
 		if runtime.GOOS != "windows" {
 			if err := f.Chmod(0600); err != nil {
-				state["error"] = fmt.Errorf("Error setting permissions of debug key: %s", err)
+				state.Put("error", fmt.Errorf("Error setting permissions of debug key: %s", err))
 				return multistep.ActionHalt
 			}
 		}
@@ -68,14 +68,14 @@ func (s *StepKeyPair) Run(state map[string]interface{}) multistep.StepAction {
 	return multistep.ActionContinue
 }
 
-func (s *StepKeyPair) Cleanup(state map[string]interface{}) {
+func (s *StepKeyPair) Cleanup(state multistep.StateBag) {
 	// If no key name is set, then we never created it, so just return
 	if s.keyName == "" {
 		return
 	}
 
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Deleting temporary keypair...")
 	_, err := ec2conn.DeleteKeyPair(s.keyName)

builder/amazon/common/step_modify_ami_attributes.go

@@ -14,10 +14,10 @@ type StepModifyAMIAttributes struct {
 	Description  string
 }
 
-func (s *StepModifyAMIAttributes) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
-	amis := state["amis"].(map[string]string)
+func (s *StepModifyAMIAttributes) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
+	amis := state.Get("amis").(map[string]string)
 	ami := amis[ec2conn.Region.Name]
 
 	// Determine if there is any work to do.
@@ -65,7 +65,7 @@ func (s *StepModifyAMIAttributes) Run(state map[string]interface{}) multistep.St
 		_, err := ec2conn.ModifyImageAttribute(ami, opts)
 		if err != nil {
 			err := fmt.Errorf("Error modify AMI attributes: %s", err)
-			state["error"] = err
+			state.Put("error", err)
 			ui.Error(err.Error())
 			return multistep.ActionHalt
 		}
@@ -74,6 +74,6 @@ func (s *StepModifyAMIAttributes) Run(state map[string]interface{}) multistep.St
 	return multistep.ActionContinue
 }
 
-func (s *StepModifyAMIAttributes) Cleanup(state map[string]interface{}) {
+func (s *StepModifyAMIAttributes) Cleanup(state multistep.StateBag) {
 	// No cleanup...
 }

builder/amazon/common/step_run_source_instance.go

@@ -23,17 +23,17 @@ type StepRunSourceInstance struct {
 	instance *ec2.Instance
 }
 
-func (s *StepRunSourceInstance) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	keyName := state["keyPair"].(string)
-	securityGroupId := state["securityGroupId"].(string)
-	ui := state["ui"].(packer.Ui)
+func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	keyName := state.Get("keyPair").(string)
+	securityGroupId := state.Get("securityGroupId").(string)
+	ui := state.Get("ui").(packer.Ui)
 
 	userData := s.UserData
 	if s.UserDataFile != "" {
 		contents, err := ioutil.ReadFile(s.UserDataFile)
 		if err != nil {
-			state["error"] = fmt.Errorf("Problem reading user data file: %s", err)
+			state.Put("error", fmt.Errorf("Problem reading user data file: %s", err))
 			return multistep.ActionHalt
 		}
 
@@ -56,27 +56,27 @@ func (s *StepRunSourceInstance) Run(state map[string]interface{}) multistep.Step
 	ui.Say("Launching a source AWS instance...")
 	imageResp, err := ec2conn.Images([]string{s.SourceAMI}, ec2.NewFilter())
 	if err != nil {
-		state["error"] = fmt.Errorf("There was a problem with the source AMI: %s", err)
+		state.Put("error", fmt.Errorf("There was a problem with the source AMI: %s", err))
 		return multistep.ActionHalt
 	}
 
 	if len(imageResp.Images) != 1 {
-		state["error"] = fmt.Errorf("The source AMI '%s' could not be found.", s.SourceAMI)
+		state.Put("error", fmt.Errorf("The source AMI '%s' could not be found.", s.SourceAMI))
 		return multistep.ActionHalt
 	}
 
 	if s.ExpectedRootDevice != "" && imageResp.Images[0].RootDeviceType != s.ExpectedRootDevice {
-		state["error"] = fmt.Errorf(
+		state.Put("error", fmt.Errorf(
 			"The provided source AMI has an invalid root device type.\n"+
 				"Expected '%s', got '%s'.",
-			s.ExpectedRootDevice, imageResp.Images[0].RootDeviceType)
+			s.ExpectedRootDevice, imageResp.Images[0].RootDeviceType))
 		return multistep.ActionHalt
 	}
 
 	runResp, err := ec2conn.RunInstances(runOpts)
 	if err != nil {
 		err := fmt.Errorf("Error launching source instance: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -95,7 +95,7 @@ func (s *StepRunSourceInstance) Run(state map[string]interface{}) multistep.Step
 	latestInstance, err := WaitForState(&stateChange)
 	if err != nil {
 		err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", s.instance.InstanceId, err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
@@ -112,18 +112,18 @@ func (s *StepRunSourceInstance) Run(state map[string]interface{}) multistep.Step
 		}
 	}
 
-	state["instance"] = s.instance
+	state.Put("instance", s.instance)
 
 	return multistep.ActionContinue
 }
 
-func (s *StepRunSourceInstance) Cleanup(state map[string]interface{}) {
+func (s *StepRunSourceInstance) Cleanup(state multistep.StateBag) {
 	if s.instance == nil {
 		return
 	}
 
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Terminating the source AWS instance...")
 	if _, err := ec2conn.TerminateInstances([]string{s.instance.InstanceId}); err != nil {

builder/amazon/common/step_security_group.go

@@ -19,13 +19,13 @@ type StepSecurityGroup struct {
 	createdGroupId string
 }
 
-func (s *StepSecurityGroup) Run(state map[string]interface{}) multistep.StepAction {
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+func (s *StepSecurityGroup) Run(state multistep.StateBag) multistep.StepAction {
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	if s.SecurityGroupId != "" {
 		log.Printf("Using specified security group: %s", s.SecurityGroupId)
-		state["securityGroupId"] = s.SecurityGroupId
+		state.Put("securityGroupId", s.SecurityGroupId)
 		return multistep.ActionContinue
 	}
 
@@ -64,24 +64,24 @@ func (s *StepSecurityGroup) Run(state map[string]interface{}) multistep.StepActi
 	ui.Say("Authorizing SSH access on the temporary security group...")
 	if _, err := ec2conn.AuthorizeSecurityGroup(groupResp.SecurityGroup, perms); err != nil {
 		err := fmt.Errorf("Error creating temporary security group: %s", err)
-		state["error"] = err
+		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	// Set some state data for use in future steps
-	state["securityGroupId"] = s.createdGroupId
+	state.Put("securityGroupId", s.createdGroupId)
 
 	return multistep.ActionContinue
 }
 
-func (s *StepSecurityGroup) Cleanup(state map[string]interface{}) {
+func (s *StepSecurityGroup) Cleanup(state multistep.StateBag) {
 	if s.createdGroupId == "" {
 		return
 	}
 
-	ec2conn := state["ec2"].(*ec2.EC2)
-	ui := state["ui"].(packer.Ui)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Deleting temporary security group...")