Vm disk feature

go.mod

@@ -7,3 +7,5 @@ require (
 	github.com/hashicorp/terraform-plugin-sdk v1.3.0
 	github.com/vmware/go-vcloud-director/v2 v2.5.0-alpha.9
 )
+
+replace github.com/vmware/go-vcloud-director/v2 => github.com/vbauzysvmware/go-vcloud-director/v2 v2.2.0-alpha.3.0.20191205150825-aeb30347581d

go.sum

@@ -197,12 +197,12 @@ github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/ulikunitz/xz v0.5.5 h1:pFrO0lVpTBXLpYw+pnLj6TbvHuyjXMfjGeCwSqCVwok=
 github.com/ulikunitz/xz v0.5.5/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
+github.com/vbauzysvmware/go-vcloud-director/v2 v2.2.0-alpha.3.0.20191205150825-aeb30347581d h1:RyfWNunUDWXkIhX/FOUUBGOdRqoRUaLGj5Dzo/K88io=
+github.com/vbauzysvmware/go-vcloud-director/v2 v2.2.0-alpha.3.0.20191205150825-aeb30347581d/go.mod h1:zjondbeyTfZlzhwxOzyF4K2sWWYgMEv5H91dp5dPbU8=
 github.com/vmihailenco/msgpack v3.3.3+incompatible h1:wapg9xDUZDzGCNFlwc5SqI1rvcciqcxEHac4CYj89xI=
 github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
 github.com/vmihailenco/msgpack v4.0.1+incompatible h1:RMF1enSPeKTlXrXdOcqjFUElywVZjjC6pqse21bKbEU=
 github.com/vmihailenco/msgpack v4.0.1+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
-github.com/vmware/go-vcloud-director/v2 v2.5.0-alpha.9 h1:jHcYDaWZtSbHdgO6Q/th0fDZxP86S0oRgM79r02BPno=
-github.com/vmware/go-vcloud-director/v2 v2.5.0-alpha.9/go.mod h1:zjondbeyTfZlzhwxOzyF4K2sWWYgMEv5H91dp5dPbU8=
 github.com/zclconf/go-cty v1.0.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
 github.com/zclconf/go-cty v1.1.0 h1:uJwc9HiBOCpoKIObTQaLR+tsEXx1HBHnOsOOpcdhZgw=
 github.com/zclconf/go-cty v1.1.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=

vcd/config.go

@@ -165,6 +165,34 @@ func (cli *VCDClient) unLockParentVapp(d *schema.ResourceData) {
 	vcdMutexKV.Unlock(key)
 }
 
