dependencies - move MySQL resources to hashicorp/go-azure-sdk

internal/services/mysql/client/client.go

@@ -6,24 +6,18 @@ package client
 import (
 	"fmt"
 
-	"github.com/Azure/azure-sdk-for-go/services/mysql/mgmt/2020-01-01/mysql" // nolint: staticcheck
+	servers_v2017_12_01 "github.com/hashicorp/go-azure-sdk/resource-manager/mysql/2017-12-01"
+	servers_v2020_01_01 "github.com/hashicorp/go-azure-sdk/resource-manager/mysql/2020-01-01"
 	flexibleServers_v2021_05_01 "github.com/hashicorp/go-azure-sdk/resource-manager/mysql/2021-05-01"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/mysql/2022-01-01/azureadadministrators"
 	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/common"
 )
 
 type Client struct {
-	FlexibleServers *flexibleServers_v2021_05_01.Client
-
-	ConfigurationsClient              *mysql.ConfigurationsClient
-	DatabasesClient                   *mysql.DatabasesClient
-	FirewallRulesClient               *mysql.FirewallRulesClient
-	ServersClient                     *mysql.ServersClient
-	ServerKeysClient                  *mysql.ServerKeysClient
-	ServerSecurityAlertPoliciesClient *mysql.ServerSecurityAlertPoliciesClient
-	VirtualNetworkRulesClient         *mysql.VirtualNetworkRulesClient
-	ServerAdministratorsClient        *mysql.ServerAdministratorsClient
+	FlexibleServers  *flexibleServers_v2021_05_01.Client
+	MySqlClient      *servers_v2017_12_01.Client
+	ServerKeysClient *servers_v2020_01_01.Client
 
 	// TODO: port over to using the Meta Client (which involves bumping the API Version)
 	AzureADAdministratorsClient *azureadadministrators.AzureADAdministratorsClient
@@ -37,48 +31,32 @@ func NewClient(o *common.ClientOptions) (*Client, error) {
 		return nil, fmt.Errorf("building Flexible Servers client: %+v", err)
 	}
 
+	mySqlMetaClient, err := servers_v2017_12_01.NewClientWithBaseURI(o.Environment.ResourceManager, func(c *resourcemanager.Client) {
+		o.Configure(c, o.Authorizers.ResourceManager)
+	})
+	if err != nil {
+		return nil, fmt.Errorf("building MySql client: %+v", err)
+	}
+
+	serverKeysClient, err := servers_v2020_01_01.NewClientWithBaseURI(o.Environment.ResourceManager, func(c *resourcemanager.Client) {
+		o.Configure(c, o.Authorizers.ResourceManager)
+	})
+	if err != nil {
+		return nil, fmt.Errorf("building MySql client: %+v", err)
+	}
+
 	azureADAdministratorsClient, err := azureadadministrators.NewAzureADAdministratorsClientWithBaseURI(o.Environment.ResourceManager)
 	if err != nil {
 		return nil, fmt.Errorf("building Azure AD Administrators client: %+v", err)
 	}
 	o.Configure(azureADAdministratorsClient.Client, o.Authorizers.ResourceManager)
 
-	ConfigurationsClient := mysql.NewConfigurationsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&ConfigurationsClient.Client, o.ResourceManagerAuthorizer)
-
-	DatabasesClient := mysql.NewDatabasesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&DatabasesClient.Client, o.ResourceManagerAuthorizer)
-
-	FirewallRulesClient := mysql.NewFirewallRulesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&FirewallRulesClient.Client, o.ResourceManagerAuthorizer)
-
-	ServersClient := mysql.NewServersClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&ServersClient.Client, o.ResourceManagerAuthorizer)
-
-	ServerKeysClient := mysql.NewServerKeysClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&ServerKeysClient.Client, o.ResourceManagerAuthorizer)
-
-	serverSecurityAlertPoliciesClient := mysql.NewServerSecurityAlertPoliciesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&serverSecurityAlertPoliciesClient.Client, o.ResourceManagerAuthorizer)
-
-	VirtualNetworkRulesClient := mysql.NewVirtualNetworkRulesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&VirtualNetworkRulesClient.Client, o.ResourceManagerAuthorizer)
-
-	serverAdministratorsClient := mysql.NewServerAdministratorsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&serverAdministratorsClient.Client, o.ResourceManagerAuthorizer)
-
 	return &Client{
-		FlexibleServers: flexibleServersMetaClient,
+		FlexibleServers:  flexibleServersMetaClient,
+		MySqlClient:      mySqlMetaClient,
+		ServerKeysClient: serverKeysClient,
 
 		// TODO: switch to using the Meta Clients
-		AzureADAdministratorsClient:       azureADAdministratorsClient,
-		ConfigurationsClient:              &ConfigurationsClient,
-		DatabasesClient:                   &DatabasesClient,
-		FirewallRulesClient:               &FirewallRulesClient,
-		ServersClient:                     &ServersClient,
-		ServerKeysClient:                  &ServerKeysClient,
-		ServerSecurityAlertPoliciesClient: &serverSecurityAlertPoliciesClient,
-		VirtualNetworkRulesClient:         &VirtualNetworkRulesClient,
-		ServerAdministratorsClient:        &serverAdministratorsClient,
+		AzureADAdministratorsClient: azureADAdministratorsClient,
 	}, nil
 }

