New Resource(s)/Data Sources for HDInsights Cluster

azurerm/common_hdinsight.go

@@ -0,0 +1,177 @@
+package azurerm
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/Azure/azure-sdk-for-go/services/preview/hdinsight/mgmt/2018-06-01-preview/hdinsight"
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func hdinsightClusterUpdate(clusterKind string, readFunc schema.ReadFunc) schema.UpdateFunc {
+	return func(d *schema.ResourceData, meta interface{}) error {
+		client := meta.(*ArmClient).hdinsightClustersClient
+		ctx := meta.(*ArmClient).StopContext
+
+		id, err := parseAzureResourceID(d.Id())
+		if err != nil {
+			return err
+		}
+
+		resourceGroup := id.ResourceGroup
+		name := id.Path["clusters"]
+
+		if d.HasChange("tags") {
+			tags := d.Get("tags").(map[string]interface{})
+			params := hdinsight.ClusterPatchParameters{
+				Tags: expandTags(tags),
+			}
+			if _, err := client.Update(ctx, resourceGroup, name, params); err != nil {
+				return fmt.Errorf("Error updating Tags for HDInsight %q Cluster %q (Resource Group %q): %+v", clusterKind, name, resourceGroup, err)
+			}
+		}
+
+		if d.HasChange("roles") {
+			log.Printf("[DEBUG] Resizing the HDInsight %q Cluster", clusterKind)
+			rolesRaw := d.Get("roles").([]interface{})
+			roles := rolesRaw[0].(map[string]interface{})
+			headNodes := roles["worker_node"].([]interface{})
+			headNode := headNodes[0].(map[string]interface{})
+			targetInstanceCount := headNode["target_instance_count"].(int)
+			params := hdinsight.ClusterResizeParameters{
+				TargetInstanceCount: utils.Int32(int32(targetInstanceCount)),
+			}
+
+			future, err := client.Resize(ctx, resourceGroup, name, params)
+			if err != nil {
+				return fmt.Errorf("Error resizing the HDInsight %q Cluster %q (Resource Group %q): %+v", clusterKind, name, resourceGroup, err)
+			}
+
+			if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
+				return fmt.Errorf("Error waiting for the HDInsight %q Cluster %q (Resource Group %q) to finish resizing: %+v", clusterKind, name, resourceGroup, err)
+			}
+		}
+
+		return readFunc(d, meta)
+	}
+}
+
+func hdinsightClusterDelete(clusterKind string) schema.DeleteFunc {
+	return func(d *schema.ResourceData, meta interface{}) error {
+		client := meta.(*ArmClient).hdinsightClustersClient
+		ctx := meta.(*ArmClient).StopContext
+
+		id, err := parseAzureResourceID(d.Id())
+		if err != nil {
+			return err
+		}
+
+		resourceGroup := id.ResourceGroup
+		name := id.Path["clusters"]
+
+		future, err := client.Delete(ctx, resourceGroup, name)
+		if err != nil {
+			return fmt.Errorf("Error deleting HDInsight %q Cluster %q (Resource Group %q): %+v", clusterKind, name, resourceGroup, err)
+		}
+
+		if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
+			return fmt.Errorf("Error waiting for deletion of HDInsight %q Cluster %q (Resource Group %q): %+v", clusterKind, name, resourceGroup, err)
+		}
+
+		return nil
+	}
+}
+
+type hdInsightRoleDefinition struct {
+	HeadNodeDef      azure.HDInsightNodeDefinition
+	WorkerNodeDef    azure.HDInsightNodeDefinition
+	ZookeeperNodeDef azure.HDInsightNodeDefinition
+	EdgeNodeDef      *azure.HDInsightNodeDefinition
+}
+
+func expandHDInsightRoles(input []interface{}, definition hdInsightRoleDefinition) (*[]hdinsight.Role, error) {
+	v := input[0].(map[string]interface{})
+
+	headNodeRaw := v["head_node"].([]interface{})
+	headNode, err := azure.ExpandHDInsightNodeDefinition("headnode", headNodeRaw, definition.HeadNodeDef)
+	if err != nil {
+		return nil, fmt.Errorf("Error expanding `head_node`: %+v", err)
+	}
+
+	workerNodeRaw := v["worker_node"].([]interface{})
+	workerNode, err := azure.ExpandHDInsightNodeDefinition("workernode", workerNodeRaw, definition.WorkerNodeDef)
+	if err != nil {
+		return nil, fmt.Errorf("Error expanding `worker_node`: %+v", err)
+	}
+
+	zookeeperNodeRaw := v["zookeeper_node"].([]interface{})
+	zookeeperNode, err := azure.ExpandHDInsightNodeDefinition("zookeepernode", zookeeperNodeRaw, definition.ZookeeperNodeDef)
+	if err != nil {
+		return nil, fmt.Errorf("Error expanding `zookeeper_node`: %+v", err)
+	}
+
+	roles := []hdinsight.Role{
+		*headNode,
+		*workerNode,
+		*zookeeperNode,
+	}
+
+	if definition.EdgeNodeDef != nil {
+		edgeNodeRaw := v["edge_node"].([]interface{})
+		edgeNode, err := azure.ExpandHDInsightNodeDefinition("edgenode", edgeNodeRaw, *definition.EdgeNodeDef)
+		if err != nil {
+			return nil, fmt.Errorf("Error expanding `edge_node`: %+v", err)
+		}
+		roles = append(roles, *edgeNode)
+	}
+
+	return &roles, nil
+}
+
+func flattenHDInsightRoles(d *schema.ResourceData, input *hdinsight.ComputeProfile, definition hdInsightRoleDefinition) []interface{} {
+	if input == nil || input.Roles == nil {
+		return []interface{}{}
+	}
+
+	var existingEdgeNodes, existingHeadNodes, existingWorkerNodes, existingZookeeperNodes []interface{}
+
+	existingVs := d.Get("roles").([]interface{})
+	if len(existingVs) > 0 {
+		existingV := existingVs[0].(map[string]interface{})
+
+		if definition.EdgeNodeDef != nil {
+			existingEdgeNodes = existingV["edge_node"].([]interface{})
+		}
+
+		existingHeadNodes = existingV["head_node"].([]interface{})
+		existingWorkerNodes = existingV["worker_node"].([]interface{})
+		existingZookeeperNodes = existingV["zookeeper_node"].([]interface{})
+	}
+
+	headNode := azure.FindHDInsightRole(input.Roles, "headnode")
+	headNodes := azure.FlattenHDInsightNodeDefinition(headNode, existingHeadNodes, definition.HeadNodeDef)
+
+	workerNode := azure.FindHDInsightRole(input.Roles, "workernode")
+	workerNodes := azure.FlattenHDInsightNodeDefinition(workerNode, existingWorkerNodes, definition.WorkerNodeDef)
+
+	zookeeperNode := azure.FindHDInsightRole(input.Roles, "zookeepernode")
+	zookeeperNodes := azure.FlattenHDInsightNodeDefinition(zookeeperNode, existingZookeeperNodes, definition.ZookeeperNodeDef)
+
+	result := map[string]interface{}{
+		"head_node":      headNodes,
+		"worker_node":    workerNodes,
+		"zookeeper_node": zookeeperNodes,
+	}
+
+	if definition.EdgeNodeDef != nil {
+		edgeNode := azure.FindHDInsightRole(input.Roles, "edgenode")
+		edgeNodes := azure.FlattenHDInsightNodeDefinition(edgeNode, existingEdgeNodes, *definition.EdgeNodeDef)
+		result["edge_node"] = edgeNodes
+	}
+
+	return []interface{}{
+		result,
+	}
+}

