mirrors/terraform-provider-proxmox
0
0
Fork 0
mirror of https://github.com/bpg/terraform-provider-proxmox.git synced 2025-07-02 03:22:59 +00:00
Code

Change state comparison and default values

Browse Source
This commit is contained in:
Dan Petersen 2019-12-31 01:40:51 +01:00
parent 38bec29683
commit 60a998cb09
10 changed files with 40 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -435,7 +435,7 @@ This resource doesn't expose any additional attributes.
* `started` - (Optional) Whether to start the virtual machine (defaults to `true`) * `started` - (Optional) Whether to start the virtual machine (defaults to `true`)
* `vga` - (Optional) The VGA configuration * `vga` - (Optional) The VGA configuration
* `enabled` - (Optional) Whether to enable the VGA device (defaults to `true`) * `enabled` - (Optional) Whether to enable the VGA device (defaults to `true`)
* `memory` - (Optional) The VGA memory in megabytes (4-512 MB) * `memory` - (Optional) The VGA memory in megabytes (defaults to `16`)
* `type` - (Optional) The VGA type (defaults to `std`) * `type` - (Optional) The VGA type (defaults to `std`)
* `cirrus` - Cirrus (deprecated since QEMU 2.2) * `cirrus` - Cirrus (deprecated since QEMU 2.2)
* `qxl` - SPICE * `qxl` - SPICE

2
proxmoxtf/data_source_virtual_environment_group.go
View File

