示例#1
0
文件: power.go 项目: ankoh/vmlcm
// 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
}
示例#2
0
文件: snapshots.go 项目: ankoh/vmlcm
// Snapshot creates a new template snapshot
func Snapshot(
	buffer *bytes.Buffer,
	vmrun vmware.VmrunWrapper,
	config *util.LCMConfiguration) error {
	// Fetch all vms that can be discovered easily (clone folder && running)
	vms, err := getVMs(vmrun, config)
	if err != nil {
		return err
	}

	// Find template
	var template *virtualMachine
	for _, vm := range vms {
		if vm.template {
			template = vm
		}
	}

	// Check if template has been found
	if template == nil {
		return fmt.Errorf("Could not find template %s", template)
	}

	// I wont hard shutdown the template for a snapshot as the template is more
	// vulnerable to hard shutdowns
	if template.running {
		util.TryWriteVerification(buffer, "Template Offline", false)

		var warning bytes.Buffer
		buffer.WriteString("\nAborting: Please shutdown the template first.\n")
		return fmt.Errorf(warning.String())
	}
	util.TryWriteVerification(buffer, "Template Offline", true)

	// Then create the snapshot
	snapshotName, err := createTemplateSnapshot(vmrun, config)
	if err != nil {
		return fmt.Errorf(
			"Failed to create a template snapshot.\nError:\n%s", err.Error())
	}
	buffer.WriteString("\n")
	util.TryWrite2Columns(buffer, 20, "Created Snapshot", snapshotName)
	buffer.WriteString("\n")
	return nil
}
示例#3
0
文件: clones.go 项目: ankoh/vmlcm
// Use ensures that <<use>> number of clones exist
// Attention buffer may be nil
func Use(
	buffer *bytes.Buffer,
	vmrun vmware.VmrunWrapper,
	config *util.LCMConfiguration,
	use int) error {
	// Check use parameter
	if use < 0 {
		return fmt.Errorf("Parameter must be >= zero")
	}

	// First check mac addresses
	if len(config.Addresses) < use {
		return fmt.Errorf("Tried to use %d clones with only %d mac addresses",
			use, len(config.Addresses))
	}

	// Then check the number of clones
	// Get all existing clones
	clones, err := getClones(vmrun, config)
	if err != nil {
		return err
	}

	util.TryWrite2Columns(buffer, 20, "Old clones", fmt.Sprint(len(clones)))
	util.TryWrite2Columns(buffer, 20, "New clones", fmt.Sprint(use))

	// Check if number of existing clones equals the parameter (== noop)
	if len(clones) == use {
		util.TryWriteln(buffer, "")
		util.TryWrite2Columns(buffer, 20, "  Nothing to do...", ":'(")
		util.TryWriteln(buffer, "")
		return nil
	}

	// Check if clones need to be created
	if len(clones) < use {
		createdClones, err := cloneUpTo(vmrun, config, clones, use)
		if err != nil {
			return err
		}
		util.TryWriteln(buffer, "")
		for _, createdClone := range createdClones {
			util.TryWrite2Columns(buffer, 20, "  Created Clone", createdClone)
		}
		util.TryWriteln(buffer, "")
	}

	// Check if clones need to be deleted
	if len(clones) > use {
		deletedClones, err := deleteUpTo(vmrun, config, clones, use)
		if err != nil {
			return err
		}
		util.TryWriteln(buffer, "")
		for _, deletedClone := range deletedClones {
			util.TryWrite2Columns(buffer, 20, "  Deleted Clone", deletedClone)
		}
		util.TryWriteln(buffer, "")
	}

	return nil
}