azurerm/common_hdinsight_test.go

@@ -0,0 +1,59 @@
+package azurerm
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func testCheckAzureRMHDInsightClusterDestroy(terraformResourceName string) func(s *terraform.State) error {
+	return func(s *terraform.State) error {
+		for _, rs := range s.RootModule().Resources {
+			if rs.Type != terraformResourceName {
+				continue
+			}
+
+			client := testAccProvider.Meta().(*ArmClient).hdinsightClustersClient
+			ctx := testAccProvider.Meta().(*ArmClient).StopContext
+			name := rs.Primary.Attributes["name"]
+			resourceGroup := rs.Primary.Attributes["resource_group_name"]
+			resp, err := client.Get(ctx, resourceGroup, name)
+
+			if err != nil {
+				if !utils.ResponseWasNotFound(resp.Response) {
+					return err
+				}
+			}
+		}
+
+		return nil
+	}
+}
+
+func testCheckAzureRMHDInsightClusterExists(resourceName string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		// Ensure we have enough information in state to look up in API
+		rs, ok := s.RootModule().Resources[resourceName]
+		if !ok {
+			return fmt.Errorf("Not found: %s", resourceName)
+		}
+
+		clusterName := rs.Primary.Attributes["name"]
+		resourceGroup := rs.Primary.Attributes["resource_group_name"]
+
+		client := testAccProvider.Meta().(*ArmClient).hdinsightClustersClient
+		ctx := testAccProvider.Meta().(*ArmClient).StopContext
+		resp, err := client.Get(ctx, resourceGroup, clusterName)
+		if err != nil {
+			if utils.ResponseWasNotFound(resp.Response) {
+				return fmt.Errorf("Bad: HDInsight Cluster %q (Resource Group: %q) does not exist", clusterName, resourceGroup)
+			}
+
+			return fmt.Errorf("Bad: Get on hdinsightClustersClient: %+v", err)
+		}
+
+		return nil
+	}
+}

