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