func (s *stepConfigureVNC) Run(state multistep.StateBag) multistep.StepAction { config := state.Get("config").(*config) driver := state.Get("driver").(vmwcommon.Driver) ui := state.Get("ui").(packer.Ui) vmxPath := state.Get("vmx_path").(string) f, err := os.Open(vmxPath) if err != nil { err := fmt.Errorf("Error reading VMX data: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmxBytes, err := ioutil.ReadAll(f) if err != nil { err := fmt.Errorf("Error reading VMX data: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } var vncFinder VNCAddressFinder if finder, ok := driver.(VNCAddressFinder); ok { vncFinder = finder } else { vncFinder = s } log.Printf("Looking for available port between %d and %d", config.VNCPortMin, config.VNCPortMax) vncIp, vncPort := vncFinder.VNCAddress(config.VNCPortMin, config.VNCPortMax) if vncPort == 0 { err := fmt.Errorf("Unable to find available VNC port between %d and %d", config.VNCPortMin, config.VNCPortMax) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } log.Printf("Found available VNC port: %d", vncPort) vmxData := vmwcommon.ParseVMX(string(vmxBytes)) vmxData["remotedisplay.vnc.enabled"] = "TRUE" vmxData["remotedisplay.vnc.port"] = fmt.Sprintf("%d", vncPort) if err := vmwcommon.WriteVMX(vmxPath, vmxData); err != nil { err := fmt.Errorf("Error writing VMX data: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } state.Put("vnc_port", vncPort) state.Put("vnc_ip", vncIp) return multistep.ActionContinue }
func (p *PostProcessor) RemoveFloppy(vmx string, ui packer.Ui) error { ui.Message(fmt.Sprintf("Removing floppy from %s", vmx)) vmxData, err := vmwarecommon.ReadVMX(vmx) if err != nil { return err } for k, _ := range vmxData { if strings.HasPrefix(k, "floppy0.") { delete(vmxData, k) } } vmxData["floppy0.present"] = "FALSE" if err := vmwarecommon.WriteVMX(vmx, vmxData); err != nil { return err } return nil }
func (p *OVFPostProcessor) stripDrives(vmx string) error { vmxData, err := vmwcommon.ReadVMX(vmx) if err != nil { return err } for k, _ := range vmxData { if strings.HasPrefix(k, "floppy0.") { delete(vmxData, k) } if strings.HasPrefix(k, "ide1:0.file") { delete(vmxData, k) } } vmxData["floppy0.present"] = "FALSE" vmxData["ide1:0.present"] = "FALSE" if err := vmwcommon.WriteVMX(vmx, vmxData); err != nil { return err } return nil }
func (p *PostProcessor) RemoveOpticalDrive(vmx string, ui packer.Ui, artifact packer.Artifact) error { ui.Message(fmt.Sprintf("Removing optical drive from %s", vmx)) vmxData, err := vmwarecommon.ReadVMX(vmx) if err != nil { return err } for k, _ := range vmxData { if strings.HasPrefix(k, "ide1:0.file") { delete(vmxData, k) } } vmxData["ide1:0.present"] = "FALSE" if err := vmwarecommon.WriteVMX(vmx, vmxData); err != nil { return err } return nil }
func (p *VMwarevCenterProvider) Process(ui packer.Ui, artifact packer.Artifact, dir string) (vagrantfile string, metadata map[string]interface{}, err error) { // Create the metadata metadata = map[string]interface{}{"provider": "vcenter"} vmx := "" ovf := "" basepath := "" for _, path := range artifact.Files() { if strings.HasSuffix(path, ".vmx") { vmx = path ovf = filepath.Base(vmx[:len(vmx)-4] + ".ovf") basepath = filepath.Dir(path) + "/ovf" } } vmxData, err := vmwcommon.ReadVMX(vmx) if err != nil { ui.Message(fmt.Sprintf("err: %s", err)) } for k, _ := range vmxData { if strings.HasPrefix(k, "floppy0.") { ui.Message(fmt.Sprintf("Deleting key: %s", k)) delete(vmxData, k) } if strings.HasPrefix(k, "ide1:0.") { ui.Message(fmt.Sprintf("Deleting key: %s", k)) delete(vmxData, k) } if strings.HasPrefix(k, "ide1:1.") { ui.Message(fmt.Sprintf("Deleting key: %s", k)) delete(vmxData, k) } } // remove floppy (again) ui.Message(fmt.Sprintf("Setting key: floppy0.present = FALSE")) vmxData["floppy0.present"] = "FALSE" // detach DVD (again) ui.Message(fmt.Sprintf("Setting key: ide1:0.present = FALSE")) vmxData["ide1:0.present"] = "FALSE" // Rewrite the VMX if err := vmwcommon.WriteVMX(vmx, vmxData); err != nil { ui.Message(fmt.Sprintf("err: %s", err)) } program, err := FindOvfTool() sourcetype := "--sourceType=VMX" targettype := "--targetType=OVF" ui.Message(fmt.Sprintf("Creating directory: %s", basepath)) if err := os.Mkdir(basepath, 0755); err != nil { ui.Message(fmt.Sprintf("err: %s", err)) } cmd := exec.Command(program, sourcetype, targettype, vmx, basepath+"/"+ovf) ui.Message(fmt.Sprintf("Starting ovftool")) cmd.Start() cmd.Wait() ui.Message(fmt.Sprintf("Reading files in %s", basepath)) files, _ := ioutil.ReadDir(basepath) for _, path := range files { ui.Message(fmt.Sprintf("Copying: %s", path.Name())) dstPath := filepath.Join(dir, path.Name()) if err = CopyContents(dstPath, basepath+"/"+path.Name()); err != nil { return } } return }
func (s *stepCreateVMX) Run(state multistep.StateBag) multistep.StepAction { config := state.Get("config").(*Config) isoPath := state.Get("iso_path").(string) ui := state.Get("ui").(packer.Ui) ui.Say("Building and writing VMX file") vmxTemplate := DefaultVMXTemplate if config.VMXTemplatePath != "" { f, err := os.Open(config.VMXTemplatePath) if err != nil { err := fmt.Errorf("Error reading VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } defer f.Close() rawBytes, err := ioutil.ReadAll(f) if err != nil { err := fmt.Errorf("Error reading VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmxTemplate = string(rawBytes) } ctx := config.ctx if len(config.AdditionalDiskSize) > 0 { for i := range config.AdditionalDiskSize { ctx.Data = &additionalDiskTemplateData{ DiskNumber: i + 1, DiskName: config.DiskName, } diskTemplate := DefaultAdditionalDiskTemplate if config.VMXDiskTemplatePath != "" { f, err := os.Open(config.VMXDiskTemplatePath) if err != nil { err := fmt.Errorf("Error reading VMX disk template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } defer f.Close() rawBytes, err := ioutil.ReadAll(f) if err != nil { err := fmt.Errorf("Error reading VMX disk template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } diskTemplate = string(rawBytes) } diskContents, err := interpolate.Render(diskTemplate, &ctx) if err != nil { err := fmt.Errorf("Error preparing VMX template for additional disk: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmxTemplate += diskContents } } ctx.Data = &vmxTemplateData{ Name: config.VMName, GuestOS: config.GuestOSType, DiskName: config.DiskName, Version: config.Version, ISOPath: isoPath, } vmxContents, err := interpolate.Render(vmxTemplate, &ctx) if err != nil { err := fmt.Errorf("Error procesing VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmxDir := config.OutputDir if config.RemoteType != "" { // For remote builds, we just put the VMX in a temporary // directory since it just gets uploaded anyways. vmxDir, err = ioutil.TempDir("", "packer-vmx") if err != nil { err := fmt.Errorf("Error preparing VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } // Set the tempDir so we clean it up s.tempDir = vmxDir } vmxPath := filepath.Join(vmxDir, config.VMName+".vmx") if err := vmwcommon.WriteVMX(vmxPath, vmwcommon.ParseVMX(vmxContents)); err != nil { err := fmt.Errorf("Error creating VMX file: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } state.Put("vmx_path", vmxPath) return multistep.ActionContinue }
func (s *stepCreateVMX) Run(state multistep.StateBag) multistep.StepAction { config := state.Get("config").(*config) isoPath := state.Get("iso_path").(string) ui := state.Get("ui").(packer.Ui) ui.Say("Building and writing VMX file") tplData := &vmxTemplateData{ Name: config.VMName, GuestOS: config.GuestOSType, DiskName: config.DiskName, ISOPath: isoPath, } vmxTemplate := DefaultVMXTemplate if config.VMXTemplatePath != "" { f, err := os.Open(config.VMXTemplatePath) if err != nil { err := fmt.Errorf("Error reading VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } defer f.Close() rawBytes, err := ioutil.ReadAll(f) if err != nil { err := fmt.Errorf("Error reading VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmxTemplate = string(rawBytes) } vmxContents, err := config.tpl.Process(vmxTemplate, tplData) if err != nil { err := fmt.Errorf("Error procesing VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmxDir := config.OutputDir if config.RemoteType != "" { // For remote builds, we just put the VMX in a temporary // directory since it just gets uploaded anyways. vmxDir, err = ioutil.TempDir("", "packer-vmx") if err != nil { err := fmt.Errorf("Error preparing VMX template: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } // Set the tempDir so we clean it up s.tempDir = vmxDir } vmxPath := filepath.Join(vmxDir, config.VMName+".vmx") if err := vmwcommon.WriteVMX(vmxPath, vmwcommon.ParseVMX(vmxContents)); err != nil { err := fmt.Errorf("Error creating VMX file: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } state.Put("vmx_path", vmxPath) return multistep.ActionContinue }