@ -89,7 +89,7 @@ func dataSourceVirtualEnvironmentGroupRead(d *schema.ResourceData, m interface{}
d.SetId(groupID) d.SetId(groupID)
aclParsed := make([]interface{}, 0) aclParsed := []interface{}{}
for _, v := range acl { for _, v := range acl {
if v.Type == "group" && v.UserOrGroupID == groupID { if v.Type == "group" && v.UserOrGroupID == groupID {

2
proxmoxtf/data_source_virtual_environment_role.go
View File

@ -47,7 +47,7 @@ func dataSourceVirtualEnvironmentRoleRead(d *schema.ResourceData, m interface{})
return err return err
} }
privileges := schema.NewSet(schema.HashString, make([]interface{}, 0)) privileges := schema.NewSet(schema.HashString, []interface{}{})
if *accessRole != nil { if *accessRole != nil {
for _, v := range *accessRole { for _, v := range *accessRole {

2
proxmoxtf/data_source_virtual_environment_roles.go
View File

@ -63,7 +63,7 @@ func dataSourceVirtualEnvironmentRolesRead(d *schema.ResourceData, m interface{}
for i, v := range list { for i, v := range list {
if v.Privileges != nil { if v.Privileges != nil {
p := schema.NewSet(schema.HashString, make([]interface{}, 0)) p := schema.NewSet(schema.HashString, []interface{}{})
for _, v := range *v.Privileges { for _, v := range *v.Privileges {
p.Add(v) p.Add(v)

2
proxmoxtf/data_source_virtual_environment_user.go
View File

@ -127,7 +127,7 @@ func dataSourceVirtualEnvironmentUserRead(d *schema.ResourceData, m interface{})
d.SetId(userID) d.SetId(userID)
aclParsed := make([]interface{}, 0) aclParsed := []interface{}{}
for _, v := range acl { for _, v := range acl {
if v.Type == "user" && v.UserOrGroupID == userID { if v.Type == "user" && v.UserOrGroupID == userID {

4
proxmoxtf/resource_virtual_environment_group.go
View File

@ -31,7 +31,7 @@ func resourceVirtualEnvironmentGroup() *schema.Resource {
Description: "The access control list", Description: "The access control list",
Optional: true, Optional: true,
DefaultFunc: func() (interface{}, error) { DefaultFunc: func() (interface{}, error) {
return make([]interface{}, 0), nil return []interface{}{}, nil
}, },
Elem: &schema.Resource{ Elem: &schema.Resource{
Schema: map[string]*schema.Schema{ Schema: map[string]*schema.Schema{
@ -158,7 +158,7 @@ func resourceVirtualEnvironmentGroupRead(d *schema.ResourceData, m interface{})
d.SetId(groupID) d.SetId(groupID)
aclParsed := make([]interface{}, 0) aclParsed := []interface{}{}
for _, v := range acl { for _, v := range acl {
if v.Type == "group" && v.UserOrGroupID == groupID { if v.Type == "group" && v.UserOrGroupID == groupID {

2
proxmoxtf/resource_virtual_environment_role.go
View File

@ -92,7 +92,7 @@ func resourceVirtualEnvironmentRoleRead(d *schema.ResourceData, m interface{}) e
return err return err
} }
privileges := schema.NewSet(schema.HashString, make([]interface{}, 0)) privileges := schema.NewSet(schema.HashString, []interface{}{})
if *role != nil { if *role != nil {
for _, v := range *role { for _, v := range *role {

6
proxmoxtf/resource_virtual_environment_user.go
View File

@ -45,7 +45,7 @@ func resourceVirtualEnvironmentUser() *schema.Resource {
Description: "The access control list", Description: "The access control list",
Optional: true, Optional: true,
DefaultFunc: func() (interface{}, error) { DefaultFunc: func() (interface{}, error) {
return make([]interface{}, 0), nil return []interface{}{}, nil
}, },
Elem: &schema.Resource{ Elem: &schema.Resource{
Schema: map[string]*schema.Schema{ Schema: map[string]*schema.Schema{
@ -243,7 +243,7 @@ func resourceVirtualEnvironmentUserRead(d *schema.ResourceData, m interface{}) e
return err return err
} }
aclParsed := make([]interface{}, 0) aclParsed := []interface{}{}
for _, v := range acl { for _, v := range acl {
if v.Type == "user" && v.UserOrGroupID == userID { if v.Type == "user" && v.UserOrGroupID == userID {
@ -295,7 +295,7 @@ func resourceVirtualEnvironmentUserRead(d *schema.ResourceData, m interface{}) e
d.Set(mkResourceVirtualEnvironmentUserFirstName, "") d.Set(mkResourceVirtualEnvironmentUserFirstName, "")
} }
groups := schema.NewSet(schema.HashString, make([]interface{}, 0)) groups := schema.NewSet(schema.HashString, []interface{}{})
if user.Groups != nil { if user.Groups != nil {
for _, v := range *user.Groups { for _, v := range *user.Groups {

56
proxmoxtf/resource_virtual_environment_vm.go
View File

@ -52,7 +52,7 @@ const (
dvResourceVirtualEnvironmentVMPoolID = "" dvResourceVirtualEnvironmentVMPoolID = ""
dvResourceVirtualEnvironmentVMStarted = true dvResourceVirtualEnvironmentVMStarted = true
dvResourceVirtualEnvironmentVMVGAEnabled = true dvResourceVirtualEnvironmentVMVGAEnabled = true
dvResourceVirtualEnvironmentVMVGAMemory = 0 dvResourceVirtualEnvironmentVMVGAMemory = 16
dvResourceVirtualEnvironmentVMVGAType = "std" dvResourceVirtualEnvironmentVMVGAType = "std"
dvResourceVirtualEnvironmentVMVMID = -1 dvResourceVirtualEnvironmentVMVMID = -1
@ -1353,19 +1353,19 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
if vmConfig.Agent.Enabled != nil { if vmConfig.Agent.Enabled != nil {
agent[mkResourceVirtualEnvironmentVMAgentEnabled] = bool(*vmConfig.Agent.Enabled) agent[mkResourceVirtualEnvironmentVMAgentEnabled] = bool(*vmConfig.Agent.Enabled)
} else { } else {
agent[mkResourceVirtualEnvironmentVMAgentEnabled] = dvResourceVirtualEnvironmentVMAgentEnabled agent[mkResourceVirtualEnvironmentVMAgentEnabled] = false
} }
if vmConfig.Agent.TrimClonedDisks != nil { if vmConfig.Agent.TrimClonedDisks != nil {
agent[mkResourceVirtualEnvironmentVMAgentTrim] = bool(*vmConfig.Agent.TrimClonedDisks) agent[mkResourceVirtualEnvironmentVMAgentTrim] = bool(*vmConfig.Agent.TrimClonedDisks)
} else { } else {
agent[mkResourceVirtualEnvironmentVMAgentTrim] = dvResourceVirtualEnvironmentVMAgentTrim agent[mkResourceVirtualEnvironmentVMAgentTrim] = false
} }
if vmConfig.Agent.Type != nil { if vmConfig.Agent.Type != nil {
agent[mkResourceVirtualEnvironmentVMAgentType] = *vmConfig.Agent.Type agent[mkResourceVirtualEnvironmentVMAgentType] = *vmConfig.Agent.Type
} else { } else {
agent[mkResourceVirtualEnvironmentVMAgentType] = dvResourceVirtualEnvironmentVMAgentType agent[mkResourceVirtualEnvironmentVMAgentType] = ""
} }
currentAgent := d.Get(mkResourceVirtualEnvironmentVMAgent).([]interface{}) currentAgent := d.Get(mkResourceVirtualEnvironmentVMAgent).([]interface{})
@ -1377,16 +1377,16 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
d.Set(mkResourceVirtualEnvironmentVMAgent, []interface{}{agent}) d.Set(mkResourceVirtualEnvironmentVMAgent, []interface{}{agent})
} }
} else { } else {
d.Set(mkResourceVirtualEnvironmentVMAgent, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMAgent, []interface{}{})
} }
// Compare the IDE devices to the CDROM and cloud-init configurations stored in the state. // Compare the IDE devices to the CDROM and cloud-init configurations stored in the state.
if vmConfig.IDEDevice2 != nil { if vmConfig.IDEDevice2 != nil {
if *vmConfig.IDEDevice2.Media == "cdrom" { if *vmConfig.IDEDevice2.Media == "cdrom" {
if strings.Contains(vmConfig.IDEDevice2.FileVolume, fmt.Sprintf("vm-%d-cloudinit", vmID)) { if strings.Contains(vmConfig.IDEDevice2.FileVolume, fmt.Sprintf("vm-%d-cloudinit", vmID)) {
d.Set(mkResourceVirtualEnvironmentVMCDROM, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMCDROM, []interface{}{})
} else { } else {
d.Set(mkResourceVirtualEnvironmentVMCloudInit, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMCloudInit, []interface{}{})
cdrom := make([]interface{}, 1) cdrom := make([]interface{}, 1)
cdromBlock := map[string]interface{}{} cdromBlock := map[string]interface{}{}
@ -1399,12 +1399,12 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
d.Set(mkResourceVirtualEnvironmentVMCDROM, cdrom) d.Set(mkResourceVirtualEnvironmentVMCDROM, cdrom)
} }
} else { } else {
d.Set(mkResourceVirtualEnvironmentVMCDROM, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMCDROM, []interface{}{})
d.Set(mkResourceVirtualEnvironmentVMCloudInit, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMCloudInit, []interface{}{})
} }
} else { } else {
d.Set(mkResourceVirtualEnvironmentVMCDROM, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMCDROM, []interface{}{})
d.Set(mkResourceVirtualEnvironmentVMCloudInit, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMCloudInit, []interface{}{})
} }
// Compare the cloud-init configuration to the one stored in the state. // Compare the cloud-init configuration to the one stored in the state.
@ -1416,13 +1416,13 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
if vmConfig.CloudInitDNSDomain != nil { if vmConfig.CloudInitDNSDomain != nil {
cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSDomain] = *vmConfig.CloudInitDNSDomain cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSDomain] = *vmConfig.CloudInitDNSDomain
} else { } else {
cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSDomain] = dvResourceVirtualEnvironmentVMCloudInitDNSDomain cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSDomain] = ""
} }
if vmConfig.CloudInitDNSServer != nil { if vmConfig.CloudInitDNSServer != nil {
cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSServer] = *vmConfig.CloudInitDNSServer cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSServer] = *vmConfig.CloudInitDNSServer
} else { } else {
cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSServer] = dvResourceVirtualEnvironmentVMCloudInitDNSServer cloudInitDNS[mkResourceVirtualEnvironmentVMCloudInitDNSServer] = ""
} }
cloudInit[mkResourceVirtualEnvironmentVMCloudInitDNS] = []interface{}{cloudInitDNS} cloudInit[mkResourceVirtualEnvironmentVMCloudInitDNS] = []interface{}{cloudInitDNS}
@ -1508,7 +1508,7 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
if vmConfig.CloudInitPassword != nil { if vmConfig.CloudInitPassword != nil {
cloudInitUserAccount[mkResourceVirtualEnvironmentVMCloudInitUserAccountPassword] = *vmConfig.CloudInitPassword cloudInitUserAccount[mkResourceVirtualEnvironmentVMCloudInitUserAccountPassword] = *vmConfig.CloudInitPassword
} else { } else {
cloudInitUserAccount[mkResourceVirtualEnvironmentVMCloudInitUserAccountPassword] = dvResourceVirtualEnvironmentVMCloudInitUserAccountPassword cloudInitUserAccount[mkResourceVirtualEnvironmentVMCloudInitUserAccountPassword] = ""
} }
if vmConfig.CloudInitUsername != nil { if vmConfig.CloudInitUsername != nil {
@ -1524,10 +1524,10 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
if vmConfig.CloudInitFiles.UserVolume != nil { if vmConfig.CloudInitFiles.UserVolume != nil {
cloudInit[mkResourceVirtualEnvironmentVMCloudInitUserDataFileID] = *vmConfig.CloudInitFiles.UserVolume cloudInit[mkResourceVirtualEnvironmentVMCloudInitUserDataFileID] = *vmConfig.CloudInitFiles.UserVolume
} else { } else {
cloudInit[mkResourceVirtualEnvironmentVMCloudInitUserDataFileID] = dvResourceVirtualEnvironmentVMCloudInitUserDataFileID cloudInit[mkResourceVirtualEnvironmentVMCloudInitUserDataFileID] = ""
} }
} else { } else {
cloudInit[mkResourceVirtualEnvironmentVMCloudInitUserDataFileID] = dvResourceVirtualEnvironmentVMCloudInitUserDataFileID cloudInit[mkResourceVirtualEnvironmentVMCloudInitUserDataFileID] = ""
} }
if len(cloudInit) > 0 { if len(cloudInit) > 0 {
@ -1542,19 +1542,19 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
if vmConfig.CPUCores != nil { if vmConfig.CPUCores != nil {
cpu[mkResourceVirtualEnvironmentVMCPUCores] = *vmConfig.CPUCores cpu[mkResourceVirtualEnvironmentVMCPUCores] = *vmConfig.CPUCores
} else { } else {
cpu[mkResourceVirtualEnvironmentVMCPUCores] = dvResourceVirtualEnvironmentVMCPUCores cpu[mkResourceVirtualEnvironmentVMCPUCores] = 0
} }
if vmConfig.VirtualCPUCount != nil { if vmConfig.VirtualCPUCount != nil {
cpu[mkResourceVirtualEnvironmentVMCPUHotplugged] = *vmConfig.VirtualCPUCount cpu[mkResourceVirtualEnvironmentVMCPUHotplugged] = *vmConfig.VirtualCPUCount
} else { } else {
cpu[mkResourceVirtualEnvironmentVMCPUHotplugged] = dvResourceVirtualEnvironmentVMCPUHotplugged cpu[mkResourceVirtualEnvironmentVMCPUHotplugged] = 0
} }
if vmConfig.CPUSockets != nil { if vmConfig.CPUSockets != nil {
cpu[mkResourceVirtualEnvironmentVMCPUSockets] = *vmConfig.CPUSockets cpu[mkResourceVirtualEnvironmentVMCPUSockets] = *vmConfig.CPUSockets
} else { } else {
cpu[mkResourceVirtualEnvironmentVMCPUSockets] = dvResourceVirtualEnvironmentVMCPUSockets cpu[mkResourceVirtualEnvironmentVMCPUSockets] = 0
} }
currentCPU := d.Get(mkResourceVirtualEnvironmentVMCPU).([]interface{}) currentCPU := d.Get(mkResourceVirtualEnvironmentVMCPU).([]interface{})
@ -1582,7 +1582,7 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
// Compare the disks to those stored in the state. // Compare the disks to those stored in the state.
currentDiskList := d.Get(mkResourceVirtualEnvironmentVMDisk).([]interface{}) currentDiskList := d.Get(mkResourceVirtualEnvironmentVMDisk).([]interface{})
diskList := make([]interface{}, 0) diskList := []interface{}{}
diskObjects := []*proxmox.CustomStorageDevice{ diskObjects := []*proxmox.CustomStorageDevice{
vmConfig.SCSIDevice0, vmConfig.SCSIDevice0,
vmConfig.SCSIDevice1, vmConfig.SCSIDevice1,
@ -1698,19 +1698,19 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
if vmConfig.DedicatedMemory != nil { if vmConfig.DedicatedMemory != nil {
memory[mkResourceVirtualEnvironmentVMMemoryDedicated] = *vmConfig.DedicatedMemory memory[mkResourceVirtualEnvironmentVMMemoryDedicated] = *vmConfig.DedicatedMemory
} else { } else {
memory[mkResourceVirtualEnvironmentVMMemoryDedicated] = dvResourceVirtualEnvironmentVMMemoryDedicated memory[mkResourceVirtualEnvironmentVMMemoryDedicated] = 0
} }
if vmConfig.FloatingMemory != nil { if vmConfig.FloatingMemory != nil {
memory[mkResourceVirtualEnvironmentVMMemoryFloating] = *vmConfig.FloatingMemory memory[mkResourceVirtualEnvironmentVMMemoryFloating] = *vmConfig.FloatingMemory
} else { } else {
memory[mkResourceVirtualEnvironmentVMMemoryFloating] = dvResourceVirtualEnvironmentVMMemoryFloating memory[mkResourceVirtualEnvironmentVMMemoryFloating] = 0
} }
if vmConfig.SharedMemory != nil { if vmConfig.SharedMemory != nil {
memory[mkResourceVirtualEnvironmentVMMemoryShared] = vmConfig.SharedMemory.Size memory[mkResourceVirtualEnvironmentVMMemoryShared] = vmConfig.SharedMemory.Size
} else { } else {
memory[mkResourceVirtualEnvironmentVMMemoryShared] = dvResourceVirtualEnvironmentVMMemoryShared memory[mkResourceVirtualEnvironmentVMMemoryShared] = 0
} }
currentMemory := d.Get(mkResourceVirtualEnvironmentVMMemory).([]interface{}) currentMemory := d.Get(mkResourceVirtualEnvironmentVMMemory).([]interface{})
@ -1820,20 +1820,20 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
if vmConfig.VGADevice.Memory != nil { if vmConfig.VGADevice.Memory != nil {
vga[mkResourceVirtualEnvironmentVMVGAMemory] = *vmConfig.VGADevice.Memory vga[mkResourceVirtualEnvironmentVMVGAMemory] = *vmConfig.VGADevice.Memory
} else { } else {
vga[mkResourceVirtualEnvironmentVMVGAMemory] = dvResourceVirtualEnvironmentVMVGAMemory vga[mkResourceVirtualEnvironmentVMVGAMemory] = 0
} }
if vgaEnabled { if vgaEnabled {
if vmConfig.VGADevice.Type != nil { if vmConfig.VGADevice.Type != nil {
vga[mkResourceVirtualEnvironmentVMVGAType] = *vmConfig.VGADevice.Type vga[mkResourceVirtualEnvironmentVMVGAType] = *vmConfig.VGADevice.Type
} else { } else {
vga[mkResourceVirtualEnvironmentVMVGAType] = dvResourceVirtualEnvironmentVMVGAType vga[mkResourceVirtualEnvironmentVMVGAType] = ""
} }
} }
} else { } else {
vga[mkResourceVirtualEnvironmentVMVGAEnabled] = true vga[mkResourceVirtualEnvironmentVMVGAEnabled] = true
vga[mkResourceVirtualEnvironmentVMVGAMemory] = dvResourceVirtualEnvironmentVMVGAMemory vga[mkResourceVirtualEnvironmentVMVGAMemory] = 0
vga[mkResourceVirtualEnvironmentVMVGAType] = dvResourceVirtualEnvironmentVMVGAType vga[mkResourceVirtualEnvironmentVMVGAType] = ""
} }
currentVGA := d.Get(mkResourceVirtualEnvironmentVMVGA).([]interface{}) currentVGA := d.Get(mkResourceVirtualEnvironmentVMVGA).([]interface{})
@ -1844,7 +1844,7 @@ func resourceVirtualEnvironmentVMRead(d *schema.ResourceData, m interface{}) err
vga[mkResourceVirtualEnvironmentVMVGAType] != dvResourceVirtualEnvironmentVMVGAType { vga[mkResourceVirtualEnvironmentVMVGAType] != dvResourceVirtualEnvironmentVMVGAType {
d.Set(mkResourceVirtualEnvironmentVMVGA, []interface{}{vga}) d.Set(mkResourceVirtualEnvironmentVMVGA, []interface{}{vga})
} else { } else {
d.Set(mkResourceVirtualEnvironmentVMVGA, make([]interface{}, 0)) d.Set(mkResourceVirtualEnvironmentVMVGA, []interface{}{})
} }
// Determine the state of the virtual machine in order to update the "started" argument. // Determine the state of the virtual machine in order to update the "started" argument.

16
proxmoxtf/utils.go
View File

@ -176,21 +176,7 @@ func getSchemaBlock(r *schema.Resource, d *schema.ResourceData, m interface{}, k
} }
func getVGAMemoryValidator() schema.SchemaValidateFunc { func getVGAMemoryValidator() schema.SchemaValidateFunc {
return func(i interface{}, k string) ([]string, []error) { return validation.IntBetween(4, 512)
v, ok := i.(int)
if !ok {
return []string{}, []error{fmt.Errorf("expected type of %s to be []interface{}", k)}
}
if v == 0 {
return []string{}, []error{}
}
validator := validation.IntBetween(4, 512)
return validator(i, k)
}
} }
func getVGATypeValidator() schema.SchemaValidateFunc { func getVGATypeValidator() schema.SchemaValidateFunc {