+// lockParentVm locks using vapp_name and vm_name names existing in resource parameters.
+// Parent means the resource belongs to the VM being locked
+func (cli *VCDClient) lockParentVm(d *schema.ResourceData) {
+	vappName := d.Get("vapp_name").(string)
+	if vappName == "" {
+		panic("vApp name not found")
+	}
+	vmName := d.Get("vm_name").(string)
+	if vmName == "" {
+		panic("vmName name not found")
+	}
+	key := fmt.Sprintf("org:%s|vdc:%s|vapp:%s|vm:%s", cli.getOrgName(d), cli.getVdcName(d), vappName, vmName)
+	vcdMutexKV.Lock(key)
+}
+
+func (cli *VCDClient) unLockParentVm(d *schema.ResourceData) {
+	vappName := d.Get("vapp_name").(string)
+	if vappName == "" {
+		panic("vApp name not found")
+	}
+	vmName := d.Get("vm_name").(string)
+	if vmName == "" {
+		panic("vmName name not found")
+	}
+	key := fmt.Sprintf("org:%s|vdc:%s|vapp:%s|vm:%s", cli.getOrgName(d), cli.getVdcName(d), vappName, vmName)
+	vcdMutexKV.Unlock(key)
+}
+
 // function lockParentEdgeGtw locks using edge_gateway name existing in resource parameters.
 // Parent means the resource belongs to the edge gateway being locked
 func (cli *VCDClient) lockParentEdgeGtw(d *schema.ResourceData) {

vcd/provider.go

@@ -128,6 +128,7 @@ func Provider() terraform.ResourceProvider {
 			"vcd_nsxv_dnat":          resourceVcdNsxvDnat(),         // 2.5
 			"vcd_nsxv_snat":          resourceVcdNsxvSnat(),         // 2.5
 			"vcd_nsxv_firewall_rule": resourceVcdNsxvFirewallRule(), // 2.5
+			"vcd_vm_internal_disk":   resourceVmInternalDisk(),      // 2.6
 			"vcd_ipset":              resourceVcdIpSet(),            // 2.6
 		},
 

vcd/resource_vcd_vapp_vm.go

@@ -3,6 +3,7 @@ package vcd
 import (
 	"bytes"
 	"fmt"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
 	"log"
 	"net"
 	"sort"
@@ -11,12 +12,12 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-sdk/helper/hashcode"
 	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
-	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
 	"github.com/vmware/go-vcloud-director/v2/govcd"
 	"github.com/vmware/go-vcloud-director/v2/types/v56"
 )
 
 func resourceVcdVAppVm() *schema.Resource {
+
 	return &schema.Resource{
 		Create: resourceVcdVAppVmCreate,
 		Update: resourceVcdVAppVmUpdate,
@@ -241,6 +242,104 @@ func resourceVcdVAppVm() *schema.Resource {
 				Optional: true,
 				Set:      resourceVcdVmIndependentDiskHash,
 			},
+			"override_template_disk": {
+				Type:        schema.TypeSet,
+				Optional:    true,
+				ForceNew:    true,
+				Description: " A block to match internal_disk interface in template. Multiple can be used. Disk will be matched by bus_type, bus_number and unit_number.",
+				Elem: &schema.Resource{Schema: map[string]*schema.Schema{
+					"bus_type": {
+						Type:         schema.TypeString,
+						Required:     true,
+						ForceNew:     true,
+						ValidateFunc: validation.StringInSlice([]string{"ide", "parallel", "sas", "paravirtual", "sata"}, true),
+						Description:  "The type of disk controller. Possible values: ide, parallel( LSI Logic Parallel SCSI), sas(LSI Logic SAS (SCSI)), paravirtual(Paravirtual (SCSI)), sata",
+					},
+					"size_in_mb": {
+						Type:        schema.TypeInt,
+						ForceNew:    true,
+						Required:    true,
+						Description: "The size of the disk in MB.",
+					},
+					"bus_number": {
+						Type:        schema.TypeInt,
+						ForceNew:    true,
+						Required:    true,
+						Description: "The number of the SCSI or IDE controller itself.",
+					},
+					"unit_number": {
+						Type:        schema.TypeInt,
+						ForceNew:    true,
+						Required:    true,
+						Description: "The device number on the SCSI or IDE controller of the disk.",
+					},
+					"thin_provisioned": {
+						Type:        schema.TypeBool,
+						ForceNew:    true,
+						Optional:    true,
+						Description: "Specifies whether the disk storage is pre-allocated or allocated on demand.",
+					},
+					"iops": {
+						Type:        schema.TypeInt,
+						ForceNew:    true,
+						Optional:    true,
+						Description: "Specifies the IOPS for the disk. Default - 0.",
+					},
+					"storage_profile": &schema.Schema{
+						Type:        schema.TypeString,
+						ForceNew:    true,
+						Optional:    true,
+						Description: "Storage profile to override the VM default one",
+					},
+				}},
+			},
+			"internal_disk": {
+				Type:        schema.TypeList,
+				Computed:    true,
+				Description: "A block will show internal disk details",
+				Elem: &schema.Resource{Schema: map[string]*schema.Schema{
+					"disk_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The disk ID.",
+					},
+					"bus_type": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The type of disk controller. Possible values: ide, parallel( LSI Logic Parallel SCSI), sas(LSI Logic SAS (SCSI)), paravirtual(Paravirtual (SCSI)), sata",
+					},
+					"size_in_mb": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The size of the disk in MB.",
+					},
+					"bus_number": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The number of the SCSI or IDE controller itself.",
+					},
+					"unit_number": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The device number on the SCSI or IDE controller of the disk.",
+					},
+					"thin_provisioned": {
+						Type:        schema.TypeBool,
+						Computed:    true,
+						Description: "Specifies whether the disk storage is pre-allocated or allocated on demand.",
+					},
+					"iops": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Specifies the IOPS for the disk. Default - 0.",
+					},
+					"storage_profile": &schema.Schema{
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Storage profile to override the VM default one",
+					},
+				}},
+			},
 			"expose_hardware_virtualization": &schema.Schema{
 				Type:        schema.TypeBool,
 				Optional:    true,
@@ -417,6 +516,20 @@ func resourceVcdVAppVmCreate(d *schema.ResourceData, meta interface{}) error {
 
 	d.SetId(vm.VM.ID)
 
+	// update existing internal disks in template
+	err = updateTemplateInternalDisks(d, meta, *vm)
+	if err != nil {
+		d.Set("override_template_disk", nil)
+		return fmt.Errorf("error managing internal disks : %s", err)
+	} else {
+		// add details of internal disk to state
+		errReadInternalDisk := updateStateOfInternalDisks(d, *vm)
+		if errReadInternalDisk != nil {
+			d.Set("internal_disk", nil)
+			log.Printf("error reading interal disks : %s", errReadInternalDisk)
+		}
+	}
+
 	// TODO do not trigger resourceVcdVAppVmUpdate from create. These must be separate actions.
 	err = resourceVcdVAppVmUpdateExecute(d, meta)
 	if err != nil {
@@ -427,6 +540,7 @@ func resourceVcdVAppVmCreate(d *schema.ResourceData, meta interface{}) error {
 		}
 		return err
 	}
+
 	return nil
 }
 
@@ -646,7 +760,8 @@ func resourceVcdVAppVmUpdateExecute(d *schema.ResourceData, meta interface{}) er
 	if d.HasChange("memory") || d.HasChange("cpus") || d.HasChange("cpu_cores") || d.HasChange("power_on") || d.HasChange("disk") ||
 		d.HasChange("expose_hardware_virtualization") || d.HasChange("network") || d.HasChange("computer_name") {
 
-		log.Printf("[TRACE] VM %s has changes: memory(%t), cpus(%t), cpu_cores(%t), power_on(%t), disk(%t), expose_hardware_virtualization(%t), network(%t), computer_name(%t)",
+		log.Printf("[TRACE] VM %s has changes: memory(%t), cpus(%t), cpu_cores(%t), power_on(%t), disk(%t), expose_hardware_virtualization(%t),"+
+			" network(%t), computer_name(%t)",
 			vm.VM.Name, d.HasChange("memory"), d.HasChange("cpus"), d.HasChange("cpu_cores"), d.HasChange("power_on"), d.HasChange("disk"),
 			d.HasChange("expose_hardware_virtualization"), d.HasChange("network"), d.HasChange("computer_name"))
 
@@ -1003,10 +1118,16 @@ func genericVcdVAppVmRead(d *schema.ResourceData, meta interface{}, origin strin
 		return fmt.Errorf("[VM read] unable to set guest properties in state: %s", err)
 	}
 
+	err = updateStateOfInternalDisks(d, *vm)
+	if err != nil {
+		d.Set("internal_disk", nil)
+		return fmt.Errorf("[VM read] error reading internal disks : %s", err)
+	}
+
 	err = updateStateOfAttachedDisks(d, *vm, vdc)
 	if err != nil {
 		d.Set("disk", nil)
-		return fmt.Errorf("[VM read] error updating attached disks : %s", err)
+		return fmt.Errorf("[VM read] error reading attached disks : %s", err)
 	}
 
 	guestCustomizationSection, err := vm.GetGuestCustomizationSection()
@@ -1042,6 +1163,109 @@ func updateStateOfAttachedDisks(d *schema.ResourceData, vm govcd.VM, vdc *govcd.
 	return d.Set("disk", transformed)
 }
 
+func updateStateOfInternalDisks(d *schema.ResourceData, vm govcd.VM) error {
+	err := vm.Refresh()
+	if err != nil {
+		return err
+	}
+
+	existingInternalDisks := vm.VM.VmSpecSection.DiskSection.DiskSettings
+	var internalDiskList []map[string]interface{}
+	for _, internalDisk := range existingInternalDisks {
+		newValue := map[string]interface{}{
+			"disk_id":          internalDisk.DiskId,
+			"bus_type":         internalDiskBusTypesFromValues[internalDisk.AdapterType],
+			"size_in_mb":       int(internalDisk.SizeMb),
+			"bus_number":       internalDisk.BusNumber,
+			"unit_number":      internalDisk.UnitNumber,
+			"iops":             int(*internalDisk.Iops),
+			"thin_provisioned": *internalDisk.ThinProvisioned,
+			"storage_profile":  internalDisk.StorageProfile.Name,
+		}
+		internalDiskList = append(internalDiskList, newValue)
+	}
+
+	return d.Set("internal_disk", internalDiskList)
+}
+
+func updateTemplateInternalDisks(d *schema.ResourceData, meta interface{}, vm govcd.VM) error {
+	vcdClient := meta.(*VCDClient)
+
+	_, vdc, err := vcdClient.GetOrgAndVdcFromResource(d)
+	if err != nil {
+		return fmt.Errorf(errorRetrievingOrgAndVdc, err)
+	}
+
+	diskSettings := vm.VM.VmSpecSection.DiskSection.DiskSettings
+
+	var storageProfilePrt *types.Reference
+	var overrideVmDefault bool
+
+	internalDisksList := d.Get("override_template_disk").(*schema.Set).List()
+
+	if len(internalDisksList) == 0 {
+		return nil
+	}
+
+	for _, internalDisk := range internalDisksList {
+		internalDiskProvidedConfig := internalDisk.(map[string]interface{})
+		diskCreatedByTemplate := getMatchedDisk(internalDiskProvidedConfig, diskSettings)
+
+		storageProfileName := internalDiskProvidedConfig["storage_profile"].(string)
+		if storageProfileName != "" {
+			storageProfile, err := vdc.FindStorageProfileReference(storageProfileName)
+			if err != nil {
+				return fmt.Errorf("[vm creation] error retrieving storage profile %s : %s", storageProfileName, err)
+			}
+			storageProfilePrt = &storageProfile
+			overrideVmDefault = true
+		} else {
+			storageProfilePrt = vm.VM.StorageProfile
+			overrideVmDefault = false
+		}
+
+		if diskCreatedByTemplate == nil {
+			return fmt.Errorf("[vm creation] disk with bus type %s, bust number %d and unit number %d not found",
+				internalDiskProvidedConfig["bus_type"].(string), internalDiskProvidedConfig["bus_number"].(int), internalDiskProvidedConfig["unit_number"].(int))
+		}
+
+		// Update details of internal disk for disk existing in template
+		if value, ok := internalDiskProvidedConfig["iops"]; ok {
+			iops := int64(value.(int))
+			diskCreatedByTemplate.Iops = &iops
+		}
+
+		if value, ok := internalDiskProvidedConfig["thin_provisioned"]; ok {
+			thinProvisioned := value.(bool)
+			diskCreatedByTemplate.ThinProvisioned = &thinProvisioned
+		}
+
+		diskCreatedByTemplate.SizeMb = int64(internalDiskProvidedConfig["size_in_mb"].(int))
+		diskCreatedByTemplate.StorageProfile = storageProfilePrt
+		diskCreatedByTemplate.OverrideVmDefault = overrideVmDefault
+	}
+
+	vmSpecSection := vm.VM.VmSpecSection
+	vmSpecSection.DiskSection.DiskSettings = diskSettings
+	_, err = vm.UpdateInternalDisks(vmSpecSection)
+	if err != nil {
+		return fmt.Errorf("error updating VM disks: %s", err)
+	}
+
+	return nil
+}
+
+func getMatchedDisk(internalDiskProvidedConfig map[string]interface{}, diskSettings []*types.DiskSettings) *types.DiskSettings {
+	for _, diskSetting := range diskSettings {
+		if diskSetting.AdapterType == internalDiskBusTypes[internalDiskProvidedConfig["bus_type"].(string)] &&
+			diskSetting.BusNumber == internalDiskProvidedConfig["bus_number"].(int) &&
+			diskSetting.UnitNumber == internalDiskProvidedConfig["unit_number"].(int) {
+			return diskSetting
+		}
+	}
+	return nil
+}
+
 func resourceVcdVAppVmDelete(d *schema.ResourceData, meta interface{}) error {
 	vcdClient := meta.(*VCDClient)