github.com/rothwerx/packer@v0.9.0/builder/vmware/common/driver_workstation9.go (about)

     1  package common
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"log"
     7  	"os"
     8  	"os/exec"
     9  	"path/filepath"
    10  	"strings"
    11  
    12  	"github.com/mitchellh/multistep"
    13  )
    14  
    15  // Workstation9Driver is a driver that can run VMware Workstation 9
    16  type Workstation9Driver struct {
    17  	AppPath          string
    18  	VdiskManagerPath string
    19  	VmrunPath        string
    20  
    21  	// SSHConfig are the SSH settings for the Fusion VM
    22  	SSHConfig *SSHConfig
    23  }
    24  
    25  func (d *Workstation9Driver) Clone(dst, src string) error {
    26  	return errors.New("Cloning is not supported with VMware WS version 9. Please use VMware WS version 10, or greater.")
    27  }
    28  
    29  func (d *Workstation9Driver) CompactDisk(diskPath string) error {
    30  	defragCmd := exec.Command(d.VdiskManagerPath, "-d", diskPath)
    31  	if _, _, err := runAndLog(defragCmd); err != nil {
    32  		return err
    33  	}
    34  
    35  	shrinkCmd := exec.Command(d.VdiskManagerPath, "-k", diskPath)
    36  	if _, _, err := runAndLog(shrinkCmd); err != nil {
    37  		return err
    38  	}
    39  
    40  	return nil
    41  }
    42  
    43  func (d *Workstation9Driver) CreateDisk(output string, size string, type_id string) error {
    44  	cmd := exec.Command(d.VdiskManagerPath, "-c", "-s", size, "-a", "lsilogic", "-t", type_id, output)
    45  	if _, _, err := runAndLog(cmd); err != nil {
    46  		return err
    47  	}
    48  
    49  	return nil
    50  }
    51  
    52  func (d *Workstation9Driver) IsRunning(vmxPath string) (bool, error) {
    53  	vmxPath, err := filepath.Abs(vmxPath)
    54  	if err != nil {
    55  		return false, err
    56  	}
    57  
    58  	cmd := exec.Command(d.VmrunPath, "-T", "ws", "list")
    59  	stdout, _, err := runAndLog(cmd)
    60  	if err != nil {
    61  		return false, err
    62  	}
    63  
    64  	for _, line := range strings.Split(stdout, "\n") {
    65  		if line == vmxPath {
    66  			return true, nil
    67  		}
    68  	}
    69  
    70  	return false, nil
    71  }
    72  
    73  func (d *Workstation9Driver) CommHost(state multistep.StateBag) (string, error) {
    74  	return CommHost(d.SSHConfig)(state)
    75  }
    76  
    77  func (d *Workstation9Driver) Start(vmxPath string, headless bool) error {
    78  	guiArgument := "gui"
    79  	if headless {
    80  		guiArgument = "nogui"
    81  	}
    82  
    83  	cmd := exec.Command(d.VmrunPath, "-T", "ws", "start", vmxPath, guiArgument)
    84  	if _, _, err := runAndLog(cmd); err != nil {
    85  		return err
    86  	}
    87  
    88  	return nil
    89  }
    90  
    91  func (d *Workstation9Driver) Stop(vmxPath string) error {
    92  	cmd := exec.Command(d.VmrunPath, "-T", "ws", "stop", vmxPath, "hard")
    93  	if _, _, err := runAndLog(cmd); err != nil {
    94  		return err
    95  	}
    96  
    97  	return nil
    98  }
    99  
   100  func (d *Workstation9Driver) SuppressMessages(vmxPath string) error {
   101  	return nil
   102  }
   103  
   104  func (d *Workstation9Driver) Verify() error {
   105  	var err error
   106  	if d.AppPath == "" {
   107  		if d.AppPath, err = workstationFindVMware(); err != nil {
   108  			return err
   109  		}
   110  	}
   111  
   112  	if d.VmrunPath == "" {
   113  		if d.VmrunPath, err = workstationFindVmrun(); err != nil {
   114  			return err
   115  		}
   116  	}
   117  
   118  	if d.VdiskManagerPath == "" {
   119  		if d.VdiskManagerPath, err = workstationFindVdiskManager(); err != nil {
   120  			return err
   121  		}
   122  	}
   123  
   124  	log.Printf("VMware app path: %s", d.AppPath)
   125  	log.Printf("vmrun path: %s", d.VmrunPath)
   126  	log.Printf("vdisk-manager path: %s", d.VdiskManagerPath)
   127  
   128  	if _, err := os.Stat(d.AppPath); err != nil {
   129  		return fmt.Errorf("VMware application not found: %s", d.AppPath)
   130  	}
   131  
   132  	if _, err := os.Stat(d.VmrunPath); err != nil {
   133  		return fmt.Errorf("'vmrun' application not found: %s", d.VmrunPath)
   134  	}
   135  
   136  	if _, err := os.Stat(d.VdiskManagerPath); err != nil {
   137  		return fmt.Errorf("'vmware-vdiskmanager' application not found: %s", d.VdiskManagerPath)
   138  	}
   139  
   140  	// Check to see if it APPEARS to be licensed.
   141  	if err := workstationCheckLicense(); err != nil {
   142  		return err
   143  	}
   144  
   145  	return nil
   146  }
   147  
   148  func (d *Workstation9Driver) ToolsIsoPath(flavor string) string {
   149  	return workstationToolsIsoPath(flavor)
   150  }
   151  
   152  func (d *Workstation9Driver) ToolsInstall() error {
   153  	return nil
   154  }
   155  
   156  func (d *Workstation9Driver) DhcpLeasesPath(device string) string {
   157  	return workstationDhcpLeasesPath(device)
   158  }
   159  
   160  func (d *Workstation9Driver) VmnetnatConfPath() string {
   161  	return workstationVmnetnatConfPath()
   162  }