hdinsight: refactoring to use hashicorp/go-azure-sdk

internal/clients/client.go

@@ -16,6 +16,7 @@ import (
 	dns_v2018_05_01 "github.com/hashicorp/go-azure-sdk/resource-manager/dns/2018-05-01"
 	eventgrid_v2022_06_15 "github.com/hashicorp/go-azure-sdk/resource-manager/eventgrid/2022-06-15"
 	fluidrelay_2022_05_26 "github.com/hashicorp/go-azure-sdk/resource-manager/fluidrelay/2022-05-26"
+	hdinsight_v2021_06_01 "github.com/hashicorp/go-azure-sdk/resource-manager/hdinsight/2021-06-01"
 	nginx_2023_09_01 "github.com/hashicorp/go-azure-sdk/resource-manager/nginx/2023-09-01"
 	redis_2023_08_01 "github.com/hashicorp/go-azure-sdk/resource-manager/redis/2023-08-01"
 	servicenetworking_v2023_05_01_preview "github.com/hashicorp/go-azure-sdk/resource-manager/servicenetworking/2023-05-01-preview"
@@ -208,7 +209,7 @@ type Client struct {
 	Frontdoor             *frontdoor.Client
 	Graph                 *graph.Client
 	HSM                   *hsm.Client
-	HDInsight             *hdinsight.Client
+	HDInsight             *hdinsight_v2021_06_01.Client
 	HybridCompute         *hybridcompute.Client
 	HealthCare            *healthcare.Client
 	IoTCentral            *iotcentral.Client
@@ -444,7 +445,9 @@ func (client *Client) Build(ctx context.Context, o *common.ClientOptions) error
 	if client.HSM, err = hsm.NewClient(o); err != nil {
 		return fmt.Errorf("building clients for HSM: %+v", err)
 	}
-	client.HDInsight = hdinsight.NewClient(o)
+	if client.HDInsight, err = hdinsight.NewClient(o); err != nil {
+		return fmt.Errorf("building clients for HDInsight: %+v", err)
+	}
 	if client.HealthCare, err = healthcare.NewClient(o); err != nil {
 		return fmt.Errorf("building clients for HealthCare: %+v", err)
 	}

internal/services/hdinsight/client/client.go

@@ -4,40 +4,16 @@
 package client
 
 import (
-	"github.com/Azure/azure-sdk-for-go/services/hdinsight/mgmt/2018-06-01/hdinsight" // nolint: staticcheck
+	hdinsight_v2021_06_01 "github.com/hashicorp/go-azure-sdk/resource-manager/hdinsight/2021-06-01"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/common"
 )
 
-type Client struct {
-	ApplicationsClient   *hdinsight.ApplicationsClient
-	ClustersClient       *hdinsight.ClustersClient
-	ConfigurationsClient *hdinsight.ConfigurationsClient
-	ExtensionsClient     *hdinsight.ExtensionsClient
-}
-
-func NewClient(o *common.ClientOptions) *Client {
-	// due to a bug in the HDInsight API we can't reuse client with the same x-ms-correlation-request-id for multiple updates
-	opts := *o
-	opts.DisableCorrelationRequestID = true
-
-	ApplicationsClient := hdinsight.NewApplicationsClientWithBaseURI(opts.ResourceManagerEndpoint, opts.SubscriptionId)
-	opts.ConfigureClient(&ApplicationsClient.Client, opts.ResourceManagerAuthorizer)
-
-	ClustersClient := hdinsight.NewClustersClientWithBaseURI(opts.ResourceManagerEndpoint, opts.SubscriptionId)
-	opts.ConfigureClient(&ClustersClient.Client, opts.ResourceManagerAuthorizer)
-
-	ConfigurationsClient := hdinsight.NewConfigurationsClientWithBaseURI(opts.ResourceManagerEndpoint, opts.SubscriptionId)
-	opts.ConfigureClient(&ConfigurationsClient.Client, opts.ResourceManagerAuthorizer)
-
-	ExtensionsClient := hdinsight.NewExtensionsClientWithBaseURI(opts.ResourceManagerEndpoint, opts.SubscriptionId)
-	opts.ConfigureClient(&ExtensionsClient.Client, opts.ResourceManagerAuthorizer)
-
-	c := &Client{
-		ApplicationsClient:   &ApplicationsClient,
-		ClustersClient:       &ClustersClient,
-		ConfigurationsClient: &ConfigurationsClient,
-		ExtensionsClient:     &ExtensionsClient,
-	}
+func NewClient(o *common.ClientOptions) (*hdinsight_v2021_06_01.Client, error) {
+	return hdinsight_v2021_06_01.NewClientWithBaseURI(o.Environment.ResourceManager, func(c *resourcemanager.Client) {
+		o.Configure(c, o.Authorizers.ResourceManager)
 
-	return c
+		// due to a bug in the HDInsight API we can't reuse client with the same x-ms-correlation-request-id for multiple updates
+		c.CorrelationId = ""
+	})
 }

internal/services/hdinsight/custompollers/disable_azure_monitor_poller.go

@@ -0,0 +1,56 @@
+package custompollers
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/hdinsight/2021-06-01/extensions"
+	"github.com/hashicorp/go-azure-sdk/sdk/client"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+)
+
+var _ pollers.PollerType = &DisableAzureMonitorPoller{}
+
+// DisableAzureMonitorPoller polls until the Azure Monitor for the specified HDInsight Cluster has been disabled
+// This works around an issue outlined in  https://github.com/hashicorp/go-azure-sdk/issues/518 where the API
+// is a LRO which doesn't use `provisioningState`.
+type DisableAzureMonitorPoller struct {
+	client    *extensions.ExtensionsClient
+	clusterId commonids.HDInsightClusterId
+}
+
+func NewDisableAzureMonitorPoller(client *extensions.ExtensionsClient, clusterId commonids.HDInsightClusterId) *DisableAzureMonitorPoller {
+	return &DisableAzureMonitorPoller{
+		client:    client,
+		clusterId: clusterId,
+	}
+}
+
+func (p *DisableAzureMonitorPoller) Poll(ctx context.Context) (*pollers.PollResult, error) {
+	resp, err := p.client.GetMonitoringStatus(ctx, p.clusterId)
+	if err != nil {
+		return nil, fmt.Errorf("retrieving Azure Monitor Status for %s: %+v", p.clusterId, err)
+	}
+	if resp.Model == nil {
+		return nil, fmt.Errorf("retrieving Azure Monitor Status for %s: `model` was nil", p.clusterId)
+	}
+	if resp.Model.ClusterMonitoringEnabled == nil {
+		return nil, fmt.Errorf("retrieving Azure Monitor Status for %s: `model.ClusterMonitoringEnabled` was nil", p.clusterId)
+	}
+
+	status := pollers.PollingStatusInProgress
+	if !*resp.Model.ClusterMonitoringEnabled {
+		status = pollers.PollingStatusSucceeded
+	}
+
+	return &pollers.PollResult{
+		HttpResponse: &client.Response{
+			OData:    resp.OData,
+			Response: resp.HttpResponse,
+		},
+		PollInterval: 10 * time.Second,
+		Status:       status,
+	}, nil
+}

internal/services/hdinsight/custompollers/disable_monitoring_poller.go

@@ -0,0 +1,56 @@
+package custompollers
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/hdinsight/2021-06-01/extensions"
+	"github.com/hashicorp/go-azure-sdk/sdk/client"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+)
+
+var _ pollers.PollerType = &DisableMonitoringPoller{}
+
+// DisableMonitoringPoller polls until the Monitoring for the specified HDInsight Cluster has been disabled
+// This works around an issue outlined in  https://github.com/hashicorp/go-azure-sdk/issues/518 where the API
+// is a LRO which doesn't use `provisioningState`.
+type DisableMonitoringPoller struct {
+	client    *extensions.ExtensionsClient
+	clusterId commonids.HDInsightClusterId
+}
+
+func NewDisableMonitoringPoller(client *extensions.ExtensionsClient, clusterId commonids.HDInsightClusterId) *DisableMonitoringPoller {
+	return &DisableMonitoringPoller{
+		client:    client,
+		clusterId: clusterId,
+	}
+}
+
+func (p *DisableMonitoringPoller) Poll(ctx context.Context) (*pollers.PollResult, error) {
+	resp, err := p.client.GetMonitoringStatus(ctx, p.clusterId)
+	if err != nil {
+		return nil, fmt.Errorf("retrieving Monitoring Status for %s: %+v", p.clusterId, err)
+	}
+	if resp.Model == nil {
+		return nil, fmt.Errorf("retrieving Monitoring Status for %s: `model` was nil", p.clusterId)
+	}
+	if resp.Model.ClusterMonitoringEnabled == nil {
+		return nil, fmt.Errorf("retrieving Monitoring Status for %s: `model.ClusterMonitoringEnabled` was nil", p.clusterId)
+	}
+
+	status := pollers.PollingStatusInProgress
+	if !*resp.Model.ClusterMonitoringEnabled {
+		status = pollers.PollingStatusSucceeded
+	}
+
+	return &pollers.PollResult{
+		HttpResponse: &client.Response{
+			OData:    resp.OData,
+			Response: resp.HttpResponse,
+		},
+		PollInterval: 10 * time.Second,
+		Status:       status,
+	}, nil
+}

internal/services/hdinsight/custompollers/edge_node_poller.go

@@ -0,0 +1,68 @@
+package custompollers
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/hdinsight/2021-06-01/clusters"
+	"github.com/hashicorp/go-azure-sdk/sdk/client"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+)
+
+var _ pollers.PollerType = &EdgeNodePoller{}
+
+// EdgeNodePoller polls until the Edge Nodes have finished provisioning
+type EdgeNodePoller struct {
+	client    *clusters.ClustersClient
+	clusterId commonids.HDInsightClusterId
+}
+
+func NewEdgeNodePoller(client *clusters.ClustersClient, clusterId commonids.HDInsightClusterId) *EdgeNodePoller {
+	return &EdgeNodePoller{
+		client:    client,
+		clusterId: clusterId,
+	}
+}
+
+func (p *EdgeNodePoller) Poll(ctx context.Context) (*pollers.PollResult, error) {
+	resp, err := p.client.Get(ctx, p.clusterId)
+	if err != nil {
+		return nil, fmt.Errorf("retrieving %s: %+v", p.clusterId, err)
+	}
+
+	clusterState := ""
+	if model := resp.Model; model != nil && model.Properties != nil {
+		clusterState = pointer.From(model.Properties.ClusterState)
+	}
+
+	if strings.EqualFold(clusterState, "Running") {
+		return &pollers.PollResult{
+			HttpResponse: &client.Response{
+				Response: resp.HttpResponse,
+			},
+			PollInterval: 10 * time.Second,
+			Status:       pollers.PollingStatusSucceeded,
+		}, nil
+	}
+
+	if strings.EqualFold(clusterState, "AzureVMConfiguration") || strings.EqualFold(clusterState, "Accepted") || strings.EqualFold(clusterState, "HdInsightConfiguration") {
+		return &pollers.PollResult{
+			HttpResponse: &client.Response{
+				Response: resp.HttpResponse,
+			},
+			PollInterval: 10 * time.Second,
+			Status:       pollers.PollingStatusInProgress,
+		}, nil
+	}
+
+	return nil, pollers.PollingFailedError{
+		HttpResponse: &client.Response{
+			Response: resp.HttpResponse,
+		},
+		Message: fmt.Sprintf("unexpected clusterState %q", clusterState),
+	}
+}