azurerm/config.go

@@ -40,6 +40,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/services/preview/devspaces/mgmt/2018-06-01-preview/devspaces"
 	"github.com/Azure/azure-sdk-for-go/services/preview/dns/mgmt/2018-03-01-preview/dns"
 	"github.com/Azure/azure-sdk-for-go/services/preview/eventgrid/mgmt/2018-09-15-preview/eventgrid"
+	"github.com/Azure/azure-sdk-for-go/services/preview/hdinsight/mgmt/2018-06-01-preview/hdinsight"
 	"github.com/Azure/azure-sdk-for-go/services/preview/iothub/mgmt/2018-12-01-preview/devices"
 	"github.com/Azure/azure-sdk-for-go/services/preview/mariadb/mgmt/2018-06-01-preview/mariadb"
 	"github.com/Azure/azure-sdk-for-go/services/preview/monitor/mgmt/2018-03-01/insights"
@@ -234,6 +235,11 @@ type ArmClient struct {
 	// Databricks
 	databricksWorkspacesClient databricks.WorkspacesClient
 
+	// HDInsight
+	hdinsightApplicationsClient   hdinsight.ApplicationsClient
+	hdinsightClustersClient       hdinsight.ClustersClient
+	hdinsightConfigurationsClient hdinsight.ConfigurationsClient
+
 	// KeyVault
 	keyVaultClient           keyvault.VaultsClient
 	keyVaultManagementClient keyVault.BaseClient
@@ -479,6 +485,7 @@ func getArmClient(c *authentication.Config, skipProviderRegistration bool, partn
 	client.registerDNSClients(endpoint, c.SubscriptionID, auth)
 	client.registerEventGridClients(endpoint, c.SubscriptionID, auth)
 	client.registerEventHubClients(endpoint, c.SubscriptionID, auth)
+	client.registerHDInsightsClients(endpoint, c.SubscriptionID, auth)
 	client.registerKeyVaultClients(endpoint, c.SubscriptionID, auth, keyVaultAuth)
 	client.registerLogicClients(endpoint, c.SubscriptionID, auth)
 	client.registerMediaServiceClients(endpoint, c.SubscriptionID, auth)
@@ -958,6 +965,20 @@ func (c *ArmClient) registerEventHubClients(endpoint, subscriptionId string, aut
 	c.eventHubNamespacesClient = ehnc
 }
 
+func (c *ArmClient) registerHDInsightsClients(endpoint, subscriptionId string, auth autorest.Authorizer) {
+	applicationsClient := hdinsight.NewApplicationsClientWithBaseURI(endpoint, subscriptionId)
+	c.configureClient(&applicationsClient.Client, auth)
+	c.hdinsightApplicationsClient = applicationsClient
+
+	clustersClient := hdinsight.NewClustersClientWithBaseURI(endpoint, subscriptionId)
+	c.configureClient(&clustersClient.Client, auth)
+	c.hdinsightClustersClient = clustersClient
+
+	configurationsClient := hdinsight.NewConfigurationsClientWithBaseURI(endpoint, subscriptionId)
+	c.configureClient(&configurationsClient.Client, auth)
+	c.hdinsightConfigurationsClient = configurationsClient
+}
+
 func (c *ArmClient) registerKeyVaultClients(endpoint, subscriptionId string, auth autorest.Authorizer, keyVaultAuth autorest.Authorizer) {
 	keyVaultClient := keyvault.NewVaultsClientWithBaseURI(endpoint, subscriptionId)
 	c.configureClient(&keyVaultClient.Client, auth)