From 8d5f8dc42390306ce9a2a6dea760200fd1cef3c5 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sat, 31 Aug 2013 12:44:58 -0700 Subject: [PATCH] builder/virtualbox: new multistep API --- builder/virtualbox/builder.go | 18 +++++------ builder/virtualbox/ssh.go | 9 +++--- builder/virtualbox/step_attach_floppy.go | 22 +++++++------- builder/virtualbox/step_attach_iso.go | 20 ++++++------- builder/virtualbox/step_create_disk.go | 18 +++++------ builder/virtualbox/step_create_vm.go | 18 +++++------ .../step_download_guest_additions.go | 30 +++++++++---------- builder/virtualbox/step_export.go | 24 +++++++-------- builder/virtualbox/step_forward_ssh.go | 16 +++++----- builder/virtualbox/step_http_server.go | 12 ++++---- builder/virtualbox/step_prepare_output_dir.go | 18 +++++------ builder/virtualbox/step_run.go | 18 +++++------ builder/virtualbox/step_shutdown.go | 20 ++++++------- builder/virtualbox/step_suppress_messages.go | 10 +++---- builder/virtualbox/step_type_boot_command.go | 20 ++++++------- .../virtualbox/step_upload_guest_additions.go | 22 +++++++------- builder/virtualbox/step_upload_version.go | 16 +++++----- builder/virtualbox/step_vboxmanage.go | 16 +++++----- 18 files changed, 164 insertions(+), 163 deletions(-) diff --git a/builder/virtualbox/builder.go b/builder/virtualbox/builder.go index 84570c92c..703a9ba92 100644 --- a/builder/virtualbox/builder.go +++ b/builder/virtualbox/builder.go @@ -368,12 +368,12 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe } // Setup the state bag - state := make(map[string]interface{}) - state["cache"] = cache - state["config"] = &b.config - state["driver"] = driver - state["hook"] = hook - state["ui"] = ui + state := new(multistep.BasicStateBag) + state.Put("cache", cache) + state.Put("config", &b.config) + state.Put("driver", driver) + state.Put("hook", hook) + state.Put("ui", ui) // Run if b.config.PackerDebug { @@ -388,16 +388,16 @@ 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 we were interrupted or cancelled, then just exit. - if _, ok := state[multistep.StateCancelled]; ok { + if _, ok := state.GetOk(multistep.StateCancelled); ok { return nil, errors.New("Build was cancelled.") } - if _, ok := state[multistep.StateHalted]; ok { + if _, ok := state.GetOk(multistep.StateHalted); ok { return nil, errors.New("Build was halted.") } diff --git a/builder/virtualbox/ssh.go b/builder/virtualbox/ssh.go index 539f7d832..b685a545f 100644 --- a/builder/virtualbox/ssh.go +++ b/builder/virtualbox/ssh.go @@ -3,18 +3,19 @@ package virtualbox import ( gossh "code.google.com/p/go.crypto/ssh" "fmt" + "github.com/mitchellh/multistep" "github.com/mitchellh/packer/communicator/ssh" "io/ioutil" "os" ) -func sshAddress(state map[string]interface{}) (string, error) { - sshHostPort := state["sshHostPort"].(uint) +func sshAddress(state multistep.StateBag) (string, error) { + sshHostPort := state.Get("sshHostPort").(uint) return fmt.Sprintf("127.0.0.1:%d", sshHostPort), nil } -func sshConfig(state map[string]interface{}) (*gossh.ClientConfig, error) { - config := state["config"].(*config) +func sshConfig(state multistep.StateBag) (*gossh.ClientConfig, error) { + config := state.Get("config").(*config) auth := []gossh.ClientAuth{ gossh.ClientAuthPassword(ssh.Password(config.SSHPassword)), diff --git a/builder/virtualbox/step_attach_floppy.go b/builder/virtualbox/step_attach_floppy.go index bb5c8c5d8..8f41441a5 100644 --- a/builder/virtualbox/step_attach_floppy.go +++ b/builder/virtualbox/step_attach_floppy.go @@ -20,10 +20,10 @@ type stepAttachFloppy struct { floppyPath string } -func (s *stepAttachFloppy) Run(state map[string]interface{}) multistep.StepAction { +func (s *stepAttachFloppy) Run(state multistep.StateBag) multistep.StepAction { // Determine if we even have a floppy disk to attach var floppyPath string - if floppyPathRaw, ok := state["floppy_path"]; ok { + if floppyPathRaw, ok := state.GetOk("floppy_path"); ok { floppyPath = floppyPathRaw.(string) } else { log.Println("No floppy disk, not attaching.") @@ -35,13 +35,13 @@ func (s *stepAttachFloppy) Run(state map[string]interface{}) multistep.StepActio // floppy. floppyPath, err := s.copyFloppy(floppyPath) if err != nil { - state["error"] = fmt.Errorf("Error preparing floppy: %s", err) + state.Put("error", fmt.Errorf("Error preparing floppy: %s", err)) return multistep.ActionHalt } - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) ui.Say("Attaching floppy disk...") @@ -52,7 +52,7 @@ func (s *stepAttachFloppy) Run(state map[string]interface{}) multistep.StepActio "--add", "floppy", } if err := driver.VBoxManage(command...); err != nil { - state["error"] = fmt.Errorf("Error creating floppy controller: %s", err) + state.Put("error", fmt.Errorf("Error creating floppy controller: %s", err)) return multistep.ActionHalt } @@ -66,7 +66,7 @@ func (s *stepAttachFloppy) Run(state map[string]interface{}) multistep.StepActio "--medium", floppyPath, } if err := driver.VBoxManage(command...); err != nil { - state["error"] = fmt.Errorf("Error attaching floppy: %s", err) + state.Put("error", fmt.Errorf("Error attaching floppy: %s", err)) return multistep.ActionHalt } @@ -76,7 +76,7 @@ func (s *stepAttachFloppy) Run(state map[string]interface{}) multistep.StepActio return multistep.ActionContinue } -func (s *stepAttachFloppy) Cleanup(state map[string]interface{}) { +func (s *stepAttachFloppy) Cleanup(state multistep.StateBag) { if s.floppyPath == "" { return } @@ -84,8 +84,8 @@ func (s *stepAttachFloppy) Cleanup(state map[string]interface{}) { // Delete the floppy disk defer os.Remove(s.floppyPath) - driver := state["driver"].(Driver) - vmName := state["vmName"].(string) + driver := state.Get("driver").(Driver) + vmName := state.Get("vmName").(string) command := []string{ "storageattach", vmName, diff --git a/builder/virtualbox/step_attach_iso.go b/builder/virtualbox/step_attach_iso.go index abcde9469..a71b6de6e 100644 --- a/builder/virtualbox/step_attach_iso.go +++ b/builder/virtualbox/step_attach_iso.go @@ -15,11 +15,11 @@ type stepAttachISO struct { diskPath string } -func (s *stepAttachISO) Run(state map[string]interface{}) multistep.StepAction { - driver := state["driver"].(Driver) - isoPath := state["iso_path"].(string) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepAttachISO) Run(state multistep.StateBag) multistep.StepAction { + driver := state.Get("driver").(Driver) + isoPath := state.Get("iso_path").(string) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) // Attach the disk to the controller command := []string{ @@ -32,7 +32,7 @@ func (s *stepAttachISO) Run(state map[string]interface{}) multistep.StepAction { } if err := driver.VBoxManage(command...); err != nil { err := fmt.Errorf("Error attaching ISO: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -43,14 +43,14 @@ func (s *stepAttachISO) Run(state map[string]interface{}) multistep.StepAction { return multistep.ActionContinue } -func (s *stepAttachISO) Cleanup(state map[string]interface{}) { +func (s *stepAttachISO) Cleanup(state multistep.StateBag) { if s.diskPath == "" { return } - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) command := []string{ "storageattach", vmName, diff --git a/builder/virtualbox/step_create_disk.go b/builder/virtualbox/step_create_disk.go index b7d221c2d..cb456ed0a 100644 --- a/builder/virtualbox/step_create_disk.go +++ b/builder/virtualbox/step_create_disk.go @@ -13,11 +13,11 @@ import ( // hard drive for the virtual machine. type stepCreateDisk struct{} -func (s *stepCreateDisk) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) format := "VDI" path := filepath.Join(config.OutputDir, fmt.Sprintf("%s.%s", config.VMName, strings.ToLower(format))) @@ -34,7 +34,7 @@ func (s *stepCreateDisk) Run(state map[string]interface{}) multistep.StepAction err := driver.VBoxManage(command...) if err != nil { err := fmt.Errorf("Error creating hard drive: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -44,7 +44,7 @@ func (s *stepCreateDisk) Run(state map[string]interface{}) multistep.StepAction err = driver.VBoxManage("storagectl", vmName, "--name", controllerName, "--add", "ide") if err != nil { err := fmt.Errorf("Error creating disk controller: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -60,7 +60,7 @@ func (s *stepCreateDisk) Run(state map[string]interface{}) multistep.StepAction } if err := driver.VBoxManage(command...); err != nil { err := fmt.Errorf("Error attaching hard drive: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -68,4 +68,4 @@ func (s *stepCreateDisk) Run(state map[string]interface{}) multistep.StepAction return multistep.ActionContinue } -func (s *stepCreateDisk) Cleanup(state map[string]interface{}) {} +func (s *stepCreateDisk) Cleanup(state multistep.StateBag) {} diff --git a/builder/virtualbox/step_create_vm.go b/builder/virtualbox/step_create_vm.go index 6a8d579ef..89375a2d3 100644 --- a/builder/virtualbox/step_create_vm.go +++ b/builder/virtualbox/step_create_vm.go @@ -14,10 +14,10 @@ type stepCreateVM struct { vmName string } -func (s *stepCreateVM) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) +func (s *stepCreateVM) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) name := config.VMName @@ -38,7 +38,7 @@ func (s *stepCreateVM) Run(state map[string]interface{}) multistep.StepAction { err := driver.VBoxManage(command...) if err != nil { err := fmt.Errorf("Error creating VM: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -50,18 +50,18 @@ func (s *stepCreateVM) Run(state map[string]interface{}) multistep.StepAction { } // Set the final name in the state bag so others can use it - state["vmName"] = s.vmName + state.Put("vmName", s.vmName) return multistep.ActionContinue } -func (s *stepCreateVM) Cleanup(state map[string]interface{}) { +func (s *stepCreateVM) Cleanup(state multistep.StateBag) { if s.vmName == "" { return } - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) ui.Say("Unregistering and deleting virtual machine...") if err := driver.VBoxManage("unregistervm", s.vmName, "--delete"); err != nil { diff --git a/builder/virtualbox/step_download_guest_additions.go b/builder/virtualbox/step_download_guest_additions.go index 5bb25a6e4..0b914b713 100644 --- a/builder/virtualbox/step_download_guest_additions.go +++ b/builder/virtualbox/step_download_guest_additions.go @@ -29,16 +29,16 @@ type guestAdditionsUrlTemplate struct { // guest_additions_path string - Path to the guest additions. type stepDownloadGuestAdditions struct{} -func (s *stepDownloadGuestAdditions) Run(state map[string]interface{}) multistep.StepAction { +func (s *stepDownloadGuestAdditions) Run(state multistep.StateBag) multistep.StepAction { var action multistep.StepAction - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - config := state["config"].(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + config := state.Get("config").(*config) // Get VBox version version, err := driver.Version() if err != nil { - state["error"] = fmt.Errorf("Error reading version for guest additions download: %s", err) + state.Put("error", fmt.Errorf("Error reading version for guest additions download: %s", err)) return multistep.ActionHalt } @@ -71,7 +71,7 @@ func (s *stepDownloadGuestAdditions) Run(state map[string]interface{}) multistep url, err = config.tpl.Process(url, tplData) if err != nil { err := fmt.Errorf("Error preparing guest additions url: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -85,7 +85,7 @@ func (s *stepDownloadGuestAdditions) Run(state map[string]interface{}) multistep url, err = common.DownloadableURL(url) if err != nil { err := fmt.Errorf("Error preparing guest additions url: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -103,9 +103,9 @@ func (s *stepDownloadGuestAdditions) Run(state map[string]interface{}) multistep return downStep.Run(state) } -func (s *stepDownloadGuestAdditions) Cleanup(state map[string]interface{}) {} +func (s *stepDownloadGuestAdditions) Cleanup(state multistep.StateBag) {} -func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state map[string]interface{}, additionsVersion string, additionsName string) (string, multistep.StepAction) { +func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state multistep.StateBag, additionsVersion string, additionsName string) (string, multistep.StepAction) { // First things first, we get the list of checksums for the files available // for this version. checksumsUrl := fmt.Sprintf( @@ -114,9 +114,9 @@ func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state map[string]in checksumsFile, err := ioutil.TempFile("", "packer") if err != nil { - state["error"] = fmt.Errorf( + state.Put("error", fmt.Errorf( "Failed creating temporary file to store guest addition checksums: %s", - err) + err)) return "", multistep.ActionHalt } defer os.Remove(checksumsFile.Name()) @@ -136,9 +136,9 @@ func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state map[string]in // Next, we find the checksum for the file we're looking to download. // It is an error if the checksum cannot be found. - checksumsF, err := os.Open(state["guest_additions_checksums_path"].(string)) + checksumsF, err := os.Open(state.Get("guest_additions_checksums_path").(string)) if err != nil { - state["error"] = fmt.Errorf("Error opening guest addition checksums: %s", err) + state.Put("error", fmt.Errorf("Error opening guest addition checksums: %s", err)) return "", multistep.ActionHalt } defer checksumsF.Close() @@ -166,8 +166,8 @@ func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state map[string]in } if checksum == "" { - state["error"] = fmt.Errorf( - "The checksum for the file '%s' could not be found.", additionsName) + state.Put("error", fmt.Errorf( + "The checksum for the file '%s' could not be found.", additionsName)) return "", multistep.ActionHalt } diff --git a/builder/virtualbox/step_export.go b/builder/virtualbox/step_export.go index 3464b6618..001aac89c 100644 --- a/builder/virtualbox/step_export.go +++ b/builder/virtualbox/step_export.go @@ -15,25 +15,25 @@ import ( // exportPath string - The path to the resulting export. type stepExport struct{} -func (s *stepExport) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepExport) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) // Clear out the Packer-created forwarding rule ui.Say("Preparing to export machine...") - ui.Message(fmt.Sprintf("Deleting forwarded port mapping for SSH (host port %d)", state["sshHostPort"])) + ui.Message(fmt.Sprintf("Deleting forwarded port mapping for SSH (host port %d)", state.Get("sshHostPort"))) command := []string{"modifyvm", vmName, "--natpf1", "delete", "packerssh"} if err := driver.VBoxManage(command...); err != nil { err := fmt.Errorf("Error deleting port forwarding rule: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } // Remove the attached floppy disk, if it exists - if _, ok := state["floppy_path"]; ok { + if _, ok := state.GetOk("floppy_path"); ok { ui.Message("Removing floppy drive...") command := []string{ "storageattach", vmName, @@ -43,7 +43,7 @@ func (s *stepExport) Run(state map[string]interface{}) multistep.StepAction { "--medium", "none", } if err := driver.VBoxManage(command...); err != nil { - state["error"] = fmt.Errorf("Error removing floppy: %s", err) + state.Put("error", fmt.Errorf("Error removing floppy: %s", err)) return multistep.ActionHalt } @@ -63,14 +63,14 @@ func (s *stepExport) Run(state map[string]interface{}) multistep.StepAction { err := driver.VBoxManage(command...) if err != nil { err := fmt.Errorf("Error exporting virtual machine: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } - state["exportPath"] = outputPath + state.Put("exportPath", outputPath) return multistep.ActionContinue } -func (s *stepExport) Cleanup(state map[string]interface{}) {} +func (s *stepExport) Cleanup(state multistep.StateBag) {} diff --git a/builder/virtualbox/step_forward_ssh.go b/builder/virtualbox/step_forward_ssh.go index 74a2354ec..5ea4ed3d5 100644 --- a/builder/virtualbox/step_forward_ssh.go +++ b/builder/virtualbox/step_forward_ssh.go @@ -17,11 +17,11 @@ import ( // Produces: type stepForwardSSH struct{} -func (s *stepForwardSSH) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepForwardSSH) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) log.Printf("Looking for available SSH port between %d and %d", config.SSHHostPortMin, config.SSHHostPortMax) var sshHostPort uint @@ -45,15 +45,15 @@ func (s *stepForwardSSH) Run(state map[string]interface{}) multistep.StepAction } if err := driver.VBoxManage(command...); err != nil { err := fmt.Errorf("Error creating port forwarding rule: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } // Save the port we're using so that future steps can use it - state["sshHostPort"] = sshHostPort + state.Put("sshHostPort", sshHostPort) return multistep.ActionContinue } -func (s *stepForwardSSH) Cleanup(state map[string]interface{}) {} +func (s *stepForwardSSH) Cleanup(state multistep.StateBag) {} diff --git a/builder/virtualbox/step_http_server.go b/builder/virtualbox/step_http_server.go index 9a518a972..ad3e9f755 100644 --- a/builder/virtualbox/step_http_server.go +++ b/builder/virtualbox/step_http_server.go @@ -23,13 +23,13 @@ type stepHTTPServer struct { l net.Listener } -func (s *stepHTTPServer) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - ui := state["ui"].(packer.Ui) +func (s *stepHTTPServer) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + ui := state.Get("ui").(packer.Ui) var httpPort uint = 0 if config.HTTPDir == "" { - state["http_port"] = httpPort + state.Put("http_port", httpPort) return multistep.ActionContinue } @@ -62,12 +62,12 @@ func (s *stepHTTPServer) Run(state map[string]interface{}) multistep.StepAction go server.Serve(s.l) // Save the address into the state so it can be accessed in the future - state["http_port"] = httpPort + state.Put("http_port", httpPort) return multistep.ActionContinue } -func (s *stepHTTPServer) Cleanup(map[string]interface{}) { +func (s *stepHTTPServer) Cleanup(multistep.StateBag) { if s.l != nil { // Close the listener so that the HTTP server stops s.l.Close() diff --git a/builder/virtualbox/step_prepare_output_dir.go b/builder/virtualbox/step_prepare_output_dir.go index 12f5a2e86..32d6260ff 100644 --- a/builder/virtualbox/step_prepare_output_dir.go +++ b/builder/virtualbox/step_prepare_output_dir.go @@ -10,9 +10,9 @@ import ( type stepPrepareOutputDir struct{} -func (stepPrepareOutputDir) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - ui := state["ui"].(packer.Ui) +func (stepPrepareOutputDir) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + ui := state.Get("ui").(packer.Ui) if _, err := os.Stat(config.OutputDir); err == nil && config.PackerForce { ui.Say("Deleting previous output directory...") @@ -20,20 +20,20 @@ func (stepPrepareOutputDir) Run(state map[string]interface{}) multistep.StepActi } if err := os.MkdirAll(config.OutputDir, 0755); err != nil { - state["error"] = err + state.Put("error", err) return multistep.ActionHalt } return multistep.ActionContinue } -func (stepPrepareOutputDir) Cleanup(state map[string]interface{}) { - _, cancelled := state[multistep.StateCancelled] - _, halted := state[multistep.StateHalted] +func (stepPrepareOutputDir) Cleanup(state multistep.StateBag) { + _, cancelled := state.GetOk(multistep.StateCancelled) + _, halted := state.GetOk(multistep.StateHalted) if cancelled || halted { - config := state["config"].(*config) - ui := state["ui"].(packer.Ui) + config := state.Get("config").(*config) + ui := state.Get("ui").(packer.Ui) ui.Say("Deleting output directory...") for i := 0; i < 5; i++ { diff --git a/builder/virtualbox/step_run.go b/builder/virtualbox/step_run.go index 2cf9ba093..7fc4e0a7c 100644 --- a/builder/virtualbox/step_run.go +++ b/builder/virtualbox/step_run.go @@ -16,11 +16,11 @@ type stepRun struct { vmName string } -func (s *stepRun) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepRun) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) ui.Say("Starting the virtual machine...") guiArgument := "gui" @@ -33,7 +33,7 @@ func (s *stepRun) Run(state map[string]interface{}) multistep.StepAction { command := []string{"startvm", vmName, "--type", guiArgument} if err := driver.VBoxManage(command...); err != nil { err := fmt.Errorf("Error starting VM: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -48,13 +48,13 @@ func (s *stepRun) Run(state map[string]interface{}) multistep.StepAction { return multistep.ActionContinue } -func (s *stepRun) Cleanup(state map[string]interface{}) { +func (s *stepRun) Cleanup(state multistep.StateBag) { if s.vmName == "" { return } - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) if running, _ := driver.IsRunning(s.vmName); running { if err := driver.VBoxManage("controlvm", s.vmName, "poweroff"); err != nil { diff --git a/builder/virtualbox/step_shutdown.go b/builder/virtualbox/step_shutdown.go index 85864470f..713368e8c 100644 --- a/builder/virtualbox/step_shutdown.go +++ b/builder/virtualbox/step_shutdown.go @@ -23,12 +23,12 @@ import ( // type stepShutdown struct{} -func (s *stepShutdown) Run(state map[string]interface{}) multistep.StepAction { - comm := state["communicator"].(packer.Communicator) - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepShutdown) Run(state multistep.StateBag) multistep.StepAction { + comm := state.Get("communicator").(packer.Communicator) + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) if config.ShutdownCommand != "" { ui.Say("Gracefully halting virtual machine...") @@ -36,7 +36,7 @@ func (s *stepShutdown) Run(state map[string]interface{}) multistep.StepAction { cmd := &packer.RemoteCmd{Command: config.ShutdownCommand} if err := cmd.StartWithUi(comm, ui); err != nil { err := fmt.Errorf("Failed to send shutdown command: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -53,7 +53,7 @@ func (s *stepShutdown) Run(state map[string]interface{}) multistep.StepAction { select { case <-shutdownTimer: err := errors.New("Timeout while waiting for machine to shut down.") - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt default: @@ -64,7 +64,7 @@ func (s *stepShutdown) Run(state map[string]interface{}) multistep.StepAction { ui.Say("Halting the virtual machine...") if err := driver.Stop(vmName); err != nil { err := fmt.Errorf("Error stopping VM: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -74,4 +74,4 @@ func (s *stepShutdown) Run(state map[string]interface{}) multistep.StepAction { return multistep.ActionContinue } -func (s *stepShutdown) Cleanup(state map[string]interface{}) {} +func (s *stepShutdown) Cleanup(state multistep.StateBag) {} diff --git a/builder/virtualbox/step_suppress_messages.go b/builder/virtualbox/step_suppress_messages.go index 5a6a2acce..4ed7f1939 100644 --- a/builder/virtualbox/step_suppress_messages.go +++ b/builder/virtualbox/step_suppress_messages.go @@ -11,14 +11,14 @@ import ( // pop-up messages don't exist. type stepSuppressMessages struct{} -func (stepSuppressMessages) Run(state map[string]interface{}) multistep.StepAction { - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) +func (stepSuppressMessages) Run(state multistep.StateBag) multistep.StepAction { + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) log.Println("Suppressing annoying messages in VirtualBox") if err := driver.SuppressMessages(); err != nil { err := fmt.Errorf("Error configuring VirtualBox to suppress messages: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -26,4 +26,4 @@ func (stepSuppressMessages) Run(state map[string]interface{}) multistep.StepActi return multistep.ActionContinue } -func (stepSuppressMessages) Cleanup(map[string]interface{}) {} +func (stepSuppressMessages) Cleanup(multistep.StateBag) {} diff --git a/builder/virtualbox/step_type_boot_command.go b/builder/virtualbox/step_type_boot_command.go index 910c122fe..60c897ea9 100644 --- a/builder/virtualbox/step_type_boot_command.go +++ b/builder/virtualbox/step_type_boot_command.go @@ -32,12 +32,12 @@ type bootCommandTemplateData struct { // type stepTypeBootCommand struct{} -func (s *stepTypeBootCommand) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - driver := state["driver"].(Driver) - httpPort := state["http_port"].(uint) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + httpPort := state.Get("http_port").(uint) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) tplData := &bootCommandTemplateData{ "10.0.2.2", @@ -50,7 +50,7 @@ func (s *stepTypeBootCommand) Run(state map[string]interface{}) multistep.StepAc command, err := config.tpl.Process(command, tplData) if err != nil { err := fmt.Errorf("Error preparing boot command: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -73,13 +73,13 @@ func (s *stepTypeBootCommand) Run(state map[string]interface{}) multistep.StepAc // Since typing is sometimes so slow, we check for an interrupt // in between each character. - if _, ok := state[multistep.StateCancelled]; ok { + if _, ok := state.GetOk(multistep.StateCancelled); ok { return multistep.ActionHalt } if err := driver.VBoxManage("controlvm", vmName, "keyboardputscancode", code); err != nil { err := fmt.Errorf("Error sending boot command: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -89,7 +89,7 @@ func (s *stepTypeBootCommand) Run(state map[string]interface{}) multistep.StepAc return multistep.ActionContinue } -func (*stepTypeBootCommand) Cleanup(map[string]interface{}) {} +func (*stepTypeBootCommand) Cleanup(multistep.StateBag) {} func scancodes(message string) []string { special := make(map[string][]string) diff --git a/builder/virtualbox/step_upload_guest_additions.go b/builder/virtualbox/step_upload_guest_additions.go index 32d3a0587..86b83b3c6 100644 --- a/builder/virtualbox/step_upload_guest_additions.go +++ b/builder/virtualbox/step_upload_guest_additions.go @@ -14,22 +14,22 @@ type guestAdditionsPathTemplate struct { // This step uploads the guest additions ISO to the VM. type stepUploadGuestAdditions struct{} -func (s *stepUploadGuestAdditions) Run(state map[string]interface{}) multistep.StepAction { - comm := state["communicator"].(packer.Communicator) - config := state["config"].(*config) - driver := state["driver"].(Driver) - guestAdditionsPath := state["guest_additions_path"].(string) - ui := state["ui"].(packer.Ui) +func (s *stepUploadGuestAdditions) Run(state multistep.StateBag) multistep.StepAction { + comm := state.Get("communicator").(packer.Communicator) + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + guestAdditionsPath := state.Get("guest_additions_path").(string) + ui := state.Get("ui").(packer.Ui) version, err := driver.Version() if err != nil { - state["error"] = fmt.Errorf("Error reading version for guest additions upload: %s", err) + state.Put("error", fmt.Errorf("Error reading version for guest additions upload: %s", err)) return multistep.ActionHalt } f, err := os.Open(guestAdditionsPath) if err != nil { - state["error"] = fmt.Errorf("Error opening guest additions ISO: %s", err) + state.Put("error", fmt.Errorf("Error opening guest additions ISO: %s", err)) return multistep.ActionHalt } @@ -40,18 +40,18 @@ func (s *stepUploadGuestAdditions) Run(state map[string]interface{}) multistep.S config.GuestAdditionsPath, err = config.tpl.Process(config.GuestAdditionsPath, tplData) if err != nil { err := fmt.Errorf("Error preparing guest additions path: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } ui.Say("Uploading VirtualBox guest additions ISO...") if err := comm.Upload(config.GuestAdditionsPath, f); err != nil { - state["error"] = fmt.Errorf("Error uploading guest additions: %s", err) + state.Put("error", fmt.Errorf("Error uploading guest additions: %s", err)) return multistep.ActionHalt } return multistep.ActionContinue } -func (s *stepUploadGuestAdditions) Cleanup(state map[string]interface{}) {} +func (s *stepUploadGuestAdditions) Cleanup(state multistep.StateBag) {} diff --git a/builder/virtualbox/step_upload_version.go b/builder/virtualbox/step_upload_version.go index b99cd7f12..c22a08117 100644 --- a/builder/virtualbox/step_upload_version.go +++ b/builder/virtualbox/step_upload_version.go @@ -12,11 +12,11 @@ import ( // can be useful for various provisioning reasons. type stepUploadVersion struct{} -func (s *stepUploadVersion) Run(state map[string]interface{}) multistep.StepAction { - comm := state["communicator"].(packer.Communicator) - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) +func (s *stepUploadVersion) Run(state multistep.StateBag) multistep.StepAction { + comm := state.Get("communicator").(packer.Communicator) + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) if config.VBoxVersionFile == "" { log.Println("VBoxVersionFile is empty. Not uploading.") @@ -25,7 +25,7 @@ func (s *stepUploadVersion) Run(state map[string]interface{}) multistep.StepActi version, err := driver.Version() if err != nil { - state["error"] = fmt.Errorf("Error reading version for metadata upload: %s", err) + state.Put("error", fmt.Errorf("Error reading version for metadata upload: %s", err)) return multistep.ActionHalt } @@ -33,11 +33,11 @@ func (s *stepUploadVersion) Run(state map[string]interface{}) multistep.StepActi var data bytes.Buffer data.WriteString(version) if err := comm.Upload(config.VBoxVersionFile, &data); err != nil { - state["error"] = fmt.Errorf("Error uploading VirtualBox version: %s", err) + state.Put("error", fmt.Errorf("Error uploading VirtualBox version: %s", err)) return multistep.ActionHalt } return multistep.ActionContinue } -func (s *stepUploadVersion) Cleanup(state map[string]interface{}) {} +func (s *stepUploadVersion) Cleanup(state multistep.StateBag) {} diff --git a/builder/virtualbox/step_vboxmanage.go b/builder/virtualbox/step_vboxmanage.go index 5cd7aa56c..2bc41b90b 100644 --- a/builder/virtualbox/step_vboxmanage.go +++ b/builder/virtualbox/step_vboxmanage.go @@ -19,11 +19,11 @@ type commandTemplate struct { // Produces: type stepVBoxManage struct{} -func (s *stepVBoxManage) Run(state map[string]interface{}) multistep.StepAction { - config := state["config"].(*config) - driver := state["driver"].(Driver) - ui := state["ui"].(packer.Ui) - vmName := state["vmName"].(string) +func (s *stepVBoxManage) Run(state multistep.StateBag) multistep.StepAction { + config := state.Get("config").(*config) + driver := state.Get("driver").(Driver) + ui := state.Get("ui").(packer.Ui) + vmName := state.Get("vmName").(string) if len(config.VBoxManage) > 0 { ui.Say("Executing custom VBoxManage commands...") @@ -42,7 +42,7 @@ func (s *stepVBoxManage) Run(state map[string]interface{}) multistep.StepAction command[i], err = config.tpl.Process(arg, tplData) if err != nil { err := fmt.Errorf("Error preparing vboxmanage command: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -51,7 +51,7 @@ func (s *stepVBoxManage) Run(state map[string]interface{}) multistep.StepAction ui.Message(fmt.Sprintf("Executing: %s", strings.Join(command, " "))) if err := driver.VBoxManage(command...); err != nil { err := fmt.Errorf("Error executing command: %s", err) - state["error"] = err + state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } @@ -60,4 +60,4 @@ func (s *stepVBoxManage) Run(state map[string]interface{}) multistep.StepAction return multistep.ActionContinue } -func (s *stepVBoxManage) Cleanup(state map[string]interface{}) {} +func (s *stepVBoxManage) Cleanup(state multistep.StateBag) {}