terraform/builtin/providers/azurerm/resource_arm_virtual_machine.go

package azurerm

//import (
//	"bytes"
//	"fmt"
//	"log"
//	"net/http"
//	"strings"
//	"time"
//
//	"github.com/Azure/azure-sdk-for-go/arm/compute"
//	"github.com/hashicorp/terraform/helper/hashcode"
//	"github.com/hashicorp/terraform/helper/resource"
//	"github.com/hashicorp/terraform/helper/schema"
//)
//
//func resourceArmVirtualMachine() *schema.Resource {
//	return &schema.Resource{
//		Create: resourceArmVirtualMachineCreate,
//		Read:   resourceArmVirtualMachineRead,
//		Update: resourceArmVirtualMachineCreate,
//		Delete: resourceArmVirtualMachineDelete,
//
//		Schema: map[string]*schema.Schema{
//			"name": &schema.Schema{
//				Type:     schema.TypeString,
//				Required: true,
//				ForceNew: true,
//			},
//
//			"location": &schema.Schema{
//				Type:      schema.TypeString,
//				Required:  true,
//				ForceNew:  true,
//				StateFunc: azureRMNormalizeLocation,
//			},
//
//			"resource_group_name": &schema.Schema{
//				Type:     schema.TypeString,
//				Required: true,
//				ForceNew: true,
//			},
//
//			"plan": &schema.Schema{
//				Type:     schema.TypeSet,
//				Optional: true,
//				Computed: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"name": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"publisher": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"product": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//					},
//				},
//				Set: resourceArmVirtualMachinePlanHash,
//			},
//
//			"availability_set_id": &schema.Schema{
//				Type:     schema.TypeString,
//				Optional: true,
//				Computed: true,
//				StateFunc: func(id interface{}) string {
//					return strings.ToLower(id.(string))
//				},
//			},
//
//			"license_type": &schema.Schema{
//				Type:     schema.TypeString,
//				Optional: true,
//				Computed: true,
//			},
//
//			"vm_size": &schema.Schema{
//				Type:     schema.TypeString,
//				Required: true,
//			},
//
//			"storage_image_reference": &schema.Schema{
//				Type:     schema.TypeSet,
//				Optional: true,
//				Computed: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"publisher": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"offer": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"sku": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"version": &schema.Schema{
//							Type:     schema.TypeString,
//							Optional: true,
//							Computed: true,
//						},
//					},
//				},
//				Set: resourceArmVirtualMachineStorageImageReferenceHash,
//			},
//
//			"storage_os_disk": &schema.Schema{
//				Type:     schema.TypeSet,
//				Required: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"os_type": &schema.Schema{
//							Type:     schema.TypeString,
//							Optional: true,
//						},
//
//						"name": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"vhd_uri": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"image_uri": &schema.Schema{
//							Type:     schema.TypeString,
//							Optional: true,
//						},
//
//						"caching": &schema.Schema{
//							Type:     schema.TypeString,
//							Optional: true,
//							Computed: true,
//						},
//
//						"create_option": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//					},
//				},
//				Set: resourceArmVirtualMachineStorageOsDiskHash,
//			},
//
//			"storage_data_disk": &schema.Schema{
//				Type:     schema.TypeList,
//				Optional: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"name": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"vhd_uri": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"create_option": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"disk_size_gb": &schema.Schema{
//							Type:     schema.TypeInt,
//							Required: true,
//							ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
//								value := v.(int)
//								if value < 1 || value > 1023 {
//									errors = append(errors, fmt.Errorf(
//										"The `disk_size_gb` can only be between 1 and 1023"))
//								}
//								return
//							},
//						},
//
//						"lun": &schema.Schema{
//							Type:     schema.TypeInt,
//							Required: true,
//						},
//					},
//				},
//			},
//
//			"os_profile": &schema.Schema{
//				Type:     schema.TypeSet,
//				Required: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"computer_name": &schema.Schema{
//							Type:     schema.TypeString,
//							Optional: true,
//							Computed: true,
//						},
//
//						"admin_username": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"admin_password": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"custom_data": &schema.Schema{
//							Type:     schema.TypeString,
//							Optional: true,
//							Computed: true,
//						},
//					},
//				},
//				Set: resourceArmVirtualMachineStorageOsProfileHash,
//			},
//
//			"os_profile_windows_config": &schema.Schema{
//				Type:     schema.TypeSet,
//				Optional: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"provision_vm_agent": &schema.Schema{
//							Type:     schema.TypeBool,
//							Optional: true,
//						},
//						"enable_automatic_upgrades": &schema.Schema{
//							Type:     schema.TypeBool,
//							Optional: true,
//						},
//						"winrm": &schema.Schema{
//							Type:     schema.TypeSet,
//							Optional: true,
//							Elem: &schema.Resource{
//								Schema: map[string]*schema.Schema{
//									"protocol": &schema.Schema{
//										Type:     schema.TypeString,
//										Required: true,
//									},
//									"certificate_url": &schema.Schema{
//										Type:     schema.TypeString,
//										Optional: true,
//									},
//								},
//							},
//						},
//						"additional_unattend_config": &schema.Schema{
//							Type:     schema.TypeSet,
//							Optional: true,
//							Elem: &schema.Resource{
//								Schema: map[string]*schema.Schema{
//									"pass": &schema.Schema{
//										Type:     schema.TypeString,
//										Required: true,
//									},
//									"component": &schema.Schema{
//										Type:     schema.TypeString,
//										Required: true,
//									},
//									"setting_name": &schema.Schema{
//										Type:     schema.TypeString,
//										Required: true,
//									},
//									"content": &schema.Schema{
//										Type:     schema.TypeString,
//										Required: true,
//									},
//								},
//							},
//						},
//					},
//				},
//				Set: resourceArmVirtualMachineStorageOsProfileWindowsConfigHash,
//			},
//
//			"os_profile_linux_config": &schema.Schema{
//				Type:     schema.TypeSet,
//				Optional: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"disable_password_authentication": &schema.Schema{
//							Type:     schema.TypeBool,
//							Required: true,
//						},
//						"ssh_keys": &schema.Schema{
//							Type:     schema.TypeList,
//							Optional: true,
//							Elem: &schema.Resource{
//								Schema: map[string]*schema.Schema{
//									"path": &schema.Schema{
//										Type:     schema.TypeString,
//										Required: true,
//									},
//									"key_data": &schema.Schema{
//										Type:     schema.TypeString,
//										Optional: true,
//									},
//								},
//							},
//						},
//					},
//				},
//				Set: resourceArmVirtualMachineStorageOsProfileLinuxConfigHash,
//			},
//
//			"os_profile_secrets": &schema.Schema{
//				Type:     schema.TypeSet,
//				Optional: true,
//				Elem: &schema.Resource{
//					Schema: map[string]*schema.Schema{
//						"source_vault_id": &schema.Schema{
//							Type:     schema.TypeString,
//							Required: true,
//						},
//
//						"vault_certificates": &schema.Schema{
//							Type:     schema.TypeSet,
//							Optional: true,
//							Elem: &schema.Resource{
//								Schema: map[string]*schema.Schema{
//									"certificate_url": &schema.Schema{
//										Type:     schema.TypeString,
//										Required: true,
//									},
//									"certificate_store": &schema.Schema{
//										Type:     schema.TypeString,
//										Optional: true,
//									},
//								},
//							},
//						},
//					},
//				},
//			},
//
//			"network_interface_ids": &schema.Schema{
//				Type:     schema.TypeSet,
//				Required: true,
//				Elem:     &schema.Schema{Type: schema.TypeString},
//				Set:      schema.HashString,
//			},
//
//			"tags": tagsSchema(),
//		},
//	}
//}
//
//func resourceArmVirtualMachineCreate(d *schema.ResourceData, meta interface{}) error {
//	client := meta.(*ArmClient)
//	vmClient := client.vmClient
//
//	log.Printf("[INFO] preparing arguments for Azure ARM Virtual Machine creation.")
//
//	name := d.Get("name").(string)
//	location := d.Get("location").(string)
//	resGroup := d.Get("resource_group_name").(string)
//	tags := d.Get("tags").(map[string]interface{})
//	expandedTags := expandTags(tags)
//
//	osDisk, err := expandAzureRmVirtualMachineOsDisk(d)
//	if err != nil {
//		return err
//	}
//	storageProfile := compute.StorageProfile{
//		OsDisk: osDisk,
//	}
//
//	if _, ok := d.GetOk("storage_image_reference"); ok {
//		imageRef, err := expandAzureRmVirtualMachineImageReference(d)
//		if err != nil {
//			return err
//		}
//		storageProfile.ImageReference = imageRef
//	}
//
//	if _, ok := d.GetOk("storage_data_disk"); ok {
//		dataDisks, err := expandAzureRmVirtualMachineDataDisk(d)
//		if err != nil {
//			return err
//		}
//		storageProfile.DataDisks = &dataDisks
//	}
//
//	networkProfile := expandAzureRmVirtualMachineNetworkProfile(d)
//	vmSize := d.Get("vm_size").(string)
//	properties := compute.VirtualMachineProperties{
//		NetworkProfile: &networkProfile,
//		HardwareProfile: &compute.HardwareProfile{
//			VMSize: compute.VirtualMachineSizeTypes(vmSize),
//		},
//		StorageProfile: &storageProfile,
//	}
//
//	osProfile, err := expandAzureRmVirtualMachineOsProfile(d)
//	if err != nil {
//		return err
//	}
//	properties.OsProfile = osProfile
//
//	if v, ok := d.GetOk("availability_set_id"); ok {
//		availabilitySet := v.(string)
//		availSet := compute.SubResource{
//			ID: &availabilitySet,
//		}
//
//		properties.AvailabilitySet = &availSet
//	}
//
//	vm := compute.VirtualMachine{
//		Name:       &name,
//		Location:   &location,
//		Properties: &properties,
//		Tags:       expandedTags,
//	}
//
//	if _, ok := d.GetOk("plan"); ok {
//		plan, err := expandAzureRmVirtualMachinePlan(d)
//		if err != nil {
//			return err
//		}
//
//		vm.Plan = plan
//	}
//
//	resp, vmErr := vmClient.CreateOrUpdate(resGroup, name, vm)
//	if vmErr != nil {
//		return vmErr
//	}
//
//	d.SetId(*resp.ID)
//
//	log.Printf("[DEBUG] Waiting for Virtual Machine (%s) to become available", name)
//	stateConf := &resource.StateChangeConf{
//		Pending:    []string{"Creating", "Updating"},
//		Target:     []string{"Succeeded"},
//		Refresh:    virtualMachineStateRefreshFunc(client, resGroup, name),
//		Timeout:    20 * time.Minute,
//		MinTimeout: 10 * time.Second,
//	}
//	if _, err := stateConf.WaitForState(); err != nil {
//		return fmt.Errorf("Error waiting for Virtual Machine (%s) to become available: %s", name, err)
//	}
//
//	return resourceArmVirtualMachineRead(d, meta)
//}
//
//func resourceArmVirtualMachineRead(d *schema.ResourceData, meta interface{}) error {
//	vmClient := meta.(*ArmClient).vmClient
//
//	id, err := parseAzureResourceID(d.Id())
//	if err != nil {
//		return err
//	}
//	resGroup := id.ResourceGroup
//	name := id.Path["virtualMachines"]
//
//	resp, err := vmClient.Get(resGroup, name, "")
//	if resp.StatusCode == http.StatusNotFound {
//		d.SetId("")
//		return nil
//	}
//	if err != nil {
//		return fmt.Errorf("Error making Read request on Azure Virtual Machine %s: %s", name, err)
//	}
//
//	if resp.Plan != nil {
//		if err := d.Set("plan", flattenAzureRmVirtualMachinePlan(resp.Plan)); err != nil {
//			return fmt.Errorf("[DEBUG] Error setting Virtual Machine Plan error: %#v", err)
//		}
//	}
//
//	if resp.Properties.AvailabilitySet != nil {
//		d.Set("availability_set_id", strings.ToLower(*resp.Properties.AvailabilitySet.ID))
//	}
//
//	d.Set("vm_size", resp.Properties.HardwareProfile.VMSize)
//
//	if resp.Properties.StorageProfile.ImageReference != nil {
//		if err := d.Set("storage_image_reference", schema.NewSet(resourceArmVirtualMachineStorageImageReferenceHash, flattenAzureRmVirtualMachineImageReference(resp.Properties.StorageProfile.ImageReference))); err != nil {
//			return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage Image Reference error: %#v", err)
//		}
//	}
//
//	if err := d.Set("storage_os_disk", schema.NewSet(resourceArmVirtualMachineStorageOsDiskHash, flattenAzureRmVirtualMachineOsDisk(resp.Properties.StorageProfile.OsDisk))); err != nil {
//		return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage OS Disk error: %#v", err)
//	}
//
//	if resp.Properties.StorageProfile.DataDisks != nil {
//		if err := d.Set("storage_data_disk", flattenAzureRmVirtualMachineDataDisk(resp.Properties.StorageProfile.DataDisks)); err != nil {
//			return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage Data Disks error: %#v", err)
//		}
//	}
//
//	if err := d.Set("os_profile", schema.NewSet(resourceArmVirtualMachineStorageOsProfileHash, flattenAzureRmVirtualMachineOsProfile(resp.Properties.OsProfile))); err != nil {
//		return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage OS Profile: %#v", err)
//	}
//
//	if resp.Properties.OsProfile.WindowsConfiguration != nil {
//		if err := d.Set("os_profile_windows_config", schema.NewSet(resourceArmVirtualMachineStorageOsProfileWindowsConfigHash, flattenAzureRmVirtualMachineOsProfileWindowsConfiguration(resp.Properties.OsProfile.WindowsConfiguration))); err != nil {
//			return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage OS Profile Windows Configuration: %#v", err)
//		}
//	}
//
//	if resp.Properties.OsProfile.LinuxConfiguration != nil {
//		if err := d.Set("os_profile_linux_config", flattenAzureRmVirtualMachineOsProfileLinuxConfiguration(resp.Properties.OsProfile.LinuxConfiguration)); err != nil {
//			return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage OS Profile Linux Configuration: %#v", err)
//		}
//	}
//
//	if resp.Properties.OsProfile.Secrets != nil {
//		if err := d.Set("os_profile_secrets", flattenAzureRmVirtualMachineOsProfileSecrets(resp.Properties.OsProfile.Secrets)); err != nil {
//			return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage OS Profile Secrets: %#v", err)
//		}
//	}
//
//	if resp.Properties.NetworkProfile != nil {
//		if err := d.Set("network_interface_ids", flattenAzureRmVirtualMachineNetworkInterfaces(resp.Properties.NetworkProfile)); err != nil {
//			return fmt.Errorf("[DEBUG] Error setting Virtual Machine Storage Network Interfaces: %#v", err)
//		}
//	}
//
//	flattenAndSetTags(d, resp.Tags)
//
//	return nil
//}
//
//func resourceArmVirtualMachineDelete(d *schema.ResourceData, meta interface{}) error {
//	vmClient := meta.(*ArmClient).vmClient
//
//	id, err := parseAzureResourceID(d.Id())
//	if err != nil {
//		return err
//	}
//	resGroup := id.ResourceGroup
//	name := id.Path["virtualMachines"]
//
//	_, err = vmClient.Delete(resGroup, name)
//
//	return err
//}
//
//func virtualMachineStateRefreshFunc(client *ArmClient, resourceGroupName string, vmName string) resource.StateRefreshFunc {
//	return func() (interface{}, string, error) {
//		res, err := client.vmClient.Get(resourceGroupName, vmName, "")
//		if err != nil {
//			return nil, "", fmt.Errorf("Error issuing read request in virtualMachineStateRefreshFunc to Azure ARM for Virtual Machine '%s' (RG: '%s'): %s", vmName, resourceGroupName, err)
//		}
//
//		return res, *res.Properties.ProvisioningState, nil
//	}
//}
//
//func resourceArmVirtualMachinePlanHash(v interface{}) int {
//	var buf bytes.Buffer
//	m := v.(map[string]interface{})
//	buf.WriteString(fmt.Sprintf("%s-", m["name"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["publisher"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["product"].(string)))
//
//	return hashcode.String(buf.String())
//}
//
//func resourceArmVirtualMachineStorageImageReferenceHash(v interface{}) int {
//	var buf bytes.Buffer
//	m := v.(map[string]interface{})
//	buf.WriteString(fmt.Sprintf("%s-", m["publisher"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["offer"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["sku"].(string)))
//
//	return hashcode.String(buf.String())
//}
//
//func resourceArmVirtualMachineStorageOsProfileHash(v interface{}) int {
//	var buf bytes.Buffer
//	m := v.(map[string]interface{})
//	buf.WriteString(fmt.Sprintf("%s-", m["admin_username"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["computer_name"].(string)))
//	return hashcode.String(buf.String())
//}
//
//func resourceArmVirtualMachineStorageDataDiskHash(v interface{}) int {
//	var buf bytes.Buffer
//	m := v.(map[string]interface{})
//	buf.WriteString(fmt.Sprintf("%s-", m["name"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["vhd_uri"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["create_option"].(string)))
//	buf.WriteString(fmt.Sprintf("%d-", m["disk_size_gb"].(int)))
//	buf.WriteString(fmt.Sprintf("%d-", m["lun"].(int)))
//
//	return hashcode.String(buf.String())
//}
//
//func resourceArmVirtualMachineStorageOsDiskHash(v interface{}) int {
//	var buf bytes.Buffer
//	m := v.(map[string]interface{})
//	buf.WriteString(fmt.Sprintf("%s-", m["name"].(string)))
//	buf.WriteString(fmt.Sprintf("%s-", m["vhd_uri"].(string)))
//
//	return hashcode.String(buf.String())
//}
//
//func resourceArmVirtualMachineStorageOsProfileLinuxConfigHash(v interface{}) int {
//	var buf bytes.Buffer
//	m := v.(map[string]interface{})
//	buf.WriteString(fmt.Sprintf("%t-", m["disable_password_authentication"].(bool)))
//
//	return hashcode.String(buf.String())
//}
//
//func resourceArmVirtualMachineStorageOsProfileWindowsConfigHash(v interface{}) int {
//	var buf bytes.Buffer
//	m := v.(map[string]interface{})
//	if m["provision_vm_agent"] != nil {
//		buf.WriteString(fmt.Sprintf("%t-", m["provision_vm_agent"].(bool)))
//	}
//	if m["enable_automatic_upgrades"] != nil {
//		buf.WriteString(fmt.Sprintf("%t-", m["enable_automatic_upgrades"].(bool)))
//	}
//	return hashcode.String(buf.String())
//}
//
//func flattenAzureRmVirtualMachinePlan(plan *compute.Plan) map[string]interface{} {
//	result := make(map[string]interface{})
//	result["name"] = *plan.Name
//	result["publisher"] = *plan.Publisher
//	result["product"] = *plan.Product
//
//	return result
//}
//
//func flattenAzureRmVirtualMachineImageReference(image *compute.ImageReference) []interface{} {
//	result := make(map[string]interface{})
//	result["offer"] = *image.Offer
//	result["publisher"] = *image.Publisher
//	result["sku"] = *image.Sku
//
//	if image.Version != nil {
//		result["version"] = *image.Version
//	}
//
//	return []interface{}{result}
//}
//
//func flattenAzureRmVirtualMachineNetworkInterfaces(profile *compute.NetworkProfile) []string {
//	result := make([]string, 0, len(*profile.NetworkInterfaces))
//	for _, nic := range *profile.NetworkInterfaces {
//		result = append(result, *nic.ID)
//	}
//	return result
//}
//
//func flattenAzureRmVirtualMachineOsProfileSecrets(secrets *[]compute.VaultSecretGroup) []map[string]interface{} {
//	result := make([]map[string]interface{}, 0, len(*secrets))
//	for _, secret := range *secrets {
//		s := map[string]interface{}{
//			"source_vault_id": *secret.SourceVault.ID,
//		}
//
//		if secret.VaultCertificates != nil {
//			certs := make([]map[string]interface{}, 0, len(*secret.VaultCertificates))
//			for _, cert := range *secret.VaultCertificates {
//				vaultCert := make(map[string]interface{})
//				vaultCert["certificate_url"] = *cert.CertificateURL
//
//				if cert.CertificateStore != nil {
//					vaultCert["certificate_store"] = *cert.CertificateStore
//				}
//
//				certs = append(certs, vaultCert)
//			}
//
//			s["vault_certificates"] = certs
//		}
//
//		result = append(result, s)
//	}
//	return result
//}
//
//func flattenAzureRmVirtualMachineDataDisk(disks *[]compute.DataDisk) interface{} {
//	result := make([]interface{}, len(*disks))
//	for i, disk := range *disks {
//		l := make(map[string]interface{})
//		l["name"] = *disk.Name
//		l["vhd_uri"] = *disk.Vhd.URI
//		l["create_option"] = disk.CreateOption
//		l["disk_size_gb"] = *disk.DiskSizeGB
//		l["lun"] = *disk.Lun
//
//		result[i] = l
//	}
//	return result
//}
//
//func flattenAzureRmVirtualMachineOsProfile(osProfile *compute.OSProfile) []interface{} {
//	result := make(map[string]interface{})
//	result["computer_name"] = *osProfile.ComputerName
//	result["admin_username"] = *osProfile.AdminUsername
//	if osProfile.CustomData != nil {
//		result["custom_data"] = *osProfile.CustomData
//	}
//
//	return []interface{}{result}
//}
//
//func flattenAzureRmVirtualMachineOsProfileWindowsConfiguration(config *compute.WindowsConfiguration) []interface{} {
//	result := make(map[string]interface{})
//
//	if config.ProvisionVMAgent != nil {
//		result["provision_vm_agent"] = *config.ProvisionVMAgent
//	}
//
//	if config.EnableAutomaticUpdates != nil {
//		result["enable_automatic_upgrades"] = *config.EnableAutomaticUpdates
//	}
//
//	if config.WinRM != nil {
//		listeners := make([]map[string]interface{}, 0, len(*config.WinRM.Listeners))
//		for _, i := range *config.WinRM.Listeners {
//			listener := make(map[string]interface{})
//			listener["protocol"] = i.Protocol
//
//			if i.CertificateURL != nil {
//				listener["certificate_url"] = *i.CertificateURL
//			}
//
//			listeners = append(listeners, listener)
//		}
//
//		result["winrm"] = listeners
//	}
//
//	if config.AdditionalUnattendContent != nil {
//		content := make([]map[string]interface{}, 0, len(*config.AdditionalUnattendContent))
//		for _, i := range *config.AdditionalUnattendContent {
//			c := make(map[string]interface{})
//			c["pass"] = i.PassName
//			c["component"] = i.ComponentName
//			c["setting_name"] = i.SettingName
//			c["content"] = *i.Content
//
//			content = append(content, c)
//		}
//
//		result["additional_unattend_config"] = content
//	}
//
//	return []interface{}{result}
//}
//
//func flattenAzureRmVirtualMachineOsProfileLinuxConfiguration(config *compute.LinuxConfiguration) []interface{} {
//
//	result := make(map[string]interface{})
//	result["disable_password_authentication"] = *config.DisablePasswordAuthentication
//
//	if config.SSH != nil && len(*config.SSH.PublicKeys) > 0 {
//		ssh_keys := make([]map[string]interface{}, len(*config.SSH.PublicKeys))
//		for _, i := range *config.SSH.PublicKeys {
//			key := make(map[string]interface{})
//			key["path"] = *i.Path
//
//			if i.KeyData != nil {
//				key["key_data"] = *i.KeyData
//			}
//
//			ssh_keys = append(ssh_keys, key)
//		}
//
//		result["ssh_keys"] = ssh_keys
//	}
//
//	return []interface{}{result}
//}
//
//func flattenAzureRmVirtualMachineOsDisk(disk *compute.OSDisk) []interface{} {
//	result := make(map[string]interface{})
//	result["name"] = *disk.Name
//	result["vhd_uri"] = *disk.Vhd.URI
//	result["create_option"] = disk.CreateOption
//	result["caching"] = disk.Caching
//
//	return []interface{}{result}
//}
//
//func expandAzureRmVirtualMachinePlan(d *schema.ResourceData) (*compute.Plan, error) {
//	planConfigs := d.Get("plan").(*schema.Set).List()
//
//	if len(planConfigs) != 1 {
//		return nil, fmt.Errorf("Cannot specify more than one plan.")
//	}
//
//	planConfig := planConfigs[0].(map[string]interface{})
//
//	publisher := planConfig["publisher"].(string)
//	name := planConfig["name"].(string)
//	product := planConfig["product"].(string)
//
//	return &compute.Plan{
//		Publisher: &publisher,
//		Name:      &name,
//		Product:   &product,
//	}, nil
//}
//
//func expandAzureRmVirtualMachineOsProfile(d *schema.ResourceData) (*compute.OSProfile, error) {
//	osProfiles := d.Get("os_profile").(*schema.Set).List()
//
//	if len(osProfiles) != 1 {
//		return nil, fmt.Errorf("[ERROR] Only 1 OS Profile Can be specified for an Azure RM Virtual Machine")
//	}
//
//	osProfile := osProfiles[0].(map[string]interface{})
//
//	adminUsername := osProfile["admin_username"].(string)
//	adminPassword := osProfile["admin_password"].(string)
//
//	profile := &compute.OSProfile{
//		AdminUsername: &adminUsername,
//	}
//
//	if adminPassword != "" {
//		profile.AdminPassword = &adminPassword
//	}
//
//	if _, ok := d.GetOk("os_profile_windows_config"); ok {
//		winConfig, err := expandAzureRmVirtualMachineOsProfileWindowsConfig(d)
//		if err != nil {
//			return nil, err
//		}
//		if winConfig != nil {
//			profile.WindowsConfiguration = winConfig
//		}
//	}
//
//	if _, ok := d.GetOk("os_profile_linux_config"); ok {
//		linuxConfig, err := expandAzureRmVirtualMachineOsProfileLinuxConfig(d)
//		if err != nil {
//			return nil, err
//		}
//		if linuxConfig != nil {
//			profile.LinuxConfiguration = linuxConfig
//		}
//	}
//
//	if _, ok := d.GetOk("os_profile_secrets"); ok {
//		secrets := expandAzureRmVirtualMachineOsProfileSecrets(d)
//		if secrets != nil {
//			profile.Secrets = secrets
//		}
//	}
//
//	if v := osProfile["computer_name"].(string); v != "" {
//		profile.ComputerName = &v
//	}
//	if v := osProfile["custom_data"].(string); v != "" {
//		profile.CustomData = &v
//	}
//
//	return profile, nil
//}
//
//func expandAzureRmVirtualMachineOsProfileSecrets(d *schema.ResourceData) *[]compute.VaultSecretGroup {
//	secretsConfig := d.Get("os_profile_secrets").(*schema.Set).List()
//	secrets := make([]compute.VaultSecretGroup, 0, len(secretsConfig))
//
//	for _, secretConfig := range secretsConfig {
//		config := secretConfig.(map[string]interface{})
//		sourceVaultId := config["source_vault_id"].(string)
//
//		vaultSecretGroup := compute.VaultSecretGroup{
//			SourceVault: &compute.SubResource{
//				ID: &sourceVaultId,
//			},
//		}
//
//		if v := config["vault_certificates"]; v != nil {
//			certsConfig := v.(*schema.Set).List()
//			certs := make([]compute.VaultCertificate, 0, len(certsConfig))
//			for _, certConfig := range certsConfig {
//				config := certConfig.(map[string]interface{})
//
//				certUrl := config["certificate_url"].(string)
//				cert := compute.VaultCertificate{
//					CertificateURL: &certUrl,
//				}
//				if v := config["certificate_store"].(string); v != "" {
//					cert.CertificateStore = &v
//				}
//
//				certs = append(certs, cert)
//			}
//			vaultSecretGroup.VaultCertificates = &certs
//		}
//
//		secrets = append(secrets, vaultSecretGroup)
//	}
//
//	return &secrets
//}
//
//func expandAzureRmVirtualMachineOsProfileLinuxConfig(d *schema.ResourceData) (*compute.LinuxConfiguration, error) {
//	osProfilesLinuxConfig := d.Get("os_profile_linux_config").(*schema.Set).List()
//
//	if len(osProfilesLinuxConfig) != 1 {
//		return nil, fmt.Errorf("[ERROR] Only 1 OS Profile Linux Config Can be specified for an Azure RM Virtual Machine")
//	}
//
//	linuxConfig := osProfilesLinuxConfig[0].(map[string]interface{})
//	disablePasswordAuth := linuxConfig["disable_password_authentication"].(bool)
//
//	config := &compute.LinuxConfiguration{
//		DisablePasswordAuthentication: &disablePasswordAuth,
//	}
//
//	linuxKeys := linuxConfig["ssh_keys"].([]interface{})
//	sshPublicKeys := []compute.SSHPublicKey{}
//	for _, key := range linuxKeys {
//
//		sshKey, ok := key.(map[string]interface{})
//		if !ok {
//			continue
//		}
//		path := sshKey["path"].(string)
//		keyData := sshKey["key_data"].(string)
//
//		sshPublicKey := compute.SSHPublicKey{
//			Path:    &path,
//			KeyData: &keyData,
//		}
//
//		sshPublicKeys = append(sshPublicKeys, sshPublicKey)
//	}
//
//	config.SSH = &compute.SSHConfiguration{
//		PublicKeys: &sshPublicKeys,
//	}
//
//	return config, nil
//}
//
//func expandAzureRmVirtualMachineOsProfileWindowsConfig(d *schema.ResourceData) (*compute.WindowsConfiguration, error) {
//	osProfilesWindowsConfig := d.Get("os_profile_windows_config").(*schema.Set).List()
//
//	if len(osProfilesWindowsConfig) != 1 {
//		return nil, fmt.Errorf("[ERROR] Only 1 OS Profile Windows Config Can be specified for an Azure RM Virtual Machine")
//	}
//
//	osProfileConfig := osProfilesWindowsConfig[0].(map[string]interface{})
//	config := &compute.WindowsConfiguration{}
//
//	if v := osProfileConfig["provision_vm_agent"]; v != nil {
//		provision := v.(bool)
//		config.ProvisionVMAgent = &provision
//	}
//
//	if v := osProfileConfig["enable_automatic_upgrades"]; v != nil {
//		update := v.(bool)
//		config.EnableAutomaticUpdates = &update
//	}
//
//	if v := osProfileConfig["winrm"]; v != nil {
//		winRm := v.(*schema.Set).List()
//		if len(winRm) > 0 {
//			winRmListners := make([]compute.WinRMListener, 0, len(winRm))
//			for _, winRmConfig := range winRm {
//				config := winRmConfig.(map[string]interface{})
//
//				protocol := config["protocol"].(string)
//				winRmListner := compute.WinRMListener{
//					Protocol: compute.ProtocolTypes(protocol),
//				}
//				if v := config["certificate_url"].(string); v != "" {
//					winRmListner.CertificateURL = &v
//				}
//
//				winRmListners = append(winRmListners, winRmListner)
//			}
//			config.WinRM = &compute.WinRMConfiguration{
//				Listeners: &winRmListners,
//			}
//		}
//	}
//	if v := osProfileConfig["additional_unattend_config"]; v != nil {
//		additionalConfig := v.(*schema.Set).List()
//		if len(additionalConfig) > 0 {
//			additionalConfigContent := make([]compute.AdditionalUnattendContent, 0, len(additionalConfig))
//			for _, addConfig := range additionalConfig {
//				config := addConfig.(map[string]interface{})
//				pass := config["pass"].(string)
//				component := config["component"].(string)
//				settingName := config["setting_name"].(string)
//				content := config["content"].(string)
//
//				addContent := compute.AdditionalUnattendContent{
//					PassName:      compute.PassNames(pass),
//					ComponentName: compute.ComponentNames(component),
//					SettingName:   compute.SettingNames(settingName),
//					Content:       &content,
//				}
//
//				additionalConfigContent = append(additionalConfigContent, addContent)
//			}
//			config.AdditionalUnattendContent = &additionalConfigContent
//		}
//	}
//	return config, nil
//}
//
//func expandAzureRmVirtualMachineDataDisk(d *schema.ResourceData) ([]compute.DataDisk, error) {
//	disks := d.Get("storage_data_disk").([]interface{})
//	data_disks := make([]compute.DataDisk, 0, len(disks))
//	for _, disk_config := range disks {
//		config := disk_config.(map[string]interface{})
//
//		name := config["name"].(string)
//		vhd := config["vhd_uri"].(string)
//		createOption := config["create_option"].(string)
//		lun := config["lun"].(int)
//		disk_size := config["disk_size_gb"].(int)
//
//		data_disk := compute.DataDisk{
//			Name: &name,
//			Vhd: &compute.VirtualHardDisk{
//				URI: &vhd,
//			},
//			Lun:          &lun,
//			DiskSizeGB:   &disk_size,
//			CreateOption: compute.DiskCreateOptionTypes(createOption),
//		}
//
//		data_disks = append(data_disks, data_disk)
//	}
//
//	return data_disks, nil
//}
//
//func expandAzureRmVirtualMachineImageReference(d *schema.ResourceData) (*compute.ImageReference, error) {
//	storageImageRefs := d.Get("storage_image_reference").(*schema.Set).List()
//
//	if len(storageImageRefs) != 1 {
//		return nil, fmt.Errorf("Cannot specify more than one storage_image_reference.")
//	}
//
//	storageImageRef := storageImageRefs[0].(map[string]interface{})
//
//	publisher := storageImageRef["publisher"].(string)
//	offer := storageImageRef["offer"].(string)
//	sku := storageImageRef["sku"].(string)
//	version := storageImageRef["version"].(string)
//
//	return &compute.ImageReference{
//		Publisher: &publisher,
//		Offer:     &offer,
//		Sku:       &sku,
//		Version:   &version,
//	}, nil
//}
//
//func expandAzureRmVirtualMachineNetworkProfile(d *schema.ResourceData) compute.NetworkProfile {
//	nicIds := d.Get("network_interface_ids").(*schema.Set).List()
//	network_interfaces := make([]compute.NetworkInterfaceReference, 0, len(nicIds))
//
//	network_profile := compute.NetworkProfile{}
//
//	for _, nic := range nicIds {
//		id := nic.(string)
//		network_interface := compute.NetworkInterfaceReference{
//			ID: &id,
//		}
//		network_interfaces = append(network_interfaces, network_interface)
//	}
//
//	network_profile.NetworkInterfaces = &network_interfaces
//
//	return network_profile
//}
//
//func expandAzureRmVirtualMachineOsDisk(d *schema.ResourceData) (*compute.OSDisk, error) {
//	disks := d.Get("storage_os_disk").(*schema.Set).List()
//
//	if len(disks) != 1 {
//		return nil, fmt.Errorf("[ERROR] Only 1 OS Disk Can be specified for an Azure RM Virtual Machine")
//	}
//
//	disk := disks[0].(map[string]interface{})
//
//	name := disk["name"].(string)
//	vhdURI := disk["vhd_uri"].(string)
//	imageURI := disk["image_uri"].(string)
//	createOption := disk["create_option"].(string)
//
//	osDisk := &compute.OSDisk{
//		Name: &name,
//		Vhd: &compute.VirtualHardDisk{
//			URI: &vhdURI,
//		},
//		CreateOption: compute.DiskCreateOptionTypes(createOption),
//	}
//
//	if v := disk["image_uri"].(string); v != "" {
//		osDisk.Image = &compute.VirtualHardDisk{
//			URI: &imageURI,
//		}
//	}
//
//	if v := disk["os_type"].(string); v != "" {
//		if v == "linux" {
//			osDisk.OsType = compute.Linux
//		} else if v == "windows" {
//			osDisk.OsType = compute.Windows
//		} else {
//			return nil, fmt.Errorf("[ERROR] os_type must be 'linux' or 'windows'")
//		}
//	}
//
//	if v := disk["caching"].(string); v != "" {
//		osDisk.Caching = compute.CachingTypes(v)
//	}
//
//	return osDisk, nil
//}