From 80ed7eddf4a1c50b6a31daea7abf0d50044e666c Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sat, 31 Aug 2013 12:58:55 -0700 Subject: [PATCH] builder/amazon/chroot: new multistep API --- builder/amazon/chroot/builder.go | 16 +++++----- builder/amazon/chroot/cleanup.go | 6 +++- builder/amazon/chroot/step_attach_volume.go | 28 ++++++++-------- .../amazon/chroot/step_chroot_provision.go | 12 +++---- builder/amazon/chroot/step_copy_files.go | 18 +++++------ builder/amazon/chroot/step_create_volume.go | 24 +++++++------- builder/amazon/chroot/step_early_cleanup.go | 10 +++--- builder/amazon/chroot/step_early_unflock.go | 10 +++--- builder/amazon/chroot/step_flock.go | 16 +++++----- builder/amazon/chroot/step_instance_info.go | 16 +++++----- builder/amazon/chroot/step_mount_device.go | 30 ++++++++--------- builder/amazon/chroot/step_mount_extra.go | 22 ++++++------- builder/amazon/chroot/step_prepare_device.go | 14 ++++---- builder/amazon/chroot/step_register_ami.go | 22 ++++++------- builder/amazon/chroot/step_snapshot.go | 24 +++++++------- builder/amazon/chroot/step_source_ami_info.go | 18 +++++------ builder/amazon/common/instance.go | 4 +-- builder/amazon/common/step_ami_region_copy.go | 18 +++++------ builder/amazon/common/step_create_tags.go | 12 +++---- builder/amazon/common/step_key_pair.go | 24 +++++++------- .../common/step_modify_ami_attributes.go | 12 +++---- .../amazon/common/step_run_source_instance.go | 32 +++++++++---------- builder/amazon/common/step_security_group.go | 18 +++++------ 23 files changed, 205 insertions(+), 201 deletions(-) diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go index 9ca967bb5..013394ee7 100644 --- a/builder/amazon/chroot/builder.go +++ b/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, } diff --git a/builder/amazon/chroot/cleanup.go b/builder/amazon/chroot/cleanup.go index 14c47aac3..0be3bef3f 100644 --- a/builder/amazon/chroot/cleanup.go +++ b/builder/amazon/chroot/cleanup.go @@ -1,6 +1,10 @@ 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 } diff --git a/builder/amazon/chroot/step_attach_volume.go b/builder/amazon/chroot/step_attach_volume.go index 051c0704c..1b1bce0f2 100644 --- a/builder/amazon/chroot/step_attach_volume.go +++ b/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) diff --git a/builder/amazon/chroot/step_chroot_provision.go b/builder/amazon/chroot/step_chroot_provision.go index a295f27bf..5ad87836d 100644 --- a/builder/amazon/chroot/step_chroot_provision.go +++ b/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) {} diff --git a/builder/amazon/chroot/step_copy_files.go b/builder/amazon/chroot/step_copy_files.go index 45ec09db3..d729ee234 100644 --- a/builder/amazon/chroot/step_copy_files.go +++ b/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) diff --git a/builder/amazon/chroot/step_create_volume.go b/builder/amazon/chroot/step_create_volume.go index d0e247989..5346bf1ca 100644 --- a/builder/amazon/chroot/step_create_volume.go +++ b/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) diff --git a/builder/amazon/chroot/step_early_cleanup.go b/builder/amazon/chroot/step_early_cleanup.go index 01ccb48d7..a7b08a26b 100644 --- a/builder/amazon/chroot/step_early_cleanup.go +++ b/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) {} diff --git a/builder/amazon/chroot/step_early_unflock.go b/builder/amazon/chroot/step_early_unflock.go index d1c09008e..138e06495 100644 --- a/builder/amazon/chroot/step_early_unflock.go +++ b/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) {} diff --git a/builder/amazon/chroot/step_flock.go b/builder/amazon/chroot/step_flock.go index 47d168d4c..989bd3930 100644 --- a/builder/amazon/chroot/step_flock.go +++ b/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 } diff --git a/builder/amazon/chroot/step_instance_info.go b/builder/amazon/chroot/step_instance_info.go index 53080e171..cb694cc07 100644 --- a/builder/amazon/chroot/step_instance_info.go +++ b/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) {} diff --git a/builder/amazon/chroot/step_mount_device.go b/builder/amazon/chroot/step_mount_device.go index 1b87163aa..6079a0293 100644 --- a/builder/amazon/chroot/step_mount_device.go +++ b/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) diff --git a/builder/amazon/chroot/step_mount_extra.go b/builder/amazon/chroot/step_mount_extra.go index 6a306fdf9..3fc35f4ac 100644 --- a/builder/amazon/chroot/step_mount_extra.go +++ b/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 diff --git a/builder/amazon/chroot/step_prepare_device.go b/builder/amazon/chroot/step_prepare_device.go index 114c0ce9d..d8683620b 100644 --- a/builder/amazon/chroot/step_prepare_device.go +++ b/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) {} diff --git a/builder/amazon/chroot/step_register_ami.go b/builder/amazon/chroot/step_register_ami.go index c93b14ff1..4c75d0c27 100644 --- a/builder/amazon/chroot/step_register_ami.go +++ b/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) {} diff --git a/builder/amazon/chroot/step_snapshot.go b/builder/amazon/chroot/step_snapshot.go index 837543ec8..22cf4d17f 100644 --- a/builder/amazon/chroot/step_snapshot.go +++ b/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 { diff --git a/builder/amazon/chroot/step_source_ami_info.go b/builder/amazon/chroot/step_source_ami_info.go index 28f47149b..32ca5fd9c 100644 --- a/builder/amazon/chroot/step_source_ami_info.go +++ b/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) {} diff --git a/builder/amazon/common/instance.go b/builder/amazon/common/instance.go index 13f5ae528..6f8f78cd4 100644 --- a/builder/amazon/common/instance.go +++ b/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") } } diff --git a/builder/amazon/common/step_ami_region_copy.go b/builder/amazon/common/step_ami_region_copy.go index 99bb35c3c..109e6de6d 100644 --- a/builder/amazon/common/step_ami_region_copy.go +++ b/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... } diff --git a/builder/amazon/common/step_create_tags.go b/builder/amazon/common/step_create_tags.go index ecebfad74..030211509 100644 --- a/builder/amazon/common/step_create_tags.go +++ b/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... } diff --git a/builder/amazon/common/step_key_pair.go b/builder/amazon/common/step_key_pair.go index 413ef537f..63c0247bc 100644 --- a/builder/amazon/common/step_key_pair.go +++ b/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) diff --git a/builder/amazon/common/step_modify_ami_attributes.go b/builder/amazon/common/step_modify_ami_attributes.go index c522b85ef..25ba79c2c 100644 --- a/builder/amazon/common/step_modify_ami_attributes.go +++ b/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... } diff --git a/builder/amazon/common/step_run_source_instance.go b/builder/amazon/common/step_run_source_instance.go index fc81b2002..4aeab217c 100644 --- a/builder/amazon/common/step_run_source_instance.go +++ b/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 { diff --git a/builder/amazon/common/step_security_group.go b/builder/amazon/common/step_security_group.go index 7bd415202..0f52548df 100644 --- a/builder/amazon/common/step_security_group.go +++ b/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...")