packer-cn/builder/hyperv/common/step_mount_floppydrive.go

183 lines
4.2 KiB
Go
Raw Normal View History

// Copyright (c) Microsoft Open Technologies, Inc.
// All Rights Reserved.
// Licensed under the Apache License, Version 2.0.
// See License.txt in the project root for license information.
package common
import (
"fmt"
"github.com/mitchellh/multistep"
"github.com/mitchellh/packer/packer"
"github.com/mitchellh/packer/powershell"
"github.com/mitchellh/packer/powershell/hyperv"
"io"
"io/ioutil"
"log"
"os"
"path/filepath"
"strings"
)
const (
FloppyFileName = "assets.vfd"
)
type StepSetUnattendedProductKey struct {
Files []string
ProductKey string
}
func (s *StepSetUnattendedProductKey) Run(state multistep.StateBag) multistep.StepAction {
ui := state.Get("ui").(packer.Ui)
if s.ProductKey == "" {
ui.Say("No product key specified...")
return multistep.ActionContinue
}
index := -1
for i, value := range s.Files {
if s.caseInsensitiveContains(value, "Autounattend.xml") {
index = i
break
}
}
ui.Say("Setting product key in Autounattend.xml...")
copyOfAutounattend, err := s.copyAutounattend(s.Files[index])
if err != nil {
state.Put("error", fmt.Errorf("Error copying Autounattend.xml: %s", err))
return multistep.ActionHalt
}
powershell.SetUnattendedProductKey(copyOfAutounattend, s.ProductKey)
s.Files[index] = copyOfAutounattend
return multistep.ActionContinue
}
func (s *StepSetUnattendedProductKey) caseInsensitiveContains(str, substr string) bool {
str, substr = strings.ToUpper(str), strings.ToUpper(substr)
return strings.Contains(str, substr)
}
func (s *StepSetUnattendedProductKey) copyAutounattend(path string) (string, error) {
tempdir, err := ioutil.TempDir("", "packer")
if err != nil {
return "", err
}
autounattend := filepath.Join(tempdir, "Autounattend.xml")
f, err := os.Create(autounattend)
if err != nil {
return "", err
}
defer f.Close()
sourceF, err := os.Open(path)
if err != nil {
return "", err
}
defer sourceF.Close()
log.Printf("Copying %s to temp location: %s", path, autounattend)
if _, err := io.Copy(f, sourceF); err != nil {
return "", err
}
return autounattend, nil
}
func (s *StepSetUnattendedProductKey) Cleanup(state multistep.StateBag) {
}
type StepMountFloppydrive struct {
floppyPath string
}
func (s *StepMountFloppydrive) Run(state multistep.StateBag) multistep.StepAction {
// Determine if we even have a floppy disk to attach
var floppyPath string
if floppyPathRaw, ok := state.GetOk("floppy_path"); ok {
floppyPath = floppyPathRaw.(string)
} else {
log.Println("No floppy disk, not attaching.")
return multistep.ActionContinue
}
// Hyper-V is really dumb and can't figure out the format of the file
// without an extension, so we need to add the "vfd" extension to the
// floppy.
floppyPath, err := s.copyFloppy(floppyPath)
if err != nil {
state.Put("error", fmt.Errorf("Error preparing floppy: %s", err))
return multistep.ActionHalt
}
ui := state.Get("ui").(packer.Ui)
vmName := state.Get("vmName").(string)
ui.Say("Mounting floppy drive...")
err = hyperv.MountFloppyDrive(vmName, floppyPath)
if err != nil {
state.Put("error", fmt.Errorf("Error mounting floppy drive: %s", err))
return multistep.ActionHalt
}
// Track the path so that we can unregister it from Hyper-V later
s.floppyPath = floppyPath
return multistep.ActionContinue
}
func (s *StepMountFloppydrive) Cleanup(state multistep.StateBag) {
if s.floppyPath == "" {
return
}
errorMsg := "Error unmounting floppy drive: %s"
vmName := state.Get("vmName").(string)
ui := state.Get("ui").(packer.Ui)
ui.Say("Unmounting floppy drive (cleanup)...")
err := hyperv.UnmountFloppyDrive(vmName)
if err != nil {
ui.Error(fmt.Sprintf(errorMsg, err))
}
err = os.Remove(s.floppyPath)
if err != nil {
ui.Error(fmt.Sprintf(errorMsg, err))
}
}
func (s *StepMountFloppydrive) copyFloppy(path string) (string, error) {
tempdir, err := ioutil.TempDir("", "packer")
if err != nil {
return "", err
}
floppyPath := filepath.Join(tempdir, "floppy.vfd")
f, err := os.Create(floppyPath)
if err != nil {
return "", err
}
defer f.Close()
sourceF, err := os.Open(path)
if err != nil {
return "", err
}
defer sourceF.Close()
log.Printf("Copying floppy to temp location: %s", floppyPath)
if _, err := io.Copy(f, sourceF); err != nil {
return "", err
}
return floppyPath, nil
}