Golang vix.VM类代码示例

func resourceVIXVMCreate(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*Config)

	vm := new(vix.VM)
	vm.Provider = config.Product
	vm.VerifySSL = config.VerifySSL

	if err := tf_to_vix(d, vm); err != nil {
		return err
	}

	id, err := vm.Create()
	if err != nil {
		return err
	}

	log.Printf("[DEBUG] Resource ID: %s\n", id)
	d.SetId(id)

	// Initialize the connection info
	d.SetConnInfo(map[string]string{
		"type": "ssh",
		"host": vm.IPAddress,
	})

	return resourceVIXVMRead(d, meta)
}

func resourceVIXVMDelete(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*Config)
	vmxFile := d.Id()

	vm := new(vix.VM)
	vm.Provider = config.Product
	vm.VerifySSL = config.VerifySSL

	if password := d.Get("password"); password != nil {
		vm.Image.Password = d.Get("password").(string)
	}

	return vm.Destroy(vmxFile)
}

func resourceVIXVMUpdate(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*Config)

	vm := new(vix.VM)
	vm.Provider = config.Product
	vm.VerifySSL = config.VerifySSL

	// Maps terraform.ResourceState attrbutes to vix.VM
	tf_to_vix(d, vm)

	err := vm.Update(d.Id())
	if err != nil {
		return err
	}

	return resourceVIXVMRead(d, meta)
}

func cdrom_tf_to_vix(d *schema.ResourceData, vm *vix.VM) error {
	cdromCount := d.Get("cdrom.#").(int)
	vm.CDDVDDrives = make([]*govix.CDDVDDrive, 0, cdromCount)

	for i := 0; i < cdromCount; i++ {
		prefix := fmt.Sprintf("cdrom.%d.", i)
		cdrom := new(govix.CDDVDDrive)

		if attr, ok := d.Get(prefix + "bus_type").(string); ok && attr != "" {
			cdrom.Bus = vmx.BusType(attr)
		}

		if attr, ok := d.Get(prefix + "image").(string); ok && attr != "" {
			cdrom.Filename = attr
		}
		vm.CDDVDDrives = append(vm.CDDVDDrives, cdrom)
	}

	return nil
}

func resourceVIXVMRead(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*Config)

	vmxFile := d.Id()

	vm := new(vix.VM)
	vm.Provider = config.Product
	vm.VerifySSL = config.VerifySSL

	running, err := vm.Refresh(vmxFile)
	if err != nil {
		return err
	}

	// This is to let TF know the resource is gone
	if !running {
		return nil
	}

	// Refreshes only what makes sense, for example, we do not refresh settings
	// that modify the behavior of this provider
	d.Set("name", vm.Name)
	d.Set("description", vm.Description)
	d.Set("cpus", vm.CPUs)
	d.Set("memory", vm.Memory)
	d.Set("ip_address", vm.IPAddress)

	err = net_vix_to_tf(vm, d)
	if err != nil {
		return err
	}

	err = cdrom_vix_to_tf(vm, d)
	if err != nil {
		return err
	}

	return nil
}

// Maps Terraform attributes to provider's structs
func tf_to_vix(d *schema.ResourceData, vm *vix.VM) error {
	var err error

	vm.Name = d.Get("name").(string)
	vm.Description = d.Get("description").(string)
	vm.CPUs = uint(d.Get("cpus").(int))

	vm.Memory = d.Get("memory").(string)
	vm.UpgradeVHardware = d.Get("upgrade_vhardware").(bool)
	vm.LaunchGUI = d.Get("gui").(bool)
	vm.SharedFolders = d.Get("sharedfolders").(bool)

	vm.ToolsInitTimeout, err = time.ParseDuration(d.Get("tools_init_timeout").(string))

	// Maps any defined networks to VIX provider's data types
	err = net_tf_to_vix(d, vm)
	if err != nil {
		return fmt.Errorf("Error mapping TF network adapter resource to VIX data types: %s", err)
	}

	if i := d.Get("image.#").(int); i > 0 {
		prefix := "image.0."
		vm.Image = vix.Image{
			URL:          d.Get(prefix + "url").(string),
			Checksum:     d.Get(prefix + "checksum").(string),
			ChecksumType: d.Get(prefix + "checksum_type").(string),
			Password:     d.Get(prefix + "password").(string),
		}
	}

	err = cdrom_tf_to_vix(d, vm)
	if err != nil {
		return fmt.Errorf("Error mapping TF cdrom resource to VIX data types: %s", err)
	}

	return nil
}

func net_tf_to_vix(d *schema.ResourceData, vm *vix.VM) error {
	tf_to_vix_virtual_device := func(attr string) (govix.VNetDevice, error) {
		switch attr {
		case "vlance":
			return govix.NETWORK_DEVICE_VLANCE, nil
		case "e1000":
			return govix.NETWORK_DEVICE_E1000, nil
		case "vmxnet3":
			return govix.NETWORK_DEVICE_VMXNET3, nil
		default:
			return "", fmt.Errorf("[ERROR] Invalid virtual network device: %s", attr)
		}
	}

	tf_to_vix_network_type := func(attr string) (govix.NetworkType, error) {
		switch attr {
		case "bridged":
			return govix.NETWORK_BRIDGED, nil
		case "nat":
			return govix.NETWORK_NAT, nil
		case "hostonly":
			return govix.NETWORK_HOSTONLY, nil
		case "custom":
			return govix.NETWORK_CUSTOM, nil
		default:
			return "", fmt.Errorf("[ERROR] Invalid virtual network adapter type: %s", attr)
		}
	}

	// tf_to_vix_vswitch := func(attr string) (vix.VSwitch, error) {
	// 	return vix.VSwitch{}, nil
	// }

	var err error
	var errs []error
	adaptersCount := d.Get("network_adapter.#").(int)
	vm.VNetworkAdapters = make([]*govix.NetworkAdapter, 0, adaptersCount)

	for i := 0; i < adaptersCount; i++ {
		prefix := fmt.Sprintf("network_adapter.%d.", i)
		adapter := new(govix.NetworkAdapter)

		if attr, ok := d.Get(prefix + "driver").(string); ok && attr != "" {
			adapter.Vdevice, err = tf_to_vix_virtual_device(attr)
		}

		if attr, ok := d.Get(prefix + "mac_address").(string); ok && attr != "" {
			// Only set a MAC address if it is declared as static
			// otherwise leave Govix to assign or continue using the generated
			// one.
			if addrtype, ok := d.Get(prefix + "mac_address_type").(string); ok && addrtype == "static" {
				adapter.MacAddress, err = net.ParseMAC(attr)
			}
		}

		if attr, ok := d.Get(prefix + "type").(string); ok && attr != "" {
			adapter.ConnType, err = tf_to_vix_network_type(attr)
		}

		// if attr, ok := adapter["vswitch"].(string); ok && attr != "" {
		// 	vnic.VSwitch, err = tf_to_vix_vswitch(attr)
		// }
		if err != nil {
			errs = append(errs, err)
		}

		log.Printf("[DEBUG] Network adapter: %+v\n", adapter)
		vm.VNetworkAdapters = append(vm.VNetworkAdapters, adapter)
	}

	if len(errs) > 0 {
		return &multierror.Error{Errors: errs}
	}

	return nil
}