internal/services/mysql/mysql_aad_administrator_resource.go

@@ -8,16 +8,15 @@ import (
 	"log"
 	"time"
 
-	"github.com/Azure/azure-sdk-for-go/services/mysql/mgmt/2020-01-01/mysql" // nolint: staticcheck
-	"github.com/gofrs/uuid"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/mysql/2017-12-01/serveradministrators"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/mysql/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
 func resourceMySQLAdministrator() *pluginsdk.Resource {
@@ -68,55 +67,49 @@ func resourceMySQLAdministrator() *pluginsdk.Resource {
 }
 
 func resourceMySQLAdministratorCreateUpdate(d *pluginsdk.ResourceData, meta interface{}) error {
-	client := meta.(*clients.Client).MySQL.ServerAdministratorsClient
+	client := meta.(*clients.Client).MySQL.MySqlClient.ServerAdministrators
 	subscriptionId := meta.(*clients.Client).Account.SubscriptionId
 	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
 	serverName := d.Get("server_name").(string)
 	resGroup := d.Get("resource_group_name").(string)
 	login := d.Get("login").(string)
-	objectId := uuid.FromStringOrNil(d.Get("object_id").(string))
-	tenantId := uuid.FromStringOrNil(d.Get("tenant_id").(string))
 
-	id := parse.NewAzureActiveDirectoryAdministratorID(subscriptionId, d.Get("resource_group_name").(string), d.Get("server_name").(string), "activeDirectory")
+	id := parse.NewAzureActiveDirectoryAdministratorID(subscriptionId, resGroup, serverName, "activeDirectory")
+	serverId := serveradministrators.NewServerID(subscriptionId, resGroup, serverName)
 	if d.IsNewResource() {
-		existing, err := client.Get(ctx, resGroup, serverName)
+		existing, err := client.Get(ctx, serverId)
 		if err != nil {
-			if !utils.ResponseWasNotFound(existing.Response) {
+			if !response.WasNotFound(existing.HttpResponse) {
 				return fmt.Errorf("checking for presence of existing %s: %+v", id, err)
 			}
 		}
 
-		if !utils.ResponseWasNotFound(existing.Response) {
+		if !response.WasNotFound(existing.HttpResponse) {
 			return tf.ImportAsExistsError("azurerm_mysql_active_directory_administrator", id.ID())
 		}
 	}
 
-	parameters := mysql.ServerAdministratorResource{
-		ServerAdministratorProperties: &mysql.ServerAdministratorProperties{
-			AdministratorType: utils.String("ActiveDirectory"),
-			Login:             utils.String(login),
-			Sid:               &objectId,
-			TenantID:          &tenantId,
+	parameters := serveradministrators.ServerAdministratorResource{
+		Properties: &serveradministrators.ServerAdministratorProperties{
+			AdministratorType: serveradministrators.AdministratorTypeActiveDirectory,
+			Login:             login,
+			Sid:               d.Get("object_id").(string),
+			TenantId:          d.Get("tenant_id").(string),
 		},
 	}
 
-	future, err := client.CreateOrUpdate(ctx, resGroup, serverName, parameters)
-	if err != nil {
+	if err := client.CreateOrUpdateThenPoll(ctx, serverId, parameters); err != nil {
 		return fmt.Errorf("creating/updating %s: %+v", id, err)
 	}
 
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for create/update of %s: %+v", id, err)
-	}
-
 	d.SetId(id.ID())
 	return nil
 }
 
 func resourceMySQLAdministratorRead(d *pluginsdk.ResourceData, meta interface{}) error {
-	client := meta.(*clients.Client).MySQL.ServerAdministratorsClient
+	client := meta.(*clients.Client).MySQL.MySqlClient.ServerAdministrators
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
@@ -125,9 +118,11 @@ func resourceMySQLAdministratorRead(d *pluginsdk.ResourceData, meta interface{})
 		return err
 	}
 
-	resp, err := client.Get(ctx, id.ResourceGroup, id.ServerName)
+	serverId := serveradministrators.NewServerID(id.SubscriptionId, id.ResourceGroup, id.ServerName)
+
+	resp, err := client.Get(ctx, serverId)
 	if err != nil {
-		if utils.ResponseWasNotFound(resp.Response) {
+		if response.WasNotFound(resp.HttpResponse) {
 			log.Printf("[INFO] %s was not found - removing from state", *id)
 			d.SetId("")
 			return nil
@@ -138,15 +133,20 @@ func resourceMySQLAdministratorRead(d *pluginsdk.ResourceData, meta interface{})
 
 	d.Set("resource_group_name", id.ResourceGroup)
 	d.Set("server_name", id.ServerName)
-	d.Set("login", resp.Login)
-	d.Set("object_id", resp.Sid.String())
-	d.Set("tenant_id", resp.TenantID.String())
+
+	if model := resp.Model; model != nil {
+		if props := model.Properties; props != nil {
+			d.Set("login", props.Login)
+			d.Set("object_id", props.Sid)
+			d.Set("tenant_id", props.TenantId)
+		}
+	}
 
 	return nil
 }
 
 func resourceMySQLAdministratorDelete(d *pluginsdk.ResourceData, meta interface{}) error {
-	client := meta.(*clients.Client).MySQL.ServerAdministratorsClient
+	client := meta.(*clients.Client).MySQL.MySqlClient.ServerAdministrators
 	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
@@ -155,13 +155,10 @@ func resourceMySQLAdministratorDelete(d *pluginsdk.ResourceData, meta interface{
 		return err
 	}
 
-	future, err := client.Delete(ctx, id.ResourceGroup, id.ServerName)
-	if err != nil {
-		return fmt.Errorf("deleting %s: %+v", *id, err)
-	}
+	serverId := serveradministrators.NewServerID(id.SubscriptionId, id.ResourceGroup, id.ServerName)
 
-	if err := future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for deletion of %s: %+v", *id, err)
+	if err = client.DeleteThenPoll(ctx, serverId); err != nil {
+		return fmt.Errorf("deleting %s: %+v", *id, err)
 	}
 
 	return nil

internal/services/mysql/mysql_aad_administrator_resource_test.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-sdk/resource-manager/mysql/2017-12-01/serveradministrators"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
@@ -78,12 +79,14 @@ func (r MySqlAdministratorResource) Exists(ctx context.Context, clients *clients
 		return nil, err
 	}
 
-	resp, err := clients.MySQL.ServerAdministratorsClient.Get(ctx, id.ResourceGroup, id.ServerName)
+	serverId := serveradministrators.NewServerID(id.SubscriptionId, id.ResourceGroup, id.ServerName)
+
+	resp, err := clients.MySQL.MySqlClient.ServerAdministrators.Get(ctx, serverId)
 	if err != nil {
 		return nil, fmt.Errorf("reading %s: %+v", *id, err)
 	}
 
-	return utils.Bool(resp.ID != nil), nil
+	return utils.Bool(resp.Model != nil), nil
 }
 
 func (r MySqlAdministratorResource) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
@@ -92,13 +95,10 @@ func (r MySqlAdministratorResource) Destroy(ctx context.Context, client *clients
 		return nil, err
 	}
 
-	future, err := client.MySQL.ServerAdministratorsClient.Delete(ctx, id.ResourceGroup, id.ServerName)
-	if err != nil {
-		return nil, fmt.Errorf("deleting %s: %+v", *id, err)
-	}
+	serverId := serveradministrators.NewServerID(id.SubscriptionId, id.ResourceGroup, id.ServerName)
 
-	if err := future.WaitForCompletionRef(ctx, client.MySQL.ServerAdministratorsClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for deletion of %s: %+v", *id, err)
+	if err = client.MySQL.MySqlClient.ServerAdministrators.DeleteThenPoll(ctx, serverId); err != nil {
+		return nil, fmt.Errorf("deleting %s: %+v", *id, err)
 	}
 
 	return utils.Bool(true), nil