skip_destroy support for RDS Option and Parameter Group Resources

.changelog/29663.txt

@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_db_option_group: Add `skip_destroy` argument
+```
+
+```release-note:enhancement
+resource/aws_db_parameter_group: Add `skip_destroy` argument
+```

internal/service/rds/cluster_activity_stream.go

@@ -8,21 +8,23 @@ import (
 	"log"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/rds"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/rds"
+	"github.com/aws/aws-sdk-go-v2/service/rds/types"
+	"github.com/hashicorp/aws-sdk-go-base/v2/tfawserr"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/retry"
 	"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/enum"
 	"github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag"
 	"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
 	"github.com/hashicorp/terraform-provider-aws/internal/verify"
 	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
-// @SDKResource("aws_rds_cluster_activity_stream")
-func ResourceClusterActivityStream() *schema.Resource {
+// @SDKResource("aws_rds_cluster_activity_stream", name="Cluster Activity Stream")
+func resourceClusterActivityStream() *schema.Resource {
 	return &schema.Resource{
 		CreateWithoutTimeout: resourceClusterActivityStreamCreate,
 		ReadWithoutTimeout:   resourceClusterActivityStreamRead,
@@ -49,10 +51,10 @@ func ResourceClusterActivityStream() *schema.Resource {
 				ForceNew: true,
 			},
 			names.AttrMode: {
-				Type:         schema.TypeString,
-				Required:     true,
-				ForceNew:     true,
-				ValidateFunc: validation.StringInSlice(rds.ActivityStreamMode_Values(), false),
+				Type:             schema.TypeString,
+				Required:         true,
+				ForceNew:         true,
+				ValidateDiagFunc: enum.Validate[types.ActivityStreamMode](),
 			},
 			names.AttrResourceARN: {
 				Type:         schema.TypeString,
@@ -66,26 +68,26 @@ func ResourceClusterActivityStream() *schema.Resource {
 
 func resourceClusterActivityStreamCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
-	conn := meta.(*conns.AWSClient).RDSConn(ctx)
+	conn := meta.(*conns.AWSClient).RDSClient(ctx)
 
 	arn := d.Get(names.AttrResourceARN).(string)
 	input := &rds.StartActivityStreamInput{
 		ApplyImmediately:                aws.Bool(true),
 		EngineNativeAuditFieldsIncluded: aws.Bool(d.Get("engine_native_audit_fields_included").(bool)),
 		KmsKeyId:                        aws.String(d.Get(names.AttrKMSKeyID).(string)),
-		Mode:                            aws.String(d.Get(names.AttrMode).(string)),
+		Mode:                            types.ActivityStreamMode(d.Get(names.AttrMode).(string)),
 		ResourceArn:                     aws.String(arn),
 	}
 
-	_, err := conn.StartActivityStreamWithContext(ctx, input)
+	_, err := conn.StartActivityStream(ctx, input)
 
 	if err != nil {
 		return sdkdiag.AppendErrorf(diags, "creating RDS Cluster Activity Stream (%s): %s", arn, err)
 	}
 
 	d.SetId(arn)
 
-	if err := waitActivityStreamStarted(ctx, conn, d.Id()); err != nil {
+	if _, err := waitActivityStreamStarted(ctx, conn, d.Id()); err != nil {
 		return sdkdiag.AppendErrorf(diags, "waiting for RDS Cluster Activity Stream (%s) start: %s", d.Id(), err)
 	}
 
@@ -94,9 +96,9 @@ func resourceClusterActivityStreamCreate(ctx context.Context, d *schema.Resource
 
 func resourceClusterActivityStreamRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
-	conn := meta.(*conns.AWSClient).RDSConn(ctx)
+	conn := meta.(*conns.AWSClient).RDSClient(ctx)
 
-	output, err := FindDBClusterWithActivityStream(ctx, conn, d.Id())
+	output, err := findDBClusterWithActivityStream(ctx, conn, d.Id())
 
 	if !d.IsNewResource() && tfresource.NotFound(err) {
 		log.Printf("[WARN] RDS Cluster Activity Stream (%s) not found, removing from state", d.Id())
@@ -118,42 +120,48 @@ func resourceClusterActivityStreamRead(ctx context.Context, d *schema.ResourceDa
 
 func resourceClusterActivityStreamDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
-	conn := meta.(*conns.AWSClient).RDSConn(ctx)
+	conn := meta.(*conns.AWSClient).RDSClient(ctx)
 
 	log.Printf("[DEBUG] Deleting RDS Cluster Activity Stream: %s", d.Id())
-	_, err := conn.StopActivityStreamWithContext(ctx, &rds.StopActivityStreamInput{
+	_, err := conn.StopActivityStream(ctx, &rds.StopActivityStreamInput{
 		ApplyImmediately: aws.Bool(true),
 		ResourceArn:      aws.String(d.Id()),
 	})
+
+	if tfawserr.ErrMessageContains(err, errCodeInvalidParameterCombination, "Activity Streams feature expected to be started, but is stopped") {
+		return diags
+	}
+
 	if err != nil {
 		return sdkdiag.AppendErrorf(diags, "stopping RDS Cluster Activity Stream (%s): %s", d.Id(), err)
 	}
 
-	if err := waitActivityStreamStopped(ctx, conn, d.Id()); err != nil {
+	if _, err := waitActivityStreamStopped(ctx, conn, d.Id()); err != nil {
 		return sdkdiag.AppendErrorf(diags, "waiting for RDS Cluster Activity Stream (%s) stop: %s", d.Id(), err)
 	}
 
 	return diags
 }
 
-func FindDBClusterWithActivityStream(ctx context.Context, conn *rds.RDS, arn string) (*rds.DBCluster, error) {
-	output, err := FindDBClusterByID(ctx, conn, arn)
+func findDBClusterWithActivityStream(ctx context.Context, conn *rds.Client, arn string) (*types.DBCluster, error) {
+	output, err := findDBClusterByID(ctx, conn, arn)
+
 	if err != nil {
 		return nil, err
 	}
 
-	if status := aws.StringValue(output.ActivityStreamStatus); status == rds.ActivityStreamStatusStopped {
+	if status := output.ActivityStreamStatus; status == types.ActivityStreamStatusStopped {
 		return nil, &retry.NotFoundError{
-			Message: status,
+			Message: string(status),
 		}
 	}
 
 	return output, nil
 }
 
-func statusDBClusterActivityStream(ctx context.Context, conn *rds.RDS, arn string) retry.StateRefreshFunc {
+func statusDBClusterActivityStream(ctx context.Context, conn *rds.Client, arn string) retry.StateRefreshFunc {
 	return func() (interface{}, string, error) {
-		output, err := FindDBClusterWithActivityStream(ctx, conn, arn)
+		output, err := findDBClusterWithActivityStream(ctx, conn, arn)
 
 		if tfresource.NotFound(err) {
 			return nil, "", nil
@@ -163,41 +171,50 @@ func statusDBClusterActivityStream(ctx context.Context, conn *rds.RDS, arn strin
 			return nil, "", err
 		}
 
-		return output, aws.StringValue(output.ActivityStreamStatus), nil
+		return output, string(output.ActivityStreamStatus), nil
 	}
 }
 
-const (
-	dbClusterActivityStreamStartedTimeout = 30 * time.Minute
-	dbClusterActivityStreamStoppedTimeout = 30 * time.Minute
-)
-
-func waitActivityStreamStarted(ctx context.Context, conn *rds.RDS, arn string) error {
+func waitActivityStreamStarted(ctx context.Context, conn *rds.Client, arn string) (*types.DBCluster, error) {
+	const (
+		timeout = 30 * time.Minute
+	)
 	stateConf := &retry.StateChangeConf{
-		Pending:    []string{rds.ActivityStreamStatusStarting},
-		Target:     []string{rds.ActivityStreamStatusStarted},
+		Pending:    enum.Slice(types.ActivityStreamStatusStarting),
+		Target:     enum.Slice(types.ActivityStreamStatusStarted),
 		Refresh:    statusDBClusterActivityStream(ctx, conn, arn),
-		Timeout:    dbClusterActivityStreamStartedTimeout,
+		Timeout:    timeout,
 		MinTimeout: 10 * time.Second,
 		Delay:      30 * time.Second,
 	}
 
-	_, err := stateConf.WaitForStateContext(ctx)
+	outputRaw, err := stateConf.WaitForStateContext(ctx)
 
-	return err
+	if output, ok := outputRaw.(*types.DBCluster); ok {
+		return output, err
+	}
+
+	return nil, err
 }
 
-func waitActivityStreamStopped(ctx context.Context, conn *rds.RDS, arn string) error {
+func waitActivityStreamStopped(ctx context.Context, conn *rds.Client, arn string) (*types.DBCluster, error) {
+	const (
+		timeout = 30 * time.Minute
+	)
 	stateConf := &retry.StateChangeConf{
-		Pending:    []string{rds.ActivityStreamStatusStopping},
+		Pending:    enum.Slice(types.ActivityStreamStatusStopping),
 		Target:     []string{},
 		Refresh:    statusDBClusterActivityStream(ctx, conn, arn),
-		Timeout:    dbClusterActivityStreamStoppedTimeout,
+		Timeout:    timeout,
 		MinTimeout: 10 * time.Second,
 		Delay:      30 * time.Second,
 	}
 
-	_, err := stateConf.WaitForStateContext(ctx)
+	outputRaw, err := stateConf.WaitForStateContext(ctx)
+
+	if output, ok := outputRaw.(*types.DBCluster); ok {
+		return output, err
+	}
 
-	return err
+	return nil, err
 }

internal/service/rds/cluster_activity_stream_test.go

@@ -8,8 +8,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws/endpoints"
-	"github.com/aws/aws-sdk-go/service/rds"
+	"github.com/aws/aws-sdk-go-v2/service/rds/types"
 	sdkacctest "github.com/hashicorp/terraform-plugin-testing/helper/acctest"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
@@ -22,14 +21,14 @@ import (
 
 func TestAccRDSClusterActivityStream_basic(t *testing.T) {
 	ctx := acctest.Context(t)
-	var dbCluster rds.DBCluster
+	var dbCluster types.DBCluster
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_rds_cluster_activity_stream.test"
 
 	resource.ParallelTest(t, resource.TestCase{
 		PreCheck: func() {
 			acctest.PreCheck(ctx, t)
-			acctest.PreCheckPartition(t, endpoints.AwsPartitionID)
+			acctest.PreCheckPartition(t, names.StandardPartitionID)
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.RDSServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
@@ -55,14 +54,14 @@ func TestAccRDSClusterActivityStream_basic(t *testing.T) {
 
 func TestAccRDSClusterActivityStream_disappears(t *testing.T) {
 	ctx := acctest.Context(t)
-	var dbCluster rds.DBCluster
+	var dbCluster types.DBCluster
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_rds_cluster_activity_stream.test"
 
 	resource.ParallelTest(t, resource.TestCase{
 		PreCheck: func() {
 			acctest.PreCheck(ctx, t)
-			acctest.PreCheckPartition(t, endpoints.AwsPartitionID)
+			acctest.PreCheckPartition(t, names.StandardPartitionID)
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.RDSServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
@@ -80,20 +79,17 @@ func TestAccRDSClusterActivityStream_disappears(t *testing.T) {
 	})
 }
 
-func testAccCheckClusterActivityStreamExists(ctx context.Context, n string, v *rds.DBCluster) resource.TestCheckFunc {
+func testAccCheckClusterActivityStreamExists(ctx context.Context, n string, v *types.DBCluster) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
 		if !ok {
 			return fmt.Errorf("Not found: %s", n)
 		}
 
-		if rs.Primary.ID == "" {
-			return fmt.Errorf("RDS Cluster Activity Stream ID is not set")
-		}
-
-		conn := acctest.Provider.Meta().(*conns.AWSClient).RDSConn(ctx)
+		conn := acctest.Provider.Meta().(*conns.AWSClient).RDSClient(ctx)
 
 		output, err := tfrds.FindDBClusterWithActivityStream(ctx, conn, rs.Primary.ID)
+
 		if err != nil {
 			return err
 		}
@@ -106,7 +102,7 @@ func testAccCheckClusterActivityStreamExists(ctx context.Context, n string, v *r
 
 func testAccCheckClusterActivityStreamDestroy(ctx context.Context) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
-		conn := acctest.Provider.Meta().(*conns.AWSClient).RDSConn(ctx)
+		conn := acctest.Provider.Meta().(*conns.AWSClient).RDSClient(ctx)
 
 		for _, rs := range s.RootModule().Resources {
 			if rs.Type != "aws_rds_cluster_activity_stream" {