From 935a604b82a46e8ea3b673e3746fcd6c2fb548d8 Mon Sep 17 00:00:00 2001 From: Michal Wieczorek Date: Mon, 20 Jul 2020 09:03:56 +0200 Subject: [PATCH 01/40] resource/aws_route53_traffic_policy: new resource --- aws/provider.go | 1 + aws/resource_aws_route53_traffic_policy.go | 224 ++++++++++++++++++ ...esource_aws_route53_traffic_policy_test.go | 61 +++++ .../r/route53_traffic_policy.html.markdown | 57 +++++ 4 files changed, 343 insertions(+) create mode 100644 aws/resource_aws_route53_traffic_policy.go create mode 100644 aws/resource_aws_route53_traffic_policy_test.go create mode 100644 website/docs/r/route53_traffic_policy.html.markdown diff --git a/aws/provider.go b/aws/provider.go index 34e5c2925841..fe842b9e1ae6 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -776,6 +776,7 @@ func Provider() *schema.Provider { "aws_route53_resolver_endpoint": resourceAwsRoute53ResolverEndpoint(), "aws_route53_resolver_rule_association": resourceAwsRoute53ResolverRuleAssociation(), "aws_route53_resolver_rule": resourceAwsRoute53ResolverRule(), + "aws_route53_traffic_policy": resourceAwsRoute53TrafficPolicy(), "aws_route": resourceAwsRoute(), "aws_route_table": resourceAwsRouteTable(), "aws_default_route_table": resourceAwsDefaultRouteTable(), diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go new file mode 100644 index 000000000000..5768d1ae20fe --- /dev/null +++ b/aws/resource_aws_route53_traffic_policy.go @@ -0,0 +1,224 @@ +package aws + +import ( + "fmt" + "log" + "strconv" + "strings" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/helper/validation" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" +) + +func resourceAwsRoute53TrafficPolicy() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsRoute53TrafficPolicyCreate, + Read: resourceAwsRoute53TrafficPolicyRead, + Update: resourceAwsRoute53TrafficPolicyUpdate, + Delete: resourceAwsRoute53TrafficPolicyDelete, + Importer: &schema.ResourceImporter{ + State: func(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { + idParts := strings.Split(d.Id(), "/") + if len(idParts) != 2 || idParts[0] == "" || idParts[1] == "" { + return nil, fmt.Errorf("Unexpected format of ID (%q), expected traffic-policy-id/traffic-policy-version", d.Id()) + } + version, err := strconv.Atoi(idParts[1]) + if err != nil { + return nil, fmt.Errorf("Cannot convert to int: %s", idParts[1]) + } + d.Set("latest_version", version) + d.SetId(idParts[0]) + + return []*schema.ResourceData{d}, nil + }, + }, + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(1, 512), + }, + "comment": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.StringLenBetween(0, 1024), + }, + "document": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringLenBetween(0, 102400), + }, + "latest_version": { + Type: schema.TypeInt, + Computed: true, + }, + }, + } +} + +func resourceAwsRoute53TrafficPolicyCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + request := &route53.CreateTrafficPolicyInput{ + Name: aws.String(d.Get("name").(string)), + Comment: aws.String(d.Get("comment").(string)), + Document: aws.String(d.Get("document").(string)), + } + + response, err := conn.CreateTrafficPolicy(request) + if err != nil { + return fmt.Errorf("Error creating Route53 Traffic Policy %s: %s", d.Get("name").(string), err) + } + + d.SetId(*response.TrafficPolicy.Id) + + err = d.Set("latest_version", *response.TrafficPolicy.Version) + if err != nil { + return fmt.Errorf("Error assigning Id for Route53 Traffic Policy %s: %s", d.Get("name").(string), err) + } + + return resourceAwsRoute53TrafficPolicyRead(d, meta) +} + +func resourceAwsRoute53TrafficPolicyRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + tp, err := getTrafficPolicyById(d.Id(), conn) + if err != nil { + return err + } + + if tp == nil { + log.Printf("[WARN] Route53 Traffic Policy (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + request := &route53.GetTrafficPolicyInput{ + Id: tp.Id, + Version: tp.LatestVersion, + } + + response, err := conn.GetTrafficPolicy(request) + if err != nil { + return fmt.Errorf("Error getting Route53 Traffic Policy %s, version %d: %s", d.Get("name").(string), d.Get("latest_version").(int), err) + } + + err = d.Set("document", *response.TrafficPolicy.Document) + if err != nil { + return fmt.Errorf("Error setting document for: %s, error: %#v", d.Id(), err) + } + + err = d.Set("name", *response.TrafficPolicy.Name) + if err != nil { + return fmt.Errorf("Error setting name for: %s, error: %#v", d.Id(), err) + } + + err = d.Set("comment", *response.TrafficPolicy.Comment) + if err != nil { + return fmt.Errorf("Error setting comment for: %s, error: %#v", d.Id(), err) + } + + return nil +} + +func getTrafficPolicyById(trafficPolicyId string, conn *route53.Route53) (*route53.TrafficPolicySummary, error) { + var idMarker *string + + for allPoliciesListed := false; !allPoliciesListed; { + listRequest := &route53.ListTrafficPoliciesInput{} + + if idMarker != nil { + listRequest.TrafficPolicyIdMarker = idMarker + } + + listResponse, err := conn.ListTrafficPolicies(listRequest) + if err != nil { + return nil, fmt.Errorf("Error listing Route 53 Traffic Policies: %v", err) + } + + for _, tp := range listResponse.TrafficPolicySummaries { + if *tp.Id == trafficPolicyId { + return tp, nil + } + } + + if *listResponse.IsTruncated { + idMarker = listResponse.TrafficPolicyIdMarker + } else { + allPoliciesListed = true + } + } + return nil, nil +} + +func resourceAwsRoute53TrafficPolicyUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + request := &route53.CreateTrafficPolicyVersionInput{ + Id: aws.String(d.Id()), + Comment: aws.String(d.Get("comment").(string)), + Document: aws.String(d.Get("document").(string)), + } + + response, err := conn.CreateTrafficPolicyVersion(request) + if err != nil { + return fmt.Errorf("Error updating Route53 Traffic Policy: %s. %#v", d.Get("name").(string), err) + } + + err = d.Set("latest_version", *response.TrafficPolicy.Version) + if err != nil { + return fmt.Errorf("Error updating Route53 Traffic Policy %s and setting new policy version. %#v", d.Get("name").(string), err) + } + + return nil +} + +func resourceAwsRoute53TrafficPolicyDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + var versionMarker *string + + var trafficPolicies []*route53.TrafficPolicy + + for allPoliciesListed := false; !allPoliciesListed; { + listRequest := &route53.ListTrafficPolicyVersionsInput{ + Id: aws.String(d.Id()), + } + if versionMarker != nil { + listRequest.TrafficPolicyVersionMarker = versionMarker + } + + listResponse, err := conn.ListTrafficPolicyVersions(listRequest) + if err != nil { + return fmt.Errorf("Error listing Route 53 Traffic Policy versions: %v", err) + } + + trafficPolicies = append(trafficPolicies, listResponse.TrafficPolicies...) + + if *listResponse.IsTruncated { + versionMarker = listResponse.TrafficPolicyVersionMarker + } else { + allPoliciesListed = true + } + } + + for _, trafficPolicy := range trafficPolicies { + deleteRequest := &route53.DeleteTrafficPolicyInput{ + Id: trafficPolicy.Id, + Version: trafficPolicy.Version, + } + + _, err := conn.DeleteTrafficPolicy(deleteRequest) + if err != nil { + return fmt.Errorf("Error deleting Route53 Traffic Policy %s, version %d: %s", *trafficPolicy.Id, *trafficPolicy.Version, err) + } + } + + return nil +} diff --git a/aws/resource_aws_route53_traffic_policy_test.go b/aws/resource_aws_route53_traffic_policy_test.go new file mode 100644 index 000000000000..a4f01b409faf --- /dev/null +++ b/aws/resource_aws_route53_traffic_policy_test.go @@ -0,0 +1,61 @@ +package aws + +import ( + "fmt" + "testing" + + "github.com/hashicorp/terraform-plugin-sdk/helper/acctest" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/terraform" +) + +func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { + policyName := fmt.Sprintf("policy-%s", acctest.RandString(8)) + resourceName := "aws_route53_traffic_policy.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, + Steps: []resource.TestStep{ + { + Config: testAccRoute53TrafficPolicyConfig(policyName), + Check: resource.ComposeTestCheckFunc( + resource.TestCheckResourceAttr(resourceName, "latest_version", "1"), + ), + }, + }, + }) +} + +func testAccRoute53TrafficPolicyConfig(name string) string { + return fmt.Sprintf(` +resource "aws_route53_traffic_policy" "test" { + name = "%s" + comment = "comment" + document = "{\"AWSPolicyFormatVersion\":\"2015-10-01\",\"RecordType\":\"A\",\"Endpoints\":{\"endpoint-start-NkPh\":{\"Type\":\"value\",\"Value\":\"10.0.0.1\"}},\"StartEndpoint\":\"endpoint-start-NkPh\"}" +} +`, name) +} + +func testAccCheckRoute53TrafficPolicyDestroy(s *terraform.State) error { + return testAccCheckRoute53TrafficPolicyDestroyWithProvider(s, testAccProvider) +} + +func testAccCheckRoute53TrafficPolicyDestroyWithProvider(s *terraform.State, provider *schema.Provider) error { + conn := provider.Meta().(*AWSClient).r53conn + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_route53_traffic_policy" { + continue + } + tp, err := getTrafficPolicyById(rs.Primary.ID, conn) + if err != nil { + return fmt.Errorf("Error during check if traffic policy still exists, %#v", err) + } + if tp != nil { + return fmt.Errorf("Traffic Policy still exists") + } + } + return nil +} diff --git a/website/docs/r/route53_traffic_policy.html.markdown b/website/docs/r/route53_traffic_policy.html.markdown new file mode 100644 index 000000000000..39e3cf85324a --- /dev/null +++ b/website/docs/r/route53_traffic_policy.html.markdown @@ -0,0 +1,57 @@ +--- +subcategory: "Route53" +layout: "aws" +page_title: "AWS: aws_route53_traffic_policy" +description: |- + Manages a Route53 Traffic Policy +--- + +# Resource: aws_route53_traffic_policy + +Manages a Route53 Traffic Policy. + +## Example Usage + +```hcl +resource "aws_route53_traffic_policy" "example" { + name = "example" + comment = "example comment" + document = < Date: Thu, 23 Jul 2020 22:52:03 +0200 Subject: [PATCH 02/40] resource/aws_route53_traffic_policy: new resource --- aws/resource_aws_route53_traffic_policy.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go index 5768d1ae20fe..1eac981a60ca 100644 --- a/aws/resource_aws_route53_traffic_policy.go +++ b/aws/resource_aws_route53_traffic_policy.go @@ -77,7 +77,7 @@ func resourceAwsRoute53TrafficPolicyCreate(d *schema.ResourceData, meta interfac d.SetId(*response.TrafficPolicy.Id) - err = d.Set("latest_version", *response.TrafficPolicy.Version) + err = d.Set("latest_version", response.TrafficPolicy.Version) if err != nil { return fmt.Errorf("Error assigning Id for Route53 Traffic Policy %s: %s", d.Get("name").(string), err) } @@ -109,17 +109,17 @@ func resourceAwsRoute53TrafficPolicyRead(d *schema.ResourceData, meta interface{ return fmt.Errorf("Error getting Route53 Traffic Policy %s, version %d: %s", d.Get("name").(string), d.Get("latest_version").(int), err) } - err = d.Set("document", *response.TrafficPolicy.Document) + err = d.Set("document", response.TrafficPolicy.Document) if err != nil { return fmt.Errorf("Error setting document for: %s, error: %#v", d.Id(), err) } - err = d.Set("name", *response.TrafficPolicy.Name) + err = d.Set("name", response.TrafficPolicy.Name) if err != nil { return fmt.Errorf("Error setting name for: %s, error: %#v", d.Id(), err) } - err = d.Set("comment", *response.TrafficPolicy.Comment) + err = d.Set("comment", response.TrafficPolicy.Comment) if err != nil { return fmt.Errorf("Error setting comment for: %s, error: %#v", d.Id(), err) } @@ -171,7 +171,7 @@ func resourceAwsRoute53TrafficPolicyUpdate(d *schema.ResourceData, meta interfac return fmt.Errorf("Error updating Route53 Traffic Policy: %s. %#v", d.Get("name").(string), err) } - err = d.Set("latest_version", *response.TrafficPolicy.Version) + err = d.Set("latest_version", response.TrafficPolicy.Version) if err != nil { return fmt.Errorf("Error updating Route53 Traffic Policy %s and setting new policy version. %#v", d.Get("name").(string), err) } From be4171fe8bd5cd144bdaebfd32b56b7ee2a716ef Mon Sep 17 00:00:00 2001 From: Michal Wieczorek Date: Mon, 27 Jul 2020 13:48:25 +0200 Subject: [PATCH 03/40] Add read at the end of update func --- aws/resource_aws_route53_traffic_policy.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go index 1eac981a60ca..2d7d8cb53391 100644 --- a/aws/resource_aws_route53_traffic_policy.go +++ b/aws/resource_aws_route53_traffic_policy.go @@ -176,7 +176,7 @@ func resourceAwsRoute53TrafficPolicyUpdate(d *schema.ResourceData, meta interfac return fmt.Errorf("Error updating Route53 Traffic Policy %s and setting new policy version. %#v", d.Get("name").(string), err) } - return nil + return resourceAwsRoute53TrafficPolicyRead(d, meta) } func resourceAwsRoute53TrafficPolicyDelete(d *schema.ResourceData, meta interface{}) error { From c79230c7a4c63a67db780ac5b1b11fa56f33d731 Mon Sep 17 00:00:00 2001 From: Michal Wieczorek Date: Mon, 27 Jul 2020 15:57:06 +0200 Subject: [PATCH 04/40] Add import testing --- ...esource_aws_route53_traffic_policy_test.go | 30 +++++++++++++++---- 1 file changed, 24 insertions(+), 6 deletions(-) diff --git a/aws/resource_aws_route53_traffic_policy_test.go b/aws/resource_aws_route53_traffic_policy_test.go index a4f01b409faf..6b55e7d5e225 100644 --- a/aws/resource_aws_route53_traffic_policy_test.go +++ b/aws/resource_aws_route53_traffic_policy_test.go @@ -12,7 +12,8 @@ import ( func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { policyName := fmt.Sprintf("policy-%s", acctest.RandString(8)) - resourceName := "aws_route53_traffic_policy.test" + resourceName := "test" + fullResourceName := fmt.Sprintf("aws_route53_traffic_policy.%s", resourceName) resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, @@ -20,23 +21,29 @@ func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, Steps: []resource.TestStep{ { - Config: testAccRoute53TrafficPolicyConfig(policyName), + Config: testAccRoute53TrafficPolicyConfig(resourceName, policyName), Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr(resourceName, "latest_version", "1"), + resource.TestCheckResourceAttr(fullResourceName, "latest_version", "1"), ), }, + { + ImportState: true, + ImportStateVerify: true, + ImportStateIdFunc: testAccAWSRoute53TrafficPolicyImportStateIdFunc(fullResourceName), + ResourceName: fullResourceName, + }, }, }) } -func testAccRoute53TrafficPolicyConfig(name string) string { +func testAccRoute53TrafficPolicyConfig(resourceName, policyName string) string { return fmt.Sprintf(` -resource "aws_route53_traffic_policy" "test" { +resource "aws_route53_traffic_policy" "%s" { name = "%s" comment = "comment" document = "{\"AWSPolicyFormatVersion\":\"2015-10-01\",\"RecordType\":\"A\",\"Endpoints\":{\"endpoint-start-NkPh\":{\"Type\":\"value\",\"Value\":\"10.0.0.1\"}},\"StartEndpoint\":\"endpoint-start-NkPh\"}" } -`, name) +`, resourceName, policyName) } func testAccCheckRoute53TrafficPolicyDestroy(s *terraform.State) error { @@ -59,3 +66,14 @@ func testAccCheckRoute53TrafficPolicyDestroyWithProvider(s *terraform.State, pro } return nil } + +func testAccAWSRoute53TrafficPolicyImportStateIdFunc(resourceName string) resource.ImportStateIdFunc { + return func(s *terraform.State) (string, error) { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return "", fmt.Errorf("Not found: %s", resourceName) + } + + return fmt.Sprintf("%s/%s", rs.Primary.Attributes["id"], rs.Primary.Attributes["latest_version"]), nil + } +} From 11a3018559af60331fe8aed60a744efa08aea117 Mon Sep 17 00:00:00 2001 From: Michal Wieczorek Date: Fri, 21 Aug 2020 15:43:48 +0200 Subject: [PATCH 05/40] Switch to terraform-plugin-sdk v2 --- aws/resource_aws_route53_traffic_policy.go | 4 ++-- aws/resource_aws_route53_traffic_policy_test.go | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go index 2d7d8cb53391..f2dd01101850 100644 --- a/aws/resource_aws_route53_traffic_policy.go +++ b/aws/resource_aws_route53_traffic_policy.go @@ -6,8 +6,8 @@ import ( "strconv" "strings" - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/helper/validation" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/route53" diff --git a/aws/resource_aws_route53_traffic_policy_test.go b/aws/resource_aws_route53_traffic_policy_test.go index 6b55e7d5e225..45ba8a32934d 100644 --- a/aws/resource_aws_route53_traffic_policy_test.go +++ b/aws/resource_aws_route53_traffic_policy_test.go @@ -4,10 +4,10 @@ import ( "fmt" "testing" - "github.com/hashicorp/terraform-plugin-sdk/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/helper/resource" - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/terraform" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" ) func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { From a6293a241e026c5b0a92b42daa29541133851a85 Mon Sep 17 00:00:00 2001 From: Michal Wieczorek Date: Mon, 27 Jul 2020 13:43:14 +0200 Subject: [PATCH 06/40] resource/aws_route53_traffic_policy_instance: new resource --- aws/provider.go | 1 + ...rce_aws_route53_traffic_policy_instance.go | 152 ++++++++++++++++++ ...ws_route53_traffic_policy_instance_test.go | 1 + ...te53_traffic_policy_instance.html.markdown | 47 ++++++ 4 files changed, 201 insertions(+) create mode 100644 aws/resource_aws_route53_traffic_policy_instance.go create mode 100644 aws/resource_aws_route53_traffic_policy_instance_test.go create mode 100644 website/docs/r/route53_traffic_policy_instance.html.markdown diff --git a/aws/provider.go b/aws/provider.go index 34e5c2925841..2dc54709eaa8 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -776,6 +776,7 @@ func Provider() *schema.Provider { "aws_route53_resolver_endpoint": resourceAwsRoute53ResolverEndpoint(), "aws_route53_resolver_rule_association": resourceAwsRoute53ResolverRuleAssociation(), "aws_route53_resolver_rule": resourceAwsRoute53ResolverRule(), + "aws_route53_traffic_policy_instance": resourceAwsRoute53TrafficPolicyInstance(), "aws_route": resourceAwsRoute(), "aws_route_table": resourceAwsRouteTable(), "aws_default_route_table": resourceAwsDefaultRouteTable(), diff --git a/aws/resource_aws_route53_traffic_policy_instance.go b/aws/resource_aws_route53_traffic_policy_instance.go new file mode 100644 index 000000000000..5cc3e488a690 --- /dev/null +++ b/aws/resource_aws_route53_traffic_policy_instance.go @@ -0,0 +1,152 @@ +package aws + +import ( + "fmt" + "strings" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" + + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" +) + +func resourceAwsRoute53TrafficPolicyInstance() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsRoute53TrafficPolicyInstanceCreate, + Read: resourceAwsRoute53TrafficPolicyInstanceRead, + Update: resourceAwsRoute53TrafficPolicyInstanceUpdate, + Delete: resourceAwsRoute53TrafficPolicyInstanceDelete, + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Schema: map[string]*schema.Schema{ + "hosted_zone_id": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(1, 32), + }, + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(1, 1024), + StateFunc: func(v interface{}) string { + value := strings.TrimSuffix(v.(string), ".") + return strings.ToLower(value) + }, + }, + "traffic_policy_id": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringLenBetween(1, 36), + }, + "traffic_policy_version": { + Type: schema.TypeInt, + Required: true, + ValidateFunc: validation.IntAtMost(1000), + }, + "ttl": { + Type: schema.TypeInt, + Optional: true, + ValidateFunc: validation.IntAtMost(2147483647), + }, + }, + } +} + +func resourceAwsRoute53TrafficPolicyInstanceCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + request := &route53.CreateTrafficPolicyInstanceInput{ + HostedZoneId: aws.String(d.Get("hosted_zone_id").(string)), + Name: aws.String(d.Get("name").(string)), + TrafficPolicyId: aws.String(d.Get("traffic_policy_id").(string)), + TrafficPolicyVersion: aws.Int64(int64(d.Get("traffic_policy_version").(int))), + TTL: aws.Int64(int64(d.Get("ttl").(int))), + } + + response, err := conn.CreateTrafficPolicyInstance(request) + if err != nil { + return fmt.Errorf("Error creating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + d.SetId(*response.TrafficPolicyInstance.Id) + + return resourceAwsRoute53TrafficPolicyInstanceRead(d, meta) +} + +func resourceAwsRoute53TrafficPolicyInstanceRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + request := &route53.GetTrafficPolicyInstanceInput{ + Id: aws.String(d.Id()), + } + + response, err := conn.GetTrafficPolicyInstance(request) + if err != nil { + return fmt.Errorf("Error reading Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + err = d.Set("name", strings.TrimSuffix(*response.TrafficPolicyInstance.Name, ".")) + if err != nil { + return fmt.Errorf("Error setting name for: %s, error: %#v", d.Id(), err) + } + + err = d.Set("hosted_zone_id", response.TrafficPolicyInstance.HostedZoneId) + if err != nil { + return fmt.Errorf("Error setting hosted_zone_id for: %s, error: %#v", d.Id(), err) + } + + err = d.Set("traffic_policy_id", response.TrafficPolicyInstance.TrafficPolicyId) + if err != nil { + return fmt.Errorf("Error setting traffic_policy_id for: %s, error: %#v", d.Id(), err) + } + + err = d.Set("traffic_policy_version", response.TrafficPolicyInstance.TrafficPolicyVersion) + if err != nil { + return fmt.Errorf("Error setting traffic_policy_version for: %s, error: %#v", d.Id(), err) + } + + err = d.Set("ttl", response.TrafficPolicyInstance.TTL) + if err != nil { + return fmt.Errorf("Error setting ttl for: %s, error: %#v", d.Id(), err) + } + + return nil +} + +func resourceAwsRoute53TrafficPolicyInstanceUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + request := &route53.UpdateTrafficPolicyInstanceInput{ + Id: aws.String(d.Id()), + TrafficPolicyId: aws.String(d.Get("traffic_policy_id").(string)), + TrafficPolicyVersion: aws.Int64(int64(d.Get("traffic_policy_version").(int))), + TTL: aws.Int64(int64(d.Get("ttl").(int))), + } + + _, err := conn.UpdateTrafficPolicyInstance(request) + if err != nil { + return fmt.Errorf("Error updating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + return resourceAwsRoute53TrafficPolicyInstanceRead(d, meta) +} + +func resourceAwsRoute53TrafficPolicyInstanceDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).r53conn + + request := &route53.DeleteTrafficPolicyInstanceInput{ + Id: aws.String(d.Id()), + } + + _, err := conn.DeleteTrafficPolicyInstance(request) + if err != nil { + return fmt.Errorf("Error deleting Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + return nil +} diff --git a/aws/resource_aws_route53_traffic_policy_instance_test.go b/aws/resource_aws_route53_traffic_policy_instance_test.go new file mode 100644 index 000000000000..a1f9c0e3beb4 --- /dev/null +++ b/aws/resource_aws_route53_traffic_policy_instance_test.go @@ -0,0 +1 @@ +package aws diff --git a/website/docs/r/route53_traffic_policy_instance.html.markdown b/website/docs/r/route53_traffic_policy_instance.html.markdown new file mode 100644 index 000000000000..52c4e488db37 --- /dev/null +++ b/website/docs/r/route53_traffic_policy_instance.html.markdown @@ -0,0 +1,47 @@ +--- +subcategory: "Route53" +layout: "aws" +page_title: "AWS: aws_route53_traffic_policy_instance" +description: |- + Provides a Route53 traffic policy instance resource. +--- + +# Resource: aws_route53_traffic_policy_instance + +Provides a Route53 traffic policy instance resource. + +## Example Usage + +```hcl +resource "aws_route53_traffic_policy_instance" "test" { + name = "test.example.com" + traffic_policy_id = "b3gb108f-ea6f-45a5-baab-9d112d8b4037" + traffic_policy_version = 1 + hosted_zone_id = "Z033120931TAQO548OGJC" + ttl = 360 +} +``` + +## Argument Reference + +The following arguments are supported: + +* `name` - (Required) The domain name for which Amazon Route 53 responds to DNS queries by using the resource record sets that Route 53 creates for this traffic policy instance. +* `traffic_policy_id` - (Required) The ID of the traffic policy that you want to use to create resource record sets in the specified hosted zone. +* `traffic_policy_version` - (Required) The version of the traffic policy +* `hosted_zone_id` - (Required) The ID of the hosted zone +* `ttl` - (Optional) The TTL that you want Amazon Route 53 to assign to all of the resource record sets that it creates in the specified hosted zone. + +## Attributes Reference + +In addition to all arguments above, the following attributes are exported: + +* `id` - Id of created traffic policy instance. + +## Import + +Route53 traffic policy instance can be imported using its id. + +``` +$ terraform import aws_route53_traffic_policy_instance.test df579d9a-6396-410e-ac22-e7ad60cf9e7e +``` From db9582636fbc7186123d11994f597af545382c0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Wed, 9 Mar 2022 13:51:07 -0700 Subject: [PATCH 07/40] feat: added resource for route53 traffic policy --- internal/provider/provider.go | 1 + internal/service/route53/find.go | 32 +++ internal/service/route53/traffic_policy.go | 217 +++++++++++++++++ .../service/route53/traffic_policy_test.go | 223 ++++++++++++++++++ 4 files changed, 473 insertions(+) create mode 100644 internal/service/route53/traffic_policy.go create mode 100644 internal/service/route53/traffic_policy_test.go diff --git a/internal/provider/provider.go b/internal/provider/provider.go index 740144a03e3f..dc144bb07ba4 100644 --- a/internal/provider/provider.go +++ b/internal/provider/provider.go @@ -1669,6 +1669,7 @@ func Provider() *schema.Provider { "aws_route53_key_signing_key": route53.ResourceKeySigningKey(), "aws_route53_query_log": route53.ResourceQueryLog(), "aws_route53_record": route53.ResourceRecord(), + "aws_route53_traffic_policy": route53.ResourceTrafficPolicy(), "aws_route53_vpc_association_authorization": route53.ResourceVPCAssociationAuthorization(), "aws_route53_zone": route53.ResourceZone(), "aws_route53_zone_association": route53.ResourceZoneAssociation(), diff --git a/internal/service/route53/find.go b/internal/service/route53/find.go index 3f3f3693d6c2..5b9eeee6bc97 100644 --- a/internal/service/route53/find.go +++ b/internal/service/route53/find.go @@ -1,6 +1,7 @@ package route53 import ( + "context" "fmt" "github.com/aws/aws-sdk-go/aws" @@ -85,3 +86,34 @@ func FindKeySigningKeyByResourceID(conn *route53.Route53, resourceID string) (*r return FindKeySigningKey(conn, hostedZoneID, name) } + +func FindTrafficPolicyById(ctx context.Context, conn *route53.Route53, trafficPolicyId string) (*route53.TrafficPolicySummary, error) { + var idMarker *string + + for allPoliciesListed := false; !allPoliciesListed; { + input := &route53.ListTrafficPoliciesInput{} + + if idMarker != nil { + input.TrafficPolicyIdMarker = idMarker + } + + listResponse, err := conn.ListTrafficPoliciesWithContext(ctx, input) + if err != nil { + return nil, err + } + + for _, summary := range listResponse.TrafficPolicySummaries { + if aws.StringValue(summary.Id) == trafficPolicyId { + return summary, nil + } + } + + if aws.BoolValue(listResponse.IsTruncated) { + idMarker = listResponse.TrafficPolicyIdMarker + } else { + allPoliciesListed = true + } + } + + return nil, nil +} diff --git a/internal/service/route53/traffic_policy.go b/internal/service/route53/traffic_policy.go new file mode 100644 index 000000000000..b9ae780eac81 --- /dev/null +++ b/internal/service/route53/traffic_policy.go @@ -0,0 +1,217 @@ +package route53 + +import ( + "context" + "fmt" + "log" + "strconv" + "strings" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" + "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "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/tfresource" +) + +func ResourceTrafficPolicy() *schema.Resource { + return &schema.Resource{ + CreateWithoutTimeout: resourceTrafficPolicyCreate, + ReadWithoutTimeout: resourceTrafficPolicyRead, + UpdateWithoutTimeout: resourceTrafficPolicyUpdate, + DeleteWithoutTimeout: resourceTrafficPolicyDelete, + Importer: &schema.ResourceImporter{ + StateContext: func(ctx context.Context, d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { + idParts := strings.Split(d.Id(), "/") + if len(idParts) != 2 || idParts[0] == "" || idParts[1] == "" { + return nil, fmt.Errorf("unexpected format of ID (%q), expected traffic-policy-id/traffic-policy-version", d.Id()) + } + version, err := strconv.Atoi(idParts[1]) + if err != nil { + return nil, fmt.Errorf("cannot convert to int: %s", idParts[1]) + } + d.Set("version", version) + d.SetId(idParts[0]) + + return []*schema.ResourceData{d}, nil + }, + }, + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(0, 512), + }, + "comment": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.StringLenBetween(0, 1024), + }, + "document": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(0, 102400), + }, + "type": { + Type: schema.TypeString, + Computed: true, + }, + "version": { + Type: schema.TypeInt, + Computed: true, + }, + }, + } +} + +func resourceTrafficPolicyCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + input := &route53.CreateTrafficPolicyInput{ + Document: aws.String(d.Get("document").(string)), + Name: aws.String(d.Get("name").(string)), + } + + if v, ok := d.GetOk("comment"); ok { + input.Comment = aws.String(v.(string)) + } + + var err error + var output *route53.CreateTrafficPolicyOutput + err = resource.RetryContext(ctx, d.Timeout(schema.TimeoutCreate), func() *resource.RetryError { + output, err = conn.CreateTrafficPolicyWithContext(ctx, input) + if err != nil { + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { + resource.RetryableError(err) + } + + return resource.NonRetryableError(err) + } + + return nil + }) + + if tfresource.TimedOut(err) { + output, err = conn.CreateTrafficPolicyWithContext(ctx, input) + } + + if err != nil { + return diag.Errorf("error creating Route53 traffic policy: %s", err) + } + + d.SetId(aws.StringValue(output.TrafficPolicy.Id)) + + return resourceTrafficPolicyRead(ctx, d, meta) +} + +func resourceTrafficPolicyRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + object, err := FindTrafficPolicyById(ctx, conn, d.Id()) + if err != nil { + return diag.Errorf("error getting Route53 Traffic Policy %s from ListTrafficPolicies: %s", d.Get("name").(string), err) + } + + if object == nil { + log.Printf("[WARN] Route53 Traffic Policy (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + request := &route53.GetTrafficPolicyInput{ + Id: aws.String(d.Id()), + Version: object.LatestVersion, + } + + response, err := conn.GetTrafficPolicy(request) + + if !d.IsNewResource() && tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { + log.Printf("[WARN] Route53 Traffic Policy (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + if err != nil { + return diag.Errorf("error getting Route53 Traffic Policy %s, version %d: %s", d.Get("name").(string), d.Get("version").(int), err) + } + + d.Set("comment", response.TrafficPolicy.Comment) + d.Set("document", response.TrafficPolicy.Document) + d.Set("name", response.TrafficPolicy.Name) + d.Set("type", response.TrafficPolicy.Type) + d.Set("version", response.TrafficPolicy.Version) + + return nil +} + +func resourceTrafficPolicyUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + input := &route53.CreateTrafficPolicyVersionInput{ + Id: aws.String(d.Id()), + Document: aws.String(d.Get("document").(string)), + } + + if d.HasChange("comment") { + input.Comment = aws.String(d.Get("comment").(string)) + } + + _, err := conn.CreateTrafficPolicyVersionWithContext(ctx, input) + if err != nil { + return diag.Errorf("error updating Route53 Traffic Policy: %s. %s", d.Get("name").(string), err) + } + + return resourceTrafficPolicyRead(ctx, d, meta) +} + +func resourceTrafficPolicyDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + var trafficPolicies []*route53.TrafficPolicy + var versionMarker *string + + for allPoliciesListed := false; !allPoliciesListed; { + listRequest := &route53.ListTrafficPolicyVersionsInput{ + Id: aws.String(d.Id()), + } + if versionMarker != nil { + listRequest.TrafficPolicyVersionMarker = versionMarker + } + + listResponse, err := conn.ListTrafficPolicyVersionsWithContext(ctx, listRequest) + if err != nil { + return diag.Errorf("error listing Route 53 Traffic Policy versions: %v", err) + } + + trafficPolicies = append(trafficPolicies, listResponse.TrafficPolicies...) + + if aws.BoolValue(listResponse.IsTruncated) { + versionMarker = listResponse.TrafficPolicyVersionMarker + } else { + allPoliciesListed = true + } + } + + for _, trafficPolicy := range trafficPolicies { + input := &route53.DeleteTrafficPolicyInput{ + Id: trafficPolicy.Id, + Version: trafficPolicy.Version, + } + + _, err := conn.DeleteTrafficPolicyWithContext(ctx, input) + if err != nil { + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { + return nil + } + + return diag.Errorf("error deleting Route53 Traffic Policy %s, version %d: %s", aws.StringValue(trafficPolicy.Id), aws.Int64Value(trafficPolicy.Version), err) + } + } + return nil +} diff --git a/internal/service/route53/traffic_policy_test.go b/internal/service/route53/traffic_policy_test.go new file mode 100644 index 000000000000..dd9a5ff8a532 --- /dev/null +++ b/internal/service/route53/traffic_policy_test.go @@ -0,0 +1,223 @@ +package route53_test + +import ( + "context" + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/service/route53" + "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" + sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" + "github.com/hashicorp/terraform-provider-aws/internal/acctest" + "github.com/hashicorp/terraform-provider-aws/internal/conns" + tfroute53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" +) + +func TestAccTrafficPolicy_basic(t *testing.T) { + var output route53.TrafficPolicySummary + resourceName := "aws_route53_traffic_policy.test" + rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + CheckDestroy: testAccCheckTrafficPolicyDestroy, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyConfig(rName), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyExists(resourceName, &output), + resource.TestCheckResourceAttr(resourceName, "name", rName), + ), + }, + { + ResourceName: resourceName, + ImportStateIdFunc: testAccTrafficPolicyImportStateIdFunc(resourceName), + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccTrafficPolicy_disappears(t *testing.T) { + var output route53.TrafficPolicySummary + resourceName := "aws_route53_traffic_policy.test" + rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + CheckDestroy: testAccCheckTrafficPolicyDestroy, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyConfig(rName), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyExists(resourceName, &output), + testAccCheckTrafficPolicyDisappears(&output), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func TestAccTrafficPolicy_complete(t *testing.T) { + var output route53.TrafficPolicySummary + resourceName := "aws_route53_traffic_policy.test" + rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) + comment := `comment` + commentUpdated := `comment updated` + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + CheckDestroy: testAccCheckTrafficPolicyDestroy, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyConfigComplete(rName, comment), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyExists(resourceName, &output), + resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "comment", comment), + ), + }, + { + Config: testAccTrafficPolicyConfigComplete(rName, commentUpdated), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyExists(resourceName, &output), + resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "comment", commentUpdated), + ), + }, + { + ResourceName: resourceName, + ImportStateIdFunc: testAccTrafficPolicyImportStateIdFunc(resourceName), + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func testAccCheckTrafficPolicyExists(resourceName string, trafficPolicy *route53.TrafficPolicySummary) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("not found: %s", resourceName) + } + + conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn + + resp, err := tfroute53.FindTrafficPolicyById(context.Background(), conn, rs.Primary.ID) + + if err != nil { + return fmt.Errorf("problem checking for traffic policy existence: %w", err) + } + + if resp == nil { + return fmt.Errorf("traffic policy %q does not exist", rs.Primary.ID) + } + + *trafficPolicy = *resp + + return nil + } +} + +func testAccCheckTrafficPolicyDestroy(s *terraform.State) error { + conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_route53_traffic_policy" { + continue + } + + resp, err := tfroute53.FindTrafficPolicyById(context.Background(), conn, rs.Primary.ID) + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) || resp == nil { + continue + } + + if err != nil { + return fmt.Errorf("error during check if traffic policy still exists, %#v", err) + } + if resp != nil { + return fmt.Errorf("traffic Policy still exists") + } + } + return nil +} + +func testAccCheckTrafficPolicyDisappears(trafficPolicy *route53.TrafficPolicySummary) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn + + input := &route53.DeleteTrafficPolicyInput{ + Id: trafficPolicy.Id, + Version: trafficPolicy.LatestVersion, + } + + _, err := conn.DeleteTrafficPolicyWithContext(context.Background(), input) + + return err + } +} + +func testAccTrafficPolicyImportStateIdFunc(resourceName string) resource.ImportStateIdFunc { + return func(s *terraform.State) (string, error) { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return "", fmt.Errorf("not found: %s", resourceName) + } + + return fmt.Sprintf("%s/%s", rs.Primary.Attributes["id"], rs.Primary.Attributes["version"]), nil + } +} + +func testAccTrafficPolicyConfig(name string) string { + return fmt.Sprintf(` +resource "aws_route53_traffic_policy" "test" { + name = %[1]q + document = <<-EOT +{ + "AWSPolicyFormatVersion":"2015-10-01", + "RecordType":"A", + "Endpoints":{ + "endpoint-start-NkPh":{ + "Type":"value", + "Value":"10.0.0.1" + } + }, + "StartEndpoint":"endpoint-start-NkPh" +} +EOT +} +`, name) +} + +func testAccTrafficPolicyConfigComplete(name, comment string) string { + return fmt.Sprintf(` +resource "aws_route53_traffic_policy" "test" { + name = %[1]q + comment = %[2]q + document = <<-EOT +{ + "AWSPolicyFormatVersion":"2015-10-01", + "RecordType":"A", + "Endpoints":{ + "endpoint-start-NkPh":{ + "Type":"value", + "Value":"10.0.0.1" + } + }, + "StartEndpoint":"endpoint-start-NkPh" +} +EOT +} +`, name, comment) +} From 274ff1c031933c21a4f6c16ccb733159aee78927 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Wed, 9 Mar 2022 13:51:32 -0700 Subject: [PATCH 08/40] docs: added resource for route53 traffic policy --- .../r/route53_traffic_policy.html.markdown | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 website/docs/r/route53_traffic_policy.html.markdown diff --git a/website/docs/r/route53_traffic_policy.html.markdown b/website/docs/r/route53_traffic_policy.html.markdown new file mode 100644 index 000000000000..74783f2689ee --- /dev/null +++ b/website/docs/r/route53_traffic_policy.html.markdown @@ -0,0 +1,61 @@ +--- +subcategory: "Route53" +layout: "aws" +page_title: "AWS: aws_route53_traffic_policy" +description: |- + Manages a Route53 Traffic Policy +--- + +# Resource: aws_route53_traffic_policy + +Manages a Route53 Traffic Policy. + +## Example Usage + +```terraform +resource "aws_route53_traffic_policy" "example" { + name = "example" + comment = "example comment" + document = < Date: Wed, 9 Mar 2022 15:24:53 -0700 Subject: [PATCH 09/40] refactor: refactorized in update traffice policy resource --- internal/service/route53/traffic_policy.go | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/internal/service/route53/traffic_policy.go b/internal/service/route53/traffic_policy.go index b9ae780eac81..3833024d5de1 100644 --- a/internal/service/route53/traffic_policy.go +++ b/internal/service/route53/traffic_policy.go @@ -153,16 +153,21 @@ func resourceTrafficPolicyRead(ctx context.Context, d *schema.ResourceData, meta func resourceTrafficPolicyUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn - input := &route53.CreateTrafficPolicyVersionInput{ - Id: aws.String(d.Id()), - Document: aws.String(d.Get("document").(string)), + object, err := FindTrafficPolicyById(ctx, conn, d.Id()) + if err != nil { + return diag.Errorf("error getting Route53 Traffic Policy %s from ListTrafficPolicies: %s", d.Get("name").(string), err) + } + + input := &route53.UpdateTrafficPolicyCommentInput{ + Id: aws.String(d.Id()), + Version: object.LatestVersion, } if d.HasChange("comment") { input.Comment = aws.String(d.Get("comment").(string)) } - _, err := conn.CreateTrafficPolicyVersionWithContext(ctx, input) + _, err = conn.UpdateTrafficPolicyCommentWithContext(ctx, input) if err != nil { return diag.Errorf("error updating Route53 Traffic Policy: %s. %s", d.Get("name").(string), err) } From 70ac896a51e664f2b58140155210341aed5da70b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Wed, 9 Mar 2022 15:25:08 -0700 Subject: [PATCH 10/40] feat: added datasource for traffic policy --- internal/provider/provider.go | 1 + .../route53/traffic_policy_data_source.go | 73 +++++++++++++++++++ .../traffic_policy_data_source_test.go | 62 ++++++++++++++++ 3 files changed, 136 insertions(+) create mode 100644 internal/service/route53/traffic_policy_data_source.go create mode 100644 internal/service/route53/traffic_policy_data_source_test.go diff --git a/internal/provider/provider.go b/internal/provider/provider.go index dc144bb07ba4..a799442c12df 100644 --- a/internal/provider/provider.go +++ b/internal/provider/provider.go @@ -756,6 +756,7 @@ func Provider() *schema.Provider { "aws_route53_delegation_set": route53.DataSourceDelegationSet(), "aws_route53_zone": route53.DataSourceZone(), + "aws_route53_traffic_policy": route53.DataSourceTrafficPolicy(), "aws_route53_resolver_endpoint": route53resolver.DataSourceEndpoint(), "aws_route53_resolver_rule": route53resolver.DataSourceRule(), diff --git a/internal/service/route53/traffic_policy_data_source.go b/internal/service/route53/traffic_policy_data_source.go new file mode 100644 index 000000000000..a62656905a27 --- /dev/null +++ b/internal/service/route53/traffic_policy_data_source.go @@ -0,0 +1,73 @@ +package route53 + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/hashicorp/terraform-provider-aws/internal/conns" +) + +func DataSourceTrafficPolicy() *schema.Resource { + return &schema.Resource{ + ReadWithoutTimeout: dataSourcePolicyRead, + Schema: map[string]*schema.Schema{ + "traffic_policy_id": { + Type: schema.TypeString, + Required: true, + }, + "comment": { + Type: schema.TypeString, + Computed: true, + }, + "document": { + Type: schema.TypeString, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Computed: true, + }, + "type": { + Type: schema.TypeString, + Computed: true, + }, + "version": { + Type: schema.TypeInt, + Computed: true, + }, + }, + } +} + +func dataSourcePolicyRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + object, err := FindTrafficPolicyById(ctx, conn, d.Get("traffic_policy_id").(string)) + if err != nil { + return diag.Errorf("error getting Route53 Traffic Policy %s from ListTrafficPolicies: %s", d.Get("name").(string), err) + } + + request := &route53.GetTrafficPolicyInput{ + Id: object.Id, + Version: object.LatestVersion, + } + + response, err := conn.GetTrafficPolicy(request) + + if err != nil { + return diag.Errorf("error getting Route53 Traffic Policy %s: %s", d.Get("name").(string), err) + } + + d.Set("comment", response.TrafficPolicy.Comment) + d.Set("document", response.TrafficPolicy.Document) + d.Set("name", response.TrafficPolicy.Name) + d.Set("type", response.TrafficPolicy.Type) + d.Set("version", response.TrafficPolicy.Version) + + d.SetId(aws.StringValue(response.TrafficPolicy.Id)) + + return nil +} diff --git a/internal/service/route53/traffic_policy_data_source_test.go b/internal/service/route53/traffic_policy_data_source_test.go new file mode 100644 index 000000000000..fc7e00f9066e --- /dev/null +++ b/internal/service/route53/traffic_policy_data_source_test.go @@ -0,0 +1,62 @@ +package route53_test + +import ( + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/service/datapipeline" + sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-provider-aws/internal/acctest" +) + +func TestAccDataPipelinePipelineDataSource_basic(t *testing.T) { + dataSourceName := "data.aws_route53_traffic_policy.test" + resourceName := "aws_route53_traffic_policy.test" + rName := sdkacctest.RandomWithPrefix("tf-acc-test") + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + CheckDestroy: testAccCheckTrafficPolicyDestroy, + ErrorCheck: acctest.ErrorCheck(t, datapipeline.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccDataPipelinePipelineDataSourceConfig(rName), + Check: resource.ComposeTestCheckFunc( + resource.TestCheckResourceAttrPair(dataSourceName, "traffic_policy_id", resourceName, "id"), + resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"), + resource.TestCheckResourceAttrPair(dataSourceName, "comment", resourceName, "comment"), + resource.TestCheckResourceAttrPair(dataSourceName, "document", resourceName, "document"), + resource.TestCheckResourceAttrPair(dataSourceName, "type", resourceName, "type"), + resource.TestCheckResourceAttrPair(dataSourceName, "version", resourceName, "version"), + ), + }, + }, + }) +} + +func testAccDataPipelinePipelineDataSourceConfig(name string) string { + return fmt.Sprintf(` +resource "aws_route53_traffic_policy" "test" { + name = %[1]q + document = <<-EOT +{ + "AWSPolicyFormatVersion":"2015-10-01", + "RecordType":"A", + "Endpoints":{ + "endpoint-start-NkPh":{ + "Type":"value", + "Value":"10.0.0.1" + } + }, + "StartEndpoint":"endpoint-start-NkPh" +} +EOT +} + +data "aws_route53_traffic_policy" "test" { + traffic_policy_id = aws_route53_traffic_policy.test.id +} +`, name) +} From 625732ce25f04e0cccbcbe937d10299fe2303030 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Wed, 9 Mar 2022 15:25:22 -0700 Subject: [PATCH 11/40] docs: added datasource for traffic policy --- .../d/route53_traffic_policy.html.markdown | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 website/docs/d/route53_traffic_policy.html.markdown diff --git a/website/docs/d/route53_traffic_policy.html.markdown b/website/docs/d/route53_traffic_policy.html.markdown new file mode 100644 index 000000000000..43fdae05843a --- /dev/null +++ b/website/docs/d/route53_traffic_policy.html.markdown @@ -0,0 +1,58 @@ +--- +subcategory: "Route53" +layout: "aws" +page_title: "AWS: aws_route53_zone" +description: |- + Provides details about a specific Route 53 Hosted Zone +--- + +# Data Source: aws_route53_zone + +`aws_route53_zone` provides details about a specific Route 53 Hosted Zone. + +This data source allows to find a Hosted Zone ID given Hosted Zone name and certain search criteria. + +## Example Usage + +The following example shows how to get a Hosted Zone from its name and from this data how to create a Record Set. + + +```terraform +resource "aws_route53_traffic_policy" "example" { + name = "example" + comment = "example comment" + document = < Date: Wed, 9 Mar 2022 16:54:34 -0700 Subject: [PATCH 12/40] feat: added resource for traffic policy instance --- internal/provider/provider.go | 1 + internal/service/route53/find.go | 28 +++ internal/service/route53/status.go | 20 ++ .../route53/traffic_policy_instance.go | 186 ++++++++++++++++ .../route53/traffic_policy_instance_test.go | 201 ++++++++++++++++++ internal/service/route53/wait.go | 39 ++++ 6 files changed, 475 insertions(+) create mode 100644 internal/service/route53/traffic_policy_instance.go create mode 100644 internal/service/route53/traffic_policy_instance_test.go diff --git a/internal/provider/provider.go b/internal/provider/provider.go index a799442c12df..a7a6fada8d38 100644 --- a/internal/provider/provider.go +++ b/internal/provider/provider.go @@ -1671,6 +1671,7 @@ func Provider() *schema.Provider { "aws_route53_query_log": route53.ResourceQueryLog(), "aws_route53_record": route53.ResourceRecord(), "aws_route53_traffic_policy": route53.ResourceTrafficPolicy(), + "aws_route53_traffic_policy_instance": route53.ResourceTrafficPolicyInstance(), "aws_route53_vpc_association_authorization": route53.ResourceVPCAssociationAuthorization(), "aws_route53_zone": route53.ResourceZone(), "aws_route53_zone_association": route53.ResourceZoneAssociation(), diff --git a/internal/service/route53/find.go b/internal/service/route53/find.go index 5b9eeee6bc97..ef64ea4d565f 100644 --- a/internal/service/route53/find.go +++ b/internal/service/route53/find.go @@ -117,3 +117,31 @@ func FindTrafficPolicyById(ctx context.Context, conn *route53.Route53, trafficPo return nil, nil } + +func FindTrafficPolicyInstanceId(ctx context.Context, conn *route53.Route53, id string) (*route53.GetTrafficPolicyInstanceOutput, error) { + input := &route53.GetTrafficPolicyInstanceInput{ + Id: aws.String(id), + } + + resp, err := conn.GetTrafficPolicyInstanceWithContext(ctx, input) + + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + return nil, &resource.NotFoundError{ + LastError: err, + LastRequest: input, + } + } + + if err != nil { + return nil, err + } + + if resp == nil { + return nil, &resource.NotFoundError{ + Message: "Empty result", + LastRequest: input, + } + } + + return resp, nil +} diff --git a/internal/service/route53/status.go b/internal/service/route53/status.go index c007e0752cdd..fe4c046cc468 100644 --- a/internal/service/route53/status.go +++ b/internal/service/route53/status.go @@ -1,9 +1,12 @@ package route53 import ( + "context" + "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/route53" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-provider-aws/internal/tfresource" ) func statusChangeInfo(conn *route53.Route53, changeID string) resource.StateRefreshFunc { @@ -57,3 +60,20 @@ func statusKeySigningKey(conn *route53.Route53, hostedZoneID string, name string return keySigningKey, aws.StringValue(keySigningKey.Status), nil } } + +//statusTrafficPolicyInstanceState fetches the traffic policy instance and its state +func statusTrafficPolicyInstanceState(ctx context.Context, conn *route53.Route53, id string) resource.StateRefreshFunc { + return func() (interface{}, string, error) { + object, err := FindTrafficPolicyInstanceId(ctx, conn, id) + + if tfresource.NotFound(err) { + return nil, "", nil + } + + if err != nil { + return nil, "Unknown", err + } + + return object, aws.StringValue(object.TrafficPolicyInstance.State), nil + } +} diff --git a/internal/service/route53/traffic_policy_instance.go b/internal/service/route53/traffic_policy_instance.go new file mode 100644 index 000000000000..6b47e7fa64cd --- /dev/null +++ b/internal/service/route53/traffic_policy_instance.go @@ -0,0 +1,186 @@ +package route53 + +import ( + "context" + "log" + "strings" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" + "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "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/tfresource" +) + +func ResourceTrafficPolicyInstance() *schema.Resource { + return &schema.Resource{ + CreateWithoutTimeout: resourceTrafficPolicyInstanceCreate, + ReadWithoutTimeout: resourceTrafficPolicyInstanceRead, + UpdateWithoutTimeout: resourceTrafficPolicyInstanceUpdate, + DeleteWithoutTimeout: resourceTrafficPolicyInstanceDelete, + Importer: &schema.ResourceImporter{ + StateContext: schema.ImportStatePassthroughContext, + }, + + Schema: map[string]*schema.Schema{ + "hosted_zone_id": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(1, 32), + }, + "message": { + Type: schema.TypeString, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(1, 1024), + StateFunc: func(v interface{}) string { + value := strings.TrimSuffix(v.(string), ".") + return strings.ToLower(value) + }, + }, + "state": { + Type: schema.TypeString, + Computed: true, + }, + "traffic_policy_id": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringLenBetween(1, 36), + }, + "traffic_policy_version": { + Type: schema.TypeInt, + Required: true, + ValidateFunc: validation.IntBetween(1, 1000), + }, + "ttl": { + Type: schema.TypeInt, + Required: true, + ValidateFunc: validation.IntAtMost(2147483647), + }, + }, + } +} + +func resourceTrafficPolicyInstanceCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + input := &route53.CreateTrafficPolicyInstanceInput{ + HostedZoneId: aws.String(d.Get("hosted_zone_id").(string)), + Name: aws.String(d.Get("name").(string)), + TrafficPolicyId: aws.String(d.Get("traffic_policy_id").(string)), + TrafficPolicyVersion: aws.Int64(int64(d.Get("traffic_policy_version").(int))), + TTL: aws.Int64(int64(d.Get("ttl").(int))), + } + + var err error + var output *route53.CreateTrafficPolicyInstanceOutput + err = resource.RetryContext(ctx, d.Timeout(schema.TimeoutCreate), func() *resource.RetryError { + output, err = conn.CreateTrafficPolicyInstanceWithContext(ctx, input) + if err != nil { + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + return resource.RetryableError(err) + } + + return resource.NonRetryableError(err) + } + + return nil + }) + + if tfresource.TimedOut(err) { + output, err = conn.CreateTrafficPolicyInstanceWithContext(ctx, input) + } + if err != nil { + return diag.Errorf("error creating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + if _, err = waitTrafficPolicyInstanceStateApplied(ctx, conn, aws.StringValue(output.TrafficPolicyInstance.Id)); err != nil { + return diag.Errorf("error waiting for Route53 Traffic Policy Instance (%s) to be Applied: %s", d.Id(), err) + } + + d.SetId(aws.StringValue(output.TrafficPolicyInstance.Id)) + + return resourceTrafficPolicyInstanceRead(ctx, d, meta) +} + +func resourceTrafficPolicyInstanceRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + input := &route53.GetTrafficPolicyInstanceInput{ + Id: aws.String(d.Id()), + } + + output, err := conn.GetTrafficPolicyInstanceWithContext(ctx, input) + + if !d.IsNewResource() && tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + log.Printf("[WARN] Route53 Traffic Policy Instance (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + if err != nil { + return diag.Errorf("error reading Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + d.Set("hosted_zone_id", output.TrafficPolicyInstance.HostedZoneId) + d.Set("message", output.TrafficPolicyInstance.Message) + d.Set("name", strings.TrimSuffix(aws.StringValue(output.TrafficPolicyInstance.Name), ".")) + d.Set("state", output.TrafficPolicyInstance.State) + d.Set("traffic_policy_id", output.TrafficPolicyInstance.TrafficPolicyId) + d.Set("traffic_policy_version", output.TrafficPolicyInstance.TrafficPolicyVersion) + d.Set("ttl", output.TrafficPolicyInstance.TTL) + + return nil +} + +func resourceTrafficPolicyInstanceUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + input := &route53.UpdateTrafficPolicyInstanceInput{ + Id: aws.String(d.Id()), + TrafficPolicyId: aws.String(d.Get("traffic_policy_id").(string)), + TrafficPolicyVersion: aws.Int64(int64(d.Get("traffic_policy_version").(int))), + TTL: aws.Int64(int64(d.Get("ttl").(int))), + } + + _, err := conn.UpdateTrafficPolicyInstanceWithContext(ctx, input) + if err != nil { + return diag.Errorf("error updating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + return resourceTrafficPolicyInstanceRead(ctx, d, meta) +} + +func resourceTrafficPolicyInstanceDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).Route53Conn + + input := &route53.DeleteTrafficPolicyInstanceInput{ + Id: aws.String(d.Id()), + } + + _, err := conn.DeleteTrafficPolicyInstanceWithContext(ctx, input) + if err != nil { + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + return nil + } + return diag.Errorf("error deleting Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + } + + if _, err = waitTrafficPolicyInstanceStateDeleted(ctx, conn, d.Id()); err != nil { + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + return nil + } + return diag.Errorf("error waiting for Route53 Traffic Policy Instance (%s) to be Deleted: %s", d.Id(), err) + } + + return nil +} diff --git a/internal/service/route53/traffic_policy_instance_test.go b/internal/service/route53/traffic_policy_instance_test.go new file mode 100644 index 000000000000..ab9300f69d49 --- /dev/null +++ b/internal/service/route53/traffic_policy_instance_test.go @@ -0,0 +1,201 @@ +package route53_test + +import ( + "context" + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" + "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" + sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" + "github.com/hashicorp/terraform-provider-aws/internal/acctest" + "github.com/hashicorp/terraform-provider-aws/internal/conns" + tfrouter53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" +) + +func TestAccTrafficPolicyInstance_basic(t *testing.T) { + var output route53.GetTrafficPolicyInstanceOutput + resourceName := "aws_route53_traffic_policy_instance.test" + + zoneName := acctest.RandomDomainName() + rName := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + CheckDestroy: testAccCheckRoute53TrafficPolicyInstanceDestroy, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + resource.TestCheckResourceAttr(resourceName, "name", rName), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccTrafficPolicyInstance_disappears(t *testing.T) { + var output route53.GetTrafficPolicyInstanceOutput + resourceName := "aws_route53_traffic_policy_instance.test" + + zoneName := acctest.RandomDomainName() + rName := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + CheckDestroy: testAccCheckRoute53TrafficPolicyInstanceDestroy, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + acctest.CheckResourceDisappears(acctest.Provider, tfrouter53.ResourceTrafficPolicyInstance(), resourceName), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func TestAccTrafficPolicyInstance_complete(t *testing.T) { + var output route53.GetTrafficPolicyInstanceOutput + resourceName := "aws_route53_traffic_policy_instance.test" + + zoneName := acctest.RandomDomainName() + rName := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) + rNameUpdated := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + CheckDestroy: testAccCheckRoute53TrafficPolicyInstanceDestroy, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + resource.TestCheckResourceAttr(resourceName, "name", rName), + ), + }, + { + Config: testAccTrafficPolicyInstanceConfig(zoneName, rNameUpdated), + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + resource.TestCheckResourceAttr(resourceName, "name", rNameUpdated), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func testAccCheckTrafficPolicyInstanceExists(resourceName string, output *route53.GetTrafficPolicyInstanceOutput) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("not found: %s", resourceName) + } + + conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn + + input := &route53.GetTrafficPolicyInstanceInput{ + Id: aws.String(rs.Primary.ID), + } + + resp, err := conn.GetTrafficPolicyInstanceWithContext(context.Background(), input) + + if err != nil { + return fmt.Errorf("problem checking for traffic policy instance existence: %w", err) + } + + if resp == nil { + return fmt.Errorf("traffic policy instance %q does not exist", rs.Primary.ID) + } + + output = resp + + return nil + } +} + +func testAccCheckRoute53TrafficPolicyInstanceDestroy(s *terraform.State) error { + conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_route53_traffic_policy_instance" { + continue + } + + input := &route53.GetTrafficPolicyInstanceInput{ + Id: aws.String(rs.Primary.ID), + } + + resp, err := conn.GetTrafficPolicyInstanceWithContext(context.Background(), input) + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + continue + } + + if err != nil { + return fmt.Errorf("error getting Route53 Traffic Policy Instance %s : %w", rs.Primary.Attributes["name"], err) + } + + if err != nil { + return fmt.Errorf("error during check if traffic policy instance still exists, %#v", err) + } + if resp != nil { + return fmt.Errorf("traffic Policy instance still exists") + } + } + return nil +} + +func testAccTrafficPolicyInstanceConfig(zoneName, instanceName string) string { + return fmt.Sprintf(` +resource "aws_route53_zone" "test" { + name = %[1]q +} + +resource "aws_route53_traffic_policy" "test" { + name = aws_route53_zone.test.name + document = <<-EOT +{ + "AWSPolicyFormatVersion":"2015-10-01", + "RecordType":"A", + "Endpoints":{ + "endpoint-start-NkPh":{ + "Type":"value", + "Value":"10.0.0.1" + } + }, + "StartEndpoint":"endpoint-start-NkPh" +} +EOT +} + +resource "aws_route53_traffic_policy_instance" "test" { + hosted_zone_id = aws_route53_zone.test.zone_id + name = %[2]q + traffic_policy_id = aws_route53_traffic_policy.test.id + traffic_policy_version = aws_route53_traffic_policy.test.version + ttl = 360 +} +`, zoneName, instanceName) +} diff --git a/internal/service/route53/wait.go b/internal/service/route53/wait.go index c7265a4bcf23..95282dbc710d 100644 --- a/internal/service/route53/wait.go +++ b/internal/service/route53/wait.go @@ -1,6 +1,7 @@ package route53 import ( + "context" "errors" "fmt" "math/rand" @@ -21,6 +22,8 @@ const ( hostedZoneDNSSECStatusTimeout = 5 * time.Minute keySigningKeyStatusTimeout = 5 * time.Minute + + trafficPolicyInstanceOperationTimeout = 4 * time.Minute ) func waitChangeInfoStatusInsync(conn *route53.Route53, changeID string) (*route53.ChangeInfo, error) { //nolint:unparam @@ -107,3 +110,39 @@ func waitKeySigningKeyStatusUpdated(conn *route53.Route53, hostedZoneID string, return nil, err } + +// waitTrafficPolicyInstanceStateApplied waits for a traffic policy instance applied +func waitTrafficPolicyInstanceStateApplied(ctx context.Context, conn *route53.Route53, id string) (*route53.GetTrafficPolicyInstanceOutput, error) { + stateConf := &resource.StateChangeConf{ + Pending: []string{"Creating"}, + Target: []string{"Applied", "Failed"}, + Refresh: statusTrafficPolicyInstanceState(ctx, conn, id), + Timeout: trafficPolicyInstanceOperationTimeout, + } + + outputRaw, err := stateConf.WaitForStateContext(ctx) + + if output, ok := outputRaw.(*route53.GetTrafficPolicyInstanceOutput); ok { + return output, err + } + + return nil, err +} + +// waitTrafficPolicyInstanceStateDeleted waits for a traffic policy instance deleted +func waitTrafficPolicyInstanceStateDeleted(ctx context.Context, conn *route53.Route53, id string) (*route53.GetTrafficPolicyInstanceOutput, error) { + stateConf := &resource.StateChangeConf{ + Pending: []string{"Deleting"}, + Target: []string{}, + Refresh: statusTrafficPolicyInstanceState(ctx, conn, id), + Timeout: trafficPolicyInstanceOperationTimeout, + } + + outputRaw, err := stateConf.WaitForStateContext(ctx) + + if output, ok := outputRaw.(*route53.GetTrafficPolicyInstanceOutput); ok { + return output, err + } + + return nil, err +} From e56ab1e0536af86b1a2a012a20cedccec3f94132 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Wed, 9 Mar 2022 16:55:45 -0700 Subject: [PATCH 13/40] docs: added resource for traffic policy instance --- ...te53_traffic_policy_instance.html.markdown | 49 +++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 website/docs/r/route53_traffic_policy_instance.html.markdown diff --git a/website/docs/r/route53_traffic_policy_instance.html.markdown b/website/docs/r/route53_traffic_policy_instance.html.markdown new file mode 100644 index 000000000000..f2a865eb873d --- /dev/null +++ b/website/docs/r/route53_traffic_policy_instance.html.markdown @@ -0,0 +1,49 @@ +--- +subcategory: "Route53" +layout: "aws" +page_title: "AWS: aws_route53_traffic_policy_instance" +description: |- + Provides a Route53 traffic policy instance resource. +--- + +# Resource: aws_route53_traffic_policy_instance + +Provides a Route53 traffic policy instance resource. + +## Example Usage + +```terraform +resource "aws_route53_traffic_policy_instance" "test" { + name = "test.example.com" + traffic_policy_id = "b3gb108f-ea6f-45a5-baab-9d112d8b4037" + traffic_policy_version = 1 + hosted_zone_id = "Z033120931TAQO548OGJC" + ttl = 360 +} +``` + +## Argument Reference + +The following arguments are required: + +* `name` - (Required) Domain name for which Amazon Route 53 responds to DNS queries by using the resource record sets that Route 53 creates for this traffic policy instance. +* `traffic_policy_id` - (Required) ID of the traffic policy that you want to use to create resource record sets in the specified hosted zone. +* `traffic_policy_version` - (Required) Version of the traffic policy +* `hosted_zone_id` - (Required) ID of the hosted zone that you want Amazon Route 53 to create resource record sets in by using the configuration in a traffic policy. +* `ttl` - (Required) TTL that you want Amazon Route 53 to assign to all the resource record sets that it creates in the specified hosted zone. + +## Attributes Reference + +In addition to all arguments above, the following attributes are exported: + +* `id` - ID of traffic policy instance. +* `message` - If `state` is `Failed`, an explanation of the reason for the failure. If `state` is another value, `message` is empty. . +* `state` - State of a policy traffic instance. + +## Import + +Route53 traffic policy instance can be imported using its id. + +``` +$ terraform import aws_route53_traffic_policy_instance.test df579d9a-6396-410e-ac22-e7ad60cf9e7e +``` From 65282a474ff87758ec223d55f0e45f35ed5526e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Wed, 9 Mar 2022 17:06:15 -0700 Subject: [PATCH 14/40] fixes typo --- .../service/route53/traffic_policy_data_source_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/internal/service/route53/traffic_policy_data_source_test.go b/internal/service/route53/traffic_policy_data_source_test.go index fc7e00f9066e..0e0dd9ba8330 100644 --- a/internal/service/route53/traffic_policy_data_source_test.go +++ b/internal/service/route53/traffic_policy_data_source_test.go @@ -4,13 +4,13 @@ import ( "fmt" "testing" - "github.com/aws/aws-sdk-go/service/datapipeline" + "github.com/aws/aws-sdk-go/service/route53" sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-provider-aws/internal/acctest" ) -func TestAccDataPipelinePipelineDataSource_basic(t *testing.T) { +func TestAccTrafficPolicyDataSource_basic(t *testing.T) { dataSourceName := "data.aws_route53_traffic_policy.test" resourceName := "aws_route53_traffic_policy.test" rName := sdkacctest.RandomWithPrefix("tf-acc-test") @@ -19,10 +19,10 @@ func TestAccDataPipelinePipelineDataSource_basic(t *testing.T) { PreCheck: func() { acctest.PreCheck(t) }, ProviderFactories: acctest.ProviderFactories, CheckDestroy: testAccCheckTrafficPolicyDestroy, - ErrorCheck: acctest.ErrorCheck(t, datapipeline.EndpointsID), + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), Steps: []resource.TestStep{ { - Config: testAccDataPipelinePipelineDataSourceConfig(rName), + Config: testAccTrafficPolicyDataSourceConfig(rName), Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttrPair(dataSourceName, "traffic_policy_id", resourceName, "id"), resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"), @@ -36,7 +36,7 @@ func TestAccDataPipelinePipelineDataSource_basic(t *testing.T) { }) } -func testAccDataPipelinePipelineDataSourceConfig(name string) string { +func testAccTrafficPolicyDataSourceConfig(name string) string { return fmt.Sprintf(` resource "aws_route53_traffic_policy" "test" { name = %[1]q From 437414a301e905a1e74583acd45a5433f5d66fff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Wed, 9 Mar 2022 17:12:47 -0700 Subject: [PATCH 15/40] added changelog --- .changelog/23602.txt | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 .changelog/23602.txt diff --git a/.changelog/23602.txt b/.changelog/23602.txt new file mode 100644 index 000000000000..f8b6ce033d5d --- /dev/null +++ b/.changelog/23602.txt @@ -0,0 +1,11 @@ +```release-note:new-resource +aws_route53_traffic_policy +``` + +```release-note:new-data-source +aws_route53_traffic_policy +``` + +```release-note:new-resource +aws_route53_traffic_policy_instance +``` \ No newline at end of file From e5a6741e93bea91484075b7896b709150a36798b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edgar=20L=C3=B3pez?= Date: Thu, 10 Mar 2022 10:32:27 -0700 Subject: [PATCH 16/40] refactor: changed datasource to traffic policy document --- .changelog/23602.txt | 2 +- internal/provider/provider.go | 6 +- .../route53/traffic_policy_data_source.go | 73 -- .../traffic_policy_data_source_test.go | 62 -- .../traffic_policy_document_data_source.go | 621 ++++++++++++++++++ ...raffic_policy_document_data_source_test.go | 314 +++++++++ .../route53/traffic_policy_document_model.go | 85 +++ .../d/route53_traffic_policy.html.markdown | 58 -- ...te53_traffic_policy_document.html.markdown | 135 ++++ 9 files changed, 1159 insertions(+), 197 deletions(-) delete mode 100644 internal/service/route53/traffic_policy_data_source.go delete mode 100644 internal/service/route53/traffic_policy_data_source_test.go create mode 100644 internal/service/route53/traffic_policy_document_data_source.go create mode 100644 internal/service/route53/traffic_policy_document_data_source_test.go create mode 100644 internal/service/route53/traffic_policy_document_model.go delete mode 100644 website/docs/d/route53_traffic_policy.html.markdown create mode 100644 website/docs/d/route53_traffic_policy_document.html.markdown diff --git a/.changelog/23602.txt b/.changelog/23602.txt index f8b6ce033d5d..2a60408c7672 100644 --- a/.changelog/23602.txt +++ b/.changelog/23602.txt @@ -3,7 +3,7 @@ aws_route53_traffic_policy ``` ```release-note:new-data-source -aws_route53_traffic_policy +aws_route53_traffic_policy_document ``` ```release-note:new-resource diff --git a/internal/provider/provider.go b/internal/provider/provider.go index a7a6fada8d38..c852a2592af8 100644 --- a/internal/provider/provider.go +++ b/internal/provider/provider.go @@ -754,9 +754,9 @@ func Provider() *schema.Provider { "aws_resourcegroupstaggingapi_resources": resourcegroupstaggingapi.DataSourceResources(), - "aws_route53_delegation_set": route53.DataSourceDelegationSet(), - "aws_route53_zone": route53.DataSourceZone(), - "aws_route53_traffic_policy": route53.DataSourceTrafficPolicy(), + "aws_route53_delegation_set": route53.DataSourceDelegationSet(), + "aws_route53_zone": route53.DataSourceZone(), + "aws_route53_traffic_policy_document": route53.DataSourceTrafficPolicyDocument(), "aws_route53_resolver_endpoint": route53resolver.DataSourceEndpoint(), "aws_route53_resolver_rule": route53resolver.DataSourceRule(), diff --git a/internal/service/route53/traffic_policy_data_source.go b/internal/service/route53/traffic_policy_data_source.go deleted file mode 100644 index a62656905a27..000000000000 --- a/internal/service/route53/traffic_policy_data_source.go +++ /dev/null @@ -1,73 +0,0 @@ -package route53 - -import ( - "context" - - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/route53" - "github.com/hashicorp/terraform-plugin-sdk/v2/diag" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" - "github.com/hashicorp/terraform-provider-aws/internal/conns" -) - -func DataSourceTrafficPolicy() *schema.Resource { - return &schema.Resource{ - ReadWithoutTimeout: dataSourcePolicyRead, - Schema: map[string]*schema.Schema{ - "traffic_policy_id": { - Type: schema.TypeString, - Required: true, - }, - "comment": { - Type: schema.TypeString, - Computed: true, - }, - "document": { - Type: schema.TypeString, - Computed: true, - }, - "name": { - Type: schema.TypeString, - Computed: true, - }, - "type": { - Type: schema.TypeString, - Computed: true, - }, - "version": { - Type: schema.TypeInt, - Computed: true, - }, - }, - } -} - -func dataSourcePolicyRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { - conn := meta.(*conns.AWSClient).Route53Conn - - object, err := FindTrafficPolicyById(ctx, conn, d.Get("traffic_policy_id").(string)) - if err != nil { - return diag.Errorf("error getting Route53 Traffic Policy %s from ListTrafficPolicies: %s", d.Get("name").(string), err) - } - - request := &route53.GetTrafficPolicyInput{ - Id: object.Id, - Version: object.LatestVersion, - } - - response, err := conn.GetTrafficPolicy(request) - - if err != nil { - return diag.Errorf("error getting Route53 Traffic Policy %s: %s", d.Get("name").(string), err) - } - - d.Set("comment", response.TrafficPolicy.Comment) - d.Set("document", response.TrafficPolicy.Document) - d.Set("name", response.TrafficPolicy.Name) - d.Set("type", response.TrafficPolicy.Type) - d.Set("version", response.TrafficPolicy.Version) - - d.SetId(aws.StringValue(response.TrafficPolicy.Id)) - - return nil -} diff --git a/internal/service/route53/traffic_policy_data_source_test.go b/internal/service/route53/traffic_policy_data_source_test.go deleted file mode 100644 index 0e0dd9ba8330..000000000000 --- a/internal/service/route53/traffic_policy_data_source_test.go +++ /dev/null @@ -1,62 +0,0 @@ -package route53_test - -import ( - "fmt" - "testing" - - "github.com/aws/aws-sdk-go/service/route53" - sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - "github.com/hashicorp/terraform-provider-aws/internal/acctest" -) - -func TestAccTrafficPolicyDataSource_basic(t *testing.T) { - dataSourceName := "data.aws_route53_traffic_policy.test" - resourceName := "aws_route53_traffic_policy.test" - rName := sdkacctest.RandomWithPrefix("tf-acc-test") - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acctest.PreCheck(t) }, - ProviderFactories: acctest.ProviderFactories, - CheckDestroy: testAccCheckTrafficPolicyDestroy, - ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), - Steps: []resource.TestStep{ - { - Config: testAccTrafficPolicyDataSourceConfig(rName), - Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttrPair(dataSourceName, "traffic_policy_id", resourceName, "id"), - resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"), - resource.TestCheckResourceAttrPair(dataSourceName, "comment", resourceName, "comment"), - resource.TestCheckResourceAttrPair(dataSourceName, "document", resourceName, "document"), - resource.TestCheckResourceAttrPair(dataSourceName, "type", resourceName, "type"), - resource.TestCheckResourceAttrPair(dataSourceName, "version", resourceName, "version"), - ), - }, - }, - }) -} - -func testAccTrafficPolicyDataSourceConfig(name string) string { - return fmt.Sprintf(` -resource "aws_route53_traffic_policy" "test" { - name = %[1]q - document = <<-EOT -{ - "AWSPolicyFormatVersion":"2015-10-01", - "RecordType":"A", - "Endpoints":{ - "endpoint-start-NkPh":{ - "Type":"value", - "Value":"10.0.0.1" - } - }, - "StartEndpoint":"endpoint-start-NkPh" -} -EOT -} - -data "aws_route53_traffic_policy" "test" { - traffic_policy_id = aws_route53_traffic_policy.test.id -} -`, name) -} diff --git a/internal/service/route53/traffic_policy_document_data_source.go b/internal/service/route53/traffic_policy_document_data_source.go new file mode 100644 index 000000000000..ebd02e070fbf --- /dev/null +++ b/internal/service/route53/traffic_policy_document_data_source.go @@ -0,0 +1,621 @@ +package route53 + +import ( + "context" + "encoding/json" + "strconv" + + "github.com/aws/aws-sdk-go/aws" + "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" +) + +func DataSourceTrafficPolicyDocument() *schema.Resource { + return &schema.Resource{ + ReadContext: dataSourceTrafficPolicyDocumentRead, + + Schema: map[string]*schema.Schema{ + "endpoint": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "id": { + Type: schema.TypeString, + Required: true, + }, + "type": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.StringInSlice(Route53TrafficPolicyDocEndpointType_Values(), false), + }, + "region": { + Type: schema.TypeString, + Optional: true, + }, + "value": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + "json": { + Type: schema.TypeString, + Computed: true, + }, + "record_type": { + Type: schema.TypeString, + Optional: true, + }, + "rule": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "id": { + Type: schema.TypeString, + Required: true, + }, + "type": { + Type: schema.TypeString, + Optional: true, + }, + "primary": { + Type: schema.TypeList, + MaxItems: 1, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "endpoint_reference": { + Type: schema.TypeString, + Optional: true, + }, + "evaluate_target_health": { + Type: schema.TypeBool, + Optional: true, + }, + "health_check": { + Type: schema.TypeString, + Optional: true, + }, + "rule_reference": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + "secondary": { + Type: schema.TypeList, + MaxItems: 1, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "endpoint_reference": { + Type: schema.TypeString, + Optional: true, + }, + "evaluate_target_health": { + Type: schema.TypeBool, + Optional: true, + }, + "health_check": { + Type: schema.TypeString, + Optional: true, + }, + "rule_reference": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + "location": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "continent": { + Type: schema.TypeString, + Optional: true, + }, + "country": { + Type: schema.TypeString, + Optional: true, + }, + "endpoint_reference": { + Type: schema.TypeString, + Optional: true, + }, + "evaluate_target_health": { + Type: schema.TypeBool, + Optional: true, + }, + "health_check": { + Type: schema.TypeString, + Optional: true, + }, + "is_default": { + Type: schema.TypeBool, + Optional: true, + }, + "rule_reference": { + Type: schema.TypeString, + Optional: true, + }, + "subdivision": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + "geo_proximity_location": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "bias": { + Type: schema.TypeString, + Optional: true, + }, + "endpoint_reference": { + Type: schema.TypeString, + Optional: true, + }, + "evaluate_target_health": { + Type: schema.TypeBool, + Optional: true, + }, + "health_check": { + Type: schema.TypeString, + Optional: true, + }, + "latitude": { + Type: schema.TypeString, + Optional: true, + }, + "longitude": { + Type: schema.TypeString, + Optional: true, + }, + "region": { + Type: schema.TypeString, + Optional: true, + }, + "rule_reference": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + "region": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "endpoint_reference": { + Type: schema.TypeString, + Optional: true, + }, + "evaluate_target_health": { + Type: schema.TypeBool, + Optional: true, + }, + "health_check": { + Type: schema.TypeString, + Optional: true, + }, + "region": { + Type: schema.TypeString, + Optional: true, + }, + "rule_reference": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + "items": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "endpoint_reference": { + Type: schema.TypeString, + Optional: true, + }, + "health_check": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + }, + }, + }, + "start_endpoint": { + Type: schema.TypeString, + Optional: true, + }, + "start_rule": { + Type: schema.TypeString, + Optional: true, + }, + "version": { + Type: schema.TypeString, + Optional: true, + Default: "2015-10-01", + ValidateFunc: validation.StringInSlice([]string{ + "2015-10-01", + }, false), + }, + }, + } +} + +func dataSourceTrafficPolicyDocumentRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + trafficDoc := &Route53TrafficPolicyDoc{} + + if v, ok := d.GetOk("endpoint"); ok { + trafficDoc.Endpoints = expandDataTrafficPolicyEndpointsDoc(v.(*schema.Set).List()) + } + if v, ok := d.GetOk("record_type"); ok { + trafficDoc.RecordType = v.(string) + } + if v, ok := d.GetOk("rule"); ok { + trafficDoc.Rules = expandDataTrafficPolicyRulesDoc(v.(*schema.Set).List()) + } + if v, ok := d.GetOk("start_endpoint"); ok { + trafficDoc.StartEndpoint = v.(string) + } + if v, ok := d.GetOk("start_rule"); ok { + trafficDoc.StartRule = v.(string) + } + if v, ok := d.GetOk("version"); ok { + trafficDoc.AWSPolicyFormatVersion = v.(string) + } + + jsonDoc, err := json.Marshal(trafficDoc) + if err != nil { + return diag.FromErr(err) + } + jsonString := string(jsonDoc) + + d.Set("json", jsonString) + + d.SetId(strconv.Itoa(schema.HashString(jsonString))) + + return nil +} + +func expandDataTrafficPolicyEndpointDoc(tfMap map[string]interface{}) *TrafficPolicyEndpoint { + if tfMap == nil { + return nil + } + + apiObject := &TrafficPolicyEndpoint{} + + if v, ok := tfMap["type"]; ok && v.(string) != "" { + apiObject.Type = v.(string) + } + if v, ok := tfMap["region"]; ok && v.(string) != "" { + apiObject.Region = v.(string) + } + if v, ok := tfMap["value"]; ok && v.(string) != "" { + apiObject.Value = v.(string) + } + + return apiObject +} + +func expandDataTrafficPolicyEndpointsDoc(tfList []interface{}) map[string]*TrafficPolicyEndpoint { + if len(tfList) == 0 { + return nil + } + + apiObjects := make(map[string]*TrafficPolicyEndpoint) + + for _, tfMapRaw := range tfList { + tfMap, ok := tfMapRaw.(map[string]interface{}) + + if !ok { + continue + } + + id := tfMap["id"].(string) + + apiObject := expandDataTrafficPolicyEndpointDoc(tfMap) + + apiObjects[id] = apiObject + } + + return apiObjects +} + +func expandDataTrafficPolicyRuleDoc(tfMap map[string]interface{}) *TrafficPolicyRule { + if tfMap == nil { + return nil + } + + apiObject := &TrafficPolicyRule{} + + if v, ok := tfMap["type"]; ok && v.(string) != "" { + apiObject.RuleType = v.(string) + } + if v, ok := tfMap["primary"]; ok && len(v.([]interface{})) > 0 { + apiObject.Primary = expandDataTrafficPolicyFailOverDoc(v.([]interface{})) + } + if v, ok := tfMap["secondary"]; ok && len(v.([]interface{})) > 0 { + apiObject.Secondary = expandDataTrafficPolicyFailOverDoc(v.([]interface{})) + } + if v, ok := tfMap["location"]; ok && len(v.(*schema.Set).List()) > 0 { + apiObject.Locations = expandDataTrafficPolicyLocationsDoc(v.(*schema.Set).List()) + } + if v, ok := tfMap["geo_proximity_location"]; ok && len(v.(*schema.Set).List()) > 0 { + apiObject.GeoProximityLocations = expandDataTrafficPolicyProximitiesDoc(v.(*schema.Set).List()) + } + if v, ok := tfMap["region"]; ok && len(v.(*schema.Set).List()) > 0 { + apiObject.Regions = expandDataTrafficPolicyRegionsDoc(v.(*schema.Set).List()) + } + if v, ok := tfMap["items"]; ok && len(v.(*schema.Set).List()) > 0 { + apiObject.Items = expandDataTrafficPolicyItemsDoc(v.(*schema.Set).List()) + } + + return apiObject +} + +func expandDataTrafficPolicyRulesDoc(tfList []interface{}) map[string]*TrafficPolicyRule { + if len(tfList) == 0 { + return nil + } + + apiObjects := make(map[string]*TrafficPolicyRule) + + for _, tfMapRaw := range tfList { + tfMap, ok := tfMapRaw.(map[string]interface{}) + + if !ok { + continue + } + + id := tfMap["id"].(string) + + apiObject := expandDataTrafficPolicyRuleDoc(tfMap) + + apiObjects[id] = apiObject + } + + return apiObjects +} + +func expandDataTrafficPolicyFailOverDoc(tfList []interface{}) *TrafficPolicyFailoverRule { + if len(tfList) == 0 { + return nil + } + + tfMap, _ := tfList[0].(map[string]interface{}) + + apiObject := &TrafficPolicyFailoverRule{} + + if v, ok := tfMap["endpoint_reference"]; ok && v.(string) != "" { + apiObject.EndpointReference = v.(string) + } + if v, ok := tfMap["rule_reference"]; ok && v.(string) != "" { + apiObject.RuleReference = v.(string) + } + if v, ok := tfMap["evaluate_target_health"]; ok && v.(bool) { + apiObject.EvaluateTargetHealth = aws.Bool(v.(bool)) + } + if v, ok := tfMap["health_check"]; ok && v.(string) != "" { + apiObject.HealthCheck = v.(string) + } + + return apiObject +} + +func expandDataTrafficPolicyLocationDoc(tfMap map[string]interface{}) *TrafficPolicyGeolocationRule { + if tfMap == nil { + return nil + } + + apiObject := &TrafficPolicyGeolocationRule{} + + if v, ok := tfMap["endpoint_reference"]; ok && v.(string) != "" { + apiObject.EndpointReference = v.(string) + } + if v, ok := tfMap["rule_reference"]; ok && v.(string) != "" { + apiObject.RuleReference = v.(string) + } + if v, ok := tfMap["is_default"]; ok && v.(bool) { + apiObject.IsDefault = aws.Bool(v.(bool)) + } + if v, ok := tfMap["continent"]; ok && v.(string) != "" { + apiObject.Continent = v.(string) + } + if v, ok := tfMap["country"]; ok && v.(string) != "" { + apiObject.Country = v.(string) + } + if v, ok := tfMap["subdivision"]; ok && v.(string) != "" { + apiObject.Subdivision = v.(string) + } + if v, ok := tfMap["evaluate_target_health"]; ok && v.(bool) { + apiObject.EvaluateTargetHealth = aws.Bool(v.(bool)) + } + if v, ok := tfMap["health_check"]; ok && v.(string) != "" { + apiObject.HealthCheck = v.(string) + } + + return apiObject +} + +func expandDataTrafficPolicyLocationsDoc(tfList []interface{}) []*TrafficPolicyGeolocationRule { + if len(tfList) == 0 { + return nil + } + + var apiObjects []*TrafficPolicyGeolocationRule + + for _, tfMapRaw := range tfList { + tfMap, ok := tfMapRaw.(map[string]interface{}) + + if !ok { + continue + } + + apiObject := expandDataTrafficPolicyLocationDoc(tfMap) + + apiObjects = append(apiObjects, apiObject) + } + + return apiObjects +} + +func expandDataTrafficPolicyProximityDoc(tfMap map[string]interface{}) *TrafficPolicyGeoproximityRule { + if tfMap == nil { + return nil + } + + apiObject := &TrafficPolicyGeoproximityRule{} + + if v, ok := tfMap["endpoint_reference"]; ok && v.(string) != "" { + apiObject.EndpointReference = v.(string) + } + if v, ok := tfMap["rule_reference"]; ok && v.(string) != "" { + apiObject.RuleReference = v.(string) + } + if v, ok := tfMap["region"]; ok && v.(string) != "" { + apiObject.Region = v.(string) + } + if v, ok := tfMap["latitude"]; ok && v.(string) != "" { + apiObject.Latitude = v.(string) + } + if v, ok := tfMap["longitude"]; ok && v.(string) != "" { + apiObject.Longitude = v.(string) + } + if v, ok := tfMap["bias"]; ok && v.(string) != "" { + apiObject.Bias = v.(string) + } + if v, ok := tfMap["evaluate_target_health"]; ok && v.(bool) { + apiObject.EvaluateTargetHealth = aws.Bool(v.(bool)) + } + if v, ok := tfMap["health_check"]; ok && v.(string) != "" { + apiObject.HealthCheck = v.(string) + } + + return apiObject +} + +func expandDataTrafficPolicyProximitiesDoc(tfList []interface{}) []*TrafficPolicyGeoproximityRule { + if len(tfList) == 0 { + return nil + } + + var apiObjects []*TrafficPolicyGeoproximityRule + + for _, tfMapRaw := range tfList { + tfMap, ok := tfMapRaw.(map[string]interface{}) + + if !ok { + continue + } + + apiObject := expandDataTrafficPolicyProximityDoc(tfMap) + + apiObjects = append(apiObjects, apiObject) + } + + return apiObjects +} + +func expandDataTrafficPolicyRegionDoc(tfMap map[string]interface{}) *TrafficPolicyLatencyRule { + if tfMap == nil { + return nil + } + + apiObject := &TrafficPolicyLatencyRule{} + + if v, ok := tfMap["endpoint_reference"]; ok && v.(string) != "" { + apiObject.EndpointReference = v.(string) + } + if v, ok := tfMap["rule_reference"]; ok && v.(string) != "" { + apiObject.RuleReference = v.(string) + } + if v, ok := tfMap["region"]; ok && v.(string) != "" { + apiObject.Region = v.(string) + } + if v, ok := tfMap["evaluate_target_health"]; ok && v.(bool) { + apiObject.EvaluateTargetHealth = aws.Bool(v.(bool)) + } + if v, ok := tfMap["health_check"]; ok && v.(string) != "" { + apiObject.HealthCheck = v.(string) + } + + return apiObject +} + +func expandDataTrafficPolicyRegionsDoc(tfList []interface{}) []*TrafficPolicyLatencyRule { + if len(tfList) == 0 { + return nil + } + + var apiObjects []*TrafficPolicyLatencyRule + + for _, tfMapRaw := range tfList { + tfMap, ok := tfMapRaw.(map[string]interface{}) + + if !ok { + continue + } + + apiObject := expandDataTrafficPolicyRegionDoc(tfMap) + + apiObjects = append(apiObjects, apiObject) + } + + return apiObjects +} + +func expandDataTrafficPolicyItemDoc(tfMap map[string]interface{}) *TrafficPolicyMultiValueAnswerRule { + if tfMap == nil { + return nil + } + + apiObject := &TrafficPolicyMultiValueAnswerRule{} + + if v, ok := tfMap["endpoint_reference"]; ok && v.(string) != "" { + apiObject.EndpointReference = v.(string) + } + if v, ok := tfMap["health_check"]; ok && v.(string) != "" { + apiObject.HealthCheck = v.(string) + } + + return apiObject +} + +func expandDataTrafficPolicyItemsDoc(tfList []interface{}) []*TrafficPolicyMultiValueAnswerRule { + if len(tfList) == 0 { + return nil + } + + var apiObjects []*TrafficPolicyMultiValueAnswerRule + + for _, tfMapRaw := range tfList { + tfMap, ok := tfMapRaw.(map[string]interface{}) + + if !ok { + continue + } + + apiObject := expandDataTrafficPolicyItemDoc(tfMap) + + apiObjects = append(apiObjects, apiObject) + } + + return apiObjects +} diff --git a/internal/service/route53/traffic_policy_document_data_source_test.go b/internal/service/route53/traffic_policy_document_data_source_test.go new file mode 100644 index 000000000000..ec691bb78117 --- /dev/null +++ b/internal/service/route53/traffic_policy_document_data_source_test.go @@ -0,0 +1,314 @@ +package route53_test + +import ( + "encoding/json" + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/aws/awsutil" + "github.com/aws/aws-sdk-go/service/route53" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" + "github.com/hashicorp/terraform-provider-aws/internal/acctest" + tfrouter53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" +) + +func TestAccDataSourceTrafficPolicyDocument_basic(t *testing.T) { + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyDocumentDataSourceConfig, + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicySameJSON("data.aws_route53_traffic_policy_document.test", + testAccTrafficPolicyDocumentConfigExpectedJSON()), + ), + }, + }, + }) +} + +func TestAccDataSourceTrafficPolicyDocument_complete(t *testing.T) { + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ProviderFactories: acctest.ProviderFactories, + ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), + Steps: []resource.TestStep{ + { + Config: testAccTrafficPolicyDocumentDataSourceConfigComplete, + Check: resource.ComposeTestCheckFunc( + testAccCheckTrafficPolicySameJSON("data.aws_route53_traffic_policy_document.test", + testAccTrafficPolicyDocumentConfigCompleteExpectedJSON()), + ), + }, + }, + }) +} + +func testAccCheckTrafficPolicySameJSON(resourceName, jsonExpected string) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("not found: %s", resourceName) + } + + var j, j2 tfrouter53.Route53TrafficPolicyDoc + if err := json.Unmarshal([]byte(rs.Primary.Attributes["json"]), &j); err != nil { + return fmt.Errorf("[ERROR] json.Unmarshal %v", err) + } + if err := json.Unmarshal([]byte(jsonExpected), &j2); err != nil { + return fmt.Errorf("[ERROR] json.Unmarshal %v", err) + } + // Marshall again so it can re order the json data because of arrays + jsonDoc, err := json.Marshal(j) + if err != nil { + return fmt.Errorf("[ERROR] json.marshal %v", err) + } + jsonDoc2, err := json.Marshal(j2) + if err != nil { + return fmt.Errorf("[ERROR] json.marshal %v", err) + } + if err = json.Unmarshal(jsonDoc, &j); err != nil { + return fmt.Errorf("[ERROR] json.Unmarshal %v", err) + } + if err = json.Unmarshal(jsonDoc2, &j); err != nil { + return fmt.Errorf("[ERROR] json.Unmarshal %v", err) + } + + if !awsutil.DeepEqual(&j, &j2) { + return fmt.Errorf("expected out to be %v, got %v", j, j2) + } + + return nil + } +} + +func testAccTrafficPolicyDocumentConfigCompleteExpectedJSON() string { + return fmt.Sprintf(`{ + "AWSPolicyFormatVersion":"2015-10-01", + "RecordType":"A", + "StartRule":"geo_restriction", + "Endpoints":{ + "east_coast_lb1":{ + "Type":"elastic-load-balancer", + "Value":"elb-111111.%[1]s.elb.amazonaws.com" + }, + "east_coast_lb2":{ + "Type":"elastic-load-balancer", + "Value":"elb-222222.%[1]s.elb.amazonaws.com" + }, + "west_coast_lb1":{ + "Type":"elastic-load-balancer", + "Value":"elb-111111.%[2]s.elb.amazonaws.com" + }, + "west_coast_lb2":{ + "Type":"elastic-load-balancer", + "Value":"elb-222222.%[2]s.elb.amazonaws.com" + }, + "denied_message":{ + "Type":"s3-website", + "Region":"%[1]s", + "Value":"video.example.com" + } + }, + "Rules":{ + "geo_restriction":{ + "RuleType":"geo", + "Locations":[ + { + "EndpointReference":"denied_message", + "IsDefault":true + }, + { + "RuleReference":"region_selector", + "Country":"US" + } + ] + }, + "region_selector":{ + "RuleType":"latency", + "Regions":[ + { + "Region":"%[1]s", + "RuleReference":"east_coast_region" + }, + { + "Region":"%[2]s", + "RuleReference":"west_coast_region" + } + ] + }, + "east_coast_region":{ + "RuleType":"failover", + "Primary":{ + "EndpointReference":"east_coast_lb1" + }, + "Secondary":{ + "EndpointReference":"east_coast_lb2" + } + }, + "west_coast_region":{ + "RuleType":"failover", + "Primary":{ + "EndpointReference":"west_coast_lb1" + }, + "Secondary":{ + "EndpointReference":"west_coast_lb2" + } + } + } +}`, acctest.Region(), acctest.AlternateRegion()) +} + +const testAccTrafficPolicyDocumentDataSourceConfig = ` +data "aws_region" "current" {} + +data "aws_route53_traffic_policy_document" "test" { + record_type = "A" + start_rule = "site_switch" + + endpoint { + id = "my_elb" + type = "elastic-load-balancer" + value = "elb-111111.${data.aws_region.current.name}.elb.amazonaws.com" + } + endpoint { + id = "site_down_banner" + type = "s3-website" + region = data.aws_region.current.name + value = "www.example.com" + } + + rule { + id = "site_switch" + type = "failover" + + primary { + endpoint_reference = "my_elb" + } + secondary { + endpoint_reference = "site_down_banner" + } + } +} +` + +const testAccTrafficPolicyDocumentDataSourceConfigComplete = ` +data "aws_availability_zones" "available" { + state = "available" +} + +data "aws_route53_traffic_policy_document" "test" { + version = "2015-10-01" + record_type = "A" + start_rule = "geo_restriction" + + endpoint { + id = "east_coast_lb1" + type = "elastic-load-balancer" + value = "elb-111111.${data.aws_availability_zones.available.names[0]}.elb.amazonaws.com" + } + endpoint { + id = "east_coast_lb2" + type = "elastic-load-balancer" + value = "elb-222222.${data.aws_availability_zones.available.names[0]}.elb.amazonaws.com" + } + endpoint { + id = "west_coast_lb1" + type = "elastic-load-balancer" + value = "elb-111111.${data.aws_availability_zones.available.names[1]}.elb.amazonaws.com" + } + endpoint { + id = "west_coast_lb2" + type = "elastic-load-balancer" + value = "elb-222222.${data.aws_availability_zones.available.names[1]}.elb.amazonaws.com" + } + endpoint { + id = "denied_message" + type = "s3-website" + region = data.aws_availability_zones.available.names[0] + value = "video.example.com" + } + + rule { + id = "geo_restriction" + type = "geo" + + location { + endpoint_reference = "denied_message" + is_default = true + } + location { + rule_reference = "region_selector" + country = "US" + } + } + rule { + id = "region_selector" + type = "latency" + + region { + region = data.aws_availability_zones.available.names[0] + rule_reference = "east_coast_region" + } + region { + region = data.aws_availability_zones.available.names[1] + rule_reference = "west_coast_region" + } + } + rule { + id = "east_coast_region" + type = "failover" + + primary { + endpoint_reference = "east_coast_lb1" + } + secondary { + endpoint_reference = "east_coast_lb2" + } + } + rule { + id = "west_coast_region" + type = "failover" + + primary { + endpoint_reference = "west_coast_lb1" + } + secondary { + endpoint_reference = "west_coast_lb2" + } + } +} +` + +func testAccTrafficPolicyDocumentConfigExpectedJSON() string { + return fmt.Sprintf(`{ + "AWSPolicyFormatVersion":"2015-10-01", + "RecordType":"A", + "StartRule":"site_switch", + "Endpoints":{ + "my_elb":{ + "Type":"elastic-load-balancer", + "Value":"elb-111111.%[1]s.elb.amazonaws.com" + }, + "site_down_banner":{ + "Type":"s3-website", + "Region":"%[1]s", + "Value":"www.example.com" + } + }, + "Rules":{ + "site_switch":{ + "RuleType":"failover", + "Primary":{ + "EndpointReference":"my_elb" + }, + "Secondary":{ + "EndpointReference":"site_down_banner" + } + } + } +}`, acctest.Region()) +} diff --git a/internal/service/route53/traffic_policy_document_model.go b/internal/service/route53/traffic_policy_document_model.go new file mode 100644 index 000000000000..386867f2033d --- /dev/null +++ b/internal/service/route53/traffic_policy_document_model.go @@ -0,0 +1,85 @@ +package route53 + +const ( + Route53TrafficPolicyDocEndpointValue = "value" + Route53TrafficPolicyDocEndpointCloudfront = "cloudfront" + Route53TrafficPolicyDocEndpointElastic = "elastic-load-balancer" + Route53TrafficPolicyDocEndpointS3 = "s3-website" +) + +// Route53TrafficPolicyDocEndpointType_Values returns all elements of the endpoints types +func Route53TrafficPolicyDocEndpointType_Values() []string { + return []string{ + Route53TrafficPolicyDocEndpointValue, + Route53TrafficPolicyDocEndpointCloudfront, + Route53TrafficPolicyDocEndpointElastic, + Route53TrafficPolicyDocEndpointS3, + } +} + +type Route53TrafficPolicyDoc struct { + AWSPolicyFormatVersion string `json:",omitempty"` + RecordType string `json:",omitempty"` + StartEndpoint string `json:",omitempty"` + StartRule string `json:",omitempty"` + Endpoints map[string]*TrafficPolicyEndpoint `json:",omitempty"` + Rules map[string]*TrafficPolicyRule `json:",omitempty"` +} + +type TrafficPolicyEndpoint struct { + Type string `json:",omitempty"` + Region string `json:",omitempty"` + Value string `json:",omitempty"` +} + +type TrafficPolicyRule struct { + RuleType string `json:",omitempty"` + Primary *TrafficPolicyFailoverRule `json:",omitempty"` + Secondary *TrafficPolicyFailoverRule `json:",omitempty"` + Locations []*TrafficPolicyGeolocationRule `json:",omitempty"` + GeoProximityLocations []*TrafficPolicyGeoproximityRule `json:",omitempty"` + Regions []*TrafficPolicyLatencyRule `json:",omitempty"` + Items []*TrafficPolicyMultiValueAnswerRule `json:",omitempty"` +} + +type TrafficPolicyFailoverRule struct { + EndpointReference string `json:",omitempty"` + RuleReference string `json:",omitempty"` + EvaluateTargetHealth *bool `json:",omitempty"` + HealthCheck string `json:",omitempty"` +} + +type TrafficPolicyGeolocationRule struct { + EndpointReference string `json:",omitempty"` + RuleReference string `json:",omitempty"` + IsDefault *bool `json:",omitempty"` + Continent string `json:",omitempty"` + Country string `json:",omitempty"` + Subdivision string `json:",omitempty"` + EvaluateTargetHealth *bool `json:",omitempty"` + HealthCheck string `json:",omitempty"` +} + +type TrafficPolicyGeoproximityRule struct { + EndpointReference string `json:",omitempty"` + RuleReference string `json:",omitempty"` + Region string `json:",omitempty"` + Latitude string `json:",omitempty"` + Longitude string `json:",omitempty"` + Bias string `json:",omitempty"` + EvaluateTargetHealth *bool `json:",omitempty"` + HealthCheck string `json:",omitempty"` +} + +type TrafficPolicyLatencyRule struct { + EndpointReference string `json:",omitempty"` + RuleReference string `json:",omitempty"` + Region string `json:",omitempty"` + EvaluateTargetHealth *bool `json:",omitempty"` + HealthCheck string `json:",omitempty"` +} + +type TrafficPolicyMultiValueAnswerRule struct { + EndpointReference string `json:",omitempty"` + HealthCheck string `json:",omitempty"` +} diff --git a/website/docs/d/route53_traffic_policy.html.markdown b/website/docs/d/route53_traffic_policy.html.markdown deleted file mode 100644 index 43fdae05843a..000000000000 --- a/website/docs/d/route53_traffic_policy.html.markdown +++ /dev/null @@ -1,58 +0,0 @@ ---- -subcategory: "Route53" -layout: "aws" -page_title: "AWS: aws_route53_zone" -description: |- - Provides details about a specific Route 53 Hosted Zone ---- - -# Data Source: aws_route53_zone - -`aws_route53_zone` provides details about a specific Route 53 Hosted Zone. - -This data source allows to find a Hosted Zone ID given Hosted Zone name and certain search criteria. - -## Example Usage - -The following example shows how to get a Hosted Zone from its name and from this data how to create a Record Set. - - -```terraform -resource "aws_route53_traffic_policy" "example" { - name = "example" - comment = "example comment" - document = < Date: Mon, 21 Mar 2022 12:02:46 -0400 Subject: [PATCH 17/40] Revert "resource/aws_route53_traffic_policy_instance: new resource" This reverts commit a6293a241e026c5b0a92b42daa29541133851a85. --- aws/provider.go | 1 - ...rce_aws_route53_traffic_policy_instance.go | 152 ------------------ ...ws_route53_traffic_policy_instance_test.go | 1 - ...te53_traffic_policy_instance.html.markdown | 47 ------ 4 files changed, 201 deletions(-) delete mode 100644 aws/resource_aws_route53_traffic_policy_instance.go delete mode 100644 aws/resource_aws_route53_traffic_policy_instance_test.go delete mode 100644 website/docs/r/route53_traffic_policy_instance.html.markdown diff --git a/aws/provider.go b/aws/provider.go index 2dc54709eaa8..34e5c2925841 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -776,7 +776,6 @@ func Provider() *schema.Provider { "aws_route53_resolver_endpoint": resourceAwsRoute53ResolverEndpoint(), "aws_route53_resolver_rule_association": resourceAwsRoute53ResolverRuleAssociation(), "aws_route53_resolver_rule": resourceAwsRoute53ResolverRule(), - "aws_route53_traffic_policy_instance": resourceAwsRoute53TrafficPolicyInstance(), "aws_route": resourceAwsRoute(), "aws_route_table": resourceAwsRouteTable(), "aws_default_route_table": resourceAwsDefaultRouteTable(), diff --git a/aws/resource_aws_route53_traffic_policy_instance.go b/aws/resource_aws_route53_traffic_policy_instance.go deleted file mode 100644 index 5cc3e488a690..000000000000 --- a/aws/resource_aws_route53_traffic_policy_instance.go +++ /dev/null @@ -1,152 +0,0 @@ -package aws - -import ( - "fmt" - "strings" - - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/route53" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" -) - -func resourceAwsRoute53TrafficPolicyInstance() *schema.Resource { - return &schema.Resource{ - Create: resourceAwsRoute53TrafficPolicyInstanceCreate, - Read: resourceAwsRoute53TrafficPolicyInstanceRead, - Update: resourceAwsRoute53TrafficPolicyInstanceUpdate, - Delete: resourceAwsRoute53TrafficPolicyInstanceDelete, - Importer: &schema.ResourceImporter{ - State: schema.ImportStatePassthrough, - }, - - Schema: map[string]*schema.Schema{ - "hosted_zone_id": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringLenBetween(1, 32), - }, - "name": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringLenBetween(1, 1024), - StateFunc: func(v interface{}) string { - value := strings.TrimSuffix(v.(string), ".") - return strings.ToLower(value) - }, - }, - "traffic_policy_id": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringLenBetween(1, 36), - }, - "traffic_policy_version": { - Type: schema.TypeInt, - Required: true, - ValidateFunc: validation.IntAtMost(1000), - }, - "ttl": { - Type: schema.TypeInt, - Optional: true, - ValidateFunc: validation.IntAtMost(2147483647), - }, - }, - } -} - -func resourceAwsRoute53TrafficPolicyInstanceCreate(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - request := &route53.CreateTrafficPolicyInstanceInput{ - HostedZoneId: aws.String(d.Get("hosted_zone_id").(string)), - Name: aws.String(d.Get("name").(string)), - TrafficPolicyId: aws.String(d.Get("traffic_policy_id").(string)), - TrafficPolicyVersion: aws.Int64(int64(d.Get("traffic_policy_version").(int))), - TTL: aws.Int64(int64(d.Get("ttl").(int))), - } - - response, err := conn.CreateTrafficPolicyInstance(request) - if err != nil { - return fmt.Errorf("Error creating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) - } - - d.SetId(*response.TrafficPolicyInstance.Id) - - return resourceAwsRoute53TrafficPolicyInstanceRead(d, meta) -} - -func resourceAwsRoute53TrafficPolicyInstanceRead(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - request := &route53.GetTrafficPolicyInstanceInput{ - Id: aws.String(d.Id()), - } - - response, err := conn.GetTrafficPolicyInstance(request) - if err != nil { - return fmt.Errorf("Error reading Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) - } - - err = d.Set("name", strings.TrimSuffix(*response.TrafficPolicyInstance.Name, ".")) - if err != nil { - return fmt.Errorf("Error setting name for: %s, error: %#v", d.Id(), err) - } - - err = d.Set("hosted_zone_id", response.TrafficPolicyInstance.HostedZoneId) - if err != nil { - return fmt.Errorf("Error setting hosted_zone_id for: %s, error: %#v", d.Id(), err) - } - - err = d.Set("traffic_policy_id", response.TrafficPolicyInstance.TrafficPolicyId) - if err != nil { - return fmt.Errorf("Error setting traffic_policy_id for: %s, error: %#v", d.Id(), err) - } - - err = d.Set("traffic_policy_version", response.TrafficPolicyInstance.TrafficPolicyVersion) - if err != nil { - return fmt.Errorf("Error setting traffic_policy_version for: %s, error: %#v", d.Id(), err) - } - - err = d.Set("ttl", response.TrafficPolicyInstance.TTL) - if err != nil { - return fmt.Errorf("Error setting ttl for: %s, error: %#v", d.Id(), err) - } - - return nil -} - -func resourceAwsRoute53TrafficPolicyInstanceUpdate(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - request := &route53.UpdateTrafficPolicyInstanceInput{ - Id: aws.String(d.Id()), - TrafficPolicyId: aws.String(d.Get("traffic_policy_id").(string)), - TrafficPolicyVersion: aws.Int64(int64(d.Get("traffic_policy_version").(int))), - TTL: aws.Int64(int64(d.Get("ttl").(int))), - } - - _, err := conn.UpdateTrafficPolicyInstance(request) - if err != nil { - return fmt.Errorf("Error updating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) - } - - return resourceAwsRoute53TrafficPolicyInstanceRead(d, meta) -} - -func resourceAwsRoute53TrafficPolicyInstanceDelete(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - request := &route53.DeleteTrafficPolicyInstanceInput{ - Id: aws.String(d.Id()), - } - - _, err := conn.DeleteTrafficPolicyInstance(request) - if err != nil { - return fmt.Errorf("Error deleting Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) - } - - return nil -} diff --git a/aws/resource_aws_route53_traffic_policy_instance_test.go b/aws/resource_aws_route53_traffic_policy_instance_test.go deleted file mode 100644 index a1f9c0e3beb4..000000000000 --- a/aws/resource_aws_route53_traffic_policy_instance_test.go +++ /dev/null @@ -1 +0,0 @@ -package aws diff --git a/website/docs/r/route53_traffic_policy_instance.html.markdown b/website/docs/r/route53_traffic_policy_instance.html.markdown deleted file mode 100644 index 52c4e488db37..000000000000 --- a/website/docs/r/route53_traffic_policy_instance.html.markdown +++ /dev/null @@ -1,47 +0,0 @@ ---- -subcategory: "Route53" -layout: "aws" -page_title: "AWS: aws_route53_traffic_policy_instance" -description: |- - Provides a Route53 traffic policy instance resource. ---- - -# Resource: aws_route53_traffic_policy_instance - -Provides a Route53 traffic policy instance resource. - -## Example Usage - -```hcl -resource "aws_route53_traffic_policy_instance" "test" { - name = "test.example.com" - traffic_policy_id = "b3gb108f-ea6f-45a5-baab-9d112d8b4037" - traffic_policy_version = 1 - hosted_zone_id = "Z033120931TAQO548OGJC" - ttl = 360 -} -``` - -## Argument Reference - -The following arguments are supported: - -* `name` - (Required) The domain name for which Amazon Route 53 responds to DNS queries by using the resource record sets that Route 53 creates for this traffic policy instance. -* `traffic_policy_id` - (Required) The ID of the traffic policy that you want to use to create resource record sets in the specified hosted zone. -* `traffic_policy_version` - (Required) The version of the traffic policy -* `hosted_zone_id` - (Required) The ID of the hosted zone -* `ttl` - (Optional) The TTL that you want Amazon Route 53 to assign to all of the resource record sets that it creates in the specified hosted zone. - -## Attributes Reference - -In addition to all arguments above, the following attributes are exported: - -* `id` - Id of created traffic policy instance. - -## Import - -Route53 traffic policy instance can be imported using its id. - -``` -$ terraform import aws_route53_traffic_policy_instance.test df579d9a-6396-410e-ac22-e7ad60cf9e7e -``` From 25f54c241bbab6588ae38322f12277f62db2c471 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Mon, 21 Mar 2022 12:03:59 -0400 Subject: [PATCH 18/40] Revert "Switch to terraform-plugin-sdk v2" This reverts commit 11a3018559af60331fe8aed60a744efa08aea117. --- aws/resource_aws_route53_traffic_policy.go | 4 ++-- aws/resource_aws_route53_traffic_policy_test.go | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go index f2dd01101850..2d7d8cb53391 100644 --- a/aws/resource_aws_route53_traffic_policy.go +++ b/aws/resource_aws_route53_traffic_policy.go @@ -6,8 +6,8 @@ import ( "strconv" "strings" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/helper/validation" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/route53" diff --git a/aws/resource_aws_route53_traffic_policy_test.go b/aws/resource_aws_route53_traffic_policy_test.go index 45ba8a32934d..6b55e7d5e225 100644 --- a/aws/resource_aws_route53_traffic_policy_test.go +++ b/aws/resource_aws_route53_traffic_policy_test.go @@ -4,10 +4,10 @@ import ( "fmt" "testing" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" + "github.com/hashicorp/terraform-plugin-sdk/helper/acctest" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/terraform" ) func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { From db9e305800085ccfdf7d2a6dff240f66228614bd Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Mon, 21 Mar 2022 12:04:09 -0400 Subject: [PATCH 19/40] Revert "Add import testing" This reverts commit c79230c7a4c63a67db780ac5b1b11fa56f33d731. --- ...esource_aws_route53_traffic_policy_test.go | 30 ++++--------------- 1 file changed, 6 insertions(+), 24 deletions(-) diff --git a/aws/resource_aws_route53_traffic_policy_test.go b/aws/resource_aws_route53_traffic_policy_test.go index 6b55e7d5e225..a4f01b409faf 100644 --- a/aws/resource_aws_route53_traffic_policy_test.go +++ b/aws/resource_aws_route53_traffic_policy_test.go @@ -12,8 +12,7 @@ import ( func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { policyName := fmt.Sprintf("policy-%s", acctest.RandString(8)) - resourceName := "test" - fullResourceName := fmt.Sprintf("aws_route53_traffic_policy.%s", resourceName) + resourceName := "aws_route53_traffic_policy.test" resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, @@ -21,29 +20,23 @@ func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, Steps: []resource.TestStep{ { - Config: testAccRoute53TrafficPolicyConfig(resourceName, policyName), + Config: testAccRoute53TrafficPolicyConfig(policyName), Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr(fullResourceName, "latest_version", "1"), + resource.TestCheckResourceAttr(resourceName, "latest_version", "1"), ), }, - { - ImportState: true, - ImportStateVerify: true, - ImportStateIdFunc: testAccAWSRoute53TrafficPolicyImportStateIdFunc(fullResourceName), - ResourceName: fullResourceName, - }, }, }) } -func testAccRoute53TrafficPolicyConfig(resourceName, policyName string) string { +func testAccRoute53TrafficPolicyConfig(name string) string { return fmt.Sprintf(` -resource "aws_route53_traffic_policy" "%s" { +resource "aws_route53_traffic_policy" "test" { name = "%s" comment = "comment" document = "{\"AWSPolicyFormatVersion\":\"2015-10-01\",\"RecordType\":\"A\",\"Endpoints\":{\"endpoint-start-NkPh\":{\"Type\":\"value\",\"Value\":\"10.0.0.1\"}},\"StartEndpoint\":\"endpoint-start-NkPh\"}" } -`, resourceName, policyName) +`, name) } func testAccCheckRoute53TrafficPolicyDestroy(s *terraform.State) error { @@ -66,14 +59,3 @@ func testAccCheckRoute53TrafficPolicyDestroyWithProvider(s *terraform.State, pro } return nil } - -func testAccAWSRoute53TrafficPolicyImportStateIdFunc(resourceName string) resource.ImportStateIdFunc { - return func(s *terraform.State) (string, error) { - rs, ok := s.RootModule().Resources[resourceName] - if !ok { - return "", fmt.Errorf("Not found: %s", resourceName) - } - - return fmt.Sprintf("%s/%s", rs.Primary.Attributes["id"], rs.Primary.Attributes["latest_version"]), nil - } -} From 296d99aae8c28822146654853350778b6477703b Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Mon, 21 Mar 2022 12:04:18 -0400 Subject: [PATCH 20/40] Revert "Add read at the end of update func" This reverts commit be4171fe8bd5cd144bdaebfd32b56b7ee2a716ef. --- aws/resource_aws_route53_traffic_policy.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go index 2d7d8cb53391..1eac981a60ca 100644 --- a/aws/resource_aws_route53_traffic_policy.go +++ b/aws/resource_aws_route53_traffic_policy.go @@ -176,7 +176,7 @@ func resourceAwsRoute53TrafficPolicyUpdate(d *schema.ResourceData, meta interfac return fmt.Errorf("Error updating Route53 Traffic Policy %s and setting new policy version. %#v", d.Get("name").(string), err) } - return resourceAwsRoute53TrafficPolicyRead(d, meta) + return nil } func resourceAwsRoute53TrafficPolicyDelete(d *schema.ResourceData, meta interface{}) error { From 71269734f0208848998b768c9165a3681988b9c7 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Mon, 21 Mar 2022 12:04:26 -0400 Subject: [PATCH 21/40] Revert "resource/aws_route53_traffic_policy: new resource" This reverts commit d43efaad0ebec440c49ed36d355e8d7639a94996. --- aws/resource_aws_route53_traffic_policy.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go index 1eac981a60ca..5768d1ae20fe 100644 --- a/aws/resource_aws_route53_traffic_policy.go +++ b/aws/resource_aws_route53_traffic_policy.go @@ -77,7 +77,7 @@ func resourceAwsRoute53TrafficPolicyCreate(d *schema.ResourceData, meta interfac d.SetId(*response.TrafficPolicy.Id) - err = d.Set("latest_version", response.TrafficPolicy.Version) + err = d.Set("latest_version", *response.TrafficPolicy.Version) if err != nil { return fmt.Errorf("Error assigning Id for Route53 Traffic Policy %s: %s", d.Get("name").(string), err) } @@ -109,17 +109,17 @@ func resourceAwsRoute53TrafficPolicyRead(d *schema.ResourceData, meta interface{ return fmt.Errorf("Error getting Route53 Traffic Policy %s, version %d: %s", d.Get("name").(string), d.Get("latest_version").(int), err) } - err = d.Set("document", response.TrafficPolicy.Document) + err = d.Set("document", *response.TrafficPolicy.Document) if err != nil { return fmt.Errorf("Error setting document for: %s, error: %#v", d.Id(), err) } - err = d.Set("name", response.TrafficPolicy.Name) + err = d.Set("name", *response.TrafficPolicy.Name) if err != nil { return fmt.Errorf("Error setting name for: %s, error: %#v", d.Id(), err) } - err = d.Set("comment", response.TrafficPolicy.Comment) + err = d.Set("comment", *response.TrafficPolicy.Comment) if err != nil { return fmt.Errorf("Error setting comment for: %s, error: %#v", d.Id(), err) } @@ -171,7 +171,7 @@ func resourceAwsRoute53TrafficPolicyUpdate(d *schema.ResourceData, meta interfac return fmt.Errorf("Error updating Route53 Traffic Policy: %s. %#v", d.Get("name").(string), err) } - err = d.Set("latest_version", response.TrafficPolicy.Version) + err = d.Set("latest_version", *response.TrafficPolicy.Version) if err != nil { return fmt.Errorf("Error updating Route53 Traffic Policy %s and setting new policy version. %#v", d.Get("name").(string), err) } From cd224363c20a1b81f346ea5f163b4a3c7374e787 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Mon, 21 Mar 2022 12:04:35 -0400 Subject: [PATCH 22/40] Revert "resource/aws_route53_traffic_policy: new resource" This reverts commit 935a604b82a46e8ea3b673e3746fcd6c2fb548d8. --- aws/provider.go | 1 - aws/resource_aws_route53_traffic_policy.go | 224 ------------------ ...esource_aws_route53_traffic_policy_test.go | 61 ----- .../r/route53_traffic_policy.html.markdown | 57 ----- 4 files changed, 343 deletions(-) delete mode 100644 aws/resource_aws_route53_traffic_policy.go delete mode 100644 aws/resource_aws_route53_traffic_policy_test.go delete mode 100644 website/docs/r/route53_traffic_policy.html.markdown diff --git a/aws/provider.go b/aws/provider.go index fe842b9e1ae6..34e5c2925841 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -776,7 +776,6 @@ func Provider() *schema.Provider { "aws_route53_resolver_endpoint": resourceAwsRoute53ResolverEndpoint(), "aws_route53_resolver_rule_association": resourceAwsRoute53ResolverRuleAssociation(), "aws_route53_resolver_rule": resourceAwsRoute53ResolverRule(), - "aws_route53_traffic_policy": resourceAwsRoute53TrafficPolicy(), "aws_route": resourceAwsRoute(), "aws_route_table": resourceAwsRouteTable(), "aws_default_route_table": resourceAwsDefaultRouteTable(), diff --git a/aws/resource_aws_route53_traffic_policy.go b/aws/resource_aws_route53_traffic_policy.go deleted file mode 100644 index 5768d1ae20fe..000000000000 --- a/aws/resource_aws_route53_traffic_policy.go +++ /dev/null @@ -1,224 +0,0 @@ -package aws - -import ( - "fmt" - "log" - "strconv" - "strings" - - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/helper/validation" - - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/route53" -) - -func resourceAwsRoute53TrafficPolicy() *schema.Resource { - return &schema.Resource{ - Create: resourceAwsRoute53TrafficPolicyCreate, - Read: resourceAwsRoute53TrafficPolicyRead, - Update: resourceAwsRoute53TrafficPolicyUpdate, - Delete: resourceAwsRoute53TrafficPolicyDelete, - Importer: &schema.ResourceImporter{ - State: func(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { - idParts := strings.Split(d.Id(), "/") - if len(idParts) != 2 || idParts[0] == "" || idParts[1] == "" { - return nil, fmt.Errorf("Unexpected format of ID (%q), expected traffic-policy-id/traffic-policy-version", d.Id()) - } - version, err := strconv.Atoi(idParts[1]) - if err != nil { - return nil, fmt.Errorf("Cannot convert to int: %s", idParts[1]) - } - d.Set("latest_version", version) - d.SetId(idParts[0]) - - return []*schema.ResourceData{d}, nil - }, - }, - - Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringLenBetween(1, 512), - }, - "comment": { - Type: schema.TypeString, - Optional: true, - ValidateFunc: validation.StringLenBetween(0, 1024), - }, - "document": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringLenBetween(0, 102400), - }, - "latest_version": { - Type: schema.TypeInt, - Computed: true, - }, - }, - } -} - -func resourceAwsRoute53TrafficPolicyCreate(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - request := &route53.CreateTrafficPolicyInput{ - Name: aws.String(d.Get("name").(string)), - Comment: aws.String(d.Get("comment").(string)), - Document: aws.String(d.Get("document").(string)), - } - - response, err := conn.CreateTrafficPolicy(request) - if err != nil { - return fmt.Errorf("Error creating Route53 Traffic Policy %s: %s", d.Get("name").(string), err) - } - - d.SetId(*response.TrafficPolicy.Id) - - err = d.Set("latest_version", *response.TrafficPolicy.Version) - if err != nil { - return fmt.Errorf("Error assigning Id for Route53 Traffic Policy %s: %s", d.Get("name").(string), err) - } - - return resourceAwsRoute53TrafficPolicyRead(d, meta) -} - -func resourceAwsRoute53TrafficPolicyRead(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - tp, err := getTrafficPolicyById(d.Id(), conn) - if err != nil { - return err - } - - if tp == nil { - log.Printf("[WARN] Route53 Traffic Policy (%s) not found, removing from state", d.Id()) - d.SetId("") - return nil - } - - request := &route53.GetTrafficPolicyInput{ - Id: tp.Id, - Version: tp.LatestVersion, - } - - response, err := conn.GetTrafficPolicy(request) - if err != nil { - return fmt.Errorf("Error getting Route53 Traffic Policy %s, version %d: %s", d.Get("name").(string), d.Get("latest_version").(int), err) - } - - err = d.Set("document", *response.TrafficPolicy.Document) - if err != nil { - return fmt.Errorf("Error setting document for: %s, error: %#v", d.Id(), err) - } - - err = d.Set("name", *response.TrafficPolicy.Name) - if err != nil { - return fmt.Errorf("Error setting name for: %s, error: %#v", d.Id(), err) - } - - err = d.Set("comment", *response.TrafficPolicy.Comment) - if err != nil { - return fmt.Errorf("Error setting comment for: %s, error: %#v", d.Id(), err) - } - - return nil -} - -func getTrafficPolicyById(trafficPolicyId string, conn *route53.Route53) (*route53.TrafficPolicySummary, error) { - var idMarker *string - - for allPoliciesListed := false; !allPoliciesListed; { - listRequest := &route53.ListTrafficPoliciesInput{} - - if idMarker != nil { - listRequest.TrafficPolicyIdMarker = idMarker - } - - listResponse, err := conn.ListTrafficPolicies(listRequest) - if err != nil { - return nil, fmt.Errorf("Error listing Route 53 Traffic Policies: %v", err) - } - - for _, tp := range listResponse.TrafficPolicySummaries { - if *tp.Id == trafficPolicyId { - return tp, nil - } - } - - if *listResponse.IsTruncated { - idMarker = listResponse.TrafficPolicyIdMarker - } else { - allPoliciesListed = true - } - } - return nil, nil -} - -func resourceAwsRoute53TrafficPolicyUpdate(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - request := &route53.CreateTrafficPolicyVersionInput{ - Id: aws.String(d.Id()), - Comment: aws.String(d.Get("comment").(string)), - Document: aws.String(d.Get("document").(string)), - } - - response, err := conn.CreateTrafficPolicyVersion(request) - if err != nil { - return fmt.Errorf("Error updating Route53 Traffic Policy: %s. %#v", d.Get("name").(string), err) - } - - err = d.Set("latest_version", *response.TrafficPolicy.Version) - if err != nil { - return fmt.Errorf("Error updating Route53 Traffic Policy %s and setting new policy version. %#v", d.Get("name").(string), err) - } - - return nil -} - -func resourceAwsRoute53TrafficPolicyDelete(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).r53conn - - var versionMarker *string - - var trafficPolicies []*route53.TrafficPolicy - - for allPoliciesListed := false; !allPoliciesListed; { - listRequest := &route53.ListTrafficPolicyVersionsInput{ - Id: aws.String(d.Id()), - } - if versionMarker != nil { - listRequest.TrafficPolicyVersionMarker = versionMarker - } - - listResponse, err := conn.ListTrafficPolicyVersions(listRequest) - if err != nil { - return fmt.Errorf("Error listing Route 53 Traffic Policy versions: %v", err) - } - - trafficPolicies = append(trafficPolicies, listResponse.TrafficPolicies...) - - if *listResponse.IsTruncated { - versionMarker = listResponse.TrafficPolicyVersionMarker - } else { - allPoliciesListed = true - } - } - - for _, trafficPolicy := range trafficPolicies { - deleteRequest := &route53.DeleteTrafficPolicyInput{ - Id: trafficPolicy.Id, - Version: trafficPolicy.Version, - } - - _, err := conn.DeleteTrafficPolicy(deleteRequest) - if err != nil { - return fmt.Errorf("Error deleting Route53 Traffic Policy %s, version %d: %s", *trafficPolicy.Id, *trafficPolicy.Version, err) - } - } - - return nil -} diff --git a/aws/resource_aws_route53_traffic_policy_test.go b/aws/resource_aws_route53_traffic_policy_test.go deleted file mode 100644 index a4f01b409faf..000000000000 --- a/aws/resource_aws_route53_traffic_policy_test.go +++ /dev/null @@ -1,61 +0,0 @@ -package aws - -import ( - "fmt" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/helper/resource" - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/terraform" -) - -func TestAccAWSRoute53TrafficPolicy_basic(t *testing.T) { - policyName := fmt.Sprintf("policy-%s", acctest.RandString(8)) - resourceName := "aws_route53_traffic_policy.test" - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, - Steps: []resource.TestStep{ - { - Config: testAccRoute53TrafficPolicyConfig(policyName), - Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr(resourceName, "latest_version", "1"), - ), - }, - }, - }) -} - -func testAccRoute53TrafficPolicyConfig(name string) string { - return fmt.Sprintf(` -resource "aws_route53_traffic_policy" "test" { - name = "%s" - comment = "comment" - document = "{\"AWSPolicyFormatVersion\":\"2015-10-01\",\"RecordType\":\"A\",\"Endpoints\":{\"endpoint-start-NkPh\":{\"Type\":\"value\",\"Value\":\"10.0.0.1\"}},\"StartEndpoint\":\"endpoint-start-NkPh\"}" -} -`, name) -} - -func testAccCheckRoute53TrafficPolicyDestroy(s *terraform.State) error { - return testAccCheckRoute53TrafficPolicyDestroyWithProvider(s, testAccProvider) -} - -func testAccCheckRoute53TrafficPolicyDestroyWithProvider(s *terraform.State, provider *schema.Provider) error { - conn := provider.Meta().(*AWSClient).r53conn - for _, rs := range s.RootModule().Resources { - if rs.Type != "aws_route53_traffic_policy" { - continue - } - tp, err := getTrafficPolicyById(rs.Primary.ID, conn) - if err != nil { - return fmt.Errorf("Error during check if traffic policy still exists, %#v", err) - } - if tp != nil { - return fmt.Errorf("Traffic Policy still exists") - } - } - return nil -} diff --git a/website/docs/r/route53_traffic_policy.html.markdown b/website/docs/r/route53_traffic_policy.html.markdown deleted file mode 100644 index 39e3cf85324a..000000000000 --- a/website/docs/r/route53_traffic_policy.html.markdown +++ /dev/null @@ -1,57 +0,0 @@ ---- -subcategory: "Route53" -layout: "aws" -page_title: "AWS: aws_route53_traffic_policy" -description: |- - Manages a Route53 Traffic Policy ---- - -# Resource: aws_route53_traffic_policy - -Manages a Route53 Traffic Policy. - -## Example Usage - -```hcl -resource "aws_route53_traffic_policy" "example" { - name = "example" - comment = "example comment" - document = < Date: Mon, 21 Mar 2022 16:47:08 -0400 Subject: [PATCH 23/40] Data source in alphabetical order. --- internal/provider/provider.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/provider/provider.go b/internal/provider/provider.go index c852a2592af8..26d625845c95 100644 --- a/internal/provider/provider.go +++ b/internal/provider/provider.go @@ -755,8 +755,8 @@ func Provider() *schema.Provider { "aws_resourcegroupstaggingapi_resources": resourcegroupstaggingapi.DataSourceResources(), "aws_route53_delegation_set": route53.DataSourceDelegationSet(), - "aws_route53_zone": route53.DataSourceZone(), "aws_route53_traffic_policy_document": route53.DataSourceTrafficPolicyDocument(), + "aws_route53_zone": route53.DataSourceZone(), "aws_route53_resolver_endpoint": route53resolver.DataSourceEndpoint(), "aws_route53_resolver_rule": route53resolver.DataSourceRule(), From 44f4c83fd92da81d548f83841fe235458679b817 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Mon, 21 Mar 2022 17:09:59 -0400 Subject: [PATCH 24/40] Generate list paginators. --- internal/service/route53/generate.go | 1 + internal/service/route53/list_pages_gen.go | 31 ++++++++++++++++++++++ 2 files changed, 32 insertions(+) create mode 100644 internal/service/route53/list_pages_gen.go diff --git a/internal/service/route53/generate.go b/internal/service/route53/generate.go index b7f24e00eb57..b82cf667b679 100644 --- a/internal/service/route53/generate.go +++ b/internal/service/route53/generate.go @@ -1,3 +1,4 @@ +//go:generate go run ../../generate/listpages/main.go -ListOps=ListTrafficPolicies -Paginator=TrafficPolicyIdMarker //go:generate go run ../../generate/tags/main.go -ListTags -ListTagsInIDElem=ResourceId -ListTagsOutTagsElem=ResourceTagSet.Tags -ServiceTagsSlice -TagOp=ChangeTagsForResource -TagInIDElem=ResourceId -TagInTagsElem=AddTags -TagResTypeElem=ResourceType -UntagOp=ChangeTagsForResource -UntagInTagsElem=RemoveTagKeys -UpdateTags // ONLY generate directives and package declaration! Do not add anything else to this file. diff --git a/internal/service/route53/list_pages_gen.go b/internal/service/route53/list_pages_gen.go new file mode 100644 index 000000000000..ef50f79f21c9 --- /dev/null +++ b/internal/service/route53/list_pages_gen.go @@ -0,0 +1,31 @@ +// Code generated by "internal/generate/listpages/main.go -ListOps=ListTrafficPolicies -Paginator=TrafficPolicyIdMarker"; DO NOT EDIT. + +package route53 + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" +) + +func listTrafficPoliciesPages(conn *route53.Route53, input *route53.ListTrafficPoliciesInput, fn func(*route53.ListTrafficPoliciesOutput, bool) bool) error { + return listTrafficPoliciesPagesWithContext(context.Background(), conn, input, fn) +} + +func listTrafficPoliciesPagesWithContext(ctx context.Context, conn *route53.Route53, input *route53.ListTrafficPoliciesInput, fn func(*route53.ListTrafficPoliciesOutput, bool) bool) error { + for { + output, err := conn.ListTrafficPoliciesWithContext(ctx, input) + if err != nil { + return err + } + + lastPage := aws.StringValue(output.TrafficPolicyIdMarker) == "" + if !fn(output, lastPage) || lastPage { + break + } + + input.TrafficPolicyIdMarker = output.TrafficPolicyIdMarker + } + return nil +} From 741cadfe1a4d9b2a64bc555c8e67e8885efefb2a Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Mon, 21 Mar 2022 17:30:48 -0400 Subject: [PATCH 25/40] r/aws_route53_traffic_policy: Tidy up 'FindTrafficPolicyByID'. Acceptance test output: % make testacc TESTS=TestAccTrafficPolicy_basic PKG=route53 ==> Checking that code complies with gofmt requirements... TF_ACC=1 go test ./internal/service/route53/... -v -count 1 -parallel 20 -run='TestAccTrafficPolicy_basic' -timeout 180m === RUN TestAccTrafficPolicy_basic === PAUSE TestAccTrafficPolicy_basic === CONT TestAccTrafficPolicy_basic --- PASS: TestAccTrafficPolicy_basic (19.28s) PASS ok github.com/hashicorp/terraform-provider-aws/internal/service/route53 26.600s --- internal/service/route53/find.go | 59 +++++++++++++------ internal/service/route53/traffic_policy.go | 58 ++++++------------ .../service/route53/traffic_policy_test.go | 50 ++++++++-------- 3 files changed, 84 insertions(+), 83 deletions(-) diff --git a/internal/service/route53/find.go b/internal/service/route53/find.go index ef64ea4d565f..0ebe611b3396 100644 --- a/internal/service/route53/find.go +++ b/internal/service/route53/find.go @@ -87,35 +87,56 @@ func FindKeySigningKeyByResourceID(conn *route53.Route53, resourceID string) (*r return FindKeySigningKey(conn, hostedZoneID, name) } -func FindTrafficPolicyById(ctx context.Context, conn *route53.Route53, trafficPolicyId string) (*route53.TrafficPolicySummary, error) { - var idMarker *string +func FindTrafficPolicyByID(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicy, error) { + var latestVersion int64 - for allPoliciesListed := false; !allPoliciesListed; { - input := &route53.ListTrafficPoliciesInput{} - - if idMarker != nil { - input.TrafficPolicyIdMarker = idMarker + err := listTrafficPoliciesPagesWithContext(ctx, conn, &route53.ListTrafficPoliciesInput{}, func(page *route53.ListTrafficPoliciesOutput, lastPage bool) bool { + if page == nil { + return !lastPage } - listResponse, err := conn.ListTrafficPoliciesWithContext(ctx, input) - if err != nil { - return nil, err - } + for _, v := range page.TrafficPolicySummaries { + if aws.StringValue(v.Id) == id { + latestVersion = aws.Int64Value(v.LatestVersion) - for _, summary := range listResponse.TrafficPolicySummaries { - if aws.StringValue(summary.Id) == trafficPolicyId { - return summary, nil + return false } } - if aws.BoolValue(listResponse.IsTruncated) { - idMarker = listResponse.TrafficPolicyIdMarker - } else { - allPoliciesListed = true + return !lastPage + }) + + if err != nil { + return nil, err + } + + if latestVersion == 0 { + return nil, tfresource.NewEmptyResultError(id) + } + + input := &route53.GetTrafficPolicyInput{ + Id: aws.String(id), + Version: aws.Int64(latestVersion), + } + + output, err := conn.GetTrafficPolicyWithContext(ctx, input) + + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { + return nil, &resource.NotFoundError{ + LastError: err, + LastRequest: input, } } - return nil, nil + if err != nil { + return nil, err + } + + if output == nil || output.TrafficPolicy == nil { + return nil, tfresource.NewEmptyResultError(input) + } + + return output.TrafficPolicy, nil } func FindTrafficPolicyInstanceId(ctx context.Context, conn *route53.Route53, id string) (*route53.GetTrafficPolicyInstanceOutput, error) { diff --git a/internal/service/route53/traffic_policy.go b/internal/service/route53/traffic_policy.go index 3833024d5de1..b256eb1880c3 100644 --- a/internal/service/route53/traffic_policy.go +++ b/internal/service/route53/traffic_policy.go @@ -41,12 +41,6 @@ func ResourceTrafficPolicy() *schema.Resource { }, }, Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringLenBetween(0, 512), - }, "comment": { Type: schema.TypeString, Optional: true, @@ -58,6 +52,12 @@ func ResourceTrafficPolicy() *schema.Resource { ForceNew: true, ValidateFunc: validation.StringLenBetween(0, 102400), }, + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(0, 512), + }, "type": { Type: schema.TypeString, Computed: true, @@ -113,39 +113,23 @@ func resourceTrafficPolicyCreate(ctx context.Context, d *schema.ResourceData, me func resourceTrafficPolicyRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn - object, err := FindTrafficPolicyById(ctx, conn, d.Id()) - if err != nil { - return diag.Errorf("error getting Route53 Traffic Policy %s from ListTrafficPolicies: %s", d.Get("name").(string), err) - } - - if object == nil { - log.Printf("[WARN] Route53 Traffic Policy (%s) not found, removing from state", d.Id()) - d.SetId("") - return nil - } + trafficPolicy, err := FindTrafficPolicyByID(ctx, conn, d.Id()) - request := &route53.GetTrafficPolicyInput{ - Id: aws.String(d.Id()), - Version: object.LatestVersion, - } - - response, err := conn.GetTrafficPolicy(request) - - if !d.IsNewResource() && tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { - log.Printf("[WARN] Route53 Traffic Policy (%s) not found, removing from state", d.Id()) + if !d.IsNewResource() && tfresource.NotFound(err) { + log.Printf("[WARN] Route53 Traffic Policy %s not found, removing from state", d.Id()) d.SetId("") return nil } if err != nil { - return diag.Errorf("error getting Route53 Traffic Policy %s, version %d: %s", d.Get("name").(string), d.Get("version").(int), err) + return diag.Errorf("error reading Route53 Traffic Policy (%s): %s", d.Id(), err) } - d.Set("comment", response.TrafficPolicy.Comment) - d.Set("document", response.TrafficPolicy.Document) - d.Set("name", response.TrafficPolicy.Name) - d.Set("type", response.TrafficPolicy.Type) - d.Set("version", response.TrafficPolicy.Version) + d.Set("comment", trafficPolicy.Comment) + d.Set("document", trafficPolicy.Document) + d.Set("name", trafficPolicy.Name) + d.Set("type", trafficPolicy.Type) + d.Set("version", trafficPolicy.Version) return nil } @@ -153,23 +137,19 @@ func resourceTrafficPolicyRead(ctx context.Context, d *schema.ResourceData, meta func resourceTrafficPolicyUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn - object, err := FindTrafficPolicyById(ctx, conn, d.Id()) - if err != nil { - return diag.Errorf("error getting Route53 Traffic Policy %s from ListTrafficPolicies: %s", d.Get("name").(string), err) - } - input := &route53.UpdateTrafficPolicyCommentInput{ Id: aws.String(d.Id()), - Version: object.LatestVersion, + Version: aws.Int64(int64(d.Get("version").(int))), } if d.HasChange("comment") { input.Comment = aws.String(d.Get("comment").(string)) } - _, err = conn.UpdateTrafficPolicyCommentWithContext(ctx, input) + _, err := conn.UpdateTrafficPolicyCommentWithContext(ctx, input) + if err != nil { - return diag.Errorf("error updating Route53 Traffic Policy: %s. %s", d.Get("name").(string), err) + return diag.Errorf("error updating Route53 Traffic Policy (%s): %s", d.Id(), err) } return resourceTrafficPolicyRead(ctx, d, meta) diff --git a/internal/service/route53/traffic_policy_test.go b/internal/service/route53/traffic_policy_test.go index dd9a5ff8a532..3c84b48fe23c 100644 --- a/internal/service/route53/traffic_policy_test.go +++ b/internal/service/route53/traffic_policy_test.go @@ -6,17 +6,17 @@ import ( "testing" "github.com/aws/aws-sdk-go/service/route53" - "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" "github.com/hashicorp/terraform-provider-aws/internal/acctest" "github.com/hashicorp/terraform-provider-aws/internal/conns" tfroute53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" + "github.com/hashicorp/terraform-provider-aws/internal/tfresource" ) func TestAccTrafficPolicy_basic(t *testing.T) { - var output route53.TrafficPolicySummary + var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) @@ -29,7 +29,7 @@ func TestAccTrafficPolicy_basic(t *testing.T) { { Config: testAccTrafficPolicyConfig(rName), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &output), + testAccCheckTrafficPolicyExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "name", rName), ), }, @@ -44,7 +44,7 @@ func TestAccTrafficPolicy_basic(t *testing.T) { } func TestAccTrafficPolicy_disappears(t *testing.T) { - var output route53.TrafficPolicySummary + var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) @@ -57,8 +57,8 @@ func TestAccTrafficPolicy_disappears(t *testing.T) { { Config: testAccTrafficPolicyConfig(rName), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &output), - testAccCheckTrafficPolicyDisappears(&output), + testAccCheckTrafficPolicyExists(resourceName, &v), + acctest.CheckResourceDisappears(acctest.Provider, tfroute53.ResourceTrafficPolicy(), resourceName), ), ExpectNonEmptyPlan: true, }, @@ -67,7 +67,7 @@ func TestAccTrafficPolicy_disappears(t *testing.T) { } func TestAccTrafficPolicy_complete(t *testing.T) { - var output route53.TrafficPolicySummary + var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) comment := `comment` @@ -82,7 +82,7 @@ func TestAccTrafficPolicy_complete(t *testing.T) { { Config: testAccTrafficPolicyConfigComplete(rName, comment), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &output), + testAccCheckTrafficPolicyExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "name", rName), resource.TestCheckResourceAttr(resourceName, "comment", comment), ), @@ -90,7 +90,7 @@ func TestAccTrafficPolicy_complete(t *testing.T) { { Config: testAccTrafficPolicyConfigComplete(rName, commentUpdated), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &output), + testAccCheckTrafficPolicyExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "name", rName), resource.TestCheckResourceAttr(resourceName, "comment", commentUpdated), ), @@ -105,26 +105,26 @@ func TestAccTrafficPolicy_complete(t *testing.T) { }) } -func testAccCheckTrafficPolicyExists(resourceName string, trafficPolicy *route53.TrafficPolicySummary) resource.TestCheckFunc { +func testAccCheckTrafficPolicyExists(n string, v *route53.TrafficPolicy) resource.TestCheckFunc { return func(s *terraform.State) error { - rs, ok := s.RootModule().Resources[resourceName] + rs, ok := s.RootModule().Resources[n] if !ok { - return fmt.Errorf("not found: %s", resourceName) + return fmt.Errorf("Not found: %s", n) + } + + if rs.Primary.ID == "" { + return fmt.Errorf("No Route53 Traffic Policy ID is set") } conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn - resp, err := tfroute53.FindTrafficPolicyById(context.Background(), conn, rs.Primary.ID) + output, err := tfroute53.FindTrafficPolicyByID(context.Background(), conn, rs.Primary.ID) if err != nil { - return fmt.Errorf("problem checking for traffic policy existence: %w", err) - } - - if resp == nil { - return fmt.Errorf("traffic policy %q does not exist", rs.Primary.ID) + return err } - *trafficPolicy = *resp + *v = *output return nil } @@ -138,17 +138,17 @@ func testAccCheckTrafficPolicyDestroy(s *terraform.State) error { continue } - resp, err := tfroute53.FindTrafficPolicyById(context.Background(), conn, rs.Primary.ID) - if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) || resp == nil { + _, err := tfroute53.FindTrafficPolicyByID(context.Background(), conn, rs.Primary.ID) + + if tfresource.NotFound(err) { continue } if err != nil { - return fmt.Errorf("error during check if traffic policy still exists, %#v", err) - } - if resp != nil { - return fmt.Errorf("traffic Policy still exists") + return err } + + return fmt.Errorf("Route53 Traffic Policy %s still exists", rs.Primary.ID) } return nil } From f12239e53f7c2131abe09c81fa19f264a253a365 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 07:48:05 -0400 Subject: [PATCH 26/40] r/aws_route53_traffic_policy: Tidy up resource Create. --- internal/service/route53/traffic_policy.go | 48 ++++++++----------- .../service/route53/traffic_policy_test.go | 15 ------ 2 files changed, 20 insertions(+), 43 deletions(-) diff --git a/internal/service/route53/traffic_policy.go b/internal/service/route53/traffic_policy.go index b256eb1880c3..64794c0edb56 100644 --- a/internal/service/route53/traffic_policy.go +++ b/internal/service/route53/traffic_policy.go @@ -11,7 +11,6 @@ import ( "github.com/aws/aws-sdk-go/service/route53" "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" "github.com/hashicorp/terraform-plugin-sdk/v2/diag" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "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" @@ -24,22 +23,28 @@ func ResourceTrafficPolicy() *schema.Resource { ReadWithoutTimeout: resourceTrafficPolicyRead, UpdateWithoutTimeout: resourceTrafficPolicyUpdate, DeleteWithoutTimeout: resourceTrafficPolicyDelete, + Importer: &schema.ResourceImporter{ StateContext: func(ctx context.Context, d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { - idParts := strings.Split(d.Id(), "/") - if len(idParts) != 2 || idParts[0] == "" || idParts[1] == "" { - return nil, fmt.Errorf("unexpected format of ID (%q), expected traffic-policy-id/traffic-policy-version", d.Id()) + const idSeparator = "/" + parts := strings.Split(d.Id(), idSeparator) + if len(parts) != 2 || parts[0] == "" || parts[1] == "" { + return nil, fmt.Errorf("unexpected format for ID (%[1]s), expected TRAFFIC-POLICY-ID%[2]sTRAFFIC-POLICY-VERSION", d.Id(), idSeparator) } - version, err := strconv.Atoi(idParts[1]) + + version, err := strconv.Atoi(parts[1]) + if err != nil { - return nil, fmt.Errorf("cannot convert to int: %s", idParts[1]) + return nil, err } + + d.SetId(parts[0]) d.Set("version", version) - d.SetId(idParts[0]) return []*schema.ResourceData{d}, nil }, }, + Schema: map[string]*schema.Schema{ "comment": { Type: schema.TypeString, @@ -73,39 +78,26 @@ func ResourceTrafficPolicy() *schema.Resource { func resourceTrafficPolicyCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn + name := d.Get("name").(string) input := &route53.CreateTrafficPolicyInput{ Document: aws.String(d.Get("document").(string)), - Name: aws.String(d.Get("name").(string)), + Name: aws.String(name), } if v, ok := d.GetOk("comment"); ok { input.Comment = aws.String(v.(string)) } - var err error - var output *route53.CreateTrafficPolicyOutput - err = resource.RetryContext(ctx, d.Timeout(schema.TimeoutCreate), func() *resource.RetryError { - output, err = conn.CreateTrafficPolicyWithContext(ctx, input) - if err != nil { - if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { - resource.RetryableError(err) - } - - return resource.NonRetryableError(err) - } - - return nil - }) - - if tfresource.TimedOut(err) { - output, err = conn.CreateTrafficPolicyWithContext(ctx, input) - } + log.Printf("[INFO] Creating Route53 Traffic Policy: %s", input) + outputRaw, err := tfresource.RetryWhenAWSErrCodeEqualsContext(ctx, d.Timeout(schema.TimeoutCreate), func() (interface{}, error) { + return conn.CreateTrafficPolicyWithContext(ctx, input) + }, route53.ErrCodeNoSuchTrafficPolicy) if err != nil { - return diag.Errorf("error creating Route53 traffic policy: %s", err) + return diag.Errorf("error creating Route53 Traffic Policy (%s): %s", name, err) } - d.SetId(aws.StringValue(output.TrafficPolicy.Id)) + d.SetId(aws.StringValue(outputRaw.(*route53.CreateTrafficPolicyOutput).TrafficPolicy.Id)) return resourceTrafficPolicyRead(ctx, d, meta) } diff --git a/internal/service/route53/traffic_policy_test.go b/internal/service/route53/traffic_policy_test.go index 3c84b48fe23c..2dd0bae51b43 100644 --- a/internal/service/route53/traffic_policy_test.go +++ b/internal/service/route53/traffic_policy_test.go @@ -153,21 +153,6 @@ func testAccCheckTrafficPolicyDestroy(s *terraform.State) error { return nil } -func testAccCheckTrafficPolicyDisappears(trafficPolicy *route53.TrafficPolicySummary) resource.TestCheckFunc { - return func(s *terraform.State) error { - conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn - - input := &route53.DeleteTrafficPolicyInput{ - Id: trafficPolicy.Id, - Version: trafficPolicy.LatestVersion, - } - - _, err := conn.DeleteTrafficPolicyWithContext(context.Background(), input) - - return err - } -} - func testAccTrafficPolicyImportStateIdFunc(resourceName string) resource.ImportStateIdFunc { return func(s *terraform.State) (string, error) { rs, ok := s.RootModule().Resources[resourceName] From 8a1d8087fb56f9d8e9e1fc4b08fd802a940f3082 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 08:05:50 -0400 Subject: [PATCH 27/40] Add optional output file argument to lister generator. --- internal/generate/listpages/README.md | 3 ++- internal/generate/listpages/main.go | 9 +++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/internal/generate/listpages/README.md b/internal/generate/listpages/README.md index 3e2f6f142097..521047d81826 100644 --- a/internal/generate/listpages/README.md +++ b/internal/generate/listpages/README.md @@ -7,10 +7,11 @@ For example, the EC2 API defines both [`DescribeInstancesPages`](https://docs.aw The `listpages` executable is called as follows: ```console -$ go run main.go -ListOps [,] +$ go run main.go -ListOps [,] [] ``` * ``: Name of a function to wrap +* ``: Name of the generated lister source file, defaults to `list_pages_gen.go` Optional Flags: diff --git a/internal/generate/listpages/main.go b/internal/generate/listpages/main.go index 5765f65a0704..4f9ce2ef8759 100644 --- a/internal/generate/listpages/main.go +++ b/internal/generate/listpages/main.go @@ -20,7 +20,7 @@ import ( ) const ( - filename = "list_pages_gen.go" + defaultFilename = "list_pages_gen.go" ) var ( @@ -31,7 +31,7 @@ var ( func usage() { fmt.Fprintf(os.Stderr, "Usage:\n") - fmt.Fprintf(os.Stderr, "\tmain.go [flags]\n\n") + fmt.Fprintf(os.Stderr, "\tmain.go [flags] []\n\n") fmt.Fprintf(os.Stderr, "Flags:\n") flag.PrintDefaults() } @@ -49,6 +49,11 @@ func main() { flag.Usage = usage flag.Parse() + filename := defaultFilename + if args := flag.Args(); len(args) > 0 { + filename = args[0] + } + wd, err := os.Getwd() if err != nil { From f79eae8280e7e59b068da9d8a9409a59c87f3a9b Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 08:06:18 -0400 Subject: [PATCH 28/40] Seperate list generator output files. --- internal/service/route53/generate.go | 3 +- ....go => list_traffic_policies_pages_gen.go} | 2 +- .../list_traffic_policy_versions_pages_gen.go | 31 +++++++++++++++++++ 3 files changed, 34 insertions(+), 2 deletions(-) rename internal/service/route53/{list_pages_gen.go => list_traffic_policies_pages_gen.go} (89%) create mode 100644 internal/service/route53/list_traffic_policy_versions_pages_gen.go diff --git a/internal/service/route53/generate.go b/internal/service/route53/generate.go index b82cf667b679..01bffe293cf5 100644 --- a/internal/service/route53/generate.go +++ b/internal/service/route53/generate.go @@ -1,4 +1,5 @@ -//go:generate go run ../../generate/listpages/main.go -ListOps=ListTrafficPolicies -Paginator=TrafficPolicyIdMarker +//go:generate go run ../../generate/listpages/main.go -ListOps=ListTrafficPolicies -Paginator=TrafficPolicyIdMarker list_traffic_policies_pages_gen.go +//go:generate go run ../../generate/listpages/main.go -ListOps=ListTrafficPolicyVersions -Paginator=TrafficPolicyVersionMarker list_traffic_policy_versions_pages_gen.go //go:generate go run ../../generate/tags/main.go -ListTags -ListTagsInIDElem=ResourceId -ListTagsOutTagsElem=ResourceTagSet.Tags -ServiceTagsSlice -TagOp=ChangeTagsForResource -TagInIDElem=ResourceId -TagInTagsElem=AddTags -TagResTypeElem=ResourceType -UntagOp=ChangeTagsForResource -UntagInTagsElem=RemoveTagKeys -UpdateTags // ONLY generate directives and package declaration! Do not add anything else to this file. diff --git a/internal/service/route53/list_pages_gen.go b/internal/service/route53/list_traffic_policies_pages_gen.go similarity index 89% rename from internal/service/route53/list_pages_gen.go rename to internal/service/route53/list_traffic_policies_pages_gen.go index ef50f79f21c9..ad403e3b140b 100644 --- a/internal/service/route53/list_pages_gen.go +++ b/internal/service/route53/list_traffic_policies_pages_gen.go @@ -1,4 +1,4 @@ -// Code generated by "internal/generate/listpages/main.go -ListOps=ListTrafficPolicies -Paginator=TrafficPolicyIdMarker"; DO NOT EDIT. +// Code generated by "internal/generate/listpages/main.go -ListOps=ListTrafficPolicies -Paginator=TrafficPolicyIdMarker list_traffic_policies_pages_gen.go"; DO NOT EDIT. package route53 diff --git a/internal/service/route53/list_traffic_policy_versions_pages_gen.go b/internal/service/route53/list_traffic_policy_versions_pages_gen.go new file mode 100644 index 000000000000..763250c4f5df --- /dev/null +++ b/internal/service/route53/list_traffic_policy_versions_pages_gen.go @@ -0,0 +1,31 @@ +// Code generated by "internal/generate/listpages/main.go -ListOps=ListTrafficPolicyVersions -Paginator=TrafficPolicyVersionMarker list_traffic_policy_versions_pages_gen.go"; DO NOT EDIT. + +package route53 + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" +) + +func listTrafficPolicyVersionsPages(conn *route53.Route53, input *route53.ListTrafficPolicyVersionsInput, fn func(*route53.ListTrafficPolicyVersionsOutput, bool) bool) error { + return listTrafficPolicyVersionsPagesWithContext(context.Background(), conn, input, fn) +} + +func listTrafficPolicyVersionsPagesWithContext(ctx context.Context, conn *route53.Route53, input *route53.ListTrafficPolicyVersionsInput, fn func(*route53.ListTrafficPolicyVersionsOutput, bool) bool) error { + for { + output, err := conn.ListTrafficPolicyVersionsWithContext(ctx, input) + if err != nil { + return err + } + + lastPage := aws.StringValue(output.TrafficPolicyVersionMarker) == "" + if !fn(output, lastPage) || lastPage { + break + } + + input.TrafficPolicyVersionMarker = output.TrafficPolicyVersionMarker + } + return nil +} From 9e5ae52297f1f288aa7067e371a0bc8918966b64 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 08:21:19 -0400 Subject: [PATCH 29/40] r/aws_route53_traffic_policy: Tidy up resource Delete. Acceptance test output: % make testacc TESTS=TestAccTrafficPolicy_ PKG=route53 ==> Checking that code complies with gofmt requirements... TF_ACC=1 go test ./internal/service/route53/... -v -count 1 -parallel 20 -run='TestAccTrafficPolicy_' -timeout 180m === RUN TestAccTrafficPolicy_basic === PAUSE TestAccTrafficPolicy_basic === RUN TestAccTrafficPolicy_disappears === PAUSE TestAccTrafficPolicy_disappears === RUN TestAccTrafficPolicy_update === PAUSE TestAccTrafficPolicy_update === CONT TestAccTrafficPolicy_basic === CONT TestAccTrafficPolicy_update === CONT TestAccTrafficPolicy_disappears --- PASS: TestAccTrafficPolicy_disappears (13.66s) --- PASS: TestAccTrafficPolicy_basic (18.33s) --- PASS: TestAccTrafficPolicy_update (29.13s) PASS ok github.com/hashicorp/terraform-provider-aws/internal/service/route53 33.269s --- internal/service/route53/traffic_policy.go | 56 +++++++++---------- .../service/route53/traffic_policy_test.go | 23 ++++---- 2 files changed, 39 insertions(+), 40 deletions(-) diff --git a/internal/service/route53/traffic_policy.go b/internal/service/route53/traffic_policy.go index 64794c0edb56..8ed8cdd8ef1b 100644 --- a/internal/service/route53/traffic_policy.go +++ b/internal/service/route53/traffic_policy.go @@ -138,10 +138,11 @@ func resourceTrafficPolicyUpdate(ctx context.Context, d *schema.ResourceData, me input.Comment = aws.String(d.Get("comment").(string)) } + log.Printf("[INFO] Updating Route53 Traffic Policy comment: %s", input) _, err := conn.UpdateTrafficPolicyCommentWithContext(ctx, input) if err != nil { - return diag.Errorf("error updating Route53 Traffic Policy (%s): %s", d.Id(), err) + return diag.Errorf("error updating Route53 Traffic Policy (%s) comment: %s", d.Id(), err) } return resourceTrafficPolicyRead(ctx, d, meta) @@ -150,45 +151,42 @@ func resourceTrafficPolicyUpdate(ctx context.Context, d *schema.ResourceData, me func resourceTrafficPolicyDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn - var trafficPolicies []*route53.TrafficPolicy - var versionMarker *string + input := &route53.ListTrafficPolicyVersionsInput{ + Id: aws.String(d.Id()), + } + var output []*route53.TrafficPolicy - for allPoliciesListed := false; !allPoliciesListed; { - listRequest := &route53.ListTrafficPolicyVersionsInput{ - Id: aws.String(d.Id()), - } - if versionMarker != nil { - listRequest.TrafficPolicyVersionMarker = versionMarker + err := listTrafficPolicyVersionsPagesWithContext(ctx, conn, input, func(page *route53.ListTrafficPolicyVersionsOutput, lastPage bool) bool { + if page == nil { + return !lastPage } - listResponse, err := conn.ListTrafficPolicyVersionsWithContext(ctx, listRequest) - if err != nil { - return diag.Errorf("error listing Route 53 Traffic Policy versions: %v", err) - } + output = append(output, page.TrafficPolicies...) - trafficPolicies = append(trafficPolicies, listResponse.TrafficPolicies...) + return !lastPage + }) - if aws.BoolValue(listResponse.IsTruncated) { - versionMarker = listResponse.TrafficPolicyVersionMarker - } else { - allPoliciesListed = true - } + if err != nil { + return diag.Errorf("error listing Route 53 Traffic Policy (%s) versions: %s", d.Id(), err) } - for _, trafficPolicy := range trafficPolicies { - input := &route53.DeleteTrafficPolicyInput{ - Id: trafficPolicy.Id, - Version: trafficPolicy.Version, + for _, v := range output { + version := aws.Int64Value(v.Version) + + log.Printf("[INFO] Delete Route53 Traffic Policy (%s) version: %d", input, version) + _, err := conn.DeleteTrafficPolicyWithContext(ctx, &route53.DeleteTrafficPolicyInput{ + Id: aws.String(d.Id()), + Version: aws.Int64(version), + }) + + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { + continue } - _, err := conn.DeleteTrafficPolicyWithContext(ctx, input) if err != nil { - if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicy) { - return nil - } - - return diag.Errorf("error deleting Route53 Traffic Policy %s, version %d: %s", aws.StringValue(trafficPolicy.Id), aws.Int64Value(trafficPolicy.Version), err) + return diag.Errorf("error deleting Route 53 Traffic Policy (%s) version (%d): %s", d.Id(), version, err) } } + return nil } diff --git a/internal/service/route53/traffic_policy_test.go b/internal/service/route53/traffic_policy_test.go index 2dd0bae51b43..c01999e8ad9f 100644 --- a/internal/service/route53/traffic_policy_test.go +++ b/internal/service/route53/traffic_policy_test.go @@ -18,7 +18,7 @@ import ( func TestAccTrafficPolicy_basic(t *testing.T) { var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" - rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, @@ -28,9 +28,12 @@ func TestAccTrafficPolicy_basic(t *testing.T) { Steps: []resource.TestStep{ { Config: testAccTrafficPolicyConfig(rName), - Check: resource.ComposeTestCheckFunc( + Check: resource.ComposeAggregateTestCheckFunc( testAccCheckTrafficPolicyExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "comment", ""), resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "type", "A"), + resource.TestCheckResourceAttr(resourceName, "version", "1"), ), }, { @@ -46,7 +49,7 @@ func TestAccTrafficPolicy_basic(t *testing.T) { func TestAccTrafficPolicy_disappears(t *testing.T) { var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" - rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, @@ -66,10 +69,10 @@ func TestAccTrafficPolicy_disappears(t *testing.T) { }) } -func TestAccTrafficPolicy_complete(t *testing.T) { +func TestAccTrafficPolicy_update(t *testing.T) { var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" - rName := fmt.Sprintf("tf-route53-traffic-policy-%s", sdkacctest.RandString(5)) + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) comment := `comment` commentUpdated := `comment updated` @@ -83,7 +86,6 @@ func TestAccTrafficPolicy_complete(t *testing.T) { Config: testAccTrafficPolicyConfigComplete(rName, comment), Check: resource.ComposeTestCheckFunc( testAccCheckTrafficPolicyExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "name", rName), resource.TestCheckResourceAttr(resourceName, "comment", comment), ), }, @@ -91,7 +93,6 @@ func TestAccTrafficPolicy_complete(t *testing.T) { Config: testAccTrafficPolicyConfigComplete(rName, commentUpdated), Check: resource.ComposeTestCheckFunc( testAccCheckTrafficPolicyExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "name", rName), resource.TestCheckResourceAttr(resourceName, "comment", commentUpdated), ), }, @@ -164,7 +165,7 @@ func testAccTrafficPolicyImportStateIdFunc(resourceName string) resource.ImportS } } -func testAccTrafficPolicyConfig(name string) string { +func testAccTrafficPolicyConfig(rName string) string { return fmt.Sprintf(` resource "aws_route53_traffic_policy" "test" { name = %[1]q @@ -182,10 +183,10 @@ resource "aws_route53_traffic_policy" "test" { } EOT } -`, name) +`, rName) } -func testAccTrafficPolicyConfigComplete(name, comment string) string { +func testAccTrafficPolicyConfigComplete(rName, comment string) string { return fmt.Sprintf(` resource "aws_route53_traffic_policy" "test" { name = %[1]q @@ -204,5 +205,5 @@ resource "aws_route53_traffic_policy" "test" { } EOT } -`, name, comment) +`, rName, comment) } From 0597814c37e7d8766f1051e15f398e3885500818 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 08:34:44 -0400 Subject: [PATCH 30/40] r/aws_route53_traffic_policy: Add Sweeper. --- internal/service/route53/sweep.go | 49 +++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/internal/service/route53/sweep.go b/internal/service/route53/sweep.go index faea7a5b14e4..c50dfdd6d835 100644 --- a/internal/service/route53/sweep.go +++ b/internal/service/route53/sweep.go @@ -35,6 +35,11 @@ func init() { F: sweepQueryLogs, }) + resource.AddTestSweepers("aws_route53_traffic_policy", &resource.Sweeper{ + Name: "aws_route53_traffic_policy", + F: sweepTrafficPolicies, + }) + resource.AddTestSweepers("aws_route53_zone", &resource.Sweeper{ Name: "aws_route53_zone", Dependencies: []string{ @@ -43,6 +48,7 @@ func init() { "aws_service_discovery_private_dns_namespace", "aws_elb", "aws_route53_key_signing_key", + "aws_route53_traffic_policy", }, F: sweepZones, }) @@ -221,6 +227,49 @@ func sweepQueryLogs(region string) error { return sweeperErrs.ErrorOrNil() } +func sweepTrafficPolicies(region string) error { + client, err := sweep.SharedRegionalSweepClient(region) + if err != nil { + return fmt.Errorf("error getting client: %w", err) + } + conn := client.(*conns.AWSClient).Route53Conn + input := &route53.ListTrafficPoliciesInput{} + sweepResources := make([]*sweep.SweepResource, 0) + + err = listTrafficPoliciesPages(conn, input, func(page *route53.ListTrafficPoliciesOutput, lastPage bool) bool { + if page == nil { + return !lastPage + } + + for _, v := range page.TrafficPolicySummaries { + r := ResourceTrafficPolicy() + d := r.Data(nil) + d.SetId(aws.StringValue(v.Id)) + + sweepResources = append(sweepResources, sweep.NewSweepResource(r, d, client)) + } + + return !lastPage + }) + + if sweep.SkipSweepError(err) { + log.Printf("[WARN] Skipping Route 53 Traffic Policy sweep for %s: %s", region, err) + return nil + } + + if err != nil { + return fmt.Errorf("error listing Route 53 Traffic Policies (%s): %w", region, err) + } + + err = sweep.SweepOrchestrator(sweepResources) + + if err != nil { + return fmt.Errorf("error sweeping Route 53 Traffic Policies (%s): %w", region, err) + } + + return nil +} + func sweepZones(region string) error { client, err := sweep.SharedRegionalSweepClient(region) From 79d1213d19174a1f8969afa57eda26870346248b Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 08:39:35 -0400 Subject: [PATCH 31/40] Add 'Route53' to acceptance test function names. --- .../service/route53/traffic_policy_test.go | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/internal/service/route53/traffic_policy_test.go b/internal/service/route53/traffic_policy_test.go index c01999e8ad9f..9d1d53eeafb7 100644 --- a/internal/service/route53/traffic_policy_test.go +++ b/internal/service/route53/traffic_policy_test.go @@ -15,7 +15,7 @@ import ( "github.com/hashicorp/terraform-provider-aws/internal/tfresource" ) -func TestAccTrafficPolicy_basic(t *testing.T) { +func TestAccRoute53TrafficPolicy_basic(t *testing.T) { var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) @@ -23,13 +23,13 @@ func TestAccTrafficPolicy_basic(t *testing.T) { resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, ProviderFactories: acctest.ProviderFactories, - CheckDestroy: testAccCheckTrafficPolicyDestroy, + CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), Steps: []resource.TestStep{ { Config: testAccTrafficPolicyConfig(rName), Check: resource.ComposeAggregateTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &v), + testAccCheckRoute53TrafficPolicyExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "comment", ""), resource.TestCheckResourceAttr(resourceName, "name", rName), resource.TestCheckResourceAttr(resourceName, "type", "A"), @@ -46,7 +46,7 @@ func TestAccTrafficPolicy_basic(t *testing.T) { }) } -func TestAccTrafficPolicy_disappears(t *testing.T) { +func TestAccRoute53TrafficPolicy_disappears(t *testing.T) { var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) @@ -54,13 +54,13 @@ func TestAccTrafficPolicy_disappears(t *testing.T) { resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, ProviderFactories: acctest.ProviderFactories, - CheckDestroy: testAccCheckTrafficPolicyDestroy, + CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), Steps: []resource.TestStep{ { Config: testAccTrafficPolicyConfig(rName), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &v), + testAccCheckRoute53TrafficPolicyExists(resourceName, &v), acctest.CheckResourceDisappears(acctest.Provider, tfroute53.ResourceTrafficPolicy(), resourceName), ), ExpectNonEmptyPlan: true, @@ -69,7 +69,7 @@ func TestAccTrafficPolicy_disappears(t *testing.T) { }) } -func TestAccTrafficPolicy_update(t *testing.T) { +func TestAccRoute53TrafficPolicy_update(t *testing.T) { var v route53.TrafficPolicy resourceName := "aws_route53_traffic_policy.test" rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) @@ -79,20 +79,20 @@ func TestAccTrafficPolicy_update(t *testing.T) { resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, ProviderFactories: acctest.ProviderFactories, - CheckDestroy: testAccCheckTrafficPolicyDestroy, + CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), Steps: []resource.TestStep{ { Config: testAccTrafficPolicyConfigComplete(rName, comment), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &v), + testAccCheckRoute53TrafficPolicyExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "comment", comment), ), }, { Config: testAccTrafficPolicyConfigComplete(rName, commentUpdated), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyExists(resourceName, &v), + testAccCheckRoute53TrafficPolicyExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "comment", commentUpdated), ), }, @@ -106,7 +106,7 @@ func TestAccTrafficPolicy_update(t *testing.T) { }) } -func testAccCheckTrafficPolicyExists(n string, v *route53.TrafficPolicy) resource.TestCheckFunc { +func testAccCheckRoute53TrafficPolicyExists(n string, v *route53.TrafficPolicy) resource.TestCheckFunc { return func(s *terraform.State) error { rs, ok := s.RootModule().Resources[n] if !ok { @@ -131,7 +131,7 @@ func testAccCheckTrafficPolicyExists(n string, v *route53.TrafficPolicy) resourc } } -func testAccCheckTrafficPolicyDestroy(s *terraform.State) error { +func testAccCheckRoute53TrafficPolicyDestroy(s *terraform.State) error { conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn for _, rs := range s.RootModule().Resources { From 8f2530092621f33e35617b0580d7ceefddbd9029 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 08:40:05 -0400 Subject: [PATCH 32/40] r/aws_route53_traffic_policy_instance: Remove 'state' attribute. --- internal/service/route53/traffic_policy_instance.go | 6 +----- .../docs/r/route53_traffic_policy_instance.html.markdown | 1 - 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/internal/service/route53/traffic_policy_instance.go b/internal/service/route53/traffic_policy_instance.go index 6b47e7fa64cd..15dda3d8848c 100644 --- a/internal/service/route53/traffic_policy_instance.go +++ b/internal/service/route53/traffic_policy_instance.go @@ -22,6 +22,7 @@ func ResourceTrafficPolicyInstance() *schema.Resource { ReadWithoutTimeout: resourceTrafficPolicyInstanceRead, UpdateWithoutTimeout: resourceTrafficPolicyInstanceUpdate, DeleteWithoutTimeout: resourceTrafficPolicyInstanceDelete, + Importer: &schema.ResourceImporter{ StateContext: schema.ImportStatePassthroughContext, }, @@ -47,10 +48,6 @@ func ResourceTrafficPolicyInstance() *schema.Resource { return strings.ToLower(value) }, }, - "state": { - Type: schema.TypeString, - Computed: true, - }, "traffic_policy_id": { Type: schema.TypeString, Required: true, @@ -134,7 +131,6 @@ func resourceTrafficPolicyInstanceRead(ctx context.Context, d *schema.ResourceDa d.Set("hosted_zone_id", output.TrafficPolicyInstance.HostedZoneId) d.Set("message", output.TrafficPolicyInstance.Message) d.Set("name", strings.TrimSuffix(aws.StringValue(output.TrafficPolicyInstance.Name), ".")) - d.Set("state", output.TrafficPolicyInstance.State) d.Set("traffic_policy_id", output.TrafficPolicyInstance.TrafficPolicyId) d.Set("traffic_policy_version", output.TrafficPolicyInstance.TrafficPolicyVersion) d.Set("ttl", output.TrafficPolicyInstance.TTL) diff --git a/website/docs/r/route53_traffic_policy_instance.html.markdown b/website/docs/r/route53_traffic_policy_instance.html.markdown index f2a865eb873d..cba66dbda9b3 100644 --- a/website/docs/r/route53_traffic_policy_instance.html.markdown +++ b/website/docs/r/route53_traffic_policy_instance.html.markdown @@ -38,7 +38,6 @@ In addition to all arguments above, the following attributes are exported: * `id` - ID of traffic policy instance. * `message` - If `state` is `Failed`, an explanation of the reason for the failure. If `state` is another value, `message` is empty. . -* `state` - State of a policy traffic instance. ## Import From ed2d010bf199b3161cf498e106c5c3fc9eba8753 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 08:45:49 -0400 Subject: [PATCH 33/40] Add 'Route53' to acceptance test function names. --- .../route53/traffic_policy_instance_test.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/internal/service/route53/traffic_policy_instance_test.go b/internal/service/route53/traffic_policy_instance_test.go index ab9300f69d49..c1e41b01dc7b 100644 --- a/internal/service/route53/traffic_policy_instance_test.go +++ b/internal/service/route53/traffic_policy_instance_test.go @@ -16,7 +16,7 @@ import ( tfrouter53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" ) -func TestAccTrafficPolicyInstance_basic(t *testing.T) { +func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { var output route53.GetTrafficPolicyInstanceOutput resourceName := "aws_route53_traffic_policy_instance.test" @@ -32,7 +32,7 @@ func TestAccTrafficPolicyInstance_basic(t *testing.T) { { Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), resource.TestCheckResourceAttr(resourceName, "name", rName), ), }, @@ -45,7 +45,7 @@ func TestAccTrafficPolicyInstance_basic(t *testing.T) { }) } -func TestAccTrafficPolicyInstance_disappears(t *testing.T) { +func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { var output route53.GetTrafficPolicyInstanceOutput resourceName := "aws_route53_traffic_policy_instance.test" @@ -61,7 +61,7 @@ func TestAccTrafficPolicyInstance_disappears(t *testing.T) { { Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), acctest.CheckResourceDisappears(acctest.Provider, tfrouter53.ResourceTrafficPolicyInstance(), resourceName), ), ExpectNonEmptyPlan: true, @@ -70,7 +70,7 @@ func TestAccTrafficPolicyInstance_disappears(t *testing.T) { }) } -func TestAccTrafficPolicyInstance_complete(t *testing.T) { +func TestAccRoute53TrafficPolicyInstance_complete(t *testing.T) { var output route53.GetTrafficPolicyInstanceOutput resourceName := "aws_route53_traffic_policy_instance.test" @@ -87,14 +87,14 @@ func TestAccTrafficPolicyInstance_complete(t *testing.T) { { Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), resource.TestCheckResourceAttr(resourceName, "name", rName), ), }, { Config: testAccTrafficPolicyInstanceConfig(zoneName, rNameUpdated), Check: resource.ComposeTestCheckFunc( - testAccCheckTrafficPolicyInstanceExists(resourceName, &output), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), resource.TestCheckResourceAttr(resourceName, "name", rNameUpdated), ), }, @@ -107,7 +107,7 @@ func TestAccTrafficPolicyInstance_complete(t *testing.T) { }) } -func testAccCheckTrafficPolicyInstanceExists(resourceName string, output *route53.GetTrafficPolicyInstanceOutput) resource.TestCheckFunc { +func testAccCheckRoute53TrafficPolicyInstanceExists(resourceName string, output *route53.GetTrafficPolicyInstanceOutput) resource.TestCheckFunc { return func(s *terraform.State) error { rs, ok := s.RootModule().Resources[resourceName] if !ok { From bb0bc4c27c3640bf269f1ef12e5dec009c5c4428 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 09:08:54 -0400 Subject: [PATCH 34/40] r/aws_route53_traffic_policy_instance: Tidy up 'FindTrafficPolicyInstanceByID' and callers. --- internal/service/route53/enum.go | 4 ++ internal/service/route53/find.go | 13 ++-- internal/service/route53/status.go | 7 +-- .../route53/traffic_policy_instance.go | 24 +++----- .../route53/traffic_policy_instance_test.go | 61 ++++++++----------- internal/service/route53/wait.go | 53 ++++++---------- 6 files changed, 66 insertions(+), 96 deletions(-) diff --git a/internal/service/route53/enum.go b/internal/service/route53/enum.go index bb8204082e5f..db92a1c03089 100644 --- a/internal/service/route53/enum.go +++ b/internal/service/route53/enum.go @@ -12,4 +12,8 @@ const ( ServeSignatureInternalFailure = "INTERNAL_FAILURE" ServeSignatureNotSigning = "NOT_SIGNING" ServeSignatureSigning = "SIGNING" + + TrafficPolicyInstanceStateApplied = "Applied" + TrafficPolicyInstanceStateCreating = "Creating" + TrafficPolicyInstanceStateFailed = "Failed" ) diff --git a/internal/service/route53/find.go b/internal/service/route53/find.go index 0ebe611b3396..c5f3dc98b69a 100644 --- a/internal/service/route53/find.go +++ b/internal/service/route53/find.go @@ -139,12 +139,12 @@ func FindTrafficPolicyByID(ctx context.Context, conn *route53.Route53, id string return output.TrafficPolicy, nil } -func FindTrafficPolicyInstanceId(ctx context.Context, conn *route53.Route53, id string) (*route53.GetTrafficPolicyInstanceOutput, error) { +func FindTrafficPolicyInstanceByID(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicyInstance, error) { input := &route53.GetTrafficPolicyInstanceInput{ Id: aws.String(id), } - resp, err := conn.GetTrafficPolicyInstanceWithContext(ctx, input) + output, err := conn.GetTrafficPolicyInstanceWithContext(ctx, input) if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { return nil, &resource.NotFoundError{ @@ -157,12 +157,9 @@ func FindTrafficPolicyInstanceId(ctx context.Context, conn *route53.Route53, id return nil, err } - if resp == nil { - return nil, &resource.NotFoundError{ - Message: "Empty result", - LastRequest: input, - } + if output == nil || output.TrafficPolicyInstance == nil { + return nil, tfresource.NewEmptyResultError(input) } - return resp, nil + return output.TrafficPolicyInstance, nil } diff --git a/internal/service/route53/status.go b/internal/service/route53/status.go index fe4c046cc468..c6d8bc5bda76 100644 --- a/internal/service/route53/status.go +++ b/internal/service/route53/status.go @@ -61,19 +61,18 @@ func statusKeySigningKey(conn *route53.Route53, hostedZoneID string, name string } } -//statusTrafficPolicyInstanceState fetches the traffic policy instance and its state func statusTrafficPolicyInstanceState(ctx context.Context, conn *route53.Route53, id string) resource.StateRefreshFunc { return func() (interface{}, string, error) { - object, err := FindTrafficPolicyInstanceId(ctx, conn, id) + output, err := FindTrafficPolicyInstanceByID(ctx, conn, id) if tfresource.NotFound(err) { return nil, "", nil } if err != nil { - return nil, "Unknown", err + return nil, "", err } - return object, aws.StringValue(object.TrafficPolicyInstance.State), nil + return output, aws.StringValue(output.State), nil } } diff --git a/internal/service/route53/traffic_policy_instance.go b/internal/service/route53/traffic_policy_instance.go index 15dda3d8848c..1b020749c2fc 100644 --- a/internal/service/route53/traffic_policy_instance.go +++ b/internal/service/route53/traffic_policy_instance.go @@ -112,28 +112,24 @@ func resourceTrafficPolicyInstanceCreate(ctx context.Context, d *schema.Resource func resourceTrafficPolicyInstanceRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn - input := &route53.GetTrafficPolicyInstanceInput{ - Id: aws.String(d.Id()), - } - - output, err := conn.GetTrafficPolicyInstanceWithContext(ctx, input) + trafficPolicyInstance, err := FindTrafficPolicyInstanceByID(ctx, conn, d.Id()) - if !d.IsNewResource() && tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { - log.Printf("[WARN] Route53 Traffic Policy Instance (%s) not found, removing from state", d.Id()) + if !d.IsNewResource() && tfresource.NotFound(err) { + log.Printf("[WARN] Route53 Traffic Policy Instance %s not found, removing from state", d.Id()) d.SetId("") return nil } if err != nil { - return diag.Errorf("error reading Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + return diag.Errorf("error reading Route53 Traffic Policy Instance (%s): %s", d.Id(), err) } - d.Set("hosted_zone_id", output.TrafficPolicyInstance.HostedZoneId) - d.Set("message", output.TrafficPolicyInstance.Message) - d.Set("name", strings.TrimSuffix(aws.StringValue(output.TrafficPolicyInstance.Name), ".")) - d.Set("traffic_policy_id", output.TrafficPolicyInstance.TrafficPolicyId) - d.Set("traffic_policy_version", output.TrafficPolicyInstance.TrafficPolicyVersion) - d.Set("ttl", output.TrafficPolicyInstance.TTL) + d.Set("hosted_zone_id", trafficPolicyInstance.HostedZoneId) + d.Set("message", trafficPolicyInstance.Message) + d.Set("name", strings.TrimSuffix(aws.StringValue(trafficPolicyInstance.Name), ".")) + d.Set("traffic_policy_id", trafficPolicyInstance.TrafficPolicyId) + d.Set("traffic_policy_version", trafficPolicyInstance.TrafficPolicyVersion) + d.Set("ttl", trafficPolicyInstance.TTL) return nil } diff --git a/internal/service/route53/traffic_policy_instance_test.go b/internal/service/route53/traffic_policy_instance_test.go index c1e41b01dc7b..0662578d5afc 100644 --- a/internal/service/route53/traffic_policy_instance_test.go +++ b/internal/service/route53/traffic_policy_instance_test.go @@ -5,19 +5,18 @@ import ( "fmt" "testing" - "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/route53" - "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" "github.com/hashicorp/terraform-provider-aws/internal/acctest" "github.com/hashicorp/terraform-provider-aws/internal/conns" - tfrouter53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" + tfroute53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" + "github.com/hashicorp/terraform-provider-aws/internal/tfresource" ) func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { - var output route53.GetTrafficPolicyInstanceOutput + var v route53.TrafficPolicyInstance resourceName := "aws_route53_traffic_policy_instance.test" zoneName := acctest.RandomDomainName() @@ -32,7 +31,7 @@ func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { { Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), Check: resource.ComposeTestCheckFunc( - testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "name", rName), ), }, @@ -46,7 +45,7 @@ func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { } func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { - var output route53.GetTrafficPolicyInstanceOutput + var v route53.TrafficPolicyInstance resourceName := "aws_route53_traffic_policy_instance.test" zoneName := acctest.RandomDomainName() @@ -61,8 +60,8 @@ func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { { Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), Check: resource.ComposeTestCheckFunc( - testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), - acctest.CheckResourceDisappears(acctest.Provider, tfrouter53.ResourceTrafficPolicyInstance(), resourceName), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), + acctest.CheckResourceDisappears(acctest.Provider, tfroute53.ResourceTrafficPolicyInstance(), resourceName), ), ExpectNonEmptyPlan: true, }, @@ -71,7 +70,7 @@ func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { } func TestAccRoute53TrafficPolicyInstance_complete(t *testing.T) { - var output route53.GetTrafficPolicyInstanceOutput + var v route53.TrafficPolicyInstance resourceName := "aws_route53_traffic_policy_instance.test" zoneName := acctest.RandomDomainName() @@ -87,14 +86,14 @@ func TestAccRoute53TrafficPolicyInstance_complete(t *testing.T) { { Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), Check: resource.ComposeTestCheckFunc( - testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "name", rName), ), }, { Config: testAccTrafficPolicyInstanceConfig(zoneName, rNameUpdated), Check: resource.ComposeTestCheckFunc( - testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &output), + testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "name", rNameUpdated), ), }, @@ -107,30 +106,26 @@ func TestAccRoute53TrafficPolicyInstance_complete(t *testing.T) { }) } -func testAccCheckRoute53TrafficPolicyInstanceExists(resourceName string, output *route53.GetTrafficPolicyInstanceOutput) resource.TestCheckFunc { +func testAccCheckRoute53TrafficPolicyInstanceExists(n string, v *route53.TrafficPolicyInstance) resource.TestCheckFunc { return func(s *terraform.State) error { - rs, ok := s.RootModule().Resources[resourceName] + rs, ok := s.RootModule().Resources[n] if !ok { - return fmt.Errorf("not found: %s", resourceName) + return fmt.Errorf("Not found: %s", n) } - conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn - - input := &route53.GetTrafficPolicyInstanceInput{ - Id: aws.String(rs.Primary.ID), + if rs.Primary.ID == "" { + return fmt.Errorf("No Route53 Traffic Policy Instance ID is set") } - resp, err := conn.GetTrafficPolicyInstanceWithContext(context.Background(), input) + conn := acctest.Provider.Meta().(*conns.AWSClient).Route53Conn - if err != nil { - return fmt.Errorf("problem checking for traffic policy instance existence: %w", err) - } + output, err := tfroute53.FindTrafficPolicyInstanceByID(context.Background(), conn, rs.Primary.ID) - if resp == nil { - return fmt.Errorf("traffic policy instance %q does not exist", rs.Primary.ID) + if err != nil { + return err } - output = resp + *v = *output return nil } @@ -144,25 +139,17 @@ func testAccCheckRoute53TrafficPolicyInstanceDestroy(s *terraform.State) error { continue } - input := &route53.GetTrafficPolicyInstanceInput{ - Id: aws.String(rs.Primary.ID), - } + _, err := tfroute53.FindTrafficPolicyInstanceByID(context.Background(), conn, rs.Primary.ID) - resp, err := conn.GetTrafficPolicyInstanceWithContext(context.Background(), input) - if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + if tfresource.NotFound(err) { continue } if err != nil { - return fmt.Errorf("error getting Route53 Traffic Policy Instance %s : %w", rs.Primary.Attributes["name"], err) + return err } - if err != nil { - return fmt.Errorf("error during check if traffic policy instance still exists, %#v", err) - } - if resp != nil { - return fmt.Errorf("traffic Policy instance still exists") - } + return fmt.Errorf("Route53 Traffic Policy Instance %s still exists", rs.Primary.ID) } return nil } diff --git a/internal/service/route53/wait.go b/internal/service/route53/wait.go index 95282dbc710d..67c8f9bdb857 100644 --- a/internal/service/route53/wait.go +++ b/internal/service/route53/wait.go @@ -3,13 +3,13 @@ package route53 import ( "context" "errors" - "fmt" "math/rand" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/route53" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-provider-aws/internal/tfresource" ) const ( @@ -61,19 +61,8 @@ func waitHostedZoneDNSSECStatusUpdated(conn *route53.Route53, hostedZoneID strin outputRaw, err := stateConf.WaitForState() if output, ok := outputRaw.(*route53.DNSSECStatus); ok { - if err != nil && output != nil && output.ServeSignature != nil && output.StatusMessage != nil { - newErr := fmt.Errorf("%s: %s", aws.StringValue(output.ServeSignature), aws.StringValue(output.StatusMessage)) - - switch e := err.(type) { - case *resource.TimeoutError: - if e.LastError == nil { - e.LastError = newErr - } - case *resource.UnexpectedStateError: - if e.LastError == nil { - e.LastError = newErr - } - } + if serveSignature := aws.StringValue(output.ServeSignature); serveSignature == ServeSignatureInternalFailure { + tfresource.SetLastError(err, errors.New(aws.StringValue(output.StatusMessage))) } return output, err @@ -93,16 +82,8 @@ func waitKeySigningKeyStatusUpdated(conn *route53.Route53, hostedZoneID string, outputRaw, err := stateConf.WaitForState() if output, ok := outputRaw.(*route53.KeySigningKey); ok { - if err != nil && output != nil && output.Status != nil && output.StatusMessage != nil { - newErr := fmt.Errorf("%s: %s", aws.StringValue(output.Status), aws.StringValue(output.StatusMessage)) - - var te *resource.TimeoutError - var use *resource.UnexpectedStateError - if ok := errors.As(err, &te); ok && te.LastError == nil { - te.LastError = newErr - } else if ok := errors.As(err, &use); ok && use.LastError == nil { - use.LastError = newErr - } + if status := aws.StringValue(output.Status); status == KeySigningKeyStatusInternalFailure { + tfresource.SetLastError(err, errors.New(aws.StringValue(output.StatusMessage))) } return output, err @@ -111,28 +92,30 @@ func waitKeySigningKeyStatusUpdated(conn *route53.Route53, hostedZoneID string, return nil, err } -// waitTrafficPolicyInstanceStateApplied waits for a traffic policy instance applied -func waitTrafficPolicyInstanceStateApplied(ctx context.Context, conn *route53.Route53, id string) (*route53.GetTrafficPolicyInstanceOutput, error) { +func waitTrafficPolicyInstanceStateApplied(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicyInstance, error) { stateConf := &resource.StateChangeConf{ - Pending: []string{"Creating"}, - Target: []string{"Applied", "Failed"}, + Pending: []string{TrafficPolicyInstanceStateCreating}, + Target: []string{TrafficPolicyInstanceStateApplied}, Refresh: statusTrafficPolicyInstanceState(ctx, conn, id), Timeout: trafficPolicyInstanceOperationTimeout, } outputRaw, err := stateConf.WaitForStateContext(ctx) - if output, ok := outputRaw.(*route53.GetTrafficPolicyInstanceOutput); ok { + if output, ok := outputRaw.(*route53.TrafficPolicyInstance); ok { + if state := aws.StringValue(output.State); state == TrafficPolicyInstanceStateFailed { + tfresource.SetLastError(err, errors.New(aws.StringValue(output.Message))) + } + return output, err } return nil, err } -// waitTrafficPolicyInstanceStateDeleted waits for a traffic policy instance deleted -func waitTrafficPolicyInstanceStateDeleted(ctx context.Context, conn *route53.Route53, id string) (*route53.GetTrafficPolicyInstanceOutput, error) { +func waitTrafficPolicyInstanceStateDeleted(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicyInstance, error) { stateConf := &resource.StateChangeConf{ - Pending: []string{"Deleting"}, + Pending: []string{TrafficPolicyInstanceStateApplied}, Target: []string{}, Refresh: statusTrafficPolicyInstanceState(ctx, conn, id), Timeout: trafficPolicyInstanceOperationTimeout, @@ -140,7 +123,11 @@ func waitTrafficPolicyInstanceStateDeleted(ctx context.Context, conn *route53.Ro outputRaw, err := stateConf.WaitForStateContext(ctx) - if output, ok := outputRaw.(*route53.GetTrafficPolicyInstanceOutput); ok { + if output, ok := outputRaw.(*route53.TrafficPolicyInstance); ok { + if state := aws.StringValue(output.State); state == TrafficPolicyInstanceStateFailed { + tfresource.SetLastError(err, errors.New(aws.StringValue(output.Message))) + } + return output, err } From c1ee0e644d5a4a3b4d0ae89d468efabea44f4b4e Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 09:09:47 -0400 Subject: [PATCH 35/40] r/aws_route53_traffic_policy_instance: Remove 'message' attribute. --- internal/service/route53/traffic_policy_instance.go | 5 ----- website/docs/r/route53_traffic_policy_instance.html.markdown | 1 - 2 files changed, 6 deletions(-) diff --git a/internal/service/route53/traffic_policy_instance.go b/internal/service/route53/traffic_policy_instance.go index 1b020749c2fc..c1493bf52081 100644 --- a/internal/service/route53/traffic_policy_instance.go +++ b/internal/service/route53/traffic_policy_instance.go @@ -34,10 +34,6 @@ func ResourceTrafficPolicyInstance() *schema.Resource { ForceNew: true, ValidateFunc: validation.StringLenBetween(1, 32), }, - "message": { - Type: schema.TypeString, - Computed: true, - }, "name": { Type: schema.TypeString, Required: true, @@ -125,7 +121,6 @@ func resourceTrafficPolicyInstanceRead(ctx context.Context, d *schema.ResourceDa } d.Set("hosted_zone_id", trafficPolicyInstance.HostedZoneId) - d.Set("message", trafficPolicyInstance.Message) d.Set("name", strings.TrimSuffix(aws.StringValue(trafficPolicyInstance.Name), ".")) d.Set("traffic_policy_id", trafficPolicyInstance.TrafficPolicyId) d.Set("traffic_policy_version", trafficPolicyInstance.TrafficPolicyVersion) diff --git a/website/docs/r/route53_traffic_policy_instance.html.markdown b/website/docs/r/route53_traffic_policy_instance.html.markdown index cba66dbda9b3..9813c7bee136 100644 --- a/website/docs/r/route53_traffic_policy_instance.html.markdown +++ b/website/docs/r/route53_traffic_policy_instance.html.markdown @@ -37,7 +37,6 @@ The following arguments are required: In addition to all arguments above, the following attributes are exported: * `id` - ID of traffic policy instance. -* `message` - If `state` is `Failed`, an explanation of the reason for the failure. If `state` is another value, `message` is empty. . ## Import From 3422839b6a29ad62654758fa900655220635de0a Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 09:39:42 -0400 Subject: [PATCH 36/40] r/aws_route53_traffic_policy_instance: Acceptance tests passing. Acceptance test output: % make testacc TESTS=TestAccRoute53TrafficPolicyInstance_ PKG=route53 ==> Checking that code complies with gofmt requirements... TF_ACC=1 go test ./internal/service/route53/... -v -count 1 -parallel 20 -run='TestAccRoute53TrafficPolicyInstance_' -timeout 180m === RUN TestAccRoute53TrafficPolicyInstance_basic === PAUSE TestAccRoute53TrafficPolicyInstance_basic === RUN TestAccRoute53TrafficPolicyInstance_disappears === PAUSE TestAccRoute53TrafficPolicyInstance_disappears === RUN TestAccRoute53TrafficPolicyInstance_update === PAUSE TestAccRoute53TrafficPolicyInstance_update === CONT TestAccRoute53TrafficPolicyInstance_basic === CONT TestAccRoute53TrafficPolicyInstance_update === CONT TestAccRoute53TrafficPolicyInstance_disappears --- PASS: TestAccRoute53TrafficPolicyInstance_basic (134.02s) --- PASS: TestAccRoute53TrafficPolicyInstance_disappears (139.24s) --- PASS: TestAccRoute53TrafficPolicyInstance_update (199.29s) PASS ok github.com/hashicorp/terraform-provider-aws/internal/service/route53 206.030s --- internal/service/route53/enum.go | 2 + internal/service/route53/traffic_policy.go | 2 +- .../route53/traffic_policy_instance.go | 61 ++++++++----------- .../route53/traffic_policy_instance_test.go | 39 ++++++------ internal/service/route53/wait.go | 25 +++++++- 5 files changed, 70 insertions(+), 59 deletions(-) diff --git a/internal/service/route53/enum.go b/internal/service/route53/enum.go index db92a1c03089..be2611b7bbb6 100644 --- a/internal/service/route53/enum.go +++ b/internal/service/route53/enum.go @@ -15,5 +15,7 @@ const ( TrafficPolicyInstanceStateApplied = "Applied" TrafficPolicyInstanceStateCreating = "Creating" + TrafficPolicyInstanceStateDeleting = "Deleting" TrafficPolicyInstanceStateFailed = "Failed" + TrafficPolicyInstanceStateUpdating = "Updating" ) diff --git a/internal/service/route53/traffic_policy.go b/internal/service/route53/traffic_policy.go index 8ed8cdd8ef1b..c46180382046 100644 --- a/internal/service/route53/traffic_policy.go +++ b/internal/service/route53/traffic_policy.go @@ -173,7 +173,7 @@ func resourceTrafficPolicyDelete(ctx context.Context, d *schema.ResourceData, me for _, v := range output { version := aws.Int64Value(v.Version) - log.Printf("[INFO] Delete Route53 Traffic Policy (%s) version: %d", input, version) + log.Printf("[INFO] Delete Route53 Traffic Policy (%s) version: %d", d.Id(), version) _, err := conn.DeleteTrafficPolicyWithContext(ctx, &route53.DeleteTrafficPolicyInput{ Id: aws.String(d.Id()), Version: aws.Int64(version), diff --git a/internal/service/route53/traffic_policy_instance.go b/internal/service/route53/traffic_policy_instance.go index c1493bf52081..33e8e43d2ca8 100644 --- a/internal/service/route53/traffic_policy_instance.go +++ b/internal/service/route53/traffic_policy_instance.go @@ -9,7 +9,6 @@ import ( "github.com/aws/aws-sdk-go/service/route53" "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" "github.com/hashicorp/terraform-plugin-sdk/v2/diag" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "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" @@ -66,41 +65,29 @@ func ResourceTrafficPolicyInstance() *schema.Resource { func resourceTrafficPolicyInstanceCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn + name := d.Get("name").(string) input := &route53.CreateTrafficPolicyInstanceInput{ HostedZoneId: aws.String(d.Get("hosted_zone_id").(string)), - Name: aws.String(d.Get("name").(string)), + Name: aws.String(name), TrafficPolicyId: aws.String(d.Get("traffic_policy_id").(string)), TrafficPolicyVersion: aws.Int64(int64(d.Get("traffic_policy_version").(int))), TTL: aws.Int64(int64(d.Get("ttl").(int))), } - var err error - var output *route53.CreateTrafficPolicyInstanceOutput - err = resource.RetryContext(ctx, d.Timeout(schema.TimeoutCreate), func() *resource.RetryError { - output, err = conn.CreateTrafficPolicyInstanceWithContext(ctx, input) - if err != nil { - if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { - return resource.RetryableError(err) - } + log.Printf("[INFO] Creating Route53 Traffic Policy Instance: %s", input) + outputRaw, err := tfresource.RetryWhenAWSErrCodeEqualsContext(ctx, d.Timeout(schema.TimeoutCreate), func() (interface{}, error) { + return conn.CreateTrafficPolicyInstanceWithContext(ctx, input) + }, route53.ErrCodeNoSuchTrafficPolicy) - return resource.NonRetryableError(err) - } - - return nil - }) - - if tfresource.TimedOut(err) { - output, err = conn.CreateTrafficPolicyInstanceWithContext(ctx, input) - } if err != nil { - return diag.Errorf("error creating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + return diag.Errorf("error creating Route53 Traffic Policy Instance (%s): %s", name, err) } - if _, err = waitTrafficPolicyInstanceStateApplied(ctx, conn, aws.StringValue(output.TrafficPolicyInstance.Id)); err != nil { - return diag.Errorf("error waiting for Route53 Traffic Policy Instance (%s) to be Applied: %s", d.Id(), err) - } + d.SetId(aws.StringValue(outputRaw.(*route53.CreateTrafficPolicyInstanceOutput).TrafficPolicyInstance.Id)) - d.SetId(aws.StringValue(output.TrafficPolicyInstance.Id)) + if _, err = waitTrafficPolicyInstanceStateCreated(ctx, conn, d.Id()); err != nil { + return diag.Errorf("error waiting for Route53 Traffic Policy Instance (%s) create: %s", d.Id(), err) + } return resourceTrafficPolicyInstanceRead(ctx, d, meta) } @@ -139,9 +126,15 @@ func resourceTrafficPolicyInstanceUpdate(ctx context.Context, d *schema.Resource TTL: aws.Int64(int64(d.Get("ttl").(int))), } + log.Printf("[INFO] Updating Route53 Traffic Policy Instance: %s", input) _, err := conn.UpdateTrafficPolicyInstanceWithContext(ctx, input) + if err != nil { - return diag.Errorf("error updating Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + return diag.Errorf("error updating Route53 Traffic Policy Instance (%s): %s", d.Id(), err) + } + + if _, err = waitTrafficPolicyInstanceStateUpdated(ctx, conn, d.Id()); err != nil { + return diag.Errorf("error waiting for Route53 Traffic Policy Instance (%s) update: %s", d.Id(), err) } return resourceTrafficPolicyInstanceRead(ctx, d, meta) @@ -150,23 +143,21 @@ func resourceTrafficPolicyInstanceUpdate(ctx context.Context, d *schema.Resource func resourceTrafficPolicyInstanceDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).Route53Conn - input := &route53.DeleteTrafficPolicyInstanceInput{ + log.Printf("[INFO] Delete Route53 Traffic Policy Instance: %s", d.Id()) + _, err := conn.DeleteTrafficPolicyInstanceWithContext(ctx, &route53.DeleteTrafficPolicyInstanceInput{ Id: aws.String(d.Id()), + }) + + if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { + return nil } - _, err := conn.DeleteTrafficPolicyInstanceWithContext(ctx, input) if err != nil { - if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { - return nil - } - return diag.Errorf("error deleting Route53 Traffic Policy Instance %s: %s", d.Get("name").(string), err) + return diag.Errorf("error deleting Route53 Traffic Policy Instance (%s): %s", d.Id(), err) } if _, err = waitTrafficPolicyInstanceStateDeleted(ctx, conn, d.Id()); err != nil { - if tfawserr.ErrCodeEquals(err, route53.ErrCodeNoSuchTrafficPolicyInstance) { - return nil - } - return diag.Errorf("error waiting for Route53 Traffic Policy Instance (%s) to be Deleted: %s", d.Id(), err) + return diag.Errorf("error waiting for Route53 Traffic Policy Instance (%s) delete: %s", d.Id(), err) } return nil diff --git a/internal/service/route53/traffic_policy_instance_test.go b/internal/service/route53/traffic_policy_instance_test.go index 0662578d5afc..57919db52d91 100644 --- a/internal/service/route53/traffic_policy_instance_test.go +++ b/internal/service/route53/traffic_policy_instance_test.go @@ -18,9 +18,8 @@ import ( func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { var v route53.TrafficPolicyInstance resourceName := "aws_route53_traffic_policy_instance.test" - + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) zoneName := acctest.RandomDomainName() - rName := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, @@ -29,10 +28,11 @@ func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), Steps: []resource.TestStep{ { - Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), + Config: testAccTrafficPolicyInstanceConfig(rName, zoneName, 3600), Check: resource.ComposeTestCheckFunc( testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "name", fmt.Sprintf("%s.%s", rName, zoneName)), + resource.TestCheckResourceAttr(resourceName, "ttl", "3600"), ), }, { @@ -47,9 +47,8 @@ func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { var v route53.TrafficPolicyInstance resourceName := "aws_route53_traffic_policy_instance.test" - + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) zoneName := acctest.RandomDomainName() - rName := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, @@ -58,7 +57,7 @@ func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), Steps: []resource.TestStep{ { - Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), + Config: testAccTrafficPolicyInstanceConfig(rName, zoneName, 360), Check: resource.ComposeTestCheckFunc( testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), acctest.CheckResourceDisappears(acctest.Provider, tfroute53.ResourceTrafficPolicyInstance(), resourceName), @@ -69,13 +68,11 @@ func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { }) } -func TestAccRoute53TrafficPolicyInstance_complete(t *testing.T) { +func TestAccRoute53TrafficPolicyInstance_update(t *testing.T) { var v route53.TrafficPolicyInstance resourceName := "aws_route53_traffic_policy_instance.test" - + rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) zoneName := acctest.RandomDomainName() - rName := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) - rNameUpdated := fmt.Sprintf("%s_%s", sdkacctest.RandString(5), zoneName) resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, @@ -84,17 +81,17 @@ func TestAccRoute53TrafficPolicyInstance_complete(t *testing.T) { ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), Steps: []resource.TestStep{ { - Config: testAccTrafficPolicyInstanceConfig(zoneName, rName), + Config: testAccTrafficPolicyInstanceConfig(rName, zoneName, 3600), Check: resource.ComposeTestCheckFunc( testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "name", rName), + resource.TestCheckResourceAttr(resourceName, "ttl", "3600"), ), }, { - Config: testAccTrafficPolicyInstanceConfig(zoneName, rNameUpdated), + Config: testAccTrafficPolicyInstanceConfig(rName, zoneName, 7200), Check: resource.ComposeTestCheckFunc( testAccCheckRoute53TrafficPolicyInstanceExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "name", rNameUpdated), + resource.TestCheckResourceAttr(resourceName, "ttl", "7200"), ), }, { @@ -154,14 +151,14 @@ func testAccCheckRoute53TrafficPolicyInstanceDestroy(s *terraform.State) error { return nil } -func testAccTrafficPolicyInstanceConfig(zoneName, instanceName string) string { +func testAccTrafficPolicyInstanceConfig(rName, zoneName string, ttl int) string { return fmt.Sprintf(` resource "aws_route53_zone" "test" { - name = %[1]q + name = %[2]q } resource "aws_route53_traffic_policy" "test" { - name = aws_route53_zone.test.name + name = %[1]q document = <<-EOT { "AWSPolicyFormatVersion":"2015-10-01", @@ -179,10 +176,10 @@ EOT resource "aws_route53_traffic_policy_instance" "test" { hosted_zone_id = aws_route53_zone.test.zone_id - name = %[2]q + name = "%[1]s.%[2]s" traffic_policy_id = aws_route53_traffic_policy.test.id traffic_policy_version = aws_route53_traffic_policy.test.version - ttl = 360 + ttl = %[3]d } -`, zoneName, instanceName) +`, rName, zoneName, ttl) } diff --git a/internal/service/route53/wait.go b/internal/service/route53/wait.go index 67c8f9bdb857..c47a81ef03d0 100644 --- a/internal/service/route53/wait.go +++ b/internal/service/route53/wait.go @@ -92,7 +92,7 @@ func waitKeySigningKeyStatusUpdated(conn *route53.Route53, hostedZoneID string, return nil, err } -func waitTrafficPolicyInstanceStateApplied(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicyInstance, error) { +func waitTrafficPolicyInstanceStateCreated(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicyInstance, error) { stateConf := &resource.StateChangeConf{ Pending: []string{TrafficPolicyInstanceStateCreating}, Target: []string{TrafficPolicyInstanceStateApplied}, @@ -115,7 +115,7 @@ func waitTrafficPolicyInstanceStateApplied(ctx context.Context, conn *route53.Ro func waitTrafficPolicyInstanceStateDeleted(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicyInstance, error) { stateConf := &resource.StateChangeConf{ - Pending: []string{TrafficPolicyInstanceStateApplied}, + Pending: []string{TrafficPolicyInstanceStateDeleting}, Target: []string{}, Refresh: statusTrafficPolicyInstanceState(ctx, conn, id), Timeout: trafficPolicyInstanceOperationTimeout, @@ -133,3 +133,24 @@ func waitTrafficPolicyInstanceStateDeleted(ctx context.Context, conn *route53.Ro return nil, err } + +func waitTrafficPolicyInstanceStateUpdated(ctx context.Context, conn *route53.Route53, id string) (*route53.TrafficPolicyInstance, error) { + stateConf := &resource.StateChangeConf{ + Pending: []string{TrafficPolicyInstanceStateUpdating}, + Target: []string{TrafficPolicyInstanceStateApplied}, + Refresh: statusTrafficPolicyInstanceState(ctx, conn, id), + Timeout: trafficPolicyInstanceOperationTimeout, + } + + outputRaw, err := stateConf.WaitForStateContext(ctx) + + if output, ok := outputRaw.(*route53.TrafficPolicyInstance); ok { + if state := aws.StringValue(output.State); state == TrafficPolicyInstanceStateFailed { + tfresource.SetLastError(err, errors.New(aws.StringValue(output.Message))) + } + + return output, err + } + + return nil, err +} From efeb888a6f62e1681d67ddf127362ea7d5b76902 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 09:54:16 -0400 Subject: [PATCH 37/40] r/aws_route53_traffic_policy_instance: Add Sweeper. --- internal/service/route53/list_pages.go | 36 +++++++++++++++++ internal/service/route53/sweep.go | 55 +++++++++++++++++++++++++- 2 files changed, 89 insertions(+), 2 deletions(-) create mode 100644 internal/service/route53/list_pages.go diff --git a/internal/service/route53/list_pages.go b/internal/service/route53/list_pages.go new file mode 100644 index 000000000000..bb50ad91b6cd --- /dev/null +++ b/internal/service/route53/list_pages.go @@ -0,0 +1,36 @@ +//go:build !generate +// +build !generate + +package route53 + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/route53" +) + +// Custom Route 53 service lister functions using the same format as generated code. + +func listTrafficPolicyInstancesPages(conn *route53.Route53, input *route53.ListTrafficPolicyInstancesInput, fn func(*route53.ListTrafficPolicyInstancesOutput, bool) bool) error { + return listTrafficPolicyInstancesPagesWithContext(context.Background(), conn, input, fn) +} + +func listTrafficPolicyInstancesPagesWithContext(ctx context.Context, conn *route53.Route53, input *route53.ListTrafficPolicyInstancesInput, fn func(*route53.ListTrafficPolicyInstancesOutput, bool) bool) error { + for { + output, err := conn.ListTrafficPolicyInstancesWithContext(ctx, input) + if err != nil { + return err + } + + lastPage := !aws.BoolValue(output.IsTruncated) + if !fn(output, lastPage) || lastPage { + break + } + + input.HostedZoneIdMarker = output.HostedZoneIdMarker + input.TrafficPolicyInstanceNameMarker = output.TrafficPolicyInstanceNameMarker + input.TrafficPolicyInstanceTypeMarker = output.TrafficPolicyInstanceTypeMarker + } + return nil +} diff --git a/internal/service/route53/sweep.go b/internal/service/route53/sweep.go index c50dfdd6d835..77c898289e0d 100644 --- a/internal/service/route53/sweep.go +++ b/internal/service/route53/sweep.go @@ -22,7 +22,7 @@ import ( func init() { resource.AddTestSweepers("aws_route53_health_check", &resource.Sweeper{ Name: "aws_route53_health_check", - F: sweepHealthchecks, + F: sweepHealthChecks, }) resource.AddTestSweepers("aws_route53_key_signing_key", &resource.Sweeper{ @@ -38,6 +38,14 @@ func init() { resource.AddTestSweepers("aws_route53_traffic_policy", &resource.Sweeper{ Name: "aws_route53_traffic_policy", F: sweepTrafficPolicies, + Dependencies: []string{ + "aws_route53_traffic_policy_instance", + }, + }) + + resource.AddTestSweepers("aws_route53_traffic_policy_instance", &resource.Sweeper{ + Name: "aws_route53_traffic_policy_instance", + F: sweepTrafficPolicyInstances, }) resource.AddTestSweepers("aws_route53_zone", &resource.Sweeper{ @@ -54,7 +62,7 @@ func init() { }) } -func sweepHealthchecks(region string) error { +func sweepHealthChecks(region string) error { client, err := sweep.SharedRegionalSweepClient(region) if err != nil { @@ -270,6 +278,49 @@ func sweepTrafficPolicies(region string) error { return nil } +func sweepTrafficPolicyInstances(region string) error { + client, err := sweep.SharedRegionalSweepClient(region) + if err != nil { + return fmt.Errorf("error getting client: %w", err) + } + conn := client.(*conns.AWSClient).Route53Conn + input := &route53.ListTrafficPolicyInstancesInput{} + sweepResources := make([]*sweep.SweepResource, 0) + + err = listTrafficPolicyInstancesPages(conn, input, func(page *route53.ListTrafficPolicyInstancesOutput, lastPage bool) bool { + if page == nil { + return !lastPage + } + + for _, v := range page.TrafficPolicyInstances { + r := ResourceTrafficPolicyInstance() + d := r.Data(nil) + d.SetId(aws.StringValue(v.Id)) + + sweepResources = append(sweepResources, sweep.NewSweepResource(r, d, client)) + } + + return !lastPage + }) + + if sweep.SkipSweepError(err) { + log.Printf("[WARN] Skipping Route 53 Traffic Policy Instance sweep for %s: %s", region, err) + return nil + } + + if err != nil { + return fmt.Errorf("error listing Route 53 Traffic Policy Instances (%s): %w", region, err) + } + + err = sweep.SweepOrchestrator(sweepResources) + + if err != nil { + return fmt.Errorf("error sweeping Route 53 Traffic Policy Instances (%s): %w", region, err) + } + + return nil +} + func sweepZones(region string) error { client, err := sweep.SharedRegionalSweepClient(region) From 9e3bcf602be06b761ce6e0e498a74ab9d434b42b Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 09:57:17 -0400 Subject: [PATCH 38/40] d/aws_route53_traffic_policy_document: Tweak acceptance test function names. --- .../route53/traffic_policy_document_data_source_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/service/route53/traffic_policy_document_data_source_test.go b/internal/service/route53/traffic_policy_document_data_source_test.go index ec691bb78117..c8b246814624 100644 --- a/internal/service/route53/traffic_policy_document_data_source_test.go +++ b/internal/service/route53/traffic_policy_document_data_source_test.go @@ -13,7 +13,7 @@ import ( tfrouter53 "github.com/hashicorp/terraform-provider-aws/internal/service/route53" ) -func TestAccDataSourceTrafficPolicyDocument_basic(t *testing.T) { +func TestAccRoute53TrafficPolicyDocumentDataSource_basic(t *testing.T) { resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, ProviderFactories: acctest.ProviderFactories, @@ -30,7 +30,7 @@ func TestAccDataSourceTrafficPolicyDocument_basic(t *testing.T) { }) } -func TestAccDataSourceTrafficPolicyDocument_complete(t *testing.T) { +func TestAccRoute53TrafficPolicyDocumentDataSource_complete(t *testing.T) { resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { acctest.PreCheck(t) }, ProviderFactories: acctest.ProviderFactories, From 5cf1edbce24277c1cb94d584ff1fc5b8ed9231f3 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 11:24:22 -0400 Subject: [PATCH 39/40] Fix golangci-lint error "'listTrafficPolicyInstancesPages' is unused (deadcode)". --- internal/service/route53/list_pages.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/service/route53/list_pages.go b/internal/service/route53/list_pages.go index bb50ad91b6cd..2d559bf9a378 100644 --- a/internal/service/route53/list_pages.go +++ b/internal/service/route53/list_pages.go @@ -12,7 +12,7 @@ import ( // Custom Route 53 service lister functions using the same format as generated code. -func listTrafficPolicyInstancesPages(conn *route53.Route53, input *route53.ListTrafficPolicyInstancesInput, fn func(*route53.ListTrafficPolicyInstancesOutput, bool) bool) error { +func listTrafficPolicyInstancesPages(conn *route53.Route53, input *route53.ListTrafficPolicyInstancesInput, fn func(*route53.ListTrafficPolicyInstancesOutput, bool) bool) error { //nolint:deadcode // This function is called from a sweeper. return listTrafficPolicyInstancesPagesWithContext(context.Background(), conn, input, fn) } From 4f3dd99d205158a5a67216d0e35ec3a3f735ee1c Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Tue, 22 Mar 2022 11:24:54 -0400 Subject: [PATCH 40/40] Route 53 Traffic Policies not available in AWS GovCloud. --- .../route53/traffic_policy_instance_test.go | 15 ++++++++++++--- internal/service/route53/traffic_policy_test.go | 6 +++--- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/internal/service/route53/traffic_policy_instance_test.go b/internal/service/route53/traffic_policy_instance_test.go index 57919db52d91..4f1844a677b2 100644 --- a/internal/service/route53/traffic_policy_instance_test.go +++ b/internal/service/route53/traffic_policy_instance_test.go @@ -5,6 +5,7 @@ import ( "fmt" "testing" + "github.com/aws/aws-sdk-go/aws/endpoints" "github.com/aws/aws-sdk-go/service/route53" sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" @@ -15,6 +16,14 @@ import ( "github.com/hashicorp/terraform-provider-aws/internal/tfresource" ) +func testAccPreCheckRoute53TrafficPolicy(t *testing.T) { + acctest.PreCheckPartitionHasService(route53.EndpointsID, t) + + if got, want := acctest.Partition(), endpoints.AwsUsGovPartitionID; got == want { + t.Skipf("Route 53 Traffic Policies are not supported in %s partition", got) + } +} + func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { var v route53.TrafficPolicyInstance resourceName := "aws_route53_traffic_policy_instance.test" @@ -22,7 +31,7 @@ func TestAccRoute53TrafficPolicyInstance_basic(t *testing.T) { zoneName := acctest.RandomDomainName() resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acctest.PreCheck(t) }, + PreCheck: func() { acctest.PreCheck(t); testAccPreCheckRoute53TrafficPolicy(t) }, ProviderFactories: acctest.ProviderFactories, CheckDestroy: testAccCheckRoute53TrafficPolicyInstanceDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), @@ -51,7 +60,7 @@ func TestAccRoute53TrafficPolicyInstance_disappears(t *testing.T) { zoneName := acctest.RandomDomainName() resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acctest.PreCheck(t) }, + PreCheck: func() { acctest.PreCheck(t); testAccPreCheckRoute53TrafficPolicy(t) }, ProviderFactories: acctest.ProviderFactories, CheckDestroy: testAccCheckRoute53TrafficPolicyInstanceDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), @@ -75,7 +84,7 @@ func TestAccRoute53TrafficPolicyInstance_update(t *testing.T) { zoneName := acctest.RandomDomainName() resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acctest.PreCheck(t) }, + PreCheck: func() { acctest.PreCheck(t); testAccPreCheckRoute53TrafficPolicy(t) }, ProviderFactories: acctest.ProviderFactories, CheckDestroy: testAccCheckRoute53TrafficPolicyInstanceDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), diff --git a/internal/service/route53/traffic_policy_test.go b/internal/service/route53/traffic_policy_test.go index 9d1d53eeafb7..458a934db00c 100644 --- a/internal/service/route53/traffic_policy_test.go +++ b/internal/service/route53/traffic_policy_test.go @@ -21,7 +21,7 @@ func TestAccRoute53TrafficPolicy_basic(t *testing.T) { rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acctest.PreCheck(t) }, + PreCheck: func() { acctest.PreCheck(t); testAccPreCheckRoute53TrafficPolicy(t) }, ProviderFactories: acctest.ProviderFactories, CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), @@ -52,7 +52,7 @@ func TestAccRoute53TrafficPolicy_disappears(t *testing.T) { rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acctest.PreCheck(t) }, + PreCheck: func() { acctest.PreCheck(t); testAccPreCheckRoute53TrafficPolicy(t) }, ProviderFactories: acctest.ProviderFactories, CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID), @@ -77,7 +77,7 @@ func TestAccRoute53TrafficPolicy_update(t *testing.T) { commentUpdated := `comment updated` resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acctest.PreCheck(t) }, + PreCheck: func() { acctest.PreCheck(t); testAccPreCheckRoute53TrafficPolicy(t) }, ProviderFactories: acctest.ProviderFactories, CheckDestroy: testAccCheckRoute53TrafficPolicyDestroy, ErrorCheck: acctest.ErrorCheck(t, route53.EndpointsID),