azurerm_mssql_server and azurerm_mssql_database - upgrade from v5.0/sql to 2023-02-01-preview

internal/services/mssql/helper/database.go

@@ -7,21 +7,24 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"strings"
 
-	"github.com/Azure/azure-sdk-for-go/services/preview/sql/mgmt/v5.0/sql"           // nolint: staticcheck
 	"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2020-06-01/resources" // nolint: staticcheck
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/location"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/mssql/parse"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/databases"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/replicationlinks"
 )
 
 // FindDatabaseReplicationPartners looks for partner databases having one of the specified replication roles, by
 // reading any replication links then attempting to discover and match the corresponding server/database resources for
 // the other end of the link.
-func FindDatabaseReplicationPartners(ctx context.Context, databasesClient *sql.DatabasesClient, replicationLinksClient *sql.ReplicationLinksClient, resourcesClient *resources.Client, id parse.DatabaseId, rolesToFind []sql.ReplicationRole) ([]sql.Database, error) {
-	var partnerDatabases []sql.Database
+func FindDatabaseReplicationPartners(ctx context.Context, databasesClient *databases.DatabasesClient, replicationLinksClient *replicationlinks.ReplicationLinksClient, resourcesClient *resources.Client, id commonids.SqlDatabaseId, rolesToFind []replicationlinks.ReplicationRole) ([]databases.Database, error) {
+	var partnerDatabases []databases.Database
+	var linkProps *replicationlinks.ReplicationLinkProperties
 
-	matchesRole := func(role sql.ReplicationRole) bool {
+	matchesRole := func(role replicationlinks.ReplicationRole) bool {
 		for _, r := range rolesToFind {
 			if r == role {
 				return true
@@ -30,84 +33,86 @@ func FindDatabaseReplicationPartners(ctx context.Context, databasesClient *sql.D
 		return false
 	}
 
-	for linksIterator, err := replicationLinksClient.ListByDatabaseComplete(ctx, id.ResourceGroup, id.ServerName, id.Name); linksIterator.NotDone(); err = linksIterator.NextWithContext(ctx) {
-		if err != nil {
-			return nil, fmt.Errorf("reading Replication Links for %s: %+v", id, err)
-		}
-		if linksIterator.Response().IsEmpty() {
-			return nil, fmt.Errorf("reading Replication Links for %s: response was empty", id)
-		}
-
-		linkProps := linksIterator.Value().ReplicationLinkProperties
-		if linkProps == nil {
-			log.Printf("[INFO] Replication Link Properties was nil for %s", id)
-			continue
-		}
-		if linkProps.PartnerLocation == nil || linkProps.PartnerServer == nil || linkProps.PartnerDatabase == nil {
-			log.Printf("[INFO] Replication Link Properties was invalid for %s", id)
-			continue
-		}
-
-		log.Printf("[INFO] Replication Link found for %s", id)
+	log.Printf("[INFO] FindDatabaseReplicationPartners lookup for %s", id)
 
-		// Look for candidate partner SQL servers
-		filter := fmt.Sprintf("(resourceType eq 'Microsoft.Sql/servers') and ((name eq '%s'))", *linkProps.PartnerServer)
-		var resourceList []resources.GenericResourceExpanded
-		for resourcesIterator, err := resourcesClient.ListComplete(ctx, filter, "", nil); resourcesIterator.NotDone(); err = resourcesIterator.NextWithContext(ctx) {
-			if err != nil {
-				return nil, fmt.Errorf("retrieving Partner SQL Servers with filter %q for %s: %+v", filter, id, err)
-			}
-			resourceList = append(resourceList, resourcesIterator.Value())
+	// Bug 2805551 ReplicationLink API ListByDatabase missed subsubcriptionId in partnerDatabaseId in response body
+	results, err := replicationLinksClient.ListByDatabaseComplete(ctx, id)
+	if err != nil {
+		// Not sure if this is really an error anymore given the change in the API...
+		if strings.Contains(err.Error(), "ResourceNotFound") {
+			log.Printf("[INFO] %s returned no result records, skipping lookup for Replication Links", id)
+			return partnerDatabases, nil
 		}
+		return nil, fmt.Errorf("reading Replication Links for %s: %+v", id, err)
+	}
 
-		for _, server := range resourceList {
-			if server.ID == nil {
-				log.Printf("[INFO] Partner SQL Server ID was nil for %s", id)
+	// loop over all results that matches this DatabaseId...
+	for _, v := range results.Items {
+		if linkProps = v.Properties; linkProps != nil {
+			if linkProps.PartnerLocation == nil || linkProps.PartnerServer == nil || linkProps.PartnerDatabase == nil {
+				log.Printf("[INFO] Replication Link Properties were invalid for %s", id)
 				continue
 			}
 
-			partnerServerId, err := parse.ServerID(*server.ID)
-			if err != nil {
-				return nil, fmt.Errorf("parsing Partner SQL Server ID %q: %+v", *server.ID, err)
-			}
+			log.Printf("[INFO] Replication Link found for %s", id)
+			var partnerTargetDatabaseId *commonids.SqlDatabaseId
 
-			// Check if like-named server has a database named like the partner database, also with a replication link
-			for linksPossiblePartnerIterator, err := replicationLinksClient.ListByDatabaseComplete(ctx, partnerServerId.ResourceGroup, partnerServerId.Name, *linkProps.PartnerDatabase); linksPossiblePartnerIterator.NotDone(); err = linksPossiblePartnerIterator.NextWithContext(ctx) {
+			if linkProps.PartnerDatabaseId != nil {
+				partnerTargetDatabaseId, err = commonids.ParseSqlDatabaseIDInsensitively(pointer.From(linkProps.PartnerDatabaseId))
 				if err != nil {
-					if utils.ResponseWasNotFound(linksPossiblePartnerIterator.Response().Response) {
-						log.Printf("[INFO] no replication link found for Database %q (%s)", *linkProps.PartnerDatabase, partnerServerId)
-						continue
-					}
-					return nil, fmt.Errorf("reading Replication Links for Database %s (%s): %+v", *linkProps.PartnerDatabase, partnerServerId, err)
-				}
-
-				linkPossiblePartner := linksPossiblePartnerIterator.Value()
-				if linkPossiblePartner.ReplicationLinkProperties == nil {
-					log.Printf("[INFO] Replication Link Properties was nil for Database %s (%s)", *linkProps.PartnerDatabase, partnerServerId)
-					continue
+					return nil, fmt.Errorf("parsing Partner SQL Server ID %s: %+v", pointer.From(linkProps.PartnerDatabaseId), err)
 				}
 
-				linkPropsPossiblePartner := *linkPossiblePartner.ReplicationLinkProperties
+				log.Printf("[INFO] Partner Database ID from ReplicationLinkProperties: %q", pointer.From(partnerTargetDatabaseId))
 
-				// If the database has a replication link for the specified role, we'll consider it a partner of this database if the location is the same as expected partner
-				if matchesRole(linkPropsPossiblePartner.Role) {
-					partnerDatabaseId := parse.NewDatabaseID(partnerServerId.SubscriptionId, partnerServerId.ResourceGroup, partnerServerId.Name, *linkProps.PartnerDatabase)
-					partnerDatabase, err := databasesClient.Get(ctx, partnerDatabaseId.ResourceGroup, partnerDatabaseId.ServerName, partnerDatabaseId.Name)
-					if err != nil {
-						return nil, fmt.Errorf("retrieving Partner %s: %+v", partnerDatabaseId, err)
-					}
-					if location.NormalizeNilable(partnerDatabase.Location) != location.Normalize(*linkProps.PartnerLocation) {
-						log.Printf("[INFO] Mismatch of possible Partner Database based on location (%s vs %s) for %s", location.NormalizeNilable(partnerDatabase.Location), location.Normalize(*linkProps.PartnerLocation), id)
+				// Check if like-named server has a database named like the partner database, also with a replication link
+				partnerResults, err := replicationLinksClient.ListByDatabaseComplete(ctx, pointer.From(partnerTargetDatabaseId))
+				if err != nil {
+					// Not sure if this is really an error anymore given the change in the API...
+					if strings.Contains(err.Error(), "ResourceNotFound") || len(partnerResults.Items) == 0 {
+						log.Printf("[INFO] %s returned no result records, skipping lookup of Partner Replication Links", partnerTargetDatabaseId)
 						continue
 					}
-					if partnerDatabase.ID != nil {
-						log.Printf("[INFO] Found Partner %s", partnerDatabaseId)
-						partnerDatabases = append(partnerDatabases, partnerDatabase)
+					return nil, fmt.Errorf("reading Partner Replication Links for Database %s: %+v", partnerTargetDatabaseId, err)
+				}
+
+				for _, partnerResult := range partnerResults.Items {
+					if partnerProps := partnerResult.Properties; partnerProps != nil {
+						// If the database has a replication link for the specified role, we'll consider
+						// it a partner of this database if the location is the same as the expected partner
+						if matchesRole(pointer.From(partnerProps.Role)) {
+							partnerDatabase, err := databasesClient.Get(ctx, pointer.From(partnerTargetDatabaseId), databases.DefaultGetOperationOptions())
+							if err != nil {
+								return nil, fmt.Errorf("retrieving Partner %s: %+v", pointer.From(partnerTargetDatabaseId), err)
+							}
+
+							if model := partnerDatabase.Model; model != nil {
+								if location.Normalize(model.Location) != location.NormalizeNilable(linkProps.PartnerLocation) {
+									log.Printf("[INFO] Mismatch of possible Partner Database based on location (%q vs %q) for %s", location.Normalize(model.Location), location.NormalizeNilable(linkProps.PartnerLocation), pointer.From(model.Id))
+									continue
+								}
+
+								log.Printf("[INFO] Found Partner %s", pointer.From(partnerTargetDatabaseId))
+								partnerDatabases = append(partnerDatabases, pointer.From(model))
+							} else {
+								log.Printf("[INFO] Partner Database %s: Model is nil", pointer.From(partnerTargetDatabaseId))
+								continue
+							}
+						} else {
+							log.Printf("[INFO] Role Mismatch: wanted %+v, got %q", rolesToFind, pointer.From(partnerProps.Role))
+						}
+					} else {
+						log.Printf("[INFO] Partner Replication Link Properties was nil for %s", pointer.From(partnerTargetDatabaseId))
+						continue
 					}
 				}
 			}
+		} else {
+			log.Printf("[INFO] Replication Link Properties was nil for %s", id)
+			continue
 		}
 	}
 
+	log.Printf("[INFO] %d Replication Link(s) found for %s", len(partnerDatabases), id)
 	return partnerDatabases, nil
 }

internal/services/mssql/helper/elasticpool.go

@@ -269,14 +269,14 @@ func MSSQLElasticPoolValidateSKU(diff *pluginsdk.ResourceDiff) error {
 
 	// Universal check for both DTU and vCore based SKUs
 	if !nameTierIsValid(s) {
-		return fmt.Errorf("Mismatch between SKU name '%s' and tier '%s', expected 'tier' to be '%s'", s.Name, s.Tier, getTierFromName[strings.ToLower(s.Name)])
+		return fmt.Errorf("mismatch between SKU name '%s' and tier '%s', expected 'tier' to be '%s'", s.Name, s.Tier, getTierFromName[strings.ToLower(s.Name)])
 	}
 
 	// Verify that Family is valid
 	if s.SkuType == DTU && s.Family != "" {
-		return fmt.Errorf("Invalid attribute 'family'(%s) for service tier '%s', remove the 'family' attribute from the configuration file", s.Family, s.Tier)
+		return fmt.Errorf("invalid attribute 'family'(%s) for service tier '%s', remove the 'family' attribute from the configuration file", s.Family, s.Tier)
 	} else if s.SkuType == VCore && !nameContainsFamily(s) {
-		return fmt.Errorf("Mismatch between SKU name '%s' and family '%s', expected '%s'", s.Name, s.Family, getFamilyFromName(s))
+		return fmt.Errorf("mismatch between SKU name '%s' and family '%s', expected '%s'", s.Name, s.Family, getFamilyFromName(s))
 	}
 
 	// get max GB and do validation based on SKU type

internal/services/mssql/helper/sql_retention_policies.go

@@ -7,11 +7,12 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/Azure/azure-sdk-for-go/services/preview/sql/mgmt/v5.0/sql" // nolint: staticcheck
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/backupshorttermretentionpolicies"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/sql/2023-02-01-preview/longtermretentionpolicies"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
 func LongTermRetentionPolicySchema() *pluginsdk.Schema {
@@ -98,62 +99,62 @@ func ShortTermRetentionPolicySchema() *pluginsdk.Schema {
 	}
 }
 
-func ExpandLongTermRetentionPolicy(input []interface{}) *sql.BaseLongTermRetentionPolicyProperties {
+func ExpandLongTermRetentionPolicy(input []interface{}) *longtermretentionpolicies.LongTermRetentionPolicyProperties {
 	if len(input) == 0 || input[0] == nil {
 		return nil
 	}
 
-	longTermRetentionPolicy := input[0].(map[string]interface{})
+	policy := input[0].(map[string]interface{})
 
-	longTermPolicyProperties := sql.BaseLongTermRetentionPolicyProperties{
-		WeeklyRetention:  utils.String("PT0S"),
-		MonthlyRetention: utils.String("PT0S"),
-		YearlyRetention:  utils.String("PT0S"),
-		WeekOfYear:       utils.Int32(1),
+	output := longtermretentionpolicies.LongTermRetentionPolicyProperties{
+		WeeklyRetention:  pointer.To("PT0S"),
+		MonthlyRetention: pointer.To("PT0S"),
+		YearlyRetention:  pointer.To("PT0S"),
+		WeekOfYear:       pointer.To(int64(1)),
 	}
 
-	if v, ok := longTermRetentionPolicy["weekly_retention"]; ok {
-		longTermPolicyProperties.WeeklyRetention = utils.String(v.(string))
+	if v, ok := policy["weekly_retention"]; ok {
+		output.WeeklyRetention = pointer.To(v.(string))
 	}
 
-	if v, ok := longTermRetentionPolicy["monthly_retention"]; ok {
-		longTermPolicyProperties.MonthlyRetention = utils.String(v.(string))
+	if v, ok := policy["monthly_retention"]; ok {
+		output.MonthlyRetention = pointer.To(v.(string))
 	}
 
-	if v, ok := longTermRetentionPolicy["yearly_retention"]; ok {
-		longTermPolicyProperties.YearlyRetention = utils.String(v.(string))
+	if v, ok := policy["yearly_retention"]; ok {
+		output.YearlyRetention = pointer.To(v.(string))
 	}
 
-	if v, ok := longTermRetentionPolicy["week_of_year"]; ok {
-		longTermPolicyProperties.WeekOfYear = utils.Int32(int32(v.(int)))
+	if v, ok := policy["week_of_year"]; ok {
+		output.WeekOfYear = pointer.To(int64(v.(int)))
 	}
 
-	return &longTermPolicyProperties
+	return pointer.To(output)
 }
 
-func FlattenLongTermRetentionPolicy(longTermRetentionPolicy *sql.LongTermRetentionPolicy, d *pluginsdk.ResourceData) []interface{} {
-	if longTermRetentionPolicy == nil {
+func FlattenLongTermRetentionPolicy(input *longtermretentionpolicies.LongTermRetentionPolicy) []interface{} {
+	if input == nil {
 		return []interface{}{}
 	}
 
 	monthlyRetention := "PT0S"
-	if longTermRetentionPolicy.MonthlyRetention != nil {
-		monthlyRetention = *longTermRetentionPolicy.MonthlyRetention
+	if input.Properties.MonthlyRetention != nil {
+		monthlyRetention = pointer.From(input.Properties.MonthlyRetention)
 	}
 
 	weeklyRetention := "PT0S"
-	if longTermRetentionPolicy.WeeklyRetention != nil {
-		weeklyRetention = *longTermRetentionPolicy.WeeklyRetention
+	if input.Properties.WeeklyRetention != nil {
+		weeklyRetention = pointer.From(input.Properties.WeeklyRetention)
 	}
 
-	weekOfYear := int32(1)
-	if longTermRetentionPolicy.WeekOfYear != nil && *longTermRetentionPolicy.WeekOfYear != 0 {
-		weekOfYear = *longTermRetentionPolicy.WeekOfYear
+	weekOfYear := int64(1)
+	if input.Properties.WeekOfYear != nil && pointer.From(input.Properties.WeekOfYear) != 0 {
+		weekOfYear = pointer.From(input.Properties.WeekOfYear)
 	}
 
 	yearlyRetention := "PT0S"
-	if longTermRetentionPolicy.YearlyRetention != nil {
-		yearlyRetention = *longTermRetentionPolicy.YearlyRetention
+	if input.Properties.YearlyRetention != nil {
+		yearlyRetention = *input.Properties.YearlyRetention
 	}
 
 	return []interface{}{
@@ -166,45 +167,47 @@ func FlattenLongTermRetentionPolicy(longTermRetentionPolicy *sql.LongTermRetenti
 	}
 }
 
-func ExpandShortTermRetentionPolicy(input []interface{}) *sql.BackupShortTermRetentionPolicyProperties {
+func ExpandShortTermRetentionPolicy(input []interface{}) *backupshorttermretentionpolicies.BackupShortTermRetentionPolicyProperties {
 	if len(input) == 0 || input[0] == nil {
 		return nil
 	}
 
-	shortTermRetentionPolicy := input[0].(map[string]interface{})
+	policy := input[0].(map[string]interface{})
 
-	shortTermPolicyProperties := sql.BackupShortTermRetentionPolicyProperties{
-		RetentionDays: utils.Int32(7),
+	props := backupshorttermretentionpolicies.BackupShortTermRetentionPolicyProperties{
+		RetentionDays: pointer.To(int64(7)),
 	}
 
-	if v, ok := shortTermRetentionPolicy["retention_days"]; ok {
-		shortTermPolicyProperties.RetentionDays = utils.Int32(int32(v.(int)))
+	if v, ok := policy["retention_days"]; ok {
+		props.RetentionDays = pointer.To(int64(v.(int)))
 	}
 
-	if v, ok := shortTermRetentionPolicy["backup_interval_in_hours"]; ok {
-		shortTermPolicyProperties.DiffBackupIntervalInHours = utils.Int32(int32(v.(int)))
+	if v, ok := policy["backup_interval_in_hours"]; ok {
+		props.DiffBackupIntervalInHours = pointer.To(backupshorttermretentionpolicies.DiffBackupIntervalInHours(int64(v.(int))))
 	}
 
-	return &shortTermPolicyProperties
+	return &props
 }
 
-func FlattenShortTermRetentionPolicy(shortTermRetentionPolicy *sql.BackupShortTermRetentionPolicy, d *pluginsdk.ResourceData) []interface{} {
+func FlattenShortTermRetentionPolicy(input *backupshorttermretentionpolicies.BackupShortTermRetentionPolicy) []interface{} {
 	result := make([]interface{}, 0)
 
-	if shortTermRetentionPolicy == nil {
+	if input == nil {
 		return result
 	}
 
-	flattenShortTermRetentionPolicy := map[string]interface{}{}
+	output := map[string]interface{}{}
 
-	flattenShortTermRetentionPolicy["retention_days"] = int32(7)
-	if shortTermRetentionPolicy.RetentionDays != nil {
-		flattenShortTermRetentionPolicy["retention_days"] = *shortTermRetentionPolicy.RetentionDays
+	output["retention_days"] = int64(7)
+	if input.Properties.RetentionDays != nil {
+		output["retention_days"] = pointer.From(input.Properties.RetentionDays)
 	}
 
-	if shortTermRetentionPolicy.DiffBackupIntervalInHours != nil {
-		flattenShortTermRetentionPolicy["backup_interval_in_hours"] = *shortTermRetentionPolicy.DiffBackupIntervalInHours
+	if input.Properties.DiffBackupIntervalInHours != nil {
+		output["backup_interval_in_hours"] = pointer.From(input.Properties.DiffBackupIntervalInHours)
 	}
-	result = append(result, flattenShortTermRetentionPolicy)
+
+	result = append(result, output)
+
 	return result
 }