// Stop tries to start all associated VMs
func Stop(
buffer *bytes.Buffer,
vmrun vmware.VmrunWrapper,
config *util.LCMConfiguration) error {
// Get all existing clones
clones, err := getClones(vmrun, config)
if err != nil {
return err
}
util.TryWrite2Columns(buffer, 20, "Clones", fmt.Sprint(len(clones)))
util.TryWriteln(buffer, "")
for _, clone := range clones {
if !clone.running {
continue
}
err := vmrun.Stop(clone.path, true)
if err != nil {
return err
}
vmName := tryVMNameExtraction(clone.path)
util.TryWrite2Columns(buffer, 20, " Stopped Clone", vmName)
}
util.TryWriteln(buffer, "")
return nil
}
// getRunningVMPaths returns the paths of running VMs
func getTemplateSnapshots(
vmrun vmware.VmrunWrapper,
config *util.LCMConfiguration) ([]string, error) {
list, err := vmrun.ListSnapshots(config.TemplatePath)
if err != nil {
return nil, err
}
lines := strings.Split(list, "\n")
// Check if at least one line is there
if len(lines) < 1 {
return nil, fmt.Errorf("Failed to parse the listSnapshots command")
}
// Then remove the first line
lines = lines[1:]
var result []string
// Now remove empty lines
for _, line := range lines {
if len(line) == 0 {
continue
}
result = append(result, line)
}
return result, nil
}
// cloneUpTo clones the template up to <<use>> times
func cloneUpTo(
vmrun vmware.VmrunWrapper,
config *util.LCMConfiguration,
clones []*virtualMachine,
use int) ([]string, error) {
// Assert use greater zero
if use <= 0 {
return []string{}, nil
}
// First get available mac addresses
availableAddresses := getAvailableMacAddresses(clones, config)
// calculate how many clones need to be created
diff := math.Max(0, float64(use-len(clones)))
toCreate := int(math.Min(float64(len(availableAddresses)), diff))
if toCreate <= 0 {
return []string{}, nil
}
// Get snapshot for the clones
snapshot, err := prepareTemplateSnapshot(vmrun, config)
if err != nil {
return nil, fmt.Errorf("Failed to prepare snapshot\n%s", err.Error())
}
var created []string
// Now fire the clone command for each of the addresses
for i := 0; i < toCreate; i++ {
address := availableAddresses[i]
vmID := util.MacAddressToVMId(address)
vmName := fmt.Sprintf("%s-%s", config.Prefix, vmID)
vmxPath := fmt.Sprintf(
"%s%s.vmwarevm/%s.vmx",
config.ClonesDirectory,
vmName, vmName)
// First create the linked clone
err := vmrun.CloneLinked(
config.TemplatePath,
config.ClonesDirectory,
vmName, snapshot)
if err != nil {
return nil, fmt.Errorf("Failed to clone vm %s\n%s", vmName, err.Error())
}
// Then configure that clone with the mac address
err = util.UpdateVMX(vmxPath, vmxPath, address)
if err != nil {
return nil, fmt.Errorf("Failed to configure the linked clone %s\n%s",
vmName, err.Error())
}
created = append(created, vmName)
}
return created, nil
}
// getRunningVMPaths returns the paths of running VMs
func getRunningVMPaths(
vmrun vmware.VmrunWrapper) ([]string, error) {
list, err := vmrun.List()
if err != nil {
return nil, err
}
matches := listVMPaths.FindAllString(list, -1)
return matches, nil
}
// createTemplateSnapshot creates a prefixed snapshot of the template
func createTemplateSnapshot(
vmrun vmware.VmrunWrapper,
config *util.LCMConfiguration) (string, error) {
timestamp := int(time.Now().Unix())
// Create snapshot name
snapshotName := fmt.Sprintf("%s-%d", config.Prefix, timestamp)
err := vmrun.Snapshot(config.TemplatePath, snapshotName)
if err != nil {
return "", err
}
return snapshotName, nil
}
// getVmrunVersion returns version information of the used vmrun executable
func getVmrunVersion(
vmrun vmware.VmrunWrapper) (*vmrunVersion, error) {
help, err := vmrun.Help()
if err != nil {
return nil, err
}
matches := helpVmrunVersion.FindStringSubmatch(help)
if len(matches) < 3 {
return nil, fmt.Errorf("Could not parse vmrun version information")
}
result := new(vmrunVersion)
// index 0 is the whole match itself
result.version = matches[1]
result.build = matches[2]
return result, nil
}
// getRunningVMNumber returns the number of running vms
func getRunningVMNumber(
vmrun vmware.VmrunWrapper) (int, error) {
list, err := vmrun.List()
if err != nil {
return 0, err
}
matches := listVMNumber.FindStringSubmatch(list)
if len(matches) < 2 {
return 0, fmt.Errorf("Could not parse vm number information")
}
number, err := strconv.Atoi(matches[1])
if err != nil {
return 0, fmt.Errorf("Could not parse regex match as integer")
}
return number, nil
}
// Deletes up to <<use>> clones
func deleteUpTo(
vmrun vmware.VmrunWrapper,
config *util.LCMConfiguration,
clones []*virtualMachine,
use int) ([]string, error) {
// First order the clones by status
clonesOrdered := orderClonesByRunning(clones)
toDelete := int(math.Min(
float64(len(clonesOrdered)),
math.Abs(float64(len(clones)-use))))
var deletedClones []string
// Then shutdown target clones
for i := 0; i < toDelete; i++ {
clone := clones[i]
// First try to stop the clone if it is running
if clone.running {
// First try a soft stop
err := vmrun.Stop(clone.path, false)
if err != nil {
// then try a hard stop
err = vmrun.Stop(clone.path, true)
if err != nil {
return nil, err
}
}
}
// Run Vmrun delete
err := vmrun.Delete(clone.path)
if err != nil {
return nil, err
}
// Try to find the vmName
vmxMatch := vmxName.FindStringSubmatch(clone.path)
if len(vmxMatch) != 2 {
deletedClones = append(deletedClones, clone.path)
} else {
vmName := strings.TrimSuffix(vmxMatch[1], ".vmx")
deletedClones = append(deletedClones, vmName)
}
}
return deletedClones, nil
}