New resource: aws_globalaccelerator_custom_routing_accelerator

.changelog/28922.txt

@@ -0,0 +1,23 @@
+```release-note:new-resource
+aws_globalaccelerator_custom_routing_accelerator
+```
+
+```release-note:new-data-source
+aws_globalaccelerator_custom_routing_accelerator
+```
+
+```release-note:new-resource
+aws_globalaccelerator_custom_routing_listener
+```
+
+```release-note:new-resource
+aws_globalaccelerator_custom_routing_endpoint_group
+```
+
+```release-note:enhancement
+resource/aws_globalaccelerator_accelerator: Add `dual_stack_dns_name` attribute
+```
+
+```release-note:enhancement
+data-source/aws_globalaccelerator_accelerator: Add `dual_stack_dns_name` attribute
+```

internal/conns/awsclient.go

@@ -39,7 +39,7 @@ func (client *AWSClient) HTTPClient() *http.Client {
 	return client.httpClient
 }
 
-// CloudFrontDistributionHostedZoneIDForPartition returns for the Route 53 hosted zone ID
+// CloudFrontDistributionHostedZoneID returns the Route 53 hosted zone ID
 // for Amazon CloudFront distributions in the configured AWS partition.
 func (client *AWSClient) CloudFrontDistributionHostedZoneID() string {
 	if client.Partition == endpoints.AwsCnPartitionID {
@@ -68,3 +68,9 @@ func (client *AWSClient) DefaultKMSKeyPolicy() string {
 }	
 `, client.Partition, client.AccountID)
 }
+
+// GlobalAcceleratorHostedZoneID returns the Route 53 hosted zone ID
+// for AWS Global Accelerator accelerators in the configured AWS partition.
+func (client *AWSClient) GlobalAcceleratorHostedZoneID() string {
+	return "Z2BJ6XQ5FK7U4H" // See https://docs.aws.amazon.com/general/latest/gr/global_accelerator.html#global_accelerator_region
+}

internal/service/globalaccelerator/accelerator.go

@@ -20,11 +20,6 @@ import (
 	"github.com/hashicorp/terraform-provider-aws/internal/verify"
 )
 
-// Global Route53 Zone ID for Global Accelerators, exported as a
-// convenience attribute for Route53 aliases (see
-// https://docs.aws.amazon.com/Route53/latest/APIReference/API_AliasTarget.html).
-const route53ZoneID = "Z2BJ6XQ5FK7U4H"
-
 // @SDKResource("aws_globalaccelerator_accelerator")
 func ResourceAccelerator() *schema.Resource {
 	return &schema.Resource{
@@ -72,6 +67,10 @@ func ResourceAccelerator() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			"dual_stack_dns_name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"enabled": {
 				Type:     schema.TypeBool,
 				Optional: true,
@@ -197,8 +196,9 @@ func resourceAcceleratorRead(ctx context.Context, d *schema.ResourceData, meta i
 	}
 
 	d.Set("dns_name", accelerator.DnsName)
+	d.Set("dual_stack_dns_name", accelerator.DualStackDnsName)
 	d.Set("enabled", accelerator.Enabled)
-	d.Set("hosted_zone_id", route53ZoneID)
+	d.Set("hosted_zone_id", meta.(*conns.AWSClient).GlobalAcceleratorHostedZoneID())
 	d.Set("ip_address_type", accelerator.IpAddressType)
 	if err := d.Set("ip_sets", flattenIPSets(accelerator.IpSets)); err != nil {
 		return diag.Errorf("setting ip_sets: %s", err)
@@ -346,6 +346,97 @@ func resourceAcceleratorDelete(ctx context.Context, d *schema.ResourceData, meta
 	return nil
 }
 
+func FindAcceleratorByARN(ctx context.Context, conn *globalaccelerator.GlobalAccelerator, arn string) (*globalaccelerator.Accelerator, error) {
+	input := &globalaccelerator.DescribeAcceleratorInput{
+		AcceleratorArn: aws.String(arn),
+	}
+
+	return findAccelerator(ctx, conn, input)
+}
+
+func findAccelerator(ctx context.Context, conn *globalaccelerator.GlobalAccelerator, input *globalaccelerator.DescribeAcceleratorInput) (*globalaccelerator.Accelerator, error) {
+	output, err := conn.DescribeAcceleratorWithContext(ctx, input)
+
+	if tfawserr.ErrCodeEquals(err, globalaccelerator.ErrCodeAcceleratorNotFoundException) {
+		return nil, &resource.NotFoundError{
+			LastError:   err,
+			LastRequest: input,
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if output == nil || output.Accelerator == nil {
+		return nil, tfresource.NewEmptyResultError(input)
+	}
+
+	return output.Accelerator, nil
+}
+
+func FindAcceleratorAttributesByARN(ctx context.Context, conn *globalaccelerator.GlobalAccelerator, arn string) (*globalaccelerator.AcceleratorAttributes, error) {
+	input := &globalaccelerator.DescribeAcceleratorAttributesInput{
+		AcceleratorArn: aws.String(arn),
+	}
+
+	return findAcceleratorAttributes(ctx, conn, input)
+}
+
+func findAcceleratorAttributes(ctx context.Context, conn *globalaccelerator.GlobalAccelerator, input *globalaccelerator.DescribeAcceleratorAttributesInput) (*globalaccelerator.AcceleratorAttributes, error) {
+	output, err := conn.DescribeAcceleratorAttributesWithContext(ctx, input)
+
+	if tfawserr.ErrCodeEquals(err, globalaccelerator.ErrCodeAcceleratorNotFoundException) {
+		return nil, &resource.NotFoundError{
+			LastError:   err,
+			LastRequest: input,
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if output == nil || output.AcceleratorAttributes == nil {
+		return nil, tfresource.NewEmptyResultError(input)
+	}
+
+	return output.AcceleratorAttributes, nil
+}
+
+func statusAccelerator(ctx context.Context, conn *globalaccelerator.GlobalAccelerator, arn string) resource.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		accelerator, err := FindAcceleratorByARN(ctx, conn, arn)
+
+		if tfresource.NotFound(err) {
+			return nil, "", nil
+		}
+
+		if err != nil {
+			return nil, "", err
+		}
+
+		return accelerator, aws.StringValue(accelerator.Status), nil
+	}
+}
+
+func waitAcceleratorDeployed(ctx context.Context, conn *globalaccelerator.GlobalAccelerator, arn string, timeout time.Duration) (*globalaccelerator.Accelerator, error) { //nolint:unparam
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{globalaccelerator.AcceleratorStatusInProgress},
+		Target:  []string{globalaccelerator.AcceleratorStatusDeployed},
+		Refresh: statusAccelerator(ctx, conn, arn),
+		Timeout: timeout,
+	}
+
+	outputRaw, err := stateConf.WaitForStateContext(ctx)
+
+	if output, ok := outputRaw.(*globalaccelerator.Accelerator); ok {
+		return output, err
+	}
+
+	return nil, err
+}
+
 func expandUpdateAcceleratorAttributesInput(tfMap map[string]interface{}) *globalaccelerator.UpdateAcceleratorAttributesInput {
 	if tfMap == nil {
 		return nil

internal/service/globalaccelerator/accelerator_data_source.go

@@ -56,6 +56,9 @@ func (d *dataSourceAccelerator) Schema(ctx context.Context, req datasource.Schem
 			"dns_name": schema.StringAttribute{
 				Computed: true,
 			},
+			"dual_stack_dns_name": schema.StringAttribute{
+				Computed: true,
+			},
 			"enabled": schema.BoolAttribute{
 				Computed: true,
 			},
@@ -150,8 +153,9 @@ func (d *dataSourceAccelerator) Read(ctx context.Context, request datasource.Rea
 		data.ARN = fwtypes.ARNValue(v)
 	}
 	data.DnsName = flex.StringToFrameworkLegacy(ctx, accelerator.DnsName)
+	data.DualStackDNSName = flex.StringToFrameworkLegacy(ctx, accelerator.DualStackDnsName)
 	data.Enabled = flex.BoolToFrameworkLegacy(ctx, accelerator.Enabled)
-	data.HostedZoneID = types.StringValue(route53ZoneID)
+	data.HostedZoneID = types.StringValue(d.Meta().GlobalAcceleratorHostedZoneID())
 	data.ID = types.StringValue(acceleratorARN)
 	data.IpAddressType = flex.StringToFrameworkLegacy(ctx, accelerator.IpAddressType)
 	data.IpSets = d.flattenIPSetsFramework(ctx, accelerator.IpSets)
@@ -240,14 +244,15 @@ func (d *dataSourceAccelerator) flattenAcceleratorAttributesFramework(ctx contex
 }
 
 type dataSourceAcceleratorData struct {
-	ARN           fwtypes.ARN  `tfsdk:"arn"`
-	Attributes    types.List   `tfsdk:"attributes"`
-	DnsName       types.String `tfsdk:"dns_name"`
-	Enabled       types.Bool   `tfsdk:"enabled"`
-	HostedZoneID  types.String `tfsdk:"hosted_zone_id"`
-	ID            types.String `tfsdk:"id"`
-	IpAddressType types.String `tfsdk:"ip_address_type"`
-	IpSets        types.List   `tfsdk:"ip_sets"`
-	Name          types.String `tfsdk:"name"`
-	Tags          types.Map    `tfsdk:"tags"`
+	ARN              fwtypes.ARN  `tfsdk:"arn"`
+	Attributes       types.List   `tfsdk:"attributes"`
+	DnsName          types.String `tfsdk:"dns_name"`
+	DualStackDNSName types.String `tfsdk:"dual_stack_dns_name"`
+	Enabled          types.Bool   `tfsdk:"enabled"`
+	HostedZoneID     types.String `tfsdk:"hosted_zone_id"`
+	ID               types.String `tfsdk:"id"`
+	IpAddressType    types.String `tfsdk:"ip_address_type"`
+	IpSets           types.List   `tfsdk:"ip_sets"`
+	Name             types.String `tfsdk:"name"`
+	Tags             types.Map    `tfsdk:"tags"`
 }

internal/service/globalaccelerator/accelerator_data_source_test.go

@@ -30,6 +30,7 @@ func TestAccGlobalAcceleratorAcceleratorDataSource_basic(t *testing.T) {
 					resource.TestCheckResourceAttrPair(dataSource1Name, "attributes.0.flow_logs_s3_bucket", resourceName, "attributes.0.flow_logs_s3_bucket"),
 					resource.TestCheckResourceAttrPair(dataSource1Name, "attributes.0.flow_logs_s3_prefix", resourceName, "attributes.0.flow_logs_s3_prefix"),
 					resource.TestCheckResourceAttrPair(dataSource1Name, "dns_name", resourceName, "dns_name"),
+					resource.TestCheckResourceAttrPair(dataSource1Name, "dual_stack_dns_name", resourceName, "dual_stack_dns_name"),
 					resource.TestCheckResourceAttrPair(dataSource1Name, "enabled", resourceName, "enabled"),
 					resource.TestCheckResourceAttrPair(dataSource1Name, "hosted_zone_id", resourceName, "hosted_zone_id"),
 					resource.TestCheckResourceAttrPair(dataSource1Name, "ip_address_type", resourceName, "ip_address_type"),
@@ -46,6 +47,7 @@ func TestAccGlobalAcceleratorAcceleratorDataSource_basic(t *testing.T) {
 					resource.TestCheckResourceAttrPair(dataSource2Name, "attributes.0.flow_logs_s3_bucket", resourceName, "attributes.0.flow_logs_s3_bucket"),
 					resource.TestCheckResourceAttrPair(dataSource2Name, "attributes.0.flow_logs_s3_prefix", resourceName, "attributes.0.flow_logs_s3_prefix"),
 					resource.TestCheckResourceAttrPair(dataSource2Name, "dns_name", resourceName, "dns_name"),
+					resource.TestCheckResourceAttrPair(dataSource2Name, "dual_stack_dns_name", resourceName, "dual_stack_dns_name"),
 					resource.TestCheckResourceAttrPair(dataSource2Name, "enabled", resourceName, "enabled"),
 					resource.TestCheckResourceAttrPair(dataSource2Name, "hosted_zone_id", resourceName, "hosted_zone_id"),
 					resource.TestCheckResourceAttrPair(dataSource2Name, "ip_address_type", resourceName, "ip_address_type"),

internal/service/globalaccelerator/accelerator_test.go

@@ -33,13 +33,14 @@ func TestAccGlobalAcceleratorAccelerator_basic(t *testing.T) {
 		Steps: []resource.TestStep{
 			{
 				Config: testAccAcceleratorConfig_basic(rName),
-				Check: resource.ComposeTestCheckFunc(
+				Check: resource.ComposeAggregateTestCheckFunc(
 					testAccCheckAcceleratorExists(ctx, resourceName),
 					resource.TestCheckResourceAttr(resourceName, "attributes.#", "1"),
 					resource.TestCheckResourceAttr(resourceName, "attributes.0.flow_logs_enabled", "false"),
 					resource.TestCheckResourceAttr(resourceName, "attributes.0.flow_logs_s3_bucket", ""),
 					resource.TestCheckResourceAttr(resourceName, "attributes.0.flow_logs_s3_prefix", ""),
 					resource.TestMatchResourceAttr(resourceName, "dns_name", dnsNameRegex),
+					resource.TestCheckResourceAttr(resourceName, "dual_stack_dns_name", ""),
 					resource.TestCheckResourceAttr(resourceName, "enabled", "true"),
 					resource.TestCheckResourceAttr(resourceName, "hosted_zone_id", "Z2BJ6XQ5FK7U4H"),
 					resource.TestCheckResourceAttr(resourceName, "ip_address_type", "IPV4"),
@@ -65,6 +66,7 @@ func TestAccGlobalAcceleratorAccelerator_ipAddressType_dualStack(t *testing.T) {
 	ctx := acctest.Context(t)
 	resourceName := "aws_globalaccelerator_accelerator.test"
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	dualStackDNSNameRegex := regexp.MustCompile(`^a[a-f0-9]{16}\.dualstack\.awsglobalaccelerator\.com$`)
 
 	resource.ParallelTest(t, resource.TestCase{
 		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
@@ -76,6 +78,7 @@ func TestAccGlobalAcceleratorAccelerator_ipAddressType_dualStack(t *testing.T) {
 				Config: testAccAcceleratorConfig_ipAddressTypeDualStack(rName),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckAcceleratorExists(ctx, resourceName),
+					resource.TestMatchResourceAttr(resourceName, "dual_stack_dns_name", dualStackDNSNameRegex),
 					resource.TestCheckResourceAttr(resourceName, "enabled", "true"),
 					resource.TestCheckResourceAttr(resourceName, "ip_address_type", "DUAL_STACK"),
 					resource.TestCheckResourceAttr(resourceName, "ip_sets.#", "2"),
@@ -473,11 +476,6 @@ resource "aws_s3_bucket" "test" {
   force_destroy = true
 }
 
-resource "aws_s3_bucket_acl" "test" {
-  bucket = aws_s3_bucket.test.id
-  acl    = "private"
-}
-
 resource "aws_globalaccelerator_accelerator" "test" {
   name            = %[1]q
   ip_address_type = "IPV4"