EMR awssdkv2 migration

internal/service/emr/block_public_access_configuration.go

@@ -7,15 +7,15 @@ import (
 	"context"
 	"log"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/emr"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/emr"
+	awstypes "github.com/aws/aws-sdk-go-v2/service/emr/types"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
-	"github.com/hashicorp/terraform-provider-aws/internal/create"
+	"github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag"
 	"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
-	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
 // @SDKResource("aws_emr_block_public_access_configuration", name="Block Public Access Configuration")
@@ -41,12 +41,12 @@ func resourceBlockPublicAccessConfiguration() *schema.Resource {
 				ForceNew: true,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
-						"min_range": {
+						"max_range": {
 							Type:             schema.TypeInt,
 							Required:         true,
 							ValidateDiagFunc: validation.ToDiagFunc(validation.IsPortNumber),
 						},
-						"max_range": {
+						"min_range": {
 							Type:             schema.TypeInt,
 							Required:         true,
 							ValidateDiagFunc: validation.ToDiagFunc(validation.IsPortNumber),
@@ -58,80 +58,77 @@ func resourceBlockPublicAccessConfiguration() *schema.Resource {
 	}
 }
 
-const (
-	ResNameBlockPublicAccessConfiguration       = "Block Public Access Configuration"
-	dummyIDBlockPublicAccessConfiguration       = "emr-block-public-access-configuration"
-	defaultPermittedPublicSecurityGroupRulePort = 22
-)
-
 func resourceBlockPublicAccessConfigurationCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
+	conn := meta.(*conns.AWSClient).EMRClient(ctx)
 
-	conn := meta.(*conns.AWSClient).EMRConn(ctx)
-
-	blockPublicAccessConfiguration := &emr.BlockPublicAccessConfiguration{}
+	blockPublicAccessConfiguration := &awstypes.BlockPublicAccessConfiguration{}
 
 	blockPublicSecurityGroupRules := d.Get("block_public_security_group_rules")
 	blockPublicAccessConfiguration.BlockPublicSecurityGroupRules = aws.Bool(blockPublicSecurityGroupRules.(bool))
 	if v, ok := d.GetOk("permitted_public_security_group_rule_range"); ok {
-		blockPublicAccessConfiguration.PermittedPublicSecurityGroupRuleRanges = expandPermittedPublicSecurityGroupRuleRanges(v.([]interface{}))
+		blockPublicAccessConfiguration.PermittedPublicSecurityGroupRuleRanges = expandPortRanges(v.([]interface{}))
 	}
 
-	in := &emr.PutBlockPublicAccessConfigurationInput{
+	input := &emr.PutBlockPublicAccessConfigurationInput{
 		BlockPublicAccessConfiguration: blockPublicAccessConfiguration,
 	}
 
-	_, err := conn.PutBlockPublicAccessConfigurationWithContext(ctx, in)
+	_, err := conn.PutBlockPublicAccessConfiguration(ctx, input)
+
 	if err != nil {
-		return create.AppendDiagError(diags, names.EMR, create.ErrActionCreating, ResNameBlockPublicAccessConfiguration, d.Id(), err)
+		return sdkdiag.AppendErrorf(diags, "setting EMR Block Public Access Configuration: %s", err)
 	}
-	d.SetId(dummyIDBlockPublicAccessConfiguration)
+
+	d.SetId("emr-block-public-access-configuration")
 
 	return append(diags, resourceBlockPublicAccessConfigurationRead(ctx, d, meta)...)
 }
 
 func resourceBlockPublicAccessConfigurationRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
+	conn := meta.(*conns.AWSClient).EMRClient(ctx)
 
-	conn := meta.(*conns.AWSClient).EMRConn(ctx)
+	bpa, err := findBlockPublicAccessConfiguration(ctx, conn)
 
-	out, err := findBlockPublicAccessConfiguration(ctx, conn)
+	if !d.IsNewResource() && tfresource.NotFound(err) {
+		log.Printf("[WARN] EMR Block Public Access Configuration (%s) not found, removing from state", d.Id())
+		d.SetId("")
+		return diags
+	}
 
 	if err != nil {
-		return create.AppendDiagError(diags, names.EMR, create.ErrActionReading, ResNameBlockPublicAccessConfiguration, d.Id(), err)
+		return sdkdiag.AppendErrorf(diags, "reading EMR Block Public Access Configuration (%s): %s", d.Id(), err)
 	}
 
-	d.Set("block_public_security_group_rules", out.BlockPublicAccessConfiguration.BlockPublicSecurityGroupRules)
-	if err := d.Set("permitted_public_security_group_rule_range", flattenPermittedPublicSecurityGroupRuleRanges(out.BlockPublicAccessConfiguration.PermittedPublicSecurityGroupRuleRanges)); err != nil {
-		return create.AppendDiagError(diags, names.EMR, create.ErrActionSetting, ResNameBlockPublicAccessConfiguration, d.Id(), err)
+	d.Set("block_public_security_group_rules", bpa.BlockPublicSecurityGroupRules)
+	if err := d.Set("permitted_public_security_group_rule_range", flattenPortRanges(bpa.PermittedPublicSecurityGroupRuleRanges)); err != nil {
+		return sdkdiag.AppendErrorf(diags, "setting permitted_public_security_group_rule_range: %s", err)
 	}
 
 	return diags
 }
 
 func resourceBlockPublicAccessConfigurationDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
+	conn := meta.(*conns.AWSClient).EMRClient(ctx)
 
-	conn := meta.(*conns.AWSClient).EMRConn(ctx)
-
-	log.Print("[INFO] Restoring EMR Block Public Access Configuration to default settings")
-
-	blockPublicAccessConfiguration := findDefaultBlockPublicAccessConfiguration()
-	in := &emr.PutBlockPublicAccessConfigurationInput{
-		BlockPublicAccessConfiguration: blockPublicAccessConfiguration,
-	}
+	log.Printf("[DEBUG] Deleting EMR Block Public Access Configuration: %s", d.Id())
+	_, err := conn.PutBlockPublicAccessConfiguration(ctx, &emr.PutBlockPublicAccessConfigurationInput{
+		BlockPublicAccessConfiguration: defaultBlockPublicAccessConfiguration(),
+	})
 
-	_, err := conn.PutBlockPublicAccessConfigurationWithContext(ctx, in)
 	if err != nil {
-		return create.AppendDiagError(diags, names.EMR, create.ErrActionDeleting, ResNameBlockPublicAccessConfiguration, d.Id(), err)
+		return sdkdiag.AppendErrorf(diags, "resetting EMR Block Public Access Configuration: %s", err)
 	}
 
 	return diags
 }
 
-func findBlockPublicAccessConfiguration(ctx context.Context, conn *emr.EMR) (*emr.GetBlockPublicAccessConfigurationOutput, error) {
+func findBlockPublicAccessConfiguration(ctx context.Context, conn *emr.Client) (*awstypes.BlockPublicAccessConfiguration, error) {
 	input := &emr.GetBlockPublicAccessConfigurationInput{}
-	output, err := conn.GetBlockPublicAccessConfigurationWithContext(ctx, input)
+	output, err := conn.GetBlockPublicAccessConfiguration(ctx, input)
+
 	if err != nil {
 		return nil, err
 	}
@@ -140,89 +137,73 @@ func findBlockPublicAccessConfiguration(ctx context.Context, conn *emr.EMR) (*em
 		return nil, tfresource.NewEmptyResultError(input)
 	}
 
-	return output, nil
+	return output.BlockPublicAccessConfiguration, nil
 }
 
-func findDefaultBlockPublicAccessConfiguration() *emr.BlockPublicAccessConfiguration {
-	defaultPort := int64(defaultPermittedPublicSecurityGroupRulePort)
-	defaultPortPointer := &defaultPort
-	portRange := &emr.PortRange{MinRange: defaultPortPointer, MaxRange: defaultPortPointer}
-	permittedPublicSecurityGroupRuleRanges := []*emr.PortRange{portRange}
-	blockPublicAccessConfiguration := &emr.BlockPublicAccessConfiguration{
-		BlockPublicSecurityGroupRules:          aws.Bool(true),
-		PermittedPublicSecurityGroupRuleRanges: permittedPublicSecurityGroupRuleRanges,
-	}
-	return blockPublicAccessConfiguration
-}
+func defaultBlockPublicAccessConfiguration() *awstypes.BlockPublicAccessConfiguration {
+	const port = 22
 
-func flattenPermittedPublicSecurityGroupRuleRange(apiObject *emr.PortRange) map[string]interface{} {
-	if apiObject == nil {
-		return nil
+	return &awstypes.BlockPublicAccessConfiguration{
+		BlockPublicSecurityGroupRules: aws.Bool(true),
+		PermittedPublicSecurityGroupRuleRanges: []awstypes.PortRange{{
+			MinRange: aws.Int32(port),
+			MaxRange: aws.Int32(port),
+		}},
 	}
+}
 
-	m := map[string]interface{}{}
+func flattenPortRange(apiObject *awstypes.PortRange) map[string]interface{} {
+	tfMap := map[string]interface{}{}
 
 	if v := apiObject.MinRange; v != nil {
-		m["min_range"] = aws.Int64Value(v)
+		tfMap["min_range"] = aws.ToInt32(v)
 	}
 
 	if v := apiObject.MaxRange; v != nil {
-		m["max_range"] = aws.Int64Value(v)
+		tfMap["max_range"] = aws.ToInt32(v)
 	}
 
-	return m
+	return tfMap
 }
 
-func flattenPermittedPublicSecurityGroupRuleRanges(apiObjects []*emr.PortRange) []interface{} {
+func flattenPortRanges(apiObjects []awstypes.PortRange) []interface{} {
 	if len(apiObjects) == 0 {
 		return nil
 	}
 
-	var l []interface{}
+	var tfMap []interface{}
 
 	for _, apiObject := range apiObjects {
-		if apiObject == nil {
-			continue
-		}
-
-		l = append(l, flattenPermittedPublicSecurityGroupRuleRange(apiObject))
+		tfMap = append(tfMap, flattenPortRange(&apiObject))
 	}
 
-	return l
+	return tfMap
 }
 
-func expandPermittedPublicSecurityGroupRuleRange(tfMap map[string]interface{}) *emr.PortRange {
-	a := &emr.PortRange{}
-
-	a.MinRange = aws.Int64(int64(tfMap["min_range"].(int)))
+func expandPortRange(tfMap map[string]interface{}) *awstypes.PortRange {
+	apiObject := &awstypes.PortRange{}
 
-	a.MaxRange = aws.Int64(int64(tfMap["max_range"].(int)))
+	apiObject.MinRange = aws.Int32(int32(tfMap["min_range"].(int)))
+	apiObject.MaxRange = aws.Int32(int32(tfMap["max_range"].(int)))
 
-	return a
+	return apiObject
 }
 
-func expandPermittedPublicSecurityGroupRuleRanges(tfList []interface{}) []*emr.PortRange {
+func expandPortRanges(tfList []interface{}) []awstypes.PortRange {
 	if len(tfList) == 0 {
 		return nil
 	}
 
-	var s []*emr.PortRange
-
-	for _, r := range tfList {
-		m, ok := r.(map[string]interface{})
+	var apiObjects []awstypes.PortRange
 
+	for _, tfMapRaw := range tfList {
+		tfMap, ok := tfMapRaw.(map[string]interface{})
 		if !ok {
 			continue
 		}
 
-		a := expandPermittedPublicSecurityGroupRuleRange(m)
-
-		if a == nil {
-			continue
-		}
-
-		s = append(s, a)
+		apiObjects = append(apiObjects, *expandPortRange(tfMap))
 	}
 
-	return s
+	return apiObjects
 }