mirror of
https://github.com/bpg/terraform-provider-proxmox.git
synced 2025-07-04 21:14:05 +00:00
1649 lines
72 KiB
Go
1649 lines
72 KiB
Go
package vm
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource/validator"
|
||
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/structure"
|
||
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/customdiff"
|
||
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
|
||
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
|
||
)
|
||
|
||
const (
|
||
dvResourceVirtualEnvironmentVMRebootAfterCreation = false
|
||
dvResourceVirtualEnvironmentVMOnBoot = true
|
||
dvResourceVirtualEnvironmentVMACPI = true
|
||
dvResourceVirtualEnvironmentVMAgentEnabled = false
|
||
dvResourceVirtualEnvironmentVMAgentTimeout = "15m"
|
||
dvResourceVirtualEnvironmentVMAgentTrim = false
|
||
dvResourceVirtualEnvironmentVMAgentType = "virtio"
|
||
dvResourceVirtualEnvironmentVMAudioDeviceDevice = "intel-hda"
|
||
dvResourceVirtualEnvironmentVMAudioDeviceDriver = "spice"
|
||
dvResourceVirtualEnvironmentVMAudioDeviceEnabled = true
|
||
dvResourceVirtualEnvironmentVMBIOS = "seabios"
|
||
dvResourceVirtualEnvironmentVMCDROMEnabled = false
|
||
dvResourceVirtualEnvironmentVMCDROMFileID = ""
|
||
dvResourceVirtualEnvironmentVMCDROMInterface = "ide3"
|
||
dvResourceVirtualEnvironmentVMCloneDatastoreID = ""
|
||
dvResourceVirtualEnvironmentVMCloneNodeName = ""
|
||
dvResourceVirtualEnvironmentVMCloneFull = true
|
||
dvResourceVirtualEnvironmentVMCloneRetries = 1
|
||
dvResourceVirtualEnvironmentVMCPUArchitecture = "x86_64"
|
||
dvResourceVirtualEnvironmentVMCPUCores = 1
|
||
dvResourceVirtualEnvironmentVMCPUHotplugged = 0
|
||
dvResourceVirtualEnvironmentVMCPULimit = 0
|
||
dvResourceVirtualEnvironmentVMCPUNUMA = false
|
||
dvResourceVirtualEnvironmentVMCPUSockets = 1
|
||
dvResourceVirtualEnvironmentVMCPUType = "qemu64"
|
||
dvResourceVirtualEnvironmentVMCPUUnits = 1024
|
||
dvResourceVirtualEnvironmentVMDescription = ""
|
||
dvResourceVirtualEnvironmentVMDiskInterface = "scsi0"
|
||
dvResourceVirtualEnvironmentVMDiskDatastoreID = "local-lvm"
|
||
dvResourceVirtualEnvironmentVMDiskFileFormat = "qcow2"
|
||
dvResourceVirtualEnvironmentVMDiskFileID = ""
|
||
dvResourceVirtualEnvironmentVMDiskSize = 8
|
||
dvResourceVirtualEnvironmentVMDiskIOThread = false
|
||
dvResourceVirtualEnvironmentVMDiskSSD = false
|
||
dvResourceVirtualEnvironmentVMDiskDiscard = "ignore"
|
||
dvResourceVirtualEnvironmentVMDiskCache = "none"
|
||
dvResourceVirtualEnvironmentVMDiskSpeedRead = 0
|
||
dvResourceVirtualEnvironmentVMDiskSpeedReadBurstable = 0
|
||
dvResourceVirtualEnvironmentVMDiskSpeedWrite = 0
|
||
dvResourceVirtualEnvironmentVMDiskSpeedWriteBurstable = 0
|
||
dvResourceVirtualEnvironmentVMEFIDiskDatastoreID = "local-lvm"
|
||
dvResourceVirtualEnvironmentVMEFIDiskFileFormat = "qcow2"
|
||
dvResourceVirtualEnvironmentVMEFIDiskType = "2m"
|
||
dvResourceVirtualEnvironmentVMEFIDiskPreEnrolledKeys = false
|
||
dvResourceVirtualEnvironmentVMTPMStateDatastoreID = "local-lvm"
|
||
dvResourceVirtualEnvironmentVMTPMStateVersion = "v2.0"
|
||
dvResourceVirtualEnvironmentVMInitializationDatastoreID = "local-lvm"
|
||
dvResourceVirtualEnvironmentVMInitializationInterface = ""
|
||
dvResourceVirtualEnvironmentVMInitializationDNSDomain = ""
|
||
dvResourceVirtualEnvironmentVMInitializationDNSServer = ""
|
||
dvResourceVirtualEnvironmentVMInitializationIPConfigIPv4Address = ""
|
||
dvResourceVirtualEnvironmentVMInitializationIPConfigIPv4Gateway = ""
|
||
dvResourceVirtualEnvironmentVMInitializationIPConfigIPv6Address = ""
|
||
dvResourceVirtualEnvironmentVMInitializationIPConfigIPv6Gateway = ""
|
||
dvResourceVirtualEnvironmentVMInitializationUserAccountPassword = ""
|
||
dvResourceVirtualEnvironmentVMInitializationUserDataFileID = ""
|
||
dvResourceVirtualEnvironmentVMInitializationVendorDataFileID = ""
|
||
dvResourceVirtualEnvironmentVMInitializationNetworkDataFileID = ""
|
||
dvResourceVirtualEnvironmentVMInitializationMetaDataFileID = ""
|
||
dvResourceVirtualEnvironmentVMInitializationType = ""
|
||
dvResourceVirtualEnvironmentVMKeyboardLayout = "en-us"
|
||
dvResourceVirtualEnvironmentVMKVMArguments = ""
|
||
dvResourceVirtualEnvironmentVMMachineType = ""
|
||
dvResourceVirtualEnvironmentVMMemoryDedicated = 512
|
||
dvResourceVirtualEnvironmentVMMemoryFloating = 0
|
||
dvResourceVirtualEnvironmentVMMemoryShared = 0
|
||
dvResourceVirtualEnvironmentVMMigrate = false
|
||
dvResourceVirtualEnvironmentVMName = ""
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceBridge = "vmbr0"
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceEnabled = true
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceFirewall = false
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceModel = "virtio"
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceQueues = 0
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceRateLimit = 0
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceVLANID = 0
|
||
dvResourceVirtualEnvironmentVMNetworkDeviceMTU = 0
|
||
dvResourceVirtualEnvironmentVMOperatingSystemType = "other"
|
||
dvResourceVirtualEnvironmentVMPoolID = ""
|
||
dvResourceVirtualEnvironmentVMSerialDeviceDevice = "socket"
|
||
dvResourceVirtualEnvironmentVMSMBIOSFamily = ""
|
||
dvResourceVirtualEnvironmentVMSMBIOSManufacturer = ""
|
||
dvResourceVirtualEnvironmentVMSMBIOSProduct = ""
|
||
dvResourceVirtualEnvironmentVMSMBIOSSKU = ""
|
||
dvResourceVirtualEnvironmentVMSMBIOSSerial = ""
|
||
dvResourceVirtualEnvironmentVMSMBIOSVersion = ""
|
||
dvResourceVirtualEnvironmentVMStarted = true
|
||
dvResourceVirtualEnvironmentVMStartupOrder = -1
|
||
dvResourceVirtualEnvironmentVMStartupUpDelay = -1
|
||
dvResourceVirtualEnvironmentVMStartupDownDelay = -1
|
||
dvResourceVirtualEnvironmentVMTabletDevice = true
|
||
dvResourceVirtualEnvironmentVMTemplate = false
|
||
dvResourceVirtualEnvironmentVMTimeoutClone = 1800
|
||
dvResourceVirtualEnvironmentVMTimeoutCreate = 1800
|
||
dvResourceVirtualEnvironmentVMTimeoutMoveDisk = 1800
|
||
dvResourceVirtualEnvironmentVMTimeoutMigrate = 1800
|
||
dvResourceVirtualEnvironmentVMTimeoutReboot = 1800
|
||
dvResourceVirtualEnvironmentVMTimeoutShutdownVM = 1800
|
||
dvResourceVirtualEnvironmentVMTimeoutStartVM = 1800
|
||
dvResourceVirtualEnvironmentVMTimeoutStopVM = 300
|
||
dvResourceVirtualEnvironmentVMVGAEnabled = true
|
||
dvResourceVirtualEnvironmentVMVGAMemory = 16
|
||
dvResourceVirtualEnvironmentVMVGAType = "std"
|
||
dvResourceVirtualEnvironmentVMSCSIHardware = "virtio-scsi-pci"
|
||
dvResourceVirtualEnvironmentVMStopOnDestroy = false
|
||
dvResourceVirtualEnvironmentVMHookScript = ""
|
||
|
||
maxResourceVirtualEnvironmentVMAudioDevices = 1
|
||
maxResourceVirtualEnvironmentVMNetworkDevices = 32
|
||
maxResourceVirtualEnvironmentVMSerialDevices = 4
|
||
maxResourceVirtualEnvironmentVMHostPCIDevices = 8
|
||
maxResourceVirtualEnvironmentVMHostUSBDevices = 4
|
||
|
||
mkResourceVirtualEnvironmentVMRebootAfterCreation = "reboot"
|
||
mkResourceVirtualEnvironmentVMOnBoot = "on_boot"
|
||
mkResourceVirtualEnvironmentVMBootOrder = "boot_order"
|
||
mkResourceVirtualEnvironmentVMACPI = "acpi"
|
||
mkResourceVirtualEnvironmentVMAgent = "agent"
|
||
mkResourceVirtualEnvironmentVMAgentEnabled = "enabled"
|
||
mkResourceVirtualEnvironmentVMAgentTimeout = "timeout"
|
||
mkResourceVirtualEnvironmentVMAgentTrim = "trim"
|
||
mkResourceVirtualEnvironmentVMAgentType = "type"
|
||
mkResourceVirtualEnvironmentVMAudioDevice = "audio_device"
|
||
mkResourceVirtualEnvironmentVMAudioDeviceDevice = "device"
|
||
mkResourceVirtualEnvironmentVMAudioDeviceDriver = "driver"
|
||
mkResourceVirtualEnvironmentVMAudioDeviceEnabled = "enabled"
|
||
mkResourceVirtualEnvironmentVMBIOS = "bios"
|
||
mkResourceVirtualEnvironmentVMCDROM = "cdrom"
|
||
mkResourceVirtualEnvironmentVMCDROMEnabled = "enabled"
|
||
mkResourceVirtualEnvironmentVMCDROMFileID = "file_id"
|
||
mkResourceVirtualEnvironmentVMCDROMInterface = "interface"
|
||
mkResourceVirtualEnvironmentVMClone = "clone"
|
||
mkResourceVirtualEnvironmentVMCloneRetries = "retries"
|
||
mkResourceVirtualEnvironmentVMCloneDatastoreID = "datastore_id"
|
||
mkResourceVirtualEnvironmentVMCloneNodeName = "node_name"
|
||
mkResourceVirtualEnvironmentVMCloneVMID = "vm_id"
|
||
mkResourceVirtualEnvironmentVMCloneFull = "full"
|
||
mkResourceVirtualEnvironmentVMCPU = "cpu"
|
||
mkResourceVirtualEnvironmentVMCPUArchitecture = "architecture"
|
||
mkResourceVirtualEnvironmentVMCPUCores = "cores"
|
||
mkResourceVirtualEnvironmentVMCPUFlags = "flags"
|
||
mkResourceVirtualEnvironmentVMCPUHotplugged = "hotplugged"
|
||
mkResourceVirtualEnvironmentVMCPULimit = "limit"
|
||
mkResourceVirtualEnvironmentVMCPUNUMA = "numa"
|
||
mkResourceVirtualEnvironmentVMCPUSockets = "sockets"
|
||
mkResourceVirtualEnvironmentVMCPUType = "type"
|
||
mkResourceVirtualEnvironmentVMCPUUnits = "units"
|
||
mkResourceVirtualEnvironmentVMDescription = "description"
|
||
mkResourceVirtualEnvironmentVMDisk = "disk"
|
||
mkResourceVirtualEnvironmentVMDiskInterface = "interface"
|
||
mkResourceVirtualEnvironmentVMDiskDatastoreID = "datastore_id"
|
||
mkResourceVirtualEnvironmentVMDiskPathInDatastore = "path_in_datastore"
|
||
mkResourceVirtualEnvironmentVMDiskFileFormat = "file_format"
|
||
mkResourceVirtualEnvironmentVMDiskFileID = "file_id"
|
||
mkResourceVirtualEnvironmentVMDiskSize = "size"
|
||
mkResourceVirtualEnvironmentVMDiskIOThread = "iothread"
|
||
mkResourceVirtualEnvironmentVMDiskSSD = "ssd"
|
||
mkResourceVirtualEnvironmentVMDiskDiscard = "discard"
|
||
mkResourceVirtualEnvironmentVMDiskCache = "cache"
|
||
mkResourceVirtualEnvironmentVMDiskSpeed = "speed"
|
||
mkResourceVirtualEnvironmentVMDiskSpeedRead = "read"
|
||
mkResourceVirtualEnvironmentVMDiskSpeedReadBurstable = "read_burstable"
|
||
mkResourceVirtualEnvironmentVMDiskSpeedWrite = "write"
|
||
mkResourceVirtualEnvironmentVMDiskSpeedWriteBurstable = "write_burstable"
|
||
mkResourceVirtualEnvironmentVMEFIDisk = "efi_disk"
|
||
mkResourceVirtualEnvironmentVMEFIDiskDatastoreID = "datastore_id"
|
||
mkResourceVirtualEnvironmentVMEFIDiskFileFormat = "file_format"
|
||
mkResourceVirtualEnvironmentVMEFIDiskType = "type"
|
||
mkResourceVirtualEnvironmentVMEFIDiskPreEnrolledKeys = "pre_enrolled_keys"
|
||
mkResourceVirtualEnvironmentVMTPMState = "tpm_state"
|
||
mkResourceVirtualEnvironmentVMTPMStateDatastoreID = "datastore_id"
|
||
mkResourceVirtualEnvironmentVMTPMStateVersion = "version"
|
||
mkResourceVirtualEnvironmentVMHostPCI = "hostpci"
|
||
mkResourceVirtualEnvironmentVMHostPCIDevice = "device"
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceID = "id"
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceMapping = "mapping"
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceMDev = "mdev"
|
||
mkResourceVirtualEnvironmentVMHostPCIDevicePCIE = "pcie"
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceROMBAR = "rombar"
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceROMFile = "rom_file"
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceXVGA = "xvga"
|
||
mkResourceVirtualEnvironmentVMInitialization = "initialization"
|
||
mkResourceVirtualEnvironmentVMInitializationDatastoreID = "datastore_id"
|
||
mkResourceVirtualEnvironmentVMInitializationInterface = "interface"
|
||
mkResourceVirtualEnvironmentVMInitializationDNS = "dns"
|
||
mkResourceVirtualEnvironmentVMInitializationDNSDomain = "domain"
|
||
mkResourceVirtualEnvironmentVMInitializationDNSServer = "server"
|
||
mkResourceVirtualEnvironmentVMInitializationDNSServers = "servers"
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfig = "ip_config"
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4 = "ipv4"
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Address = "address"
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Gateway = "gateway"
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6 = "ipv6"
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Address = "address"
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Gateway = "gateway"
|
||
mkResourceVirtualEnvironmentVMInitializationType = "type"
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccount = "user_account"
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccountKeys = "keys"
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccountPassword = "password"
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccountUsername = "username"
|
||
mkResourceVirtualEnvironmentVMInitializationUserDataFileID = "user_data_file_id"
|
||
mkResourceVirtualEnvironmentVMInitializationVendorDataFileID = "vendor_data_file_id"
|
||
mkResourceVirtualEnvironmentVMInitializationNetworkDataFileID = "network_data_file_id"
|
||
mkResourceVirtualEnvironmentVMInitializationMetaDataFileID = "meta_data_file_id"
|
||
mkResourceVirtualEnvironmentVMIPv4Addresses = "ipv4_addresses"
|
||
mkResourceVirtualEnvironmentVMIPv6Addresses = "ipv6_addresses"
|
||
mkResourceVirtualEnvironmentVMKeyboardLayout = "keyboard_layout"
|
||
mkResourceVirtualEnvironmentVMKVMArguments = "kvm_arguments"
|
||
mkResourceVirtualEnvironmentVMMachine = "machine"
|
||
mkResourceVirtualEnvironmentVMMACAddresses = "mac_addresses"
|
||
mkResourceVirtualEnvironmentVMMemory = "memory"
|
||
mkResourceVirtualEnvironmentVMMemoryDedicated = "dedicated"
|
||
mkResourceVirtualEnvironmentVMMemoryFloating = "floating"
|
||
mkResourceVirtualEnvironmentVMMemoryShared = "shared"
|
||
mkResourceVirtualEnvironmentVMMigrate = "migrate"
|
||
mkResourceVirtualEnvironmentVMName = "name"
|
||
mkResourceVirtualEnvironmentVMNetworkDevice = "network_device"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceBridge = "bridge"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceEnabled = "enabled"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceFirewall = "firewall"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceMACAddress = "mac_address"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceModel = "model"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceQueues = "queues"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceRateLimit = "rate_limit"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceVLANID = "vlan_id"
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceMTU = "mtu"
|
||
mkResourceVirtualEnvironmentVMNetworkInterfaceNames = "network_interface_names"
|
||
mkResourceVirtualEnvironmentVMNodeName = "node_name"
|
||
mkResourceVirtualEnvironmentVMOperatingSystem = "operating_system"
|
||
mkResourceVirtualEnvironmentVMOperatingSystemType = "type"
|
||
mkResourceVirtualEnvironmentVMPoolID = "pool_id"
|
||
mkResourceVirtualEnvironmentVMSerialDevice = "serial_device"
|
||
mkResourceVirtualEnvironmentVMSerialDeviceDevice = "device"
|
||
mkResourceVirtualEnvironmentVMSMBIOS = "smbios"
|
||
mkResourceVirtualEnvironmentVMSMBIOSFamily = "family"
|
||
mkResourceVirtualEnvironmentVMSMBIOSManufacturer = "manufacturer"
|
||
mkResourceVirtualEnvironmentVMSMBIOSProduct = "product"
|
||
mkResourceVirtualEnvironmentVMSMBIOSSKU = "sku"
|
||
mkResourceVirtualEnvironmentVMSMBIOSSerial = "serial"
|
||
mkResourceVirtualEnvironmentVMSMBIOSUUID = "uuid"
|
||
mkResourceVirtualEnvironmentVMSMBIOSVersion = "version"
|
||
mkResourceVirtualEnvironmentVMStarted = "started"
|
||
mkResourceVirtualEnvironmentVMStartup = "startup"
|
||
mkResourceVirtualEnvironmentVMStartupOrder = "order"
|
||
mkResourceVirtualEnvironmentVMStartupUpDelay = "up_delay"
|
||
mkResourceVirtualEnvironmentVMStartupDownDelay = "down_delay"
|
||
mkResourceVirtualEnvironmentVMTabletDevice = "tablet_device"
|
||
mkResourceVirtualEnvironmentVMTags = "tags"
|
||
mkResourceVirtualEnvironmentVMTemplate = "template"
|
||
mkResourceVirtualEnvironmentVMTimeoutClone = "timeout_clone"
|
||
mkResourceVirtualEnvironmentVMTimeoutCreate = "timeout_create"
|
||
mkResourceVirtualEnvironmentVMTimeoutMoveDisk = "timeout_move_disk"
|
||
mkResourceVirtualEnvironmentVMTimeoutMigrate = "timeout_migrate"
|
||
mkResourceVirtualEnvironmentVMTimeoutReboot = "timeout_reboot"
|
||
mkResourceVirtualEnvironmentVMTimeoutShutdownVM = "timeout_shutdown_vm"
|
||
mkResourceVirtualEnvironmentVMTimeoutStartVM = "timeout_start_vm"
|
||
mkResourceVirtualEnvironmentVMTimeoutStopVM = "timeout_stop_vm"
|
||
mkResourceVirtualEnvironmentVMHostUSB = "usb"
|
||
mkResourceVirtualEnvironmentVMHostUSBDevice = "host"
|
||
mkResourceVirtualEnvironmentVMHostUSBDeviceMapping = "mapping"
|
||
mkResourceVirtualEnvironmentVMHostUSBDeviceUSB3 = "usb3"
|
||
mkResourceVirtualEnvironmentVMVGA = "vga"
|
||
mkResourceVirtualEnvironmentVMVGAEnabled = "enabled"
|
||
mkResourceVirtualEnvironmentVMVGAMemory = "memory"
|
||
mkResourceVirtualEnvironmentVMVGAType = "type"
|
||
mkResourceVirtualEnvironmentVMVMID = "vm_id"
|
||
mkResourceVirtualEnvironmentVMSCSIHardware = "scsi_hardware"
|
||
mkResourceVirtualEnvironmentVMHookScriptFileID = "hook_script_file_id"
|
||
mkResourceVirtualEnvironmentVMStopOnDestroy = "stop_on_destroy"
|
||
)
|
||
|
||
// VM returns a resource that manages VMs.
|
||
func VM() *schema.Resource {
|
||
return &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMRebootAfterCreation: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to reboot vm after creation",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMRebootAfterCreation,
|
||
},
|
||
mkResourceVirtualEnvironmentVMOnBoot: {
|
||
Type: schema.TypeBool,
|
||
Description: "Start VM on Node boot",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMOnBoot,
|
||
},
|
||
mkResourceVirtualEnvironmentVMBootOrder: {
|
||
Type: schema.TypeList,
|
||
Description: "The guest will attempt to boot from devices in the order they appear here",
|
||
Optional: true,
|
||
Elem: &schema.Schema{Type: schema.TypeString},
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMACPI: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable ACPI",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMACPI,
|
||
},
|
||
mkResourceVirtualEnvironmentVMAgent: {
|
||
Type: schema.TypeList,
|
||
Description: "The QEMU agent configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMAgentEnabled: dvResourceVirtualEnvironmentVMAgentEnabled,
|
||
mkResourceVirtualEnvironmentVMAgentTimeout: dvResourceVirtualEnvironmentVMAgentTimeout,
|
||
mkResourceVirtualEnvironmentVMAgentTrim: dvResourceVirtualEnvironmentVMAgentTrim,
|
||
mkResourceVirtualEnvironmentVMAgentType: dvResourceVirtualEnvironmentVMAgentType,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMAgentEnabled: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable the QEMU agent",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMAgentEnabled,
|
||
},
|
||
mkResourceVirtualEnvironmentVMAgentTimeout: {
|
||
Type: schema.TypeString,
|
||
Description: "The maximum amount of time to wait for data from the QEMU agent to become available",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMAgentTimeout,
|
||
ValidateDiagFunc: validator.Timeout(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMAgentTrim: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable the FSTRIM feature in the QEMU agent",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMAgentTrim,
|
||
},
|
||
mkResourceVirtualEnvironmentVMAgentType: {
|
||
Type: schema.TypeString,
|
||
Description: "The QEMU agent interface type",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMAgentType,
|
||
ValidateDiagFunc: validator.QEMUAgentType(),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMKVMArguments: {
|
||
Type: schema.TypeString,
|
||
Description: "The args implementation",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMKVMArguments,
|
||
},
|
||
mkResourceVirtualEnvironmentVMAudioDevice: {
|
||
Type: schema.TypeList,
|
||
Description: "The audio devices",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMAudioDeviceDevice: {
|
||
Type: schema.TypeString,
|
||
Description: "The device",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMAudioDeviceDevice,
|
||
ValidateDiagFunc: vmGetAudioDeviceValidator(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMAudioDeviceDriver: {
|
||
Type: schema.TypeString,
|
||
Description: "The driver",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMAudioDeviceDriver,
|
||
ValidateDiagFunc: vmGetAudioDriverValidator(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMAudioDeviceEnabled: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable the audio device",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMAudioDeviceEnabled,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: maxResourceVirtualEnvironmentVMAudioDevices,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMBIOS: {
|
||
Type: schema.TypeString,
|
||
Description: "The BIOS implementation",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMBIOS,
|
||
ValidateDiagFunc: validator.BIOS(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCDROM: {
|
||
Type: schema.TypeList,
|
||
Description: "The CDROM drive",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMCDROMEnabled: dvResourceVirtualEnvironmentVMCDROMEnabled,
|
||
mkResourceVirtualEnvironmentVMCDROMFileID: dvResourceVirtualEnvironmentVMCDROMFileID,
|
||
mkResourceVirtualEnvironmentVMCDROMInterface: dvResourceVirtualEnvironmentVMCDROMInterface,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMCDROMEnabled: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable the CDROM drive",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCDROMEnabled,
|
||
},
|
||
mkResourceVirtualEnvironmentVMCDROMFileID: {
|
||
Type: schema.TypeString,
|
||
Description: "The file id",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCDROMFileID,
|
||
ValidateDiagFunc: validator.FileID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCDROMInterface: {
|
||
Type: schema.TypeString,
|
||
Description: "The CDROM interface",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCDROMInterface,
|
||
ValidateDiagFunc: validator.IDEInterface(),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMClone: {
|
||
Type: schema.TypeList,
|
||
Description: "The cloning configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMCloneRetries: {
|
||
Type: schema.TypeInt,
|
||
Description: "The number of Retries to create a clone",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMCloneRetries,
|
||
},
|
||
mkResourceVirtualEnvironmentVMCloneDatastoreID: {
|
||
Type: schema.TypeString,
|
||
Description: "The ID of the target datastore",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMCloneDatastoreID,
|
||
},
|
||
mkResourceVirtualEnvironmentVMCloneNodeName: {
|
||
Type: schema.TypeString,
|
||
Description: "The name of the source node",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMCloneNodeName,
|
||
},
|
||
mkResourceVirtualEnvironmentVMCloneVMID: {
|
||
Type: schema.TypeInt,
|
||
Description: "The ID of the source VM",
|
||
Required: true,
|
||
ForceNew: true,
|
||
ValidateDiagFunc: validator.VMID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCloneFull: {
|
||
Type: schema.TypeBool,
|
||
Description: "The Clone Type, create a Full Clone (true) or a linked Clone (false)",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMCloneFull,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPU: {
|
||
Type: schema.TypeList,
|
||
Description: "The CPU allocation",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMCPUArchitecture: dvResourceVirtualEnvironmentVMCPUArchitecture,
|
||
mkResourceVirtualEnvironmentVMCPUCores: dvResourceVirtualEnvironmentVMCPUCores,
|
||
mkResourceVirtualEnvironmentVMCPUFlags: []interface{}{},
|
||
mkResourceVirtualEnvironmentVMCPUHotplugged: dvResourceVirtualEnvironmentVMCPUHotplugged,
|
||
mkResourceVirtualEnvironmentVMCPULimit: dvResourceVirtualEnvironmentVMCPULimit,
|
||
mkResourceVirtualEnvironmentVMCPUNUMA: dvResourceVirtualEnvironmentVMCPUNUMA,
|
||
mkResourceVirtualEnvironmentVMCPUSockets: dvResourceVirtualEnvironmentVMCPUSockets,
|
||
mkResourceVirtualEnvironmentVMCPUType: dvResourceVirtualEnvironmentVMCPUType,
|
||
mkResourceVirtualEnvironmentVMCPUUnits: dvResourceVirtualEnvironmentVMCPUUnits,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMCPUArchitecture: {
|
||
Type: schema.TypeString,
|
||
Description: "The CPU architecture",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPUArchitecture,
|
||
ValidateDiagFunc: vmGetCPUArchitectureValidator(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPUCores: {
|
||
Type: schema.TypeInt,
|
||
Description: "The number of CPU cores",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPUCores,
|
||
ValidateDiagFunc: validation.ToDiagFunc(validation.IntBetween(1, 2304)),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPUFlags: {
|
||
Type: schema.TypeList,
|
||
Description: "The CPU flags",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Schema{Type: schema.TypeString},
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPUHotplugged: {
|
||
Type: schema.TypeInt,
|
||
Description: "The number of hotplugged vCPUs",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPUHotplugged,
|
||
ValidateDiagFunc: validation.ToDiagFunc(validation.IntBetween(0, 2304)),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPULimit: {
|
||
Type: schema.TypeInt,
|
||
Description: "Limit of CPU usage",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPULimit,
|
||
ValidateDiagFunc: validation.ToDiagFunc(
|
||
validation.IntBetween(0, 128),
|
||
),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPUNUMA: {
|
||
Type: schema.TypeBool,
|
||
Description: "Enable/disable NUMA.",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPUNUMA,
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPUSockets: {
|
||
Type: schema.TypeInt,
|
||
Description: "The number of CPU sockets",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPUSockets,
|
||
ValidateDiagFunc: validation.ToDiagFunc(validation.IntBetween(1, 16)),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPUType: {
|
||
Type: schema.TypeString,
|
||
Description: "The emulated CPU type",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPUType,
|
||
ValidateDiagFunc: validator.CPUType(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMCPUUnits: {
|
||
Type: schema.TypeInt,
|
||
Description: "The CPU units",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMCPUUnits,
|
||
ValidateDiagFunc: validation.ToDiagFunc(
|
||
validation.IntBetween(2, 262144),
|
||
),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDescription: {
|
||
Type: schema.TypeString,
|
||
Description: "The description",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDescription,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDisk: {
|
||
Type: schema.TypeList,
|
||
Description: "The disk devices",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMDiskDatastoreID: dvResourceVirtualEnvironmentVMDiskDatastoreID,
|
||
mkResourceVirtualEnvironmentVMDiskPathInDatastore: nil,
|
||
mkResourceVirtualEnvironmentVMDiskFileID: dvResourceVirtualEnvironmentVMDiskFileID,
|
||
mkResourceVirtualEnvironmentVMDiskInterface: dvResourceVirtualEnvironmentVMDiskInterface,
|
||
mkResourceVirtualEnvironmentVMDiskSize: dvResourceVirtualEnvironmentVMDiskSize,
|
||
mkResourceVirtualEnvironmentVMDiskIOThread: dvResourceVirtualEnvironmentVMDiskIOThread,
|
||
mkResourceVirtualEnvironmentVMDiskSSD: dvResourceVirtualEnvironmentVMDiskSSD,
|
||
mkResourceVirtualEnvironmentVMDiskDiscard: dvResourceVirtualEnvironmentVMDiskDiscard,
|
||
mkResourceVirtualEnvironmentVMDiskCache: dvResourceVirtualEnvironmentVMDiskCache,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMDiskInterface: {
|
||
Type: schema.TypeString,
|
||
Description: "The datastore name",
|
||
Required: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskDatastoreID: {
|
||
Type: schema.TypeString,
|
||
Description: "The datastore id",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskDatastoreID,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskPathInDatastore: {
|
||
Type: schema.TypeString,
|
||
Description: "The in-datastore path to disk image",
|
||
Computed: true,
|
||
Optional: true,
|
||
Default: nil,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskFileFormat: {
|
||
Type: schema.TypeString,
|
||
Description: "The file format",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Computed: true,
|
||
ValidateDiagFunc: validator.FileFormat(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskFileID: {
|
||
Type: schema.TypeString,
|
||
Description: "The file id for a disk image",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskFileID,
|
||
ValidateDiagFunc: validator.FileID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskSize: {
|
||
Type: schema.TypeInt,
|
||
Description: "The disk size in gigabytes",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskSize,
|
||
ValidateDiagFunc: validation.ToDiagFunc(validation.IntAtLeast(1)),
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskIOThread: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to use iothreads for this disk drive",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskIOThread,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskSSD: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to use ssd for this disk drive",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskSSD,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskDiscard: {
|
||
Type: schema.TypeString,
|
||
Description: "Whether to pass discard/trim requests to the underlying storage.",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskDiscard,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskCache: {
|
||
Type: schema.TypeString,
|
||
Description: "The drive’s cache mode",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskCache,
|
||
ValidateDiagFunc: validation.ToDiagFunc(
|
||
validation.StringInSlice([]string{
|
||
"none",
|
||
"writethrough",
|
||
"writeback",
|
||
"unsafe",
|
||
"directsync",
|
||
}, false),
|
||
),
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskSpeed: {
|
||
Type: schema.TypeList,
|
||
Description: "The speed limits",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMDiskSpeedRead: dvResourceVirtualEnvironmentVMDiskSpeedRead,
|
||
mkResourceVirtualEnvironmentVMDiskSpeedReadBurstable: dvResourceVirtualEnvironmentVMDiskSpeedReadBurstable,
|
||
mkResourceVirtualEnvironmentVMDiskSpeedWrite: dvResourceVirtualEnvironmentVMDiskSpeedWrite,
|
||
mkResourceVirtualEnvironmentVMDiskSpeedWriteBurstable: dvResourceVirtualEnvironmentVMDiskSpeedWriteBurstable,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMDiskSpeedRead: {
|
||
Type: schema.TypeInt,
|
||
Description: "The maximum read speed in megabytes per second",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskSpeedRead,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskSpeedReadBurstable: {
|
||
Type: schema.TypeInt,
|
||
Description: "The maximum burstable read speed in megabytes per second",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskSpeedReadBurstable,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskSpeedWrite: {
|
||
Type: schema.TypeInt,
|
||
Description: "The maximum write speed in megabytes per second",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskSpeedWrite,
|
||
},
|
||
mkResourceVirtualEnvironmentVMDiskSpeedWriteBurstable: {
|
||
Type: schema.TypeInt,
|
||
Description: "The maximum burstable write speed in megabytes per second",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMDiskSpeedWriteBurstable,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 14,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMEFIDisk: {
|
||
Type: schema.TypeList,
|
||
Description: "The efidisk device",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMEFIDiskDatastoreID: {
|
||
Type: schema.TypeString,
|
||
Description: "The datastore id",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMEFIDiskDatastoreID,
|
||
},
|
||
mkResourceVirtualEnvironmentVMEFIDiskFileFormat: {
|
||
Type: schema.TypeString,
|
||
Description: "The file format",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Computed: true,
|
||
ValidateDiagFunc: validator.FileFormat(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMEFIDiskType: {
|
||
Type: schema.TypeString,
|
||
Description: "Size and type of the OVMF EFI disk",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMEFIDiskType,
|
||
ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{
|
||
"2m",
|
||
"4m",
|
||
}, true)),
|
||
},
|
||
mkResourceVirtualEnvironmentVMEFIDiskPreEnrolledKeys: {
|
||
Type: schema.TypeBool,
|
||
Description: "Use an EFI vars template with distribution-specific and Microsoft Standard " +
|
||
"keys enrolled, if used with efi type=`4m`.",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMEFIDiskPreEnrolledKeys,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTPMState: {
|
||
Type: schema.TypeList,
|
||
Description: "The tpmstate device",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMTPMStateDatastoreID: {
|
||
Type: schema.TypeString,
|
||
Description: "Datastore ID",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTPMStateDatastoreID,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTPMStateVersion: {
|
||
Type: schema.TypeString,
|
||
Description: "TPM version",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMTPMStateVersion,
|
||
ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{
|
||
"v1.2",
|
||
"v2.0",
|
||
}, true)),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitialization: {
|
||
Type: schema.TypeList,
|
||
Description: "The cloud-init configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMInitializationDatastoreID: {
|
||
Type: schema.TypeString,
|
||
Description: "The datastore id",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationDatastoreID,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationInterface: {
|
||
Type: schema.TypeString,
|
||
Description: "The IDE interface on which the CloudInit drive will be added",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationInterface,
|
||
ValidateDiagFunc: validator.CloudInitInterface(),
|
||
DiffSuppressFunc: func(k, oldValue, newValue string, d *schema.ResourceData) bool {
|
||
return newValue == ""
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationDNS: {
|
||
Type: schema.TypeList,
|
||
Description: "The DNS configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMInitializationDNSDomain: {
|
||
Type: schema.TypeString,
|
||
Description: "The DNS search domain",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationDNSDomain,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationDNSServer: {
|
||
Type: schema.TypeString,
|
||
Description: "The DNS server",
|
||
Deprecated: "The `server` attribute is deprecated and will be removed in a future release. " +
|
||
"Please use the `servers` attribute instead.",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationDNSServer,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationDNSServers: {
|
||
Type: schema.TypeList,
|
||
Description: "The list of DNS servers",
|
||
Optional: true,
|
||
Elem: &schema.Schema{Type: schema.TypeString, ValidateFunc: validation.IsIPAddress},
|
||
MinItems: 0,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfig: {
|
||
Type: schema.TypeList,
|
||
Description: "The IP configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4: {
|
||
Type: schema.TypeList,
|
||
Description: "The IPv4 configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Address: {
|
||
Type: schema.TypeString,
|
||
Description: "The IPv4 address",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationIPConfigIPv4Address,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Gateway: {
|
||
Type: schema.TypeString,
|
||
Description: "The IPv4 gateway",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationIPConfigIPv4Gateway,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6: {
|
||
Type: schema.TypeList,
|
||
Description: "The IPv6 configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Address: {
|
||
Type: schema.TypeString,
|
||
Description: "The IPv6 address",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationIPConfigIPv6Address,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Gateway: {
|
||
Type: schema.TypeString,
|
||
Description: "The IPv6 gateway",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationIPConfigIPv6Gateway,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 8,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccount: {
|
||
Type: schema.TypeList,
|
||
Description: "The user account configuration",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccountKeys: {
|
||
Type: schema.TypeList,
|
||
Description: "The SSH keys",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Elem: &schema.Schema{Type: schema.TypeString},
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccountPassword: {
|
||
Type: schema.TypeString,
|
||
Description: "The SSH password",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Sensitive: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationUserAccountPassword,
|
||
DiffSuppressFunc: func(k, old, new string, d *schema.ResourceData) bool {
|
||
return len(old) > 0 &&
|
||
strings.ReplaceAll(old, "*", "") == ""
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationUserAccountUsername: {
|
||
Type: schema.TypeString,
|
||
Description: "The SSH username",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationUserDataFileID: {
|
||
Type: schema.TypeString,
|
||
Description: "The ID of a file containing custom user data",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationUserDataFileID,
|
||
ValidateDiagFunc: validator.FileID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationVendorDataFileID: {
|
||
Type: schema.TypeString,
|
||
Description: "The ID of a file containing vendor data",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationVendorDataFileID,
|
||
ValidateDiagFunc: validator.FileID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationNetworkDataFileID: {
|
||
Type: schema.TypeString,
|
||
Description: "The ID of a file containing network config",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationNetworkDataFileID,
|
||
ValidateDiagFunc: validator.FileID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationMetaDataFileID: {
|
||
Type: schema.TypeString,
|
||
Description: "The ID of a file containing meta data config",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationMetaDataFileID,
|
||
ValidateDiagFunc: validator.FileID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMInitializationType: {
|
||
Type: schema.TypeString,
|
||
Description: "The cloud-init configuration format",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMInitializationType,
|
||
ValidateDiagFunc: validator.CloudInitType(),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMIPv4Addresses: {
|
||
Type: schema.TypeList,
|
||
Description: "The IPv4 addresses published by the QEMU agent",
|
||
Computed: true,
|
||
Elem: &schema.Schema{
|
||
Type: schema.TypeList,
|
||
Elem: &schema.Schema{Type: schema.TypeString},
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMIPv6Addresses: {
|
||
Type: schema.TypeList,
|
||
Description: "The IPv6 addresses published by the QEMU agent",
|
||
Computed: true,
|
||
Elem: &schema.Schema{
|
||
Type: schema.TypeList,
|
||
Elem: &schema.Schema{Type: schema.TypeString},
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCI: {
|
||
Type: schema.TypeList,
|
||
Description: "The Host PCI devices mapped to the VM",
|
||
Optional: true,
|
||
ForceNew: false,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMHostPCIDevice: {
|
||
Type: schema.TypeString,
|
||
Description: "The PCI device name for Proxmox, in form of 'hostpciX' where X is a sequential number from 0 to 3",
|
||
Required: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceID: {
|
||
Type: schema.TypeString,
|
||
Description: "The PCI ID of the device, for example 0000:00:1f.0 (or 0000:00:1f.0;0000:00:1f.1 for multiple " +
|
||
"device functions, or 0000:00:1f for all functions). Use either this or mapping.",
|
||
Optional: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceMapping: {
|
||
Type: schema.TypeString,
|
||
Description: "The resource mapping name of the device, for example gpu. Use either this or id.",
|
||
Optional: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceMDev: {
|
||
Type: schema.TypeString,
|
||
Description: "The the mediated device to use",
|
||
Optional: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCIDevicePCIE: {
|
||
Type: schema.TypeBool,
|
||
Description: "Tells Proxmox VE to use a PCIe or PCI port. Some guests/device combination require PCIe rather " +
|
||
"than PCI. PCIe is only available for q35 machine types.",
|
||
Optional: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceROMBAR: {
|
||
Type: schema.TypeBool,
|
||
Description: "Makes the firmware ROM visible for the guest. Default is true",
|
||
Optional: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceROMFile: {
|
||
Type: schema.TypeString,
|
||
Description: "A path to a ROM file for the device to use. This is a relative path under /usr/share/kvm/",
|
||
Optional: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostPCIDeviceXVGA: {
|
||
Type: schema.TypeBool,
|
||
Description: "Marks the PCI(e) device as the primary GPU of the VM. With this enabled the vga configuration argument will be ignored.",
|
||
Optional: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostUSB: {
|
||
Type: schema.TypeList,
|
||
Description: "The Host USB devices mapped to the VM",
|
||
Optional: true,
|
||
ForceNew: false,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMHostUSBDevice: {
|
||
Type: schema.TypeString,
|
||
Description: "The USB device ID for Proxmox, in form of '<MANUFACTURER>:<ID>'",
|
||
Required: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostUSBDeviceMapping: {
|
||
Type: schema.TypeString,
|
||
Description: "The resource mapping name of the device, for example usbdisk. Use either this or id.",
|
||
Optional: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMHostUSBDeviceUSB3: {
|
||
Type: schema.TypeBool,
|
||
Description: "Makes the USB device a USB3 device for the machine. Default is false",
|
||
Optional: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMKeyboardLayout: {
|
||
Type: schema.TypeString,
|
||
Description: "The keyboard layout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMKeyboardLayout,
|
||
ValidateDiagFunc: validator.KeyboardLayout(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMMachine: {
|
||
Type: schema.TypeString,
|
||
Description: "The VM machine type, either default `pc` or `q35`",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMMachineType,
|
||
ValidateDiagFunc: validator.MachineType(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMMACAddresses: {
|
||
Type: schema.TypeList,
|
||
Description: "The MAC addresses for the network interfaces",
|
||
Computed: true,
|
||
Elem: &schema.Schema{Type: schema.TypeString},
|
||
},
|
||
mkResourceVirtualEnvironmentVMMemory: {
|
||
Type: schema.TypeList,
|
||
Description: "The memory allocation",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMMemoryDedicated: dvResourceVirtualEnvironmentVMMemoryDedicated,
|
||
mkResourceVirtualEnvironmentVMMemoryFloating: dvResourceVirtualEnvironmentVMMemoryFloating,
|
||
mkResourceVirtualEnvironmentVMMemoryShared: dvResourceVirtualEnvironmentVMMemoryShared,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMMemoryDedicated: {
|
||
Type: schema.TypeInt,
|
||
Description: "The dedicated memory in megabytes",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMMemoryDedicated,
|
||
ValidateDiagFunc: validation.ToDiagFunc(
|
||
validation.IntBetween(64, 268435456),
|
||
),
|
||
},
|
||
mkResourceVirtualEnvironmentVMMemoryFloating: {
|
||
Type: schema.TypeInt,
|
||
Description: "The floating memory in megabytes (balloon)",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMMemoryFloating,
|
||
ValidateDiagFunc: validation.ToDiagFunc(
|
||
validation.IntBetween(0, 268435456),
|
||
),
|
||
},
|
||
mkResourceVirtualEnvironmentVMMemoryShared: {
|
||
Type: schema.TypeInt,
|
||
Description: "The shared memory in megabytes",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMMemoryShared,
|
||
ValidateDiagFunc: validation.ToDiagFunc(
|
||
validation.IntBetween(0, 268435456),
|
||
),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMName: {
|
||
Type: schema.TypeString,
|
||
Description: "The name",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMName,
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDevice: {
|
||
Type: schema.TypeList,
|
||
Description: "The network devices",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return make([]interface{}, 1), nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceBridge: {
|
||
Type: schema.TypeString,
|
||
Description: "The bridge",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceBridge,
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceEnabled: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable the network device",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceEnabled,
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceFirewall: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether this interface's firewall rules should be used",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceFirewall,
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceMACAddress: {
|
||
Type: schema.TypeString,
|
||
Description: "The MAC address",
|
||
Optional: true,
|
||
Computed: true,
|
||
ValidateDiagFunc: validator.MACAddress(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceModel: {
|
||
Type: schema.TypeString,
|
||
Description: "The model",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceModel,
|
||
ValidateDiagFunc: validator.NetworkDeviceModel(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceQueues: {
|
||
Type: schema.TypeInt,
|
||
Description: "Number of packet queues to be used on the device",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceQueues,
|
||
ValidateDiagFunc: validation.ToDiagFunc(validation.IntBetween(0, 64)),
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceRateLimit: {
|
||
Type: schema.TypeFloat,
|
||
Description: "The rate limit in megabytes per second",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceRateLimit,
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceVLANID: {
|
||
Type: schema.TypeInt,
|
||
Description: "The VLAN identifier",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceVLANID,
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkDeviceMTU: {
|
||
Type: schema.TypeInt,
|
||
Description: "Maximum transmission unit (MTU)",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMNetworkDeviceMTU,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: maxResourceVirtualEnvironmentVMNetworkDevices,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMNetworkInterfaceNames: {
|
||
Type: schema.TypeList,
|
||
Description: "The network interface names published by the QEMU agent",
|
||
Computed: true,
|
||
Elem: &schema.Schema{Type: schema.TypeString},
|
||
},
|
||
mkResourceVirtualEnvironmentVMNodeName: {
|
||
Type: schema.TypeString,
|
||
Description: "The node name",
|
||
Required: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMMigrate: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to migrate the VM on node change instead of re-creating it",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMMigrate,
|
||
},
|
||
mkResourceVirtualEnvironmentVMOperatingSystem: {
|
||
Type: schema.TypeList,
|
||
Description: "The operating system configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMOperatingSystemType: dvResourceVirtualEnvironmentVMOperatingSystemType,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMOperatingSystemType: {
|
||
Type: schema.TypeString,
|
||
Description: "The type",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMOperatingSystemType,
|
||
ValidateDiagFunc: vmGetOperatingSystemTypeValidator(),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMPoolID: {
|
||
Type: schema.TypeString,
|
||
Description: "The ID of the pool to assign the virtual machine to",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMPoolID,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSerialDevice: {
|
||
Type: schema.TypeList,
|
||
Description: "The serial devices",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMSerialDeviceDevice: dvResourceVirtualEnvironmentVMSerialDeviceDevice,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMSerialDeviceDevice: {
|
||
Type: schema.TypeString,
|
||
Description: "The device",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSerialDeviceDevice,
|
||
ValidateDiagFunc: vmGetSerialDeviceValidator(),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: maxResourceVirtualEnvironmentVMSerialDevices,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSMBIOS: {
|
||
Type: schema.TypeList,
|
||
Description: "Specifies SMBIOS (type1) settings for the VM",
|
||
Optional: true,
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMSMBIOSFamily: {
|
||
Type: schema.TypeString,
|
||
Description: "Sets SMBIOS family string",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSMBIOSFamily,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSMBIOSManufacturer: {
|
||
Type: schema.TypeString,
|
||
Description: "Sets SMBIOS manufacturer",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSMBIOSManufacturer,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSMBIOSProduct: {
|
||
Type: schema.TypeString,
|
||
Description: "Sets SMBIOS product ID",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSMBIOSProduct,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSMBIOSSerial: {
|
||
Type: schema.TypeString,
|
||
Description: "Sets SMBIOS serial number",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSMBIOSSerial,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSMBIOSSKU: {
|
||
Type: schema.TypeString,
|
||
Description: "Sets SMBIOS SKU",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSMBIOSSKU,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSMBIOSUUID: {
|
||
Type: schema.TypeString,
|
||
Description: "Sets SMBIOS UUID",
|
||
Optional: true,
|
||
Computed: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMSMBIOSVersion: {
|
||
Type: schema.TypeString,
|
||
Description: "Sets SMBIOS version",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSMBIOSVersion,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMStarted: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to start the virtual machine",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMStarted,
|
||
DiffSuppressFunc: func(k, old, new string, d *schema.ResourceData) bool {
|
||
return d.Get(mkResourceVirtualEnvironmentVMTemplate).(bool)
|
||
},
|
||
},
|
||
mkResourceVirtualEnvironmentVMStartup: {
|
||
Type: schema.TypeList,
|
||
Description: "Defines startup and shutdown behavior of the VM",
|
||
Optional: true,
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMStartupOrder: {
|
||
Type: schema.TypeInt,
|
||
Description: "A non-negative number defining the general startup order",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMStartupOrder,
|
||
},
|
||
mkResourceVirtualEnvironmentVMStartupUpDelay: {
|
||
Type: schema.TypeInt,
|
||
Description: "A non-negative number defining the delay in seconds before the next VM is started",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMStartupUpDelay,
|
||
},
|
||
mkResourceVirtualEnvironmentVMStartupDownDelay: {
|
||
Type: schema.TypeInt,
|
||
Description: "A non-negative number defining the delay in seconds before the next VM is shut down",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMStartupDownDelay,
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTabletDevice: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable the USB tablet device",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTabletDevice,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTags: {
|
||
Type: schema.TypeList,
|
||
Description: "Tags of the virtual machine. This is only meta information.",
|
||
Optional: true,
|
||
Elem: &schema.Schema{
|
||
Type: schema.TypeString,
|
||
ValidateFunc: validation.StringIsNotEmpty,
|
||
},
|
||
DiffSuppressFunc: structure.SuppressIfListsAreEqualIgnoringOrder,
|
||
DiffSuppressOnRefresh: true,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTemplate: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to create a template",
|
||
Optional: true,
|
||
ForceNew: true,
|
||
Default: dvResourceVirtualEnvironmentVMTemplate,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutClone: {
|
||
Type: schema.TypeInt,
|
||
Description: "Clone VM timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutClone,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutCreate: {
|
||
Type: schema.TypeInt,
|
||
Description: "Create VM timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutCreate,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutMoveDisk: {
|
||
Type: schema.TypeInt,
|
||
Description: "MoveDisk timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutMoveDisk,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutMigrate: {
|
||
Type: schema.TypeInt,
|
||
Description: "Migrate VM timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutMigrate,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutReboot: {
|
||
Type: schema.TypeInt,
|
||
Description: "Reboot timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutReboot,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutShutdownVM: {
|
||
Type: schema.TypeInt,
|
||
Description: "Shutdown timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutShutdownVM,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutStartVM: {
|
||
Type: schema.TypeInt,
|
||
Description: "Start VM timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutStartVM,
|
||
},
|
||
mkResourceVirtualEnvironmentVMTimeoutStopVM: {
|
||
Type: schema.TypeInt,
|
||
Description: "Stop VM timeout",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMTimeoutStopVM,
|
||
},
|
||
mkResourceVirtualEnvironmentVMVGA: {
|
||
Type: schema.TypeList,
|
||
Description: "The VGA configuration",
|
||
Optional: true,
|
||
DefaultFunc: func() (interface{}, error) {
|
||
return []interface{}{
|
||
map[string]interface{}{
|
||
mkResourceVirtualEnvironmentVMVGAEnabled: dvResourceVirtualEnvironmentVMVGAEnabled,
|
||
mkResourceVirtualEnvironmentVMVGAMemory: dvResourceVirtualEnvironmentVMVGAMemory,
|
||
mkResourceVirtualEnvironmentVMVGAType: dvResourceVirtualEnvironmentVMVGAType,
|
||
},
|
||
}, nil
|
||
},
|
||
Elem: &schema.Resource{
|
||
Schema: map[string]*schema.Schema{
|
||
mkResourceVirtualEnvironmentVMVGAEnabled: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to enable the VGA device",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMVGAEnabled,
|
||
},
|
||
mkResourceVirtualEnvironmentVMVGAMemory: {
|
||
Type: schema.TypeInt,
|
||
Description: "The VGA memory in megabytes (4-512 MB)",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMVGAMemory,
|
||
ValidateDiagFunc: validator.VGAMemory(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMVGAType: {
|
||
Type: schema.TypeString,
|
||
Description: "The VGA type",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMVGAType,
|
||
ValidateDiagFunc: validator.VGAType(),
|
||
},
|
||
},
|
||
},
|
||
MaxItems: 1,
|
||
MinItems: 0,
|
||
},
|
||
mkResourceVirtualEnvironmentVMVMID: {
|
||
Type: schema.TypeInt,
|
||
Description: "The VM identifier",
|
||
Optional: true,
|
||
Computed: true,
|
||
// "ForceNew: true" handled in CustomizeDiff, making sure VMs with legacy configs with vm_id = -1
|
||
// do not require re-creation.
|
||
ValidateDiagFunc: validator.VMID(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMSCSIHardware: {
|
||
Type: schema.TypeString,
|
||
Description: "The SCSI hardware type",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMSCSIHardware,
|
||
ValidateDiagFunc: validator.SCSIHardware(),
|
||
},
|
||
mkResourceVirtualEnvironmentVMHookScriptFileID: {
|
||
Type: schema.TypeString,
|
||
Description: "A hook script",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMHookScript,
|
||
},
|
||
mkResourceVirtualEnvironmentVMStopOnDestroy: {
|
||
Type: schema.TypeBool,
|
||
Description: "Whether to stop rather than shutdown on VM destroy",
|
||
Optional: true,
|
||
Default: dvResourceVirtualEnvironmentVMStopOnDestroy,
|
||
},
|
||
},
|
||
CreateContext: vmCreate,
|
||
ReadContext: vmRead,
|
||
UpdateContext: vmUpdate,
|
||
DeleteContext: vmDelete,
|
||
CustomizeDiff: customdiff.All(
|
||
customdiff.ComputedIf(
|
||
mkResourceVirtualEnvironmentVMIPv4Addresses,
|
||
func(ctx context.Context, d *schema.ResourceDiff, meta interface{}) bool {
|
||
return d.HasChange(mkResourceVirtualEnvironmentVMStarted) ||
|
||
d.HasChange(mkResourceVirtualEnvironmentVMNetworkDevice)
|
||
},
|
||
),
|
||
customdiff.ComputedIf(
|
||
mkResourceVirtualEnvironmentVMIPv6Addresses,
|
||
func(ctx context.Context, d *schema.ResourceDiff, meta interface{}) bool {
|
||
return d.HasChange(mkResourceVirtualEnvironmentVMStarted) ||
|
||
d.HasChange(mkResourceVirtualEnvironmentVMNetworkDevice)
|
||
},
|
||
),
|
||
customdiff.ComputedIf(
|
||
mkResourceVirtualEnvironmentVMNetworkInterfaceNames,
|
||
func(ctx context.Context, d *schema.ResourceDiff, meta interface{}) bool {
|
||
return d.HasChange(mkResourceVirtualEnvironmentVMStarted) ||
|
||
d.HasChange(mkResourceVirtualEnvironmentVMNetworkDevice)
|
||
},
|
||
),
|
||
customdiff.ForceNewIf(
|
||
mkResourceVirtualEnvironmentVMVMID,
|
||
func(ctx context.Context, d *schema.ResourceDiff, meta interface{}) bool {
|
||
newValue := d.Get(mkResourceVirtualEnvironmentVMVMID)
|
||
|
||
// 'vm_id' is ForceNew, except when changing 'vm_id' to existing correct id
|
||
// (automatic fix from -1 to actual vm_id must not re-create VM)
|
||
return strconv.Itoa(newValue.(int)) != d.Id()
|
||
},
|
||
),
|
||
customdiff.ForceNewIf(
|
||
mkResourceVirtualEnvironmentVMNodeName,
|
||
func(ctx context.Context, d *schema.ResourceDiff, meta interface{}) bool {
|
||
return !d.Get(mkResourceVirtualEnvironmentVMMigrate).(bool)
|
||
},
|
||
),
|
||
),
|
||
Importer: &schema.ResourceImporter{
|
||
StateContext: func(ctx context.Context, d *schema.ResourceData, i interface{}) ([]*schema.ResourceData, error) {
|
||
node, id, err := parseImportIDWithNodeName(d.Id())
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
d.SetId(id)
|
||
err = d.Set(mkResourceVirtualEnvironmentVMNodeName, node)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed setting state during import: %w", err)
|
||
}
|
||
|
||
return []*schema.ResourceData{d}, nil
|
||
},
|
||
},
|
||
}
|
||
}
|