internal/services/hdinsight/custompollers/enable_azure_monitor_poller.go

@@ -0,0 +1,56 @@
+package custompollers
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/hdinsight/2021-06-01/extensions"
+	"github.com/hashicorp/go-azure-sdk/sdk/client"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+)
+
+var _ pollers.PollerType = &EnableAzureMonitorPoller{}
+
+// EnableAzureMonitorPoller polls until the Azure Monitor for the specified HDInsight Cluster has been enabled
+// This works around an issue outlined in  https://github.com/hashicorp/go-azure-sdk/issues/518 where the API
+// is a LRO which doesn't use `provisioningState`.
+type EnableAzureMonitorPoller struct {
+	client    *extensions.ExtensionsClient
+	clusterId commonids.HDInsightClusterId
+}
+
+func NewEnableAzureMonitorPoller(client *extensions.ExtensionsClient, clusterId commonids.HDInsightClusterId) *EnableAzureMonitorPoller {
+	return &EnableAzureMonitorPoller{
+		client:    client,
+		clusterId: clusterId,
+	}
+}
+
+func (p *EnableAzureMonitorPoller) Poll(ctx context.Context) (*pollers.PollResult, error) {
+	resp, err := p.client.GetAzureMonitorStatus(ctx, p.clusterId)
+	if err != nil {
+		return nil, fmt.Errorf("retrieving Azure Monitor Status for %s: %+v", p.clusterId, err)
+	}
+	if resp.Model == nil {
+		return nil, fmt.Errorf("retrieving Azure Monitor Status for %s: `model` was nil", p.clusterId)
+	}
+	if resp.Model.ClusterMonitoringEnabled == nil {
+		return nil, fmt.Errorf("retrieving Azure Monitor Status for %s: `model.ClusterMonitoringEnabled` was nil", p.clusterId)
+	}
+
+	status := pollers.PollingStatusInProgress
+	if *resp.Model.ClusterMonitoringEnabled {
+		status = pollers.PollingStatusSucceeded
+	}
+
+	return &pollers.PollResult{
+		HttpResponse: &client.Response{
+			OData:    resp.OData,
+			Response: resp.HttpResponse,
+		},
+		PollInterval: 10 * time.Second,
+		Status:       status,
+	}, nil
+}

internal/services/hdinsight/custompollers/enable_monitoring_poller.go

@@ -0,0 +1,56 @@
+package custompollers
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/hdinsight/2021-06-01/extensions"
+	"github.com/hashicorp/go-azure-sdk/sdk/client"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+)
+
+var _ pollers.PollerType = &EnableMonitoringPoller{}
+
+// EnableMonitoringPoller polls until the Monitoring for the specified HDInsight Cluster has been enabled
+// This works around an issue outlined in  https://github.com/hashicorp/go-azure-sdk/issues/518 where the API
+// is a LRO which doesn't use `provisioningState`.
+type EnableMonitoringPoller struct {
+	client    *extensions.ExtensionsClient
+	clusterId commonids.HDInsightClusterId
+}
+
+func NewEnableMonitoringPoller(client *extensions.ExtensionsClient, clusterId commonids.HDInsightClusterId) *EnableMonitoringPoller {
+	return &EnableMonitoringPoller{
+		client:    client,
+		clusterId: clusterId,
+	}
+}
+
+func (p *EnableMonitoringPoller) Poll(ctx context.Context) (*pollers.PollResult, error) {
+	resp, err := p.client.GetMonitoringStatus(ctx, p.clusterId)
+	if err != nil {
+		return nil, fmt.Errorf("retrieving Monitoring Status for %s: %+v", p.clusterId, err)
+	}
+	if resp.Model == nil {
+		return nil, fmt.Errorf("retrieving Monitoring Status for %s: `model` was nil", p.clusterId)
+	}
+	if resp.Model.ClusterMonitoringEnabled == nil {
+		return nil, fmt.Errorf("retrieving Monitoring Status for %s: `model.ClusterMonitoringEnabled` was nil", p.clusterId)
+	}
+
+	status := pollers.PollingStatusInProgress
+	if *resp.Model.ClusterMonitoringEnabled {
+		status = pollers.PollingStatusSucceeded
+	}
+
+	return &pollers.PollResult{
+		HttpResponse: &client.Response{
+			OData:    resp.OData,
+			Response: resp.HttpResponse,
+		},
+		PollInterval: 10 * time.Second,
+		Status:       status,
+	}, nil
+}