AzureRM Managed Disks

builtin/providers/azurerm/config.go

@@ -11,6 +11,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/arm/compute"
 	"github.com/Azure/azure-sdk-for-go/arm/containerregistry"
 	"github.com/Azure/azure-sdk-for-go/arm/containerservice"
+	"github.com/Azure/azure-sdk-for-go/arm/disk"
 	"github.com/Azure/azure-sdk-for-go/arm/eventhub"
 	"github.com/Azure/azure-sdk-for-go/arm/keyvault"
 	"github.com/Azure/azure-sdk-for-go/arm/network"
@@ -47,6 +48,8 @@ type ArmClient struct {
 	vmImageClient          compute.VirtualMachineImagesClient
 	vmClient               compute.VirtualMachinesClient
 
+	diskClient disk.DisksClient
+
 	appGatewayClient             network.ApplicationGatewaysClient
 	ifaceClient                  network.InterfacesClient
 	loadBalancerClient           network.LoadBalancersClient
@@ -245,6 +248,12 @@ func (c *Config) getArmClient() (*ArmClient, error) {
 	csc.Sender = autorest.CreateSender(withRequestLogging())
 	client.containerServicesClient = csc
 
+	dkc := disk.NewDisksClientWithBaseURI(endpoint, c.SubscriptionID)
+	setUserAgent(&dkc.Client)
+	dkc.Authorizer = spt
+	dkc.Sender = autorest.CreateSender(withRequestLogging())
+	client.diskClient = dkc
+
 	ehc := eventhub.NewEventHubsClientWithBaseURI(endpoint, c.SubscriptionID)
 	setUserAgent(&ehc.Client)
 	ehc.Authorizer = spt

builtin/providers/azurerm/import_arm_managed_disk_test.go

@@ -0,0 +1,30 @@
+package azurerm
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccAzureRMManagedDisk_importEmpty(t *testing.T) {
+	ri := acctest.RandInt()
+	config := fmt.Sprintf(testAccAzureRMManagedDisk_empty, ri, ri)
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testCheckAzureRMManagedDiskDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: config,
+			},
+			{
+				ResourceName:      "azurerm_managed_disk.test",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}

builtin/providers/azurerm/import_arm_virtual_machine_test.go

@@ -19,11 +19,39 @@ func TestAccAzureRMVirtualMachine_importBasic(t *testing.T) {
 		Providers:    testAccProviders,
 		CheckDestroy: testCheckAzureRMVirtualMachineDestroy,
 		Steps: []resource.TestStep{
-			resource.TestStep{
+			{
 				Config: config,
 			},
 
-			resource.TestStep{
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateVerifyIgnore: []string{
+					"delete_data_disks_on_termination",
+					"delete_os_disk_on_termination",
+				},
+			},
+		},
+	})
+}
+
+func TestAccAzureRMVirtualMachine_importBasic_managedDisk(t *testing.T) {
+	resourceName := "azurerm_virtual_machine.test"
+
+	ri := acctest.RandInt()
+	config := fmt.Sprintf(testAccAzureRMVirtualMachine_basicLinuxMachine_managedDisk_explicit, ri, ri, ri, ri, ri, ri, ri)
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testCheckAzureRMVirtualMachineDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: config,
+			},
+
+			{
 				ResourceName:      resourceName,
 				ImportState:       true,
 				ImportStateVerify: true,

builtin/providers/azurerm/provider.go

@@ -85,6 +85,8 @@ func Provider() terraform.ResourceProvider {
 			"azurerm_lb_probe":                resourceArmLoadBalancerProbe(),
 			"azurerm_lb_rule":                 resourceArmLoadBalancerRule(),
 
+			"azurerm_managed_disk": resourceArmManagedDisk(),
+
 			"azurerm_key_vault":                 resourceArmKeyVault(),
 			"azurerm_local_network_gateway":     resourceArmLocalNetworkGateway(),
 			"azurerm_network_interface":         resourceArmNetworkInterface(),

builtin/providers/azurerm/resource_arm_managed_disk.go

@@ -0,0 +1,238 @@
+package azurerm
+
+import (
+	"fmt"
+	"github.com/Azure/azure-sdk-for-go/arm/disk"
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/helper/validation"
+	"log"
+	"net/http"
+	"strings"
+)
+
+func resourceArmManagedDisk() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceArmManagedDiskCreate,
+		Read:   resourceArmManagedDiskRead,
+		Update: resourceArmManagedDiskCreate,
+		Delete: resourceArmManagedDiskDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"location": locationSchema(),
+
+			"resource_group_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"storage_account_type": {
+				Type:     schema.TypeString,
+				Required: true,
+				ValidateFunc: validation.StringInSlice([]string{
+					string(disk.PremiumLRS),
+					string(disk.StandardLRS),
+				}, true),
+			},
+
+			"create_option": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+				ValidateFunc: validation.StringInSlice([]string{
+					string(disk.Import),
+					string(disk.Empty),
+					string(disk.Copy),
+				}, true),
+			},
+
+			"source_uri": {
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+				ForceNew: true,
+			},
+
+			"source_resource_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"os_type": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ValidateFunc: validation.StringInSlice([]string{
+					string(disk.Windows),
+					string(disk.Linux),
+				}, true),
+			},
+
+			"disk_size_gb": {
+				Type:         schema.TypeInt,
+				Required:     true,
+				ValidateFunc: validateDiskSizeGB,
+			},
+
+			"tags": tagsSchema(),
+		},
+	}
+}
+
+func validateDiskSizeGB(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
+}
+
+func resourceArmManagedDiskCreate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*ArmClient)
+	diskClient := client.diskClient
+
+	log.Printf("[INFO] preparing arguments for Azure ARM Managed Disk 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)
+
+	createDisk := disk.Model{
+		Name:     &name,
+		Location: &location,
+		Tags:     expandedTags,
+	}
+
+	storageAccountType := d.Get("storage_account_type").(string)
+	osType := d.Get("os_type").(string)
+
+	createDisk.Properties = &disk.Properties{
+		AccountType: disk.StorageAccountTypes(storageAccountType),
+		OsType:      disk.OperatingSystemTypes(osType),
+	}
+
+	if v := d.Get("disk_size_gb"); v != 0 {
+		diskSize := int32(v.(int))
+		createDisk.Properties.DiskSizeGB = &diskSize
+	}
+	createOption := d.Get("create_option").(string)
+
+	creationData := &disk.CreationData{
+		CreateOption: disk.CreateOption(createOption),
+	}
+
+	if strings.EqualFold(createOption, string(disk.Import)) {
+		if sourceUri := d.Get("source_uri").(string); sourceUri != "" {
+			creationData.SourceURI = &sourceUri
+		} else {
+			return fmt.Errorf("[ERROR] source_uri must be specified when create_option is `%s`", disk.Import)
+		}
+	} else if strings.EqualFold(createOption, string(disk.Copy)) {
+		if sourceResourceId := d.Get("source_resource_id").(string); sourceResourceId != "" {
+			creationData.SourceResourceID = &sourceResourceId
+		} else {
+			return fmt.Errorf("[ERROR] source_resource_id must be specified when create_option is `%s`", disk.Copy)
+		}
+	}
+
+	createDisk.CreationData = creationData
+
+	_, diskErr := diskClient.CreateOrUpdate(resGroup, name, createDisk, make(chan struct{}))
+	if diskErr != nil {
+		return diskErr
+	}
+
+	read, err := diskClient.Get(resGroup, name)
+	if err != nil {
+		return err
+	}
+	if read.ID == nil {
+		return fmt.Errorf("[ERROR] Cannot read Managed Disk %s (resource group %s) ID", name, resGroup)
+	}
+
+	d.SetId(*read.ID)
+
+	return resourceArmManagedDiskRead(d, meta)
+}
+
+func resourceArmManagedDiskRead(d *schema.ResourceData, meta interface{}) error {
+	diskClient := meta.(*ArmClient).diskClient
+
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resGroup := id.ResourceGroup
+	name := id.Path["disks"]
+
+	resp, err := diskClient.Get(resGroup, name)
+	if err != nil {
+		if resp.StatusCode == http.StatusNotFound {
+			d.SetId("")
+			return nil
+		}
+		return fmt.Errorf("[ERROR] Error making Read request on Azure Managed Disk %s (resource group %s): %s", name, resGroup, err)
+	}
+
+	d.Set("name", resp.Name)
+	d.Set("resource_group_name", resGroup)
+	d.Set("location", resp.Location)
+
+	if resp.Properties != nil {
+		flattenAzureRmManagedDiskProperties(d, resp.Properties)
+	}
+
+	if resp.CreationData != nil {
+		flattenAzureRmManagedDiskCreationData(d, resp.CreationData)
+	}
+
+	flattenAndSetTags(d, resp.Tags)
+
+	return nil
+}
+
+func resourceArmManagedDiskDelete(d *schema.ResourceData, meta interface{}) error {
+	diskClient := meta.(*ArmClient).diskClient
+
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resGroup := id.ResourceGroup
+	name := id.Path["disks"]
+
+	if _, err = diskClient.Delete(resGroup, name, make(chan struct{})); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func flattenAzureRmManagedDiskProperties(d *schema.ResourceData, properties *disk.Properties) {
+	d.Set("storage_account_type", string(properties.AccountType))
+	if properties.DiskSizeGB != nil {
+		d.Set("disk_size_gb", *properties.DiskSizeGB)
+	}
+	if properties.OsType != "" {
+		d.Set("os_type", string(properties.OsType))
+	}
+}
+
+func flattenAzureRmManagedDiskCreationData(d *schema.ResourceData, creationData *disk.CreationData) {
+	d.Set("create_option", string(creationData.CreateOption))
+	if creationData.SourceURI != nil {
+		d.Set("source_uri", *creationData.SourceURI)
+	}
+}