iSharkFly-Docs
/
packer-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'rasa-master' 

This adds support for Windows VMware Workstation
This commit is contained in:
Mitchell Hashimoto 2013-07-31 11:53:00 -07:00
parent cecb797e61 fc89919347
commit 60520c11c2
8 changed files with 405 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
builder/vmware/driver.go
View File

@ -46,7 +46,9 @@ func NewDriver() (Driver, error) {
AppPath: "/Applications/VMware Fusion.app",
}
case "linux":
driver = &Workstation9LinuxDriver{}
fallthrough
case "windows":
driver = &Workstation9Driver{}
default:
return nil, fmt.Errorf("can't find driver for OS: %s", runtime.GOOS)
}

32
builder/vmware/driver_workstation9.go
View File

@ -1,3 +1,5 @@
// +build darwin freebsd linux netbsd openbsd
package vmware
import (
@ -10,15 +12,15 @@ import (
"strings"
)
// Workstation9LinuxDriver is a driver that can run VMware Workstation 9
// on Linux.
type Workstation9LinuxDriver struct {
// Workstation9Driver is a driver that can run VMware Workstation 9
// on non-Windows platforms.
type Workstation9Driver struct {
AppPath string
VdiskManagerPath string
VmrunPath string
}
func (d *Workstation9LinuxDriver) CompactDisk(diskPath string) error {
func (d *Workstation9Driver) CompactDisk(diskPath string) error {
defragCmd := exec.Command(d.VdiskManagerPath, "-d", diskPath)
if _, _, err := d.runAndLog(defragCmd); err != nil {
return err
@ -32,7 +34,7 @@ func (d *Workstation9LinuxDriver) CompactDisk(diskPath string) error {
return nil
}
func (d *Workstation9LinuxDriver) CreateDisk(output string, size string) error {
func (d *Workstation9Driver) CreateDisk(output string, size string) error {
cmd := exec.Command(d.VdiskManagerPath, "-c", "-s", size, "-a", "lsilogic", "-t", "1", output)
if _, _, err := d.runAndLog(cmd); err != nil {
return err
@ -41,7 +43,7 @@ func (d *Workstation9LinuxDriver) CreateDisk(output string, size string) error {
return nil
}
func (d *Workstation9LinuxDriver) IsRunning(vmxPath string) (bool, error) {
func (d *Workstation9Driver) IsRunning(vmxPath string) (bool, error) {
vmxPath, err := filepath.Abs(vmxPath)
if err != nil {
return false, err
@ -62,7 +64,7 @@ func (d *Workstation9LinuxDriver) IsRunning(vmxPath string) (bool, error) {
return false, nil
}
func (d *Workstation9LinuxDriver) Start(vmxPath string, headless bool) error {
func (d *Workstation9Driver) Start(vmxPath string, headless bool) error {
guiArgument := "gui"
if headless {
guiArgument = "nogui"
@ -76,7 +78,7 @@ func (d *Workstation9LinuxDriver) Start(vmxPath string, headless bool) error {
return nil
}
func (d *Workstation9LinuxDriver) Stop(vmxPath string) error {
func (d *Workstation9Driver) Stop(vmxPath string) error {
cmd := exec.Command(d.VmrunPath, "-T", "ws", "stop", vmxPath, "hard")
if _, _, err := d.runAndLog(cmd); err != nil {
return err
@ -85,7 +87,7 @@ func (d *Workstation9LinuxDriver) Stop(vmxPath string) error {
return nil
}
func (d *Workstation9LinuxDriver) Verify() error {
func (d *Workstation9Driver) Verify() error {
if err := d.findApp(); err != nil {
return fmt.Errorf("VMware Workstation application ('vmware') not found in path.")
}
@ -111,7 +113,7 @@ func (d *Workstation9LinuxDriver) Verify() error {
return nil
}
func (d *Workstation9LinuxDriver) findApp() error {
func (d *Workstation9Driver) findApp() error {
path, err := exec.LookPath("vmware")
if err != nil {
return err
@ -120,7 +122,7 @@ func (d *Workstation9LinuxDriver) findApp() error {
return nil
}
func (d *Workstation9LinuxDriver) findVdiskManager() error {
func (d *Workstation9Driver) findVdiskManager() error {
path, err := exec.LookPath("vmware-vdiskmanager")
if err != nil {
return err
@ -129,7 +131,7 @@ func (d *Workstation9LinuxDriver) findVdiskManager() error {
return nil
}
func (d *Workstation9LinuxDriver) findVmrun() error {
func (d *Workstation9Driver) findVmrun() error {
path, err := exec.LookPath("vmrun")
if err != nil {
return err
@ -138,15 +140,15 @@ func (d *Workstation9LinuxDriver) findVmrun() error {
return nil
}
func (d *Workstation9LinuxDriver) ToolsIsoPath(flavor string) string {
func (d *Workstation9Driver) ToolsIsoPath(flavor string) string {
return "/usr/lib/vmware/isoimages/" + flavor + ".iso"
}
func (d *Workstation9LinuxDriver) DhcpLeasesPath(device string) string {
func (d *Workstation9Driver) DhcpLeasesPath(device string) string {
return "/etc/vmware/" + device + "/dhcpd/dhcpd.leases"
}
func (d *Workstation9LinuxDriver) runAndLog(cmd *exec.Cmd) (string, string, error) {
func (d *Workstation9Driver) runAndLog(cmd *exec.Cmd) (string, string, error) {
var stdout, stderr bytes.Buffer
log.Printf("Executing: %s %v", cmd.Path, cmd.Args[1:])

257
builder/vmware/driver_workstation9_windows.go Normal file
View File

@ -0,0 +1,257 @@
// +build windows
// Contributed by Ross Smith II (smithii.com)
package vmware
import (
"bytes"
"fmt"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"syscall"
"unsafe"
)
// Workstation9Driver is a driver that can run VMware Workstation 9
// on Windows.
type Workstation9Driver struct {
AppPath string
VdiskManagerPath string
VmrunPath string
}
func (d *Workstation9Driver) CompactDisk(diskPath string) error {
defragCmd := exec.Command(d.VdiskManagerPath, "-d", diskPath)
if _, _, err := d.runAndLog(defragCmd); err != nil {
return err
}
shrinkCmd := exec.Command(d.VdiskManagerPath, "-k", diskPath)
if _, _, err := d.runAndLog(shrinkCmd); err != nil {
return err
}
return nil
}
func (d *Workstation9Driver) CreateDisk(output string, size string) error {
cmd := exec.Command(d.VdiskManagerPath, "-c", "-s", size, "-a", "lsilogic", "-t", "1", output)
if _, _, err := d.runAndLog(cmd); err != nil {
return err
}
return nil
}
func (d *Workstation9Driver) IsRunning(vmxPath string) (bool, error) {
vmxPath, err := filepath.Abs(vmxPath)
if err != nil {
return false, err
}
cmd := exec.Command(d.VmrunPath, "-T", "ws", "list")
stdout, _, err := d.runAndLog(cmd)
if err != nil {
return false, err
}
for _, line := range strings.Split(stdout, "\n") {
if line == vmxPath {
return true, nil
}
}
return false, nil
}
func (d *Workstation9Driver) Start(vmxPath string, headless bool) error {
guiArgument := "gui"
if headless {
guiArgument = "nogui"
}
cmd := exec.Command(d.VmrunPath, "-T", "ws", "start", vmxPath, guiArgument)
if _, _, err := d.runAndLog(cmd); err != nil {
return err
}
return nil
}
func (d *Workstation9Driver) Stop(vmxPath string) error {
cmd := exec.Command(d.VmrunPath, "-T", "ws", "stop", vmxPath, "hard")
if _, _, err := d.runAndLog(cmd); err != nil {
return err
}
return nil
}
func (d *Workstation9Driver) Verify() error {
if err := d.findApp(); err != nil {
return fmt.Errorf("VMware Workstation application ('vmware') not found in path.")
}
if err := d.findVmrun(); err != nil {
return fmt.Errorf("Required application 'vmrun' not found in path.")
}
if err := d.findVdiskManager(); err != nil {
return fmt.Errorf("Required application 'vmware-vdiskmanager' not found in path.")
}
// Check to see if it APPEARS to be licensed.
/*
matches, err := filepath.Glob("/etc/vmware/license-*")
if err != nil {
return fmt.Errorf("Error looking for VMware license: %s", err)
}
if len(matches) == 0 {
return errors.New("Workstation does not appear to be licensed. Please license it.")
}
*/
return nil
}
func (d *Workstation9Driver) findApp() error {
path, err := exec.LookPath("vmware.exe")
if err != nil {
path, err := getVmwarePath()
if err != nil {
return err
}
path += "vmware.exe"
}
path = strings.Replace(path, "\\", "/", -1)
log.Printf("Using '%s' for vmware path", path)
d.AppPath = path
return nil
}
func (d *Workstation9Driver) findVdiskManager() error {
path, err := exec.LookPath("vmware-vdiskmanager.exe")
if err != nil {
path, err := getVmwarePath()
if err != nil {
return err
}
path += "vmware-vdiskmanager.exe"
}
path = strings.Replace(path, "\\", "/", -1)
log.Printf("Using '%s' for vmware-vdiskmanager path", path)
d.VdiskManagerPath = path
return nil
}
func (d *Workstation9Driver) findVmrun() error {
path, err := exec.LookPath("vmrun.exe")
if err != nil {
path, err := getVmwarePath()
if err != nil {
return err
}
path += "vmrun.exe"
}
path = strings.Replace(path, "\\", "/", -1)
log.Printf("Using '%s' for vmrun path", path)
d.VmrunPath = path
return nil
}
func (d *Workstation9Driver) ToolsIsoPath(flavor string) string {
path, err := getVmwarePath()
if err != nil {
return ""
} else {
return path + flavor + ".iso"
}
}
func (d *Workstation9Driver) DhcpLeasesPath(device string) string {
programData := os.Getenv("ProgramData")
rv := programData + "/VMware/vmnetdhcp.leases"
if _, err := os.Stat(rv); os.IsNotExist(err) {
log.Printf("File not found: '%s' (found '%s' in %%ProgramData%%)", rv, programData)
return ""
}
return rv
}
func (d *Workstation9Driver) runAndLog(cmd *exec.Cmd) (string, string, error) {
var stdout, stderr bytes.Buffer
log.Printf("Executing: %s %v", cmd.Path, cmd.Args[1:])
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
stdoutString := strings.TrimSpace(stdout.String())
stderrString := strings.TrimSpace(stderr.String())
if _, ok := err.(*exec.ExitError); ok {
err = fmt.Errorf("VMware error: %s", stderrString)
}
log.Printf("stdout: %s", stdoutString)
log.Printf("stderr: %s", stderrString)
return stdout.String(), stderr.String(), err
}
// see http://blog.natefinch.com/2012/11/go-win-stuff.html
func readRegString(hive syscall.Handle, subKeyPath, valueName string) (value string, err error) {
var h syscall.Handle
err = syscall.RegOpenKeyEx(hive, syscall.StringToUTF16Ptr(subKeyPath), 0, syscall.KEY_READ, &h)
if err != nil {
return
}
defer syscall.RegCloseKey(h)
var typ uint32
var bufSize uint32
err = syscall.RegQueryValueEx(
h,
syscall.StringToUTF16Ptr(valueName),
nil,
&typ,
nil,
&bufSize)
if err != nil {
return
}
data := make([]uint16, bufSize/2+1)
err = syscall.RegQueryValueEx(
h,
syscall.StringToUTF16Ptr(valueName),
nil,
&typ,
(*byte)(unsafe.Pointer(&data[0])),
&bufSize)
if err != nil {
return
}
return syscall.UTF16ToString(data), nil
}
func getVmwarePath() (s string, e error) {
key := "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\vmware.exe"
subkey := "Path"
s, e = readRegString(syscall.HKEY_LOCAL_MACHINE, key, subkey)
if e != nil {
log.Printf("Unable to read registry key %s\\%s", key, subkey)
return "", e
}
log.Printf("Found '%s' in registry key %s\\%s", s, key, subkey)
s = strings.Replace(s, "\\", "/", -1)
return s, nil
}

3
builder/vmware/guest_ip.go
View File

@ -50,6 +50,9 @@ func (f *DHCPLeaseGuestLookup) GuestIP() (string, error) {
macLineRe := regexp.MustCompile(`^\s*hardware ethernet (.+?);$`)
for _, line := range strings.Split(string(dhcpBytes), "\n") {
// Need to trim off CR character when running in windows
line = strings.TrimRight(line, "\r")
matches := ipLineRe.FindStringSubmatch(line)
if matches != nil {
lastIp = matches[1]

2
builder/vmware/host_ip.go
View File

@ -1,3 +1,5 @@
// +build darwin freebsd linux netbsd openbsd
package vmware
import (

118
builder/vmware/host_ip_windows.go Normal file
View File

@ -0,0 +1,118 @@
// +build windows
// Contributed by Ross Smith II (smithii.com)
package vmware
import (
"errors"
"io/ioutil"
"log"
"net"
"os"
"regexp"
"strings"
)
// Interface to help find the host IP that is available from within
// the VMware virtual machines.
type HostIPFinder interface {
HostIP() (string, error)
}
// IfconfigIPFinder finds the host IP based on the output of `ifconfig`.
type IfconfigIPFinder struct {
Device string
}
func (f *IfconfigIPFinder) HostIP() (string, error) {
ift, err := net.Interfaces()
if err != nil {
return "", errors.New("No network interfaces found")
}
vmwareMac, err := getVMWareMAC()
if err != nil {
log.Print(err)
}
log.Printf("Searching for MAC %s", vmwareMac)
re := regexp.MustCompile("(?i)^" + vmwareMac)
ip := ""
for _, ifi := range ift {
mac := ifi.HardwareAddr.String()
log.Printf("Found MAC %s", mac)
matches := re.FindStringSubmatch(mac)
if matches == nil {
continue
}
addrs, err := ifi.Addrs()
if err != nil {
log.Printf("No IP addresses found for MAC %s", mac)
continue
}
for _, address := range addrs {
ip = address.String()
log.Printf("Found IP address %s for MAC %s", ip, mac)
}
// continue looping as VMNet8 comes after VMNet1 (at least on my system)
}
if ip == "" {
return "", errors.New("No MACs found matching " + vmwareMac)
}
log.Printf("Returning IP address %s", ip)
return ip, nil
}
func getVMWareMAC() (string, error) {
// return the first three tuples, if the actual MAC cannot be found
const defaultMacRe = "00:50:56"
programData := os.Getenv("ProgramData")
programData = strings.Replace(programData, "\\", "/", -1)
vmnetnat := programData + "/VMware/vmnetnat.conf"
if _, err := os.Stat(vmnetnat); os.IsNotExist(err) {
log.Printf("File not found: '%s' (found '%s' in %%ProgramData%%)", vmnetnat, programData)
return defaultMacRe, err
}
log.Printf("Searching for key hostMAC in '%s'", vmnetnat)
fh, err := os.Open(vmnetnat)
if err != nil {
return defaultMacRe, err
}
defer fh.Close()
bytes, err := ioutil.ReadAll(fh)
if err != nil {
return defaultMacRe, err
}
hostMacRe := regexp.MustCompile(`(?i)^\s*hostMAC\s*=\s*(.+)\s*$`)
for _, line := range strings.Split(string(bytes), "\n") {
// Need to trim off CR character when running in windows
line = strings.TrimRight(line, "\r")
matches := hostMacRe.FindStringSubmatch(line)
if matches != nil {
log.Printf("Found MAC '%s' in '%s'", matches[1], vmnetnat)
return matches[1], nil
}
}
log.Printf("Did not find key hostMAC in '%s', using %s instead", vmnetnat, defaultMacRe)
return defaultMacRe, nil
}

1
scripts/dist.sh Executable file → Normal file
View File

@ -36,6 +36,7 @@ xc() {
-d="${DIR}/pkg" \
-pv="${VERSION}" \
-pr="${PREVERSION}" \
$XC_OPTS \
go-install \
xc
}

7
website/source/docs/builders/vmware.html.markdown
View File

@ -7,9 +7,10 @@ layout: "docs"
Type: `vmware`
The VMware builder is able to create VMware virtual machines. It currently
only supports building the virtual machines using
[VMware Fusion](http://www.vmware.com/products/fusion/overview.html), but
support for Windows and other VMware products is forthcoming.
supports building virtual machines on hosts running
[VMware Fusion](http://www.vmware.com/products/fusion/overview.html) for OS X, and
[VMware Workstation](http://www.vmware.com/products/workstation/overview.html) for Linux and Windows.
Support for VMWare ESXi/vSphere and VMWare Player is forthcoming.
The builder builds a virtual machine by creating a new virtual machine
from scratch, booting it, installing an OS, provisioning software within