Merge pull request #5307 from magodo/dedicated_host_group

New Data Source/Resource: `azurerm_dedicated_host_group`
hashicorp · Jan 9, 2020 · 2ee890c · 2ee890c
2 parents d61a748 + ea6d2b1
commit 2ee890c
Show file tree

Hide file tree

Showing 9 changed files with 628 additions and 0 deletions.
diff --git a/azurerm/internal/services/compute/client/client.go b/azurerm/internal/services/compute/client/client.go
@@ -8,6 +8,7 @@ import (
 
 type Client struct {
 	AvailabilitySetsClient         *compute.AvailabilitySetsClient
+	DedicatedHostGroupsClient      *compute.DedicatedHostGroupsClient
 	DisksClient                    *compute.DisksClient
 	GalleriesClient                *compute.GalleriesClient
 	GalleryImagesClient            *compute.GalleryImagesClient
@@ -30,6 +31,9 @@ func NewClient(o *common.ClientOptions) *Client {
 	availabilitySetsClient := compute.NewAvailabilitySetsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&availabilitySetsClient.Client, o.ResourceManagerAuthorizer)
 
+	dedicatedHostGroupsClient := compute.NewDedicatedHostGroupsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
+	o.ConfigureClient(&dedicatedHostGroupsClient.Client, o.ResourceManagerAuthorizer)
+
 	disksClient := compute.NewDisksClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&disksClient.Client, o.ResourceManagerAuthorizer)
 
@@ -80,6 +84,7 @@ func NewClient(o *common.ClientOptions) *Client {
 
 	return &Client{
 		AvailabilitySetsClient:         &availabilitySetsClient,
+		DedicatedHostGroupsClient:      &dedicatedHostGroupsClient,
 		DisksClient:                    &disksClient,
 		GalleriesClient:                &galleriesClient,
 		GalleryImagesClient:            &galleryImagesClient,

diff --git a/azurerm/internal/services/compute/data_source_dedicated_host_group.go b/azurerm/internal/services/compute/data_source_dedicated_host_group.go
@@ -0,0 +1,90 @@
+package compute
+
+import (
+	"fmt"
+	"regexp"
+	"time"
+
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
+
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func dataSourceArmDedicatedHostGroup() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceArmDedicatedHostGroupRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read: schema.DefaultTimeout(5 * time.Minute),
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ValidateFunc: validation.StringMatch(regexp.MustCompile(`^[^_\W][\w-.]{0,78}[\w]$`), ""),
+			},
+
+			"location": azure.SchemaLocationForDataSource(),
+
+			"resource_group_name": azure.SchemaResourceGroupNameForDataSource(),
+
+			"platform_fault_domain_count": {
+				Type:     schema.TypeInt,
+				Computed: true,
+			},
+
+			"zones": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+
+			"tags": tags.SchemaDataSource(),
+		},
+	}
+}
+
+func dataSourceArmDedicatedHostGroupRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Compute.DedicatedHostGroupsClient
+	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	name := d.Get("name").(string)
+	resourceGroupName := d.Get("resource_group_name").(string)
+
+	resp, err := client.Get(ctx, resourceGroupName, name)
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			return fmt.Errorf("Error: Dedicated Host Group %q (Resource Group %q) was not found", name, resourceGroupName)
+		}
+		return fmt.Errorf("Error reading Dedicated Host Group %q (Resource Group %q): %+v", name, resourceGroupName, err)
+	}
+
+	d.SetId(*resp.ID)
+
+	d.Set("name", name)
+	d.Set("resource_group_name", resourceGroupName)
+	if location := resp.Location; location != nil {
+		d.Set("location", azure.NormalizeLocation(*location))
+	}
+	if props := resp.DedicatedHostGroupProperties; props != nil {
+		platformFaultDomainCount := 0
+		if props.PlatformFaultDomainCount != nil {
+			platformFaultDomainCount = int(*props.PlatformFaultDomainCount)
+		}
+		d.Set("platform_fault_domain_count", platformFaultDomainCount)
+	}
+
+	d.Set("zones", utils.FlattenStringSlice(resp.Zones))
+
+	return tags.FlattenAndSet(d, resp.Tags)
+}
diff --git a/azurerm/internal/services/compute/registration.go b/azurerm/internal/services/compute/registration.go
@@ -16,6 +16,7 @@ func (r Registration) Name() string {
 func (r Registration) SupportedDataSources() map[string]*schema.Resource {
 	return map[string]*schema.Resource{
 		"azurerm_availability_set":          dataSourceArmAvailabilitySet(),
+		"azurerm_dedicated_host_group":      dataSourceArmDedicatedHostGroup(),
 		"azurerm_managed_disk":              dataSourceArmManagedDisk(),
 		"azurerm_image":                     dataSourceArmImage(),
 		"azurerm_platform_image":            dataSourceArmPlatformImage(),
@@ -32,6 +33,7 @@ func (r Registration) SupportedDataSources() map[string]*schema.Resource {
 func (r Registration) SupportedResources() map[string]*schema.Resource {
 	resources := map[string]*schema.Resource{
 		"azurerm_availability_set":                     resourceArmAvailabilitySet(),
+		"azurerm_dedicated_host_group":                 resourceArmDedicatedHostGroup(),
 		"azurerm_image":                                resourceArmImage(),
 		"azurerm_managed_disk":                         resourceArmManagedDisk(),
 		"azurerm_marketplace_agreement":                resourceArmMarketplaceAgreement(),

diff --git a/azurerm/internal/services/compute/resource_arm_dedicated_host_group.go b/azurerm/internal/services/compute/resource_arm_dedicated_host_group.go
@@ -0,0 +1,198 @@
+package compute
+
+import (
+	"fmt"
+	"log"
+	"regexp"
+	"time"
+
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
+
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
+
+	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-07-01/compute"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/features"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func resourceArmDedicatedHostGroup() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceArmDedicatedHostGroupCreate,
+		Read:   resourceArmDedicatedHostGroupRead,
+		Update: resourceArmDedicatedHostGroupUpdate,
+		Delete: resourceArmDedicatedHostGroupDelete,
+
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Timeouts: &schema.ResourceTimeout{
+			Create: schema.DefaultTimeout(30 * time.Minute),
+			Read:   schema.DefaultTimeout(5 * time.Minute),
+			Update: schema.DefaultTimeout(30 * time.Minute),
+			Delete: schema.DefaultTimeout(30 * time.Minute),
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validation.StringMatch(regexp.MustCompile(`^[^_\W][\w-.]{0,78}[\w]$`), ""),
+			},
+
+			"location": azure.SchemaLocation(),
+
+			// There's a bug in the Azure API where this is returned in upper-case
+			// BUG: https://github.com/Azure/azure-rest-api-specs/issues/8068
+			"resource_group_name": azure.SchemaResourceGroupNameDiffSuppress(),
+
+			"platform_fault_domain_count": {
+				Type:         schema.TypeInt,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validation.IntBetween(1, 3),
+			},
+
+			// Currently only one endpoint is allowed.
+			// we'll leave this open to enhancement when they add multiple zones support.
+			"zones": azure.SchemaSingleZone(),
+
+			"tags": tags.Schema(),
+		},
+	}
+}
+
+func resourceArmDedicatedHostGroupCreate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Compute.DedicatedHostGroupsClient
+	ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	name := d.Get("name").(string)
+	resourceGroupName := d.Get("resource_group_name").(string)
+
+	if features.ShouldResourcesBeImported() && d.IsNewResource() {
+		existing, err := client.Get(ctx, resourceGroupName, name)
+		if err != nil {
+			if !utils.ResponseWasNotFound(existing.Response) {
+				return fmt.Errorf("Error checking for present of existing Dedicated Host Group %q (Resource Group %q): %+v", name, resourceGroupName, err)
+			}
+		}
+		if existing.ID != nil && *existing.ID != "" {
+			return tf.ImportAsExistsError("azurerm_dedicated_host_group", *existing.ID)
+		}
+	}
+
+	location := azure.NormalizeLocation(d.Get("location").(string))
+	platformFaultDomainCount := d.Get("platform_fault_domain_count").(int)
+	t := d.Get("tags").(map[string]interface{})
+
+	parameters := compute.DedicatedHostGroup{
+		Location: utils.String(location),
+		DedicatedHostGroupProperties: &compute.DedicatedHostGroupProperties{
+			PlatformFaultDomainCount: utils.Int32(int32(platformFaultDomainCount)),
+		},
+		Tags: tags.Expand(t),
+	}
+	if zones, ok := d.GetOk("zones"); ok {
+		parameters.Zones = utils.ExpandStringSlice(zones.([]interface{}))
+	}
+
+	if _, err := client.CreateOrUpdate(ctx, resourceGroupName, name, parameters); err != nil {
+		return fmt.Errorf("Error creating Dedicated Host Group %q (Resource Group %q): %+v", name, resourceGroupName, err)
+	}
+
+	resp, err := client.Get(ctx, resourceGroupName, name)
+	if err != nil {
+		return fmt.Errorf("Error retrieving Dedicated Host Group %q (Resource Group %q): %+v", name, resourceGroupName, err)
+	}
+	if resp.ID == nil {
+		return fmt.Errorf("Cannot read Dedicated Host Group %q (Resource Group %q) ID", name, resourceGroupName)
+	}
+	d.SetId(*resp.ID)
+
+	return resourceArmDedicatedHostGroupRead(d, meta)
+}
+
+func resourceArmDedicatedHostGroupRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Compute.DedicatedHostGroupsClient
+	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := azure.ParseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resourceGroupName := id.ResourceGroup
+	name := id.Path["hostGroups"]
+
+	resp, err := client.Get(ctx, resourceGroupName, name)
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			log.Printf("[INFO] Dedicated Host Group %q does not exist - removing from state", d.Id())
+			d.SetId("")
+			return nil
+		}
+		return fmt.Errorf("Error reading Dedicated Host Group %q (Resource Group %q): %+v", name, resourceGroupName, err)
+	}
+
+	d.Set("name", name)
+	d.Set("resource_group_name", resourceGroupName)
+	if location := resp.Location; location != nil {
+		d.Set("location", azure.NormalizeLocation(*location))
+	}
+	if props := resp.DedicatedHostGroupProperties; props != nil {
+		platformFaultDomainCount := 0
+		if props.PlatformFaultDomainCount != nil {
+			platformFaultDomainCount = int(*props.PlatformFaultDomainCount)
+		}
+		d.Set("platform_fault_domain_count", platformFaultDomainCount)
+	}
+	d.Set("zones", utils.FlattenStringSlice(resp.Zones))
+
+	return tags.FlattenAndSet(d, resp.Tags)
+}
+
+func resourceArmDedicatedHostGroupUpdate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Compute.DedicatedHostGroupsClient
+	ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	name := d.Get("name").(string)
+	resourceGroupName := d.Get("resource_group_name").(string)
+	t := d.Get("tags").(map[string]interface{})
+
+	parameters := compute.DedicatedHostGroupUpdate{
+		Tags: tags.Expand(t),
+	}
+
+	if _, err := client.Update(ctx, resourceGroupName, name, parameters); err != nil {
+		return fmt.Errorf("Error updating Dedicated Host Group %q (Resource Group %q): %+v", name, resourceGroupName, err)
+	}
+
+	return resourceArmDedicatedHostGroupRead(d, meta)
+}
+
+func resourceArmDedicatedHostGroupDelete(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Compute.DedicatedHostGroupsClient
+	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := azure.ParseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resourceGroup := id.ResourceGroup
+	name := id.Path["hostGroups"]
+
+	if _, err := client.Delete(ctx, resourceGroup, name); err != nil {
+		return fmt.Errorf("Error deleting Dedicated Host Group %q (Resource Group %q): %+v", name, resourceGroup, err)
+	}
+
+	return nil
+}
diff --git a/azurerm/internal/services/compute/tests/data_source_dedicated_host_group_test.go b/azurerm/internal/services/compute/tests/data_source_dedicated_host_group_test.go
@@ -0,0 +1,42 @@
+package tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+)
+
+func TestAccDataSourceAzureRMDedicatedHostGroup_basic(t *testing.T) {
+	data := acceptance.BuildTestData(t, "data.azurerm_dedicated_host_group", "test")
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:  func() { acceptance.PreCheck(t) },
+		Providers: acceptance.SupportedProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceDedicatedHostGroup_basic(data),
+				Check: resource.ComposeTestCheckFunc(
+					testCheckAzureRMDedicatedHostGroupExists(data.ResourceName),
+					resource.TestCheckResourceAttr(data.ResourceName, "zones.#", "1"),
+					resource.TestCheckResourceAttr(data.ResourceName, "zones.0", "1"),
+					resource.TestCheckResourceAttr(data.ResourceName, "platform_fault_domain_count", "2"),
+				),
+			},
+		},
+	})
+}
+
+func testAccDataSourceDedicatedHostGroup_basic(data acceptance.TestData) string {
+	config := testAccAzureRMDedicatedHostGroup_complete(data)
+	return fmt.Sprintf(`
+%s
+
+data "azurerm_dedicated_host_group" "test" {
+  name           		= "${azurerm_dedicated_host_group.test.name}"
+  resource_group_name 	= "${azurerm_dedicated_host_group.test.resource_group_name}"
+}
+`, config)
+}