From fa61df28d7bb546c577e6068b07cee1d5f5b9fe5 Mon Sep 17 00:00:00 2001 From: Aleksander Aleksic Date: Wed, 7 Sep 2022 12:51:31 +0200 Subject: [PATCH 01/12] Use DescribeManagedPrefixListsPagesWithContext to get prefix list Replaces DescribeManagedPrefixListsWithContext --- .../vpc_managed_prefix_list_data_source.go | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/internal/service/ec2/vpc_managed_prefix_list_data_source.go b/internal/service/ec2/vpc_managed_prefix_list_data_source.go index 5eb4489a765e..4beb29072238 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_data_source.go +++ b/internal/service/ec2/vpc_managed_prefix_list_data_source.go @@ -94,21 +94,32 @@ func dataSourceManagedPrefixListRead(ctx context.Context, d *schema.ResourceData }) } - out, err := conn.DescribeManagedPrefixListsWithContext(ctx, &input) + var prefixLists []*ec2.ManagedPrefixList + + err := conn.DescribeManagedPrefixListsPagesWithContext( + ctx, + &input, + func(output *ec2.DescribeManagedPrefixListsOutput, lastPage bool) bool { + for _, prefixList := range output.PrefixLists { + prefixLists = append(prefixLists, prefixList) + } + + return !lastPage + }) if err != nil { return diag.Errorf("error describing EC2 Managed Prefix Lists: %s", err) } - if out == nil || len(out.PrefixLists) < 1 || out.PrefixLists[0] == nil { + if len(prefixLists) < 1 || prefixLists[0] == nil { return diag.Errorf("no managed prefix lists matched the given criteria") } - if len(out.PrefixLists) > 1 { + if len(prefixLists) > 1 { return diag.Errorf("more than 1 prefix list matched the given criteria") } - pl := out.PrefixLists[0] + pl := prefixLists[0] d.SetId(aws.StringValue(pl.PrefixListId)) d.Set("name", pl.PrefixListName) From 20f8428437bbafcd14b9fe13390cf3618ffcf4f0 Mon Sep 17 00:00:00 2001 From: Aleksander Aleksic Date: Wed, 7 Sep 2022 13:11:54 +0200 Subject: [PATCH 02/12] Added changelog --- .changelog/26683.txt | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 .changelog/26683.txt diff --git a/.changelog/26683.txt b/.changelog/26683.txt new file mode 100644 index 000000000000..ebd81fdbb56d --- /dev/null +++ b/.changelog/26683.txt @@ -0,0 +1,3 @@ +```release-note:bug +data-source/aws_ec2_managed_prefix_list: Fixes bug where an error is returned for regions with more than 100 managed prefix lists +``` From 1d2d86fda717eee651883649b7215ee8a2395a3b Mon Sep 17 00:00:00 2001 From: Aleksander Aleksic Date: Wed, 7 Sep 2022 13:16:03 +0200 Subject: [PATCH 03/12] No need for for-loop --- internal/service/ec2/vpc_managed_prefix_list_data_source.go | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/internal/service/ec2/vpc_managed_prefix_list_data_source.go b/internal/service/ec2/vpc_managed_prefix_list_data_source.go index 4beb29072238..9278d678ee16 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_data_source.go +++ b/internal/service/ec2/vpc_managed_prefix_list_data_source.go @@ -100,10 +100,7 @@ func dataSourceManagedPrefixListRead(ctx context.Context, d *schema.ResourceData ctx, &input, func(output *ec2.DescribeManagedPrefixListsOutput, lastPage bool) bool { - for _, prefixList := range output.PrefixLists { - prefixLists = append(prefixLists, prefixList) - } - + prefixLists = append(prefixLists, output.PrefixLists...) return !lastPage }) From 31bb7a2e453e40046bcb2dfbcbd3ce67e9a211e0 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 10:57:21 -0400 Subject: [PATCH 04/12] Add 'FindManagedPrefixLists' and 'FindManagedPrefixListEntries'. --- internal/service/ec2/find.go | 95 ++++++++++++++++++++++++++---------- 1 file changed, 68 insertions(+), 27 deletions(-) diff --git a/internal/service/ec2/find.go b/internal/service/ec2/find.go index 3f0936c02fc1..dce9a03df50a 100644 --- a/internal/service/ec2/find.go +++ b/internal/service/ec2/find.go @@ -4980,12 +4980,40 @@ func FindLaunchTemplateVersionByTwoPartKey(conn *ec2.EC2, launchTemplateID, vers return output, nil } -func FindManagedPrefixListByID(conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { - input := &ec2.DescribeManagedPrefixListsInput{ - PrefixListIds: aws.StringSlice([]string{id}), +func FindManagedPrefixList(conn *ec2.EC2, input *ec2.DescribeManagedPrefixListsInput) (*ec2.ManagedPrefixList, error) { + output, err := FindManagedPrefixLists(conn, input) + + if err != nil { + return nil, err } - output, err := conn.DescribeManagedPrefixLists(input) + if len(output) == 0 || output[0] == nil { + return nil, tfresource.NewEmptyResultError(input) + } + + if count := len(output); count > 1 { + return nil, tfresource.NewTooManyResultsError(count, input) + } + + return output[0], nil +} + +func FindManagedPrefixLists(conn *ec2.EC2, input *ec2.DescribeManagedPrefixListsInput) ([]*ec2.ManagedPrefixList, error) { + var output []*ec2.ManagedPrefixList + + err := conn.DescribeManagedPrefixListsPages(input, func(page *ec2.DescribeManagedPrefixListsOutput, lastPage bool) bool { + if page == nil { + return !lastPage + } + + for _, v := range page.PrefixLists { + if v != nil { + output = append(output, v) + } + } + + return !lastPage + }) if tfawserr.ErrCodeEquals(err, errCodeInvalidPrefixListIDNotFound) { return nil, &resource.NotFoundError{ @@ -4998,44 +5026,49 @@ func FindManagedPrefixListByID(conn *ec2.EC2, id string) (*ec2.ManagedPrefixList return nil, err } - if output == nil || len(output.PrefixLists) == 0 || output.PrefixLists[0] == nil { - return nil, tfresource.NewEmptyResultError(input) - } + return output, nil +} - if count := len(output.PrefixLists); count > 1 { - return nil, tfresource.NewTooManyResultsError(count, input) +func FindManagedPrefixListByID(conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { + input := &ec2.DescribeManagedPrefixListsInput{ + PrefixListIds: aws.StringSlice([]string{id}), } - prefixList := output.PrefixLists[0] + output, err := FindManagedPrefixList(conn, input) - if state := aws.StringValue(prefixList.State); state == ec2.PrefixListStateDeleteComplete { + if err != nil { + return nil, err + } + + if state := aws.StringValue(output.State); state == ec2.PrefixListStateDeleteComplete { return nil, &resource.NotFoundError{ Message: state, LastRequest: input, } } - return prefixList, nil -} - -func FindManagedPrefixListEntriesByID(conn *ec2.EC2, id string) ([]*ec2.PrefixListEntry, error) { - input := &ec2.GetManagedPrefixListEntriesInput{ - PrefixListId: aws.String(id), + // Eventual consistency check. + if aws.StringValue(output.PrefixListId) != id { + return nil, &resource.NotFoundError{ + LastRequest: input, + } } - var prefixListEntries []*ec2.PrefixListEntry + return output, nil +} + +func FindManagedPrefixListEntries(conn *ec2.EC2, input *ec2.GetManagedPrefixListEntriesInput) ([]*ec2.PrefixListEntry, error) { + var output []*ec2.PrefixListEntry err := conn.GetManagedPrefixListEntriesPages(input, func(page *ec2.GetManagedPrefixListEntriesOutput, lastPage bool) bool { if page == nil { return !lastPage } - for _, entry := range page.Entries { - if entry == nil { - continue + for _, v := range page.Entries { + if v != nil { + output = append(output, v) } - - prefixListEntries = append(prefixListEntries, entry) } return !lastPage @@ -5052,7 +5085,15 @@ func FindManagedPrefixListEntriesByID(conn *ec2.EC2, id string) ([]*ec2.PrefixLi return nil, err } - return prefixListEntries, nil + return output, nil +} + +func FindManagedPrefixListEntriesByID(conn *ec2.EC2, id string) ([]*ec2.PrefixListEntry, error) { + input := &ec2.GetManagedPrefixListEntriesInput{ + PrefixListId: aws.String(id), + } + + return FindManagedPrefixListEntries(conn, input) } func FindManagedPrefixListEntryByIDAndCIDR(conn *ec2.EC2, id, cidr string) (*ec2.PrefixListEntry, error) { @@ -5062,9 +5103,9 @@ func FindManagedPrefixListEntryByIDAndCIDR(conn *ec2.EC2, id, cidr string) (*ec2 return nil, err } - for _, entry := range prefixListEntries { - if aws.StringValue(entry.Cidr) == cidr { - return entry, nil + for _, v := range prefixListEntries { + if aws.StringValue(v.Cidr) == cidr { + return v, nil } } From 0aff483ed790eb07bd2953e709857015c99519ec Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 12:14:52 -0400 Subject: [PATCH 05/12] r/aws_ec2_managed_prefix_list(_entry): Start to add context. --- internal/service/ec2/find.go | 12 ++++++------ internal/service/ec2/status.go | 4 ++-- .../service/ec2/vpc_managed_prefix_list.go | 10 +++++----- .../ec2/vpc_managed_prefix_list_entry.go | 9 +++++---- .../ec2/vpc_managed_prefix_list_test.go | 5 +++-- internal/service/ec2/wait.go | 18 +++++++++--------- 6 files changed, 30 insertions(+), 28 deletions(-) diff --git a/internal/service/ec2/find.go b/internal/service/ec2/find.go index dce9a03df50a..c6edc991d9fc 100644 --- a/internal/service/ec2/find.go +++ b/internal/service/ec2/find.go @@ -4980,8 +4980,8 @@ func FindLaunchTemplateVersionByTwoPartKey(conn *ec2.EC2, launchTemplateID, vers return output, nil } -func FindManagedPrefixList(conn *ec2.EC2, input *ec2.DescribeManagedPrefixListsInput) (*ec2.ManagedPrefixList, error) { - output, err := FindManagedPrefixLists(conn, input) +func FindManagedPrefixList(ctx context.Context, conn *ec2.EC2, input *ec2.DescribeManagedPrefixListsInput) (*ec2.ManagedPrefixList, error) { + output, err := FindManagedPrefixLists(ctx, conn, input) if err != nil { return nil, err @@ -4998,10 +4998,10 @@ func FindManagedPrefixList(conn *ec2.EC2, input *ec2.DescribeManagedPrefixListsI return output[0], nil } -func FindManagedPrefixLists(conn *ec2.EC2, input *ec2.DescribeManagedPrefixListsInput) ([]*ec2.ManagedPrefixList, error) { +func FindManagedPrefixLists(ctx context.Context, conn *ec2.EC2, input *ec2.DescribeManagedPrefixListsInput) ([]*ec2.ManagedPrefixList, error) { var output []*ec2.ManagedPrefixList - err := conn.DescribeManagedPrefixListsPages(input, func(page *ec2.DescribeManagedPrefixListsOutput, lastPage bool) bool { + err := conn.DescribeManagedPrefixListsPagesWithContext(ctx, input, func(page *ec2.DescribeManagedPrefixListsOutput, lastPage bool) bool { if page == nil { return !lastPage } @@ -5029,12 +5029,12 @@ func FindManagedPrefixLists(conn *ec2.EC2, input *ec2.DescribeManagedPrefixLists return output, nil } -func FindManagedPrefixListByID(conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { +func FindManagedPrefixListByID(ctx context.Context, conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { input := &ec2.DescribeManagedPrefixListsInput{ PrefixListIds: aws.StringSlice([]string{id}), } - output, err := FindManagedPrefixList(conn, input) + output, err := FindManagedPrefixList(ctx, conn, input) if err != nil { return nil, err diff --git a/internal/service/ec2/status.go b/internal/service/ec2/status.go index e534665e4dbf..7dc2bdcd2a0a 100644 --- a/internal/service/ec2/status.go +++ b/internal/service/ec2/status.go @@ -1101,9 +1101,9 @@ func StatusInternetGatewayAttachmentState(conn *ec2.EC2, internetGatewayID, vpcI } } -func StatusManagedPrefixListState(conn *ec2.EC2, id string) resource.StateRefreshFunc { +func StatusManagedPrefixListState(ctx context.Context, conn *ec2.EC2, id string) resource.StateRefreshFunc { return func() (interface{}, string, error) { - output, err := FindManagedPrefixListByID(conn, id) + output, err := FindManagedPrefixListByID(ctx, conn, id) if tfresource.NotFound(err) { return nil, "", nil diff --git a/internal/service/ec2/vpc_managed_prefix_list.go b/internal/service/ec2/vpc_managed_prefix_list.go index 4fa5b3cfbc1e..02def807d647 100644 --- a/internal/service/ec2/vpc_managed_prefix_list.go +++ b/internal/service/ec2/vpc_managed_prefix_list.go @@ -127,7 +127,7 @@ func resourceManagedPrefixListCreate(d *schema.ResourceData, meta interface{}) e d.SetId(aws.StringValue(output.PrefixList.PrefixListId)) - if _, err := WaitManagedPrefixListCreated(conn, d.Id()); err != nil { + if _, err := WaitManagedPrefixListCreated(context.TODO(), conn, d.Id()); err != nil { return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) create: %w", d.Id(), err) } @@ -139,7 +139,7 @@ func resourceManagedPrefixListRead(d *schema.ResourceData, meta interface{}) err defaultTagsConfig := meta.(*conns.AWSClient).DefaultTagsConfig ignoreTagsConfig := meta.(*conns.AWSClient).IgnoreTagsConfig - pl, err := FindManagedPrefixListByID(conn, d.Id()) + pl, err := FindManagedPrefixListByID(context.TODO(), conn, d.Id()) if !d.IsNewResource() && tfresource.NotFound(err) { log.Printf("[WARN] EC2 Managed Prefix List %s not found, removing from state", d.Id()) @@ -251,7 +251,7 @@ func resourceManagedPrefixListUpdate(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("error updating EC2 Managed Prefix List (%s): %w", d.Id(), err) } - managedPrefixList, err := WaitManagedPrefixListModified(conn, d.Id()) + managedPrefixList, err := WaitManagedPrefixListModified(context.TODO(), conn, d.Id()) if err != nil { return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) update: %w", d.Id(), err) @@ -285,7 +285,7 @@ func resourceManagedPrefixListUpdate(d *schema.ResourceData, meta interface{}) e } if wait { - if _, err := WaitManagedPrefixListModified(conn, d.Id()); err != nil { + if _, err := WaitManagedPrefixListModified(context.TODO(), conn, d.Id()); err != nil { return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) update: %w", d.Id(), err) } } @@ -317,7 +317,7 @@ func resourceManagedPrefixListDelete(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("error deleting EC2 Managed Prefix List (%s): %w", d.Id(), err) } - if _, err := WaitManagedPrefixListDeleted(conn, d.Id()); err != nil { + if _, err := WaitManagedPrefixListDeleted(context.TODO(), conn, d.Id()); err != nil { return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) delete: %w", d.Id(), err) } diff --git a/internal/service/ec2/vpc_managed_prefix_list_entry.go b/internal/service/ec2/vpc_managed_prefix_list_entry.go index 20f7653963b1..ce03c2a692c6 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_entry.go +++ b/internal/service/ec2/vpc_managed_prefix_list_entry.go @@ -1,6 +1,7 @@ package ec2 import ( + "context" "fmt" "log" @@ -62,7 +63,7 @@ func resourceManagedPrefixListEntryCreate(d *schema.ResourceData, meta interface conns.GlobalMutexKV.Lock(mutexKey) defer conns.GlobalMutexKV.Unlock(mutexKey) - pl, err := FindManagedPrefixListByID(conn, plID) + pl, err := FindManagedPrefixListByID(context.TODO(), conn, plID) if err != nil { return nil, fmt.Errorf("error reading VPC Managed Prefix List (%s): %w", plID, err) @@ -83,7 +84,7 @@ func resourceManagedPrefixListEntryCreate(d *schema.ResourceData, meta interface d.SetId(id) - if _, err := WaitManagedPrefixListModified(conn, plID); err != nil { + if _, err := WaitManagedPrefixListModified(context.TODO(), conn, plID); err != nil { return fmt.Errorf("error waiting for VPC Managed Prefix List Entry (%s) create: %w", d.Id(), err) } @@ -135,7 +136,7 @@ func resourceManagedPrefixListEntryDelete(d *schema.ResourceData, meta interface conns.GlobalMutexKV.Lock(mutexKey) defer conns.GlobalMutexKV.Unlock(mutexKey) - pl, err := FindManagedPrefixListByID(conn, plID) + pl, err := FindManagedPrefixListByID(context.TODO(), conn, plID) if err != nil { return nil, fmt.Errorf("error reading VPC Managed Prefix List (%s): %w", plID, err) @@ -154,7 +155,7 @@ func resourceManagedPrefixListEntryDelete(d *schema.ResourceData, meta interface return fmt.Errorf("error deleting VPC Managed Prefix List Entry (%s): %w", d.Id(), err) } - _, err = WaitManagedPrefixListModified(conn, plID) + _, err = WaitManagedPrefixListModified(context.TODO(), conn, plID) if err != nil { return fmt.Errorf("error waiting for VPC Managed Prefix List Entry (%s) delete: %w", d.Id(), err) diff --git a/internal/service/ec2/vpc_managed_prefix_list_test.go b/internal/service/ec2/vpc_managed_prefix_list_test.go index a6612dc0221e..a8225f81d3df 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_test.go +++ b/internal/service/ec2/vpc_managed_prefix_list_test.go @@ -1,6 +1,7 @@ package ec2_test import ( + "context" "fmt" "regexp" "testing" @@ -310,7 +311,7 @@ func testAccCheckManagedPrefixListDestroy(s *terraform.State) error { continue } - _, err := tfec2.FindManagedPrefixListByID(conn, rs.Primary.ID) + _, err := tfec2.FindManagedPrefixListByID(context.Background(), conn, rs.Primary.ID) if tfresource.NotFound(err) { continue @@ -339,7 +340,7 @@ func testAccManagedPrefixListExists(resourceName string) resource.TestCheckFunc conn := acctest.Provider.Meta().(*conns.AWSClient).EC2Conn - _, err := tfec2.FindManagedPrefixListByID(conn, rs.Primary.ID) + _, err := tfec2.FindManagedPrefixListByID(context.Background(), conn, rs.Primary.ID) return err } diff --git a/internal/service/ec2/wait.go b/internal/service/ec2/wait.go index 360ffd8f2d63..d096f2c18f96 100644 --- a/internal/service/ec2/wait.go +++ b/internal/service/ec2/wait.go @@ -2281,15 +2281,15 @@ const ( ManagedPrefixListTimeout = 15 * time.Minute ) -func WaitManagedPrefixListCreated(conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { +func WaitManagedPrefixListCreated(ctx context.Context, conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { stateConf := &resource.StateChangeConf{ Pending: []string{ec2.PrefixListStateCreateInProgress}, Target: []string{ec2.PrefixListStateCreateComplete}, Timeout: ManagedPrefixListTimeout, - Refresh: StatusManagedPrefixListState(conn, id), + Refresh: StatusManagedPrefixListState(ctx, conn, id), } - outputRaw, err := stateConf.WaitForState() + outputRaw, err := stateConf.WaitForStateContext(ctx) if output, ok := outputRaw.(*ec2.ManagedPrefixList); ok { if state := aws.StringValue(output.State); state == ec2.PrefixListStateCreateFailed { @@ -2302,15 +2302,15 @@ func WaitManagedPrefixListCreated(conn *ec2.EC2, id string) (*ec2.ManagedPrefixL return nil, err } -func WaitManagedPrefixListModified(conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { +func WaitManagedPrefixListModified(ctx context.Context, conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { stateConf := &resource.StateChangeConf{ Pending: []string{ec2.PrefixListStateModifyInProgress}, Target: []string{ec2.PrefixListStateModifyComplete}, Timeout: ManagedPrefixListTimeout, - Refresh: StatusManagedPrefixListState(conn, id), + Refresh: StatusManagedPrefixListState(ctx, conn, id), } - outputRaw, err := stateConf.WaitForState() + outputRaw, err := stateConf.WaitForStateContext(ctx) if output, ok := outputRaw.(*ec2.ManagedPrefixList); ok { if state := aws.StringValue(output.State); state == ec2.PrefixListStateModifyFailed { @@ -2323,15 +2323,15 @@ func WaitManagedPrefixListModified(conn *ec2.EC2, id string) (*ec2.ManagedPrefix return nil, err } -func WaitManagedPrefixListDeleted(conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { +func WaitManagedPrefixListDeleted(ctx context.Context, conn *ec2.EC2, id string) (*ec2.ManagedPrefixList, error) { stateConf := &resource.StateChangeConf{ Pending: []string{ec2.PrefixListStateDeleteInProgress}, Target: []string{}, Timeout: ManagedPrefixListTimeout, - Refresh: StatusManagedPrefixListState(conn, id), + Refresh: StatusManagedPrefixListState(ctx, conn, id), } - outputRaw, err := stateConf.WaitForState() + outputRaw, err := stateConf.WaitForStateContext(ctx) if output, ok := outputRaw.(*ec2.ManagedPrefixList); ok { if state := aws.StringValue(output.State); state == ec2.PrefixListStateDeleteFailed { From 50ac59d68aef0e52c9b36c48659d8b9157781697 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 12:18:22 -0400 Subject: [PATCH 06/12] r/aws_ec2_managed_prefix_list(_entry): More context. --- internal/service/ec2/find.go | 12 ++++++------ internal/service/ec2/vpc_managed_prefix_list.go | 2 +- .../service/ec2/vpc_managed_prefix_list_entry.go | 2 +- .../ec2/vpc_managed_prefix_list_entry_test.go | 5 +++-- 4 files changed, 11 insertions(+), 10 deletions(-) diff --git a/internal/service/ec2/find.go b/internal/service/ec2/find.go index c6edc991d9fc..30c97208d2c9 100644 --- a/internal/service/ec2/find.go +++ b/internal/service/ec2/find.go @@ -5057,10 +5057,10 @@ func FindManagedPrefixListByID(ctx context.Context, conn *ec2.EC2, id string) (* return output, nil } -func FindManagedPrefixListEntries(conn *ec2.EC2, input *ec2.GetManagedPrefixListEntriesInput) ([]*ec2.PrefixListEntry, error) { +func FindManagedPrefixListEntries(ctx context.Context, conn *ec2.EC2, input *ec2.GetManagedPrefixListEntriesInput) ([]*ec2.PrefixListEntry, error) { var output []*ec2.PrefixListEntry - err := conn.GetManagedPrefixListEntriesPages(input, func(page *ec2.GetManagedPrefixListEntriesOutput, lastPage bool) bool { + err := conn.GetManagedPrefixListEntriesPagesWithContext(ctx, input, func(page *ec2.GetManagedPrefixListEntriesOutput, lastPage bool) bool { if page == nil { return !lastPage } @@ -5088,16 +5088,16 @@ func FindManagedPrefixListEntries(conn *ec2.EC2, input *ec2.GetManagedPrefixList return output, nil } -func FindManagedPrefixListEntriesByID(conn *ec2.EC2, id string) ([]*ec2.PrefixListEntry, error) { +func FindManagedPrefixListEntriesByID(ctx context.Context, conn *ec2.EC2, id string) ([]*ec2.PrefixListEntry, error) { input := &ec2.GetManagedPrefixListEntriesInput{ PrefixListId: aws.String(id), } - return FindManagedPrefixListEntries(conn, input) + return FindManagedPrefixListEntries(ctx, conn, input) } -func FindManagedPrefixListEntryByIDAndCIDR(conn *ec2.EC2, id, cidr string) (*ec2.PrefixListEntry, error) { - prefixListEntries, err := FindManagedPrefixListEntriesByID(conn, id) +func FindManagedPrefixListEntryByIDAndCIDR(ctx context.Context, conn *ec2.EC2, id, cidr string) (*ec2.PrefixListEntry, error) { + prefixListEntries, err := FindManagedPrefixListEntriesByID(ctx, conn, id) if err != nil { return nil, err diff --git a/internal/service/ec2/vpc_managed_prefix_list.go b/internal/service/ec2/vpc_managed_prefix_list.go index 02def807d647..c2f28e6b6e5a 100644 --- a/internal/service/ec2/vpc_managed_prefix_list.go +++ b/internal/service/ec2/vpc_managed_prefix_list.go @@ -151,7 +151,7 @@ func resourceManagedPrefixListRead(d *schema.ResourceData, meta interface{}) err return fmt.Errorf("error reading EC2 Managed Prefix List (%s): %w", d.Id(), err) } - prefixListEntries, err := FindManagedPrefixListEntriesByID(conn, d.Id()) + prefixListEntries, err := FindManagedPrefixListEntriesByID(context.TODO(), conn, d.Id()) if err != nil { return fmt.Errorf("error reading EC2 Managed Prefix List (%s) Entries: %w", d.Id(), err) diff --git a/internal/service/ec2/vpc_managed_prefix_list_entry.go b/internal/service/ec2/vpc_managed_prefix_list_entry.go index ce03c2a692c6..3a4f82728917 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_entry.go +++ b/internal/service/ec2/vpc_managed_prefix_list_entry.go @@ -101,7 +101,7 @@ func resourceManagedPrefixListEntryRead(d *schema.ResourceData, meta interface{} } outputRaw, err := tfresource.RetryWhenNewResourceNotFound(ManagedPrefixListEntryCreateTimeout, func() (interface{}, error) { - return FindManagedPrefixListEntryByIDAndCIDR(conn, plID, cidr) + return FindManagedPrefixListEntryByIDAndCIDR(context.TODO(), conn, plID, cidr) }, d.IsNewResource()) if !d.IsNewResource() && tfresource.NotFound(err) { diff --git a/internal/service/ec2/vpc_managed_prefix_list_entry_test.go b/internal/service/ec2/vpc_managed_prefix_list_entry_test.go index 57174d8513e8..6f4573891a1a 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_entry_test.go +++ b/internal/service/ec2/vpc_managed_prefix_list_entry_test.go @@ -1,6 +1,7 @@ package ec2_test import ( + "context" "fmt" "regexp" "testing" @@ -211,7 +212,7 @@ func testAccCheckManagedPrefixListEntryDestroy(s *terraform.State) error { return err } - _, err = tfec2.FindManagedPrefixListEntryByIDAndCIDR(conn, plID, cidr) + _, err = tfec2.FindManagedPrefixListEntryByIDAndCIDR(context.Background(), conn, plID, cidr) if tfresource.NotFound(err) { continue @@ -246,7 +247,7 @@ func testAccCheckManagedPrefixListEntryExists(n string, v *ec2.PrefixListEntry) return err } - output, err := tfec2.FindManagedPrefixListEntryByIDAndCIDR(conn, plID, cidr) + output, err := tfec2.FindManagedPrefixListEntryByIDAndCIDR(context.Background(), conn, plID, cidr) if err != nil { return err From 8a73d54556057c24cbfd861ac9fd311b42d1692d Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 12:35:52 -0400 Subject: [PATCH 07/12] r/aws_ec2_managed_prefix_list_entry: Switch to '_WithoutTimeout' CRUD handler signatures (#15090). Acceptance test output: % make testacc TESTARGS='-run=TestAccVPCManagedPrefixListEntry_' PKG=ec2 ACCTEST_PARALLELISM=2 ==> Checking that code complies with gofmt requirements... TF_ACC=1 go test ./internal/service/ec2/... -v -count 1 -parallel 2 -run=TestAccVPCManagedPrefixListEntry_ -timeout 180m === RUN TestAccVPCManagedPrefixListEntry_ipv4 === PAUSE TestAccVPCManagedPrefixListEntry_ipv4 === RUN TestAccVPCManagedPrefixListEntry_ipv4Multiple === PAUSE TestAccVPCManagedPrefixListEntry_ipv4Multiple === RUN TestAccVPCManagedPrefixListEntry_ipv6 === PAUSE TestAccVPCManagedPrefixListEntry_ipv6 === RUN TestAccVPCManagedPrefixListEntry_expectInvalidTypeError === PAUSE TestAccVPCManagedPrefixListEntry_expectInvalidTypeError === RUN TestAccVPCManagedPrefixListEntry_expectInvalidCIDR === PAUSE TestAccVPCManagedPrefixListEntry_expectInvalidCIDR === RUN TestAccVPCManagedPrefixListEntry_description === PAUSE TestAccVPCManagedPrefixListEntry_description === RUN TestAccVPCManagedPrefixListEntry_disappears === PAUSE TestAccVPCManagedPrefixListEntry_disappears === CONT TestAccVPCManagedPrefixListEntry_ipv4 === CONT TestAccVPCManagedPrefixListEntry_expectInvalidCIDR --- PASS: TestAccVPCManagedPrefixListEntry_expectInvalidCIDR (2.75s) === CONT TestAccVPCManagedPrefixListEntry_disappears --- PASS: TestAccVPCManagedPrefixListEntry_disappears (24.30s) === CONT TestAccVPCManagedPrefixListEntry_description --- PASS: TestAccVPCManagedPrefixListEntry_ipv4 (28.17s) === CONT TestAccVPCManagedPrefixListEntry_ipv6 --- PASS: TestAccVPCManagedPrefixListEntry_description (28.06s) === CONT TestAccVPCManagedPrefixListEntry_expectInvalidTypeError --- PASS: TestAccVPCManagedPrefixListEntry_ipv6 (27.37s) === CONT TestAccVPCManagedPrefixListEntry_ipv4Multiple --- PASS: TestAccVPCManagedPrefixListEntry_expectInvalidTypeError (1.45s) --- PASS: TestAccVPCManagedPrefixListEntry_ipv4Multiple (31.93s) PASS ok github.com/hashicorp/terraform-provider-aws/internal/service/ec2 92.312s --- internal/service/ec2/errors.go | 1 + .../ec2/vpc_managed_prefix_list_entry.go | 58 ++++++++++--------- 2 files changed, 31 insertions(+), 28 deletions(-) diff --git a/internal/service/ec2/errors.go b/internal/service/ec2/errors.go index 5d7f6b67984d..6bb283d837fb 100644 --- a/internal/service/ec2/errors.go +++ b/internal/service/ec2/errors.go @@ -91,6 +91,7 @@ const ( errCodeInvalidVPNGatewayAttachmentNotFound = "InvalidVpnGatewayAttachment.NotFound" errCodeInvalidVPNGatewayIDNotFound = "InvalidVpnGatewayID.NotFound" errCodeNatGatewayNotFound = "NatGatewayNotFound" + errCodePrefixListVersionMismatch = "PrefixListVersionMismatch" errCodeResourceNotReady = "ResourceNotReady" errCodeSnapshotCreationPerVolumeRateExceeded = "SnapshotCreationPerVolumeRateExceeded" errCodeUnsupportedOperation = "UnsupportedOperation" diff --git a/internal/service/ec2/vpc_managed_prefix_list_entry.go b/internal/service/ec2/vpc_managed_prefix_list_entry.go index 3a4f82728917..f59788d494dd 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_entry.go +++ b/internal/service/ec2/vpc_managed_prefix_list_entry.go @@ -7,6 +7,7 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" "github.com/hashicorp/terraform-provider-aws/internal/conns" @@ -16,9 +17,10 @@ import ( func ResourceManagedPrefixListEntry() *schema.Resource { //lintignore:R011 return &schema.Resource{ - Create: resourceManagedPrefixListEntryCreate, - Read: resourceManagedPrefixListEntryRead, - Delete: resourceManagedPrefixListEntryDelete, + CreateWithoutTimeout: resourceManagedPrefixListEntryCreate, + ReadWithoutTimeout: resourceManagedPrefixListEntryRead, + DeleteWithoutTimeout: resourceManagedPrefixListEntryDelete, + Importer: &schema.ResourceImporter{ State: resourceManagedPrefixListEntryImport, }, @@ -45,7 +47,7 @@ func ResourceManagedPrefixListEntry() *schema.Resource { } } -func resourceManagedPrefixListEntryCreate(d *schema.ResourceData, meta interface{}) error { +func resourceManagedPrefixListEntryCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn cidr := d.Get("cidr").(string) @@ -58,15 +60,15 @@ func resourceManagedPrefixListEntryCreate(d *schema.ResourceData, meta interface addPrefixListEntry.Description = aws.String(v.(string)) } - _, err := tfresource.RetryWhenAWSErrCodeEquals(d.Timeout(schema.TimeoutCreate), func() (interface{}, error) { + _, err := tfresource.RetryWhenAWSErrCodeEqualsContext(ctx, d.Timeout(schema.TimeoutCreate), func() (interface{}, error) { mutexKey := fmt.Sprintf("vpc-managed-prefix-list-%s", plID) conns.GlobalMutexKV.Lock(mutexKey) defer conns.GlobalMutexKV.Unlock(mutexKey) - pl, err := FindManagedPrefixListByID(context.TODO(), conn, plID) + pl, err := FindManagedPrefixListByID(ctx, conn, plID) if err != nil { - return nil, fmt.Errorf("error reading VPC Managed Prefix List (%s): %w", plID, err) + return nil, fmt.Errorf("reading VPC Managed Prefix List (%s): %w", plID, err) } input := &ec2.ModifyManagedPrefixListInput{ @@ -75,33 +77,33 @@ func resourceManagedPrefixListEntryCreate(d *schema.ResourceData, meta interface PrefixListId: aws.String(plID), } - return conn.ModifyManagedPrefixList(input) - }, "IncorrectState", "PrefixListVersionMismatch") + return conn.ModifyManagedPrefixListWithContext(ctx, input) + }, errCodeIncorrectState, errCodePrefixListVersionMismatch) if err != nil { - return fmt.Errorf("error creating VPC Managed Prefix List Entry (%s): %w", id, err) + return diag.Errorf("creating VPC Managed Prefix List Entry (%s): %s", id, err) } d.SetId(id) - if _, err := WaitManagedPrefixListModified(context.TODO(), conn, plID); err != nil { - return fmt.Errorf("error waiting for VPC Managed Prefix List Entry (%s) create: %w", d.Id(), err) + if _, err := WaitManagedPrefixListModified(ctx, conn, plID); err != nil { + return diag.Errorf("waiting for VPC Managed Prefix List Entry (%s) create: %s", d.Id(), err) } - return resourceManagedPrefixListEntryRead(d, meta) + return resourceManagedPrefixListEntryRead(ctx, d, meta) } -func resourceManagedPrefixListEntryRead(d *schema.ResourceData, meta interface{}) error { +func resourceManagedPrefixListEntryRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn plID, cidr, err := ManagedPrefixListEntryParseID(d.Id()) if err != nil { - return err + return diag.FromErr(err) } - outputRaw, err := tfresource.RetryWhenNewResourceNotFound(ManagedPrefixListEntryCreateTimeout, func() (interface{}, error) { - return FindManagedPrefixListEntryByIDAndCIDR(context.TODO(), conn, plID, cidr) + outputRaw, err := tfresource.RetryWhenNewResourceNotFoundContext(ctx, ManagedPrefixListEntryCreateTimeout, func() (interface{}, error) { + return FindManagedPrefixListEntryByIDAndCIDR(ctx, conn, plID, cidr) }, d.IsNewResource()) if !d.IsNewResource() && tfresource.NotFound(err) { @@ -111,7 +113,7 @@ func resourceManagedPrefixListEntryRead(d *schema.ResourceData, meta interface{} } if err != nil { - return fmt.Errorf("error reading VPC Managed Prefix List Entry (%s): %w", d.Id(), err) + return diag.Errorf("reading VPC Managed Prefix List Entry (%s): %s", d.Id(), err) } entry := outputRaw.(*ec2.PrefixListEntry) @@ -122,24 +124,24 @@ func resourceManagedPrefixListEntryRead(d *schema.ResourceData, meta interface{} return nil } -func resourceManagedPrefixListEntryDelete(d *schema.ResourceData, meta interface{}) error { +func resourceManagedPrefixListEntryDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn plID, cidr, err := ManagedPrefixListEntryParseID(d.Id()) if err != nil { - return fmt.Errorf("error parsing VPC Managed Prefix List Entry ID (%s): %w", d.Id(), err) + return diag.FromErr(err) } - _, err = tfresource.RetryWhenAWSErrCodeEquals(d.Timeout(schema.TimeoutCreate), func() (interface{}, error) { + _, err = tfresource.RetryWhenAWSErrCodeEqualsContext(ctx, d.Timeout(schema.TimeoutCreate), func() (interface{}, error) { mutexKey := fmt.Sprintf("vpc-managed-prefix-list-%s", plID) conns.GlobalMutexKV.Lock(mutexKey) defer conns.GlobalMutexKV.Unlock(mutexKey) - pl, err := FindManagedPrefixListByID(context.TODO(), conn, plID) + pl, err := FindManagedPrefixListByID(ctx, conn, plID) if err != nil { - return nil, fmt.Errorf("error reading VPC Managed Prefix List (%s): %w", plID, err) + return nil, fmt.Errorf("reading VPC Managed Prefix List (%s): %w", plID, err) } input := &ec2.ModifyManagedPrefixListInput{ @@ -148,17 +150,17 @@ func resourceManagedPrefixListEntryDelete(d *schema.ResourceData, meta interface RemoveEntries: []*ec2.RemovePrefixListEntry{{Cidr: aws.String(cidr)}}, } - return conn.ModifyManagedPrefixList(input) - }, "IncorrectState", "PrefixListVersionMismatch") + return conn.ModifyManagedPrefixListWithContext(ctx, input) + }, errCodeIncorrectState, errCodePrefixListVersionMismatch) if err != nil { - return fmt.Errorf("error deleting VPC Managed Prefix List Entry (%s): %w", d.Id(), err) + return diag.Errorf("deleting VPC Managed Prefix List Entry (%s): %s", d.Id(), err) } - _, err = WaitManagedPrefixListModified(context.TODO(), conn, plID) + _, err = WaitManagedPrefixListModified(ctx, conn, plID) if err != nil { - return fmt.Errorf("error waiting for VPC Managed Prefix List Entry (%s) delete: %w", d.Id(), err) + return diag.Errorf("waiting for VPC Managed Prefix List Entry (%s) delete: %s", d.Id(), err) } return nil From 97e2e34f1eb2a77cab5ace73d9af0a577e5793b9 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 12:37:40 -0400 Subject: [PATCH 08/12] 'errCodeInvalidSecurityGroupRuleIDNotFound' -> 'errCodeInvalidSecurityGroupRuleIdNotFound'. --- internal/service/ec2/errors.go | 2 +- internal/service/ec2/vpc_security_group.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/service/ec2/errors.go b/internal/service/ec2/errors.go index 6bb283d837fb..6ee04e78ba46 100644 --- a/internal/service/ec2/errors.go +++ b/internal/service/ec2/errors.go @@ -64,7 +64,7 @@ const ( errCodeInvalidRouteTableIDNotFound = "InvalidRouteTableID.NotFound" errCodeInvalidRouteTableIdNotFound = "InvalidRouteTableId.NotFound" errCodeInvalidSecurityGroupIDNotFound = "InvalidSecurityGroupID.NotFound" - errCodeInvalidSecurityGroupRuleIDNotFound = "InvalidSecurityGroupRuleId.NotFound" + errCodeInvalidSecurityGroupRuleIdNotFound = "InvalidSecurityGroupRuleId.NotFound" errCodeInvalidServiceName = "InvalidServiceName" errCodeInvalidSnapshotInUse = "InvalidSnapshot.InUse" errCodeInvalidSnapshotNotFound = "InvalidSnapshot.NotFound" diff --git a/internal/service/ec2/vpc_security_group.go b/internal/service/ec2/vpc_security_group.go index 5be0253a1315..912e3aa0d565 100644 --- a/internal/service/ec2/vpc_security_group.go +++ b/internal/service/ec2/vpc_security_group.go @@ -476,7 +476,7 @@ func forceRevokeSecurityGroupRules(conn *ec2.EC2, id string, searchAll bool) err _, err = conn.RevokeSecurityGroupEgress(input) } - if tfawserr.ErrCodeEquals(err, errCodeInvalidSecurityGroupRuleIDNotFound) { + if tfawserr.ErrCodeEquals(err, errCodeInvalidSecurityGroupRuleIdNotFound) { continue } From e453aa36cf975003da16530789fd91bc3fd36015 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 12:42:01 -0400 Subject: [PATCH 09/12] 'ManagedPrefixListEntryCreateID' -> 'ManagedPrefixListEntryCreateResourceID' and 'ManagedPrefixListEntryParseID' -> 'ManagedPrefixListEntryParseResourceID'. --- internal/service/ec2/id.go | 18 ------------ .../ec2/vpc_managed_prefix_list_entry.go | 28 ++++++++++++++++--- .../ec2/vpc_managed_prefix_list_entry_test.go | 6 ++-- 3 files changed, 27 insertions(+), 25 deletions(-) diff --git a/internal/service/ec2/id.go b/internal/service/ec2/id.go index 47320afac5ec..b6e1064ec1f4 100644 --- a/internal/service/ec2/id.go +++ b/internal/service/ec2/id.go @@ -7,24 +7,6 @@ import ( "github.com/hashicorp/terraform-provider-aws/internal/create" ) -const managedPrefixListEntryIDSeparator = "," - -func ManagedPrefixListEntryCreateID(prefixListID, cidrBlock string) string { - parts := []string{prefixListID, cidrBlock} - id := strings.Join(parts, managedPrefixListEntryIDSeparator) - return id -} - -func ManagedPrefixListEntryParseID(id string) (string, string, error) { - parts := strings.Split(id, managedPrefixListEntryIDSeparator) - if len(parts) == 2 && parts[0] != "" && parts[1] != "" { - return parts[0], parts[1], nil - } - - return "", "", - fmt.Errorf("unexpected format for ID (%q), expected prefix-list-id"+managedPrefixListEntryIDSeparator+"cidr-block", id) -} - // RouteCreateID returns a route resource ID. func RouteCreateID(routeTableID, destination string) string { return fmt.Sprintf("r-%s%d", routeTableID, create.StringHashcode(destination)) diff --git a/internal/service/ec2/vpc_managed_prefix_list_entry.go b/internal/service/ec2/vpc_managed_prefix_list_entry.go index f59788d494dd..d2aa2a97acc0 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_entry.go +++ b/internal/service/ec2/vpc_managed_prefix_list_entry.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "log" + "strings" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" @@ -52,7 +53,7 @@ func resourceManagedPrefixListEntryCreate(ctx context.Context, d *schema.Resourc cidr := d.Get("cidr").(string) plID := d.Get("prefix_list_id").(string) - id := ManagedPrefixListEntryCreateID(plID, cidr) + id := ManagedPrefixListEntryCreateResourceID(plID, cidr) addPrefixListEntry := &ec2.AddPrefixListEntry{Cidr: aws.String(cidr)} @@ -96,7 +97,7 @@ func resourceManagedPrefixListEntryCreate(ctx context.Context, d *schema.Resourc func resourceManagedPrefixListEntryRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn - plID, cidr, err := ManagedPrefixListEntryParseID(d.Id()) + plID, cidr, err := ManagedPrefixListEntryParseResourceID(d.Id()) if err != nil { return diag.FromErr(err) @@ -127,7 +128,7 @@ func resourceManagedPrefixListEntryRead(ctx context.Context, d *schema.ResourceD func resourceManagedPrefixListEntryDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn - plID, cidr, err := ManagedPrefixListEntryParseID(d.Id()) + plID, cidr, err := ManagedPrefixListEntryParseResourceID(d.Id()) if err != nil { return diag.FromErr(err) @@ -167,7 +168,7 @@ func resourceManagedPrefixListEntryDelete(ctx context.Context, d *schema.Resourc } func resourceManagedPrefixListEntryImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { - plID, cidr, err := ManagedPrefixListEntryParseID(d.Id()) + plID, cidr, err := ManagedPrefixListEntryParseResourceID(d.Id()) if err != nil { return nil, err @@ -178,3 +179,22 @@ func resourceManagedPrefixListEntryImport(d *schema.ResourceData, meta interface return []*schema.ResourceData{d}, nil } + +const managedPrefixListEntryIDSeparator = "," + +func ManagedPrefixListEntryCreateResourceID(prefixListID, cidrBlock string) string { + parts := []string{prefixListID, cidrBlock} + id := strings.Join(parts, managedPrefixListEntryIDSeparator) + + return id +} + +func ManagedPrefixListEntryParseResourceID(id string) (string, string, error) { + parts := strings.Split(id, managedPrefixListEntryIDSeparator) + + if len(parts) == 2 && parts[0] != "" && parts[1] != "" { + return parts[0], parts[1], nil + } + + return "", "", fmt.Errorf("unexpected format for ID (%[1]s), expected prefix-list-id%[2]scidr-block", id, managedPrefixListEntryIDSeparator) +} diff --git a/internal/service/ec2/vpc_managed_prefix_list_entry_test.go b/internal/service/ec2/vpc_managed_prefix_list_entry_test.go index 6f4573891a1a..6da573a232c0 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_entry_test.go +++ b/internal/service/ec2/vpc_managed_prefix_list_entry_test.go @@ -206,7 +206,7 @@ func testAccCheckManagedPrefixListEntryDestroy(s *terraform.State) error { continue } - plID, cidr, err := tfec2.ManagedPrefixListEntryParseID(rs.Primary.ID) + plID, cidr, err := tfec2.ManagedPrefixListEntryParseResourceID(rs.Primary.ID) if err != nil { return err @@ -241,7 +241,7 @@ func testAccCheckManagedPrefixListEntryExists(n string, v *ec2.PrefixListEntry) conn := acctest.Provider.Meta().(*conns.AWSClient).EC2Conn - plID, cidr, err := tfec2.ManagedPrefixListEntryParseID(rs.Primary.ID) + plID, cidr, err := tfec2.ManagedPrefixListEntryParseResourceID(rs.Primary.ID) if err != nil { return err @@ -269,7 +269,7 @@ func testAccManagedPrefixListEntryImportStateIdFunc(resourceName string) resourc plID := rs.Primary.Attributes["prefix_list_id"] cidr := rs.Primary.Attributes["cidr"] - return tfec2.ManagedPrefixListEntryCreateID(plID, cidr), nil + return tfec2.ManagedPrefixListEntryCreateResourceID(plID, cidr), nil } } From 430a1331379eee092f1448659baead4a2d181422 Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 12:55:14 -0400 Subject: [PATCH 10/12] r/aws_ec2_managed_prefix_list: Switch to '_WithoutTimeout' CRUD handler signatures (#15090). Acceptance test output: % make testacc TESTARGS='-run=TestAccVPCManagedPrefixList_' PKG=ec2 ACCTEST_PARALLELISM=2 ==> Checking that code complies with gofmt requirements... TF_ACC=1 go test ./internal/service/ec2/... -v -count 1 -parallel 2 -run=TestAccVPCManagedPrefixList_ -timeout 180m === RUN TestAccVPCManagedPrefixList_basic === PAUSE TestAccVPCManagedPrefixList_basic === RUN TestAccVPCManagedPrefixList_disappears === PAUSE TestAccVPCManagedPrefixList_disappears === RUN TestAccVPCManagedPrefixList_AddressFamily_ipv6 === PAUSE TestAccVPCManagedPrefixList_AddressFamily_ipv6 === RUN TestAccVPCManagedPrefixList_Entry_cidr === PAUSE TestAccVPCManagedPrefixList_Entry_cidr === RUN TestAccVPCManagedPrefixList_Entry_description === PAUSE TestAccVPCManagedPrefixList_Entry_description === RUN TestAccVPCManagedPrefixList_name === PAUSE TestAccVPCManagedPrefixList_name === RUN TestAccVPCManagedPrefixList_tags === PAUSE TestAccVPCManagedPrefixList_tags === CONT TestAccVPCManagedPrefixList_basic === CONT TestAccVPCManagedPrefixList_Entry_description --- PASS: TestAccVPCManagedPrefixList_Entry_description (38.14s) === CONT TestAccVPCManagedPrefixList_AddressFamily_ipv6 --- PASS: TestAccVPCManagedPrefixList_basic (44.13s) === CONT TestAccVPCManagedPrefixList_Entry_cidr --- PASS: TestAccVPCManagedPrefixList_AddressFamily_ipv6 (25.14s) === CONT TestAccVPCManagedPrefixList_tags --- PASS: TestAccVPCManagedPrefixList_Entry_cidr (39.83s) === CONT TestAccVPCManagedPrefixList_disappears === CONT TestAccVPCManagedPrefixList_name --- PASS: TestAccVPCManagedPrefixList_disappears (20.94s) --- PASS: TestAccVPCManagedPrefixList_tags (48.23s) --- PASS: TestAccVPCManagedPrefixList_name (37.63s) PASS ok github.com/hashicorp/terraform-provider-aws/internal/service/ec2 146.639s --- .../service/ec2/vpc_managed_prefix_list.go | 82 +++++++++---------- 1 file changed, 38 insertions(+), 44 deletions(-) diff --git a/internal/service/ec2/vpc_managed_prefix_list.go b/internal/service/ec2/vpc_managed_prefix_list.go index c2f28e6b6e5a..40093355aad2 100644 --- a/internal/service/ec2/vpc_managed_prefix_list.go +++ b/internal/service/ec2/vpc_managed_prefix_list.go @@ -2,12 +2,12 @@ package ec2 import ( "context" - "fmt" "log" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" "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/customdiff" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" @@ -19,10 +19,10 @@ import ( func ResourceManagedPrefixList() *schema.Resource { return &schema.Resource{ - Create: resourceManagedPrefixListCreate, - Read: resourceManagedPrefixListRead, - Update: resourceManagedPrefixListUpdate, - Delete: resourceManagedPrefixListDelete, + CreateWithoutTimeout: resourceManagedPrefixListCreate, + ReadWithoutTimeout: resourceManagedPrefixListRead, + UpdateWithoutTimeout: resourceManagedPrefixListUpdate, + DeleteWithoutTimeout: resourceManagedPrefixListDelete, Importer: &schema.ResourceImporter{ State: schema.ImportStatePassthrough, @@ -91,7 +91,7 @@ func ResourceManagedPrefixList() *schema.Resource { } } -func resourceManagedPrefixListCreate(d *schema.ResourceData, meta interface{}) error { +func resourceManagedPrefixListCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn defaultTagsConfig := meta.(*conns.AWSClient).DefaultTagsConfig tags := defaultTagsConfig.MergeTags(tftags.New(d.Get("tags").(map[string]interface{}))) @@ -119,27 +119,27 @@ func resourceManagedPrefixListCreate(d *schema.ResourceData, meta interface{}) e } log.Printf("[DEBUG] Creating EC2 Managed Prefix List: %s", input) - output, err := conn.CreateManagedPrefixList(input) + output, err := conn.CreateManagedPrefixListWithContext(ctx, input) if err != nil { - return fmt.Errorf("error creating EC2 Managed Prefix List: %w", err) + return diag.Errorf("creating EC2 Managed Prefix List: %s", err) } d.SetId(aws.StringValue(output.PrefixList.PrefixListId)) - if _, err := WaitManagedPrefixListCreated(context.TODO(), conn, d.Id()); err != nil { - return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) create: %w", d.Id(), err) + if _, err := WaitManagedPrefixListCreated(ctx, conn, d.Id()); err != nil { + return diag.Errorf("waiting for EC2 Managed Prefix List (%s) create: %s", d.Id(), err) } - return resourceManagedPrefixListRead(d, meta) + return resourceManagedPrefixListRead(ctx, d, meta) } -func resourceManagedPrefixListRead(d *schema.ResourceData, meta interface{}) error { +func resourceManagedPrefixListRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn defaultTagsConfig := meta.(*conns.AWSClient).DefaultTagsConfig ignoreTagsConfig := meta.(*conns.AWSClient).IgnoreTagsConfig - pl, err := FindManagedPrefixListByID(context.TODO(), conn, d.Id()) + pl, err := FindManagedPrefixListByID(ctx, conn, d.Id()) if !d.IsNewResource() && tfresource.NotFound(err) { log.Printf("[WARN] EC2 Managed Prefix List %s not found, removing from state", d.Id()) @@ -148,43 +148,40 @@ func resourceManagedPrefixListRead(d *schema.ResourceData, meta interface{}) err } if err != nil { - return fmt.Errorf("error reading EC2 Managed Prefix List (%s): %w", d.Id(), err) + return diag.Errorf("reading EC2 Managed Prefix List (%s): %s", d.Id(), err) } - prefixListEntries, err := FindManagedPrefixListEntriesByID(context.TODO(), conn, d.Id()) + prefixListEntries, err := FindManagedPrefixListEntriesByID(ctx, conn, d.Id()) if err != nil { - return fmt.Errorf("error reading EC2 Managed Prefix List (%s) Entries: %w", d.Id(), err) + return diag.Errorf("reading EC2 Managed Prefix List (%s) Entries: %s", d.Id(), err) } d.Set("address_family", pl.AddressFamily) d.Set("arn", pl.PrefixListArn) - if err := d.Set("entry", flattenPrefixListEntries(prefixListEntries)); err != nil { - return fmt.Errorf("error setting entry: %w", err) + return diag.Errorf("setting entry: %s", err) } - d.Set("max_entries", pl.MaxEntries) d.Set("name", pl.PrefixListName) d.Set("owner_id", pl.OwnerId) + d.Set("version", pl.Version) tags := KeyValueTags(pl.Tags).IgnoreAWS().IgnoreConfig(ignoreTagsConfig) //lintignore:AWSR002 if err := d.Set("tags", tags.RemoveDefaultConfig(defaultTagsConfig).Map()); err != nil { - return fmt.Errorf("error setting tags: %w", err) + return diag.Errorf("setting tags: %s", err) } if err := d.Set("tags_all", tags.Map()); err != nil { - return fmt.Errorf("error setting tags_all: %w", err) + return diag.Errorf("setting tags_all: %s", err) } - d.Set("version", pl.Version) - return nil } -func resourceManagedPrefixListUpdate(d *schema.ResourceData, meta interface{}) error { +func resourceManagedPrefixListUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn if d.HasChangesExcept("tags", "tags_all") { @@ -241,24 +238,20 @@ func resourceManagedPrefixListUpdate(d *schema.ResourceData, meta interface{}) e } if len(descriptionOnlyRemovals) > 0 { - _, err := conn.ModifyManagedPrefixList(&ec2.ModifyManagedPrefixListInput{ + _, err := conn.ModifyManagedPrefixListWithContext(ctx, &ec2.ModifyManagedPrefixListInput{ CurrentVersion: input.CurrentVersion, PrefixListId: aws.String(d.Id()), RemoveEntries: descriptionOnlyRemovals, }) if err != nil { - return fmt.Errorf("error updating EC2 Managed Prefix List (%s): %w", d.Id(), err) + return diag.Errorf("updating EC2 Managed Prefix List (%s): %s", d.Id(), err) } - managedPrefixList, err := WaitManagedPrefixListModified(context.TODO(), conn, d.Id()) + managedPrefixList, err := WaitManagedPrefixListModified(ctx, conn, d.Id()) if err != nil { - return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) update: %w", d.Id(), err) - } - - if managedPrefixList == nil { - return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) update: empty response", d.Id()) + return diag.Errorf("waiting for EC2 Managed Prefix List (%s) update: %s", d.Id(), err) } input.CurrentVersion = managedPrefixList.Version @@ -278,34 +271,35 @@ func resourceManagedPrefixListUpdate(d *schema.ResourceData, meta interface{}) e wait = true } - _, err := conn.ModifyManagedPrefixList(input) + _, err := conn.ModifyManagedPrefixListWithContext(ctx, input) if err != nil { - return fmt.Errorf("error updating EC2 Managed Prefix List (%s): %w", d.Id(), err) + return diag.Errorf("updating EC2 Managed Prefix List (%s): %s", d.Id(), err) } if wait { - if _, err := WaitManagedPrefixListModified(context.TODO(), conn, d.Id()); err != nil { - return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) update: %w", d.Id(), err) + if _, err := WaitManagedPrefixListModified(ctx, conn, d.Id()); err != nil { + return diag.Errorf("waiting for EC2 Managed Prefix List (%s) update: %s", d.Id(), err) } } } if d.HasChange("tags_all") { o, n := d.GetChange("tags_all") - if err := UpdateTags(conn, d.Id(), o, n); err != nil { - return fmt.Errorf("error updating EC2 Managed Prefix List (%s) tags: %w", d.Id(), err) + + if err := UpdateTagsWithContext(ctx, conn, d.Id(), o, n); err != nil { + return diag.Errorf("updating EC2 Managed Prefix List (%s) tags: %s", d.Id(), err) } } - return resourceManagedPrefixListRead(d, meta) + return resourceManagedPrefixListRead(ctx, d, meta) } -func resourceManagedPrefixListDelete(d *schema.ResourceData, meta interface{}) error { +func resourceManagedPrefixListDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { conn := meta.(*conns.AWSClient).EC2Conn log.Printf("[INFO] Deleting EC2 Managed Prefix List: %s", d.Id()) - _, err := conn.DeleteManagedPrefixList(&ec2.DeleteManagedPrefixListInput{ + _, err := conn.DeleteManagedPrefixListWithContext(ctx, &ec2.DeleteManagedPrefixListInput{ PrefixListId: aws.String(d.Id()), }) @@ -314,11 +308,11 @@ func resourceManagedPrefixListDelete(d *schema.ResourceData, meta interface{}) e } if err != nil { - return fmt.Errorf("error deleting EC2 Managed Prefix List (%s): %w", d.Id(), err) + return diag.Errorf("deleting EC2 Managed Prefix List (%s): %s", d.Id(), err) } - if _, err := WaitManagedPrefixListDeleted(context.TODO(), conn, d.Id()); err != nil { - return fmt.Errorf("error waiting for EC2 Managed Prefix List (%s) delete: %w", d.Id(), err) + if _, err := WaitManagedPrefixListDeleted(ctx, conn, d.Id()); err != nil { + return diag.Errorf("waiting for EC2 Managed Prefix List (%s) delete: %s", d.Id(), err) } return nil From 83175eb917358b12e595e87ee41a44fc76bdb31f Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 13:01:02 -0400 Subject: [PATCH 11/12] Add and use 'managedPrefixListAddressFamily_Values()'. --- internal/service/ec2/consts.go | 12 ++++++++++++ internal/service/ec2/vpc_managed_prefix_list.go | 10 ++++------ 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/internal/service/ec2/consts.go b/internal/service/ec2/consts.go index 89e273860632..e7996d4a47f0 100644 --- a/internal/service/ec2/consts.go +++ b/internal/service/ec2/consts.go @@ -85,6 +85,18 @@ const ( CustomerGatewayStatePending = "pending" ) +const ( + managedPrefixListAddressFamilyIPv4 = "IPv4" + managedPrefixListAddressFamilyIPv6 = "IPv6" +) + +func managedPrefixListAddressFamily_Values() []string { + return []string{ + managedPrefixListAddressFamilyIPv4, + managedPrefixListAddressFamilyIPv6, + } +} + const ( vpnTunnelOptionsDPDTimeoutActionClear = "clear" vpnTunnelOptionsDPDTimeoutActionNone = "none" diff --git a/internal/service/ec2/vpc_managed_prefix_list.go b/internal/service/ec2/vpc_managed_prefix_list.go index 40093355aad2..99040d7387f5 100644 --- a/internal/service/ec2/vpc_managed_prefix_list.go +++ b/internal/service/ec2/vpc_managed_prefix_list.go @@ -37,12 +37,10 @@ func ResourceManagedPrefixList() *schema.Resource { Schema: map[string]*schema.Schema{ "address_family": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringInSlice( - []string{"IPv4", "IPv6"}, - false), + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice(managedPrefixListAddressFamily_Values(), false), }, "arn": { Type: schema.TypeString, From 8d05030cf04b560a374c3c2469f63680abf0c18c Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Wed, 7 Sep 2022 13:47:50 -0400 Subject: [PATCH 12/12] d/aws_ec2_managed_prefix_list: Use 'FindManagedPrefixList'. Acceptance test output: % make testacc TESTARGS='-run=TestAccVPCManagedPrefixListDataSource_' PKG=ec2 ACCTEST_PARALLELISM=2 ==> Checking that code complies with gofmt requirements... TF_ACC=1 go test ./internal/service/ec2/... -v -count 1 -parallel 2 -run=TestAccVPCManagedPrefixListDataSource_ -timeout 180m === RUN TestAccVPCManagedPrefixListDataSource_basic === PAUSE TestAccVPCManagedPrefixListDataSource_basic === RUN TestAccVPCManagedPrefixListDataSource_filter === PAUSE TestAccVPCManagedPrefixListDataSource_filter === RUN TestAccVPCManagedPrefixListDataSource_matchesTooMany === PAUSE TestAccVPCManagedPrefixListDataSource_matchesTooMany === CONT TestAccVPCManagedPrefixListDataSource_basic === CONT TestAccVPCManagedPrefixListDataSource_matchesTooMany --- PASS: TestAccVPCManagedPrefixListDataSource_matchesTooMany (3.48s) === CONT TestAccVPCManagedPrefixListDataSource_filter --- PASS: TestAccVPCManagedPrefixListDataSource_basic (16.70s) --- PASS: TestAccVPCManagedPrefixListDataSource_filter (14.58s) PASS ok github.com/hashicorp/terraform-provider-aws/internal/service/ec2 22.291s --- .../vpc_managed_prefix_list_data_source.go | 89 ++++++------------- ...pc_managed_prefix_list_data_source_test.go | 2 +- 2 files changed, 30 insertions(+), 61 deletions(-) diff --git a/internal/service/ec2/vpc_managed_prefix_list_data_source.go b/internal/service/ec2/vpc_managed_prefix_list_data_source.go index 9278d678ee16..14a14b152e36 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_data_source.go +++ b/internal/service/ec2/vpc_managed_prefix_list_data_source.go @@ -10,11 +10,12 @@ import ( "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-provider-aws/internal/conns" tftags "github.com/hashicorp/terraform-provider-aws/internal/tags" + "github.com/hashicorp/terraform-provider-aws/internal/tfresource" ) func DataSourceManagedPrefixList() *schema.Resource { return &schema.Resource{ - ReadContext: dataSourceManagedPrefixListRead, + ReadWithoutTimeout: dataSourceManagedPrefixListRead, Timeouts: &schema.ResourceTimeout{ Read: schema.DefaultTimeout(20 * time.Minute), @@ -45,7 +46,7 @@ func DataSourceManagedPrefixList() *schema.Resource { }, }, }, - "filter": DataSourceFiltersSchema(), + "filter": CustomFiltersSchema(), "id": { Type: schema.TypeString, Computed: true, @@ -77,83 +78,51 @@ func dataSourceManagedPrefixListRead(ctx context.Context, d *schema.ResourceData conn := meta.(*conns.AWSClient).EC2Conn ignoreTagsConfig := meta.(*conns.AWSClient).IgnoreTagsConfig - input := ec2.DescribeManagedPrefixListsInput{} - - if filters, ok := d.GetOk("filter"); ok { - input.Filters = BuildFiltersDataSource(filters.(*schema.Set)) + input := &ec2.DescribeManagedPrefixListsInput{ + Filters: BuildAttributeFilterList(map[string]string{ + "prefix-list-name": d.Get("name").(string), + }), } - if prefixListId, ok := d.GetOk("id"); ok { - input.PrefixListIds = aws.StringSlice([]string{prefixListId.(string)}) + if v, ok := d.GetOk("id"); ok { + input.PrefixListIds = aws.StringSlice([]string{v.(string)}) } - if prefixListName, ok := d.GetOk("name"); ok { - input.Filters = append(input.Filters, &ec2.Filter{ - Name: aws.String("prefix-list-name"), - Values: aws.StringSlice([]string{prefixListName.(string)}), - }) - } + input.Filters = append(input.Filters, BuildCustomFilterList( + d.Get("filter").(*schema.Set), + )...) - var prefixLists []*ec2.ManagedPrefixList + if len(input.Filters) == 0 { + // Don't send an empty filters list; the EC2 API won't accept it. + input.Filters = nil + } - err := conn.DescribeManagedPrefixListsPagesWithContext( - ctx, - &input, - func(output *ec2.DescribeManagedPrefixListsOutput, lastPage bool) bool { - prefixLists = append(prefixLists, output.PrefixLists...) - return !lastPage - }) + pl, err := FindManagedPrefixList(ctx, conn, input) if err != nil { - return diag.Errorf("error describing EC2 Managed Prefix Lists: %s", err) + return diag.FromErr(tfresource.SingularDataSourceFindError("EC2 Managed Prefix List", err)) } - if len(prefixLists) < 1 || prefixLists[0] == nil { - return diag.Errorf("no managed prefix lists matched the given criteria") - } + d.SetId(aws.StringValue(pl.PrefixListId)) - if len(prefixLists) > 1 { - return diag.Errorf("more than 1 prefix list matched the given criteria") - } + prefixListEntries, err := FindManagedPrefixListEntriesByID(ctx, conn, d.Id()) - pl := prefixLists[0] + if err != nil { + return diag.Errorf("reading EC2 Managed Prefix List (%s) Entries: %s", d.Id(), err) + } - d.SetId(aws.StringValue(pl.PrefixListId)) - d.Set("name", pl.PrefixListName) - d.Set("owner_id", pl.OwnerId) d.Set("address_family", pl.AddressFamily) d.Set("arn", pl.PrefixListArn) + if err := d.Set("entries", flattenPrefixListEntries(prefixListEntries)); err != nil { + return diag.Errorf("setting entries: %s", err) + } d.Set("max_entries", pl.MaxEntries) + d.Set("name", pl.PrefixListName) + d.Set("owner_id", pl.OwnerId) d.Set("version", pl.Version) if err := d.Set("tags", KeyValueTags(pl.Tags).IgnoreAWS().IgnoreConfig(ignoreTagsConfig).Map()); err != nil { - return diag.Errorf("error setting tags attribute: %s", err) - } - - var entries []interface{} - - err = conn.GetManagedPrefixListEntriesPages( - &ec2.GetManagedPrefixListEntriesInput{ - PrefixListId: pl.PrefixListId, - }, - func(output *ec2.GetManagedPrefixListEntriesOutput, lastPage bool) bool { - for _, entry := range output.Entries { - entries = append(entries, map[string]interface{}{ - "cidr": aws.StringValue(entry.Cidr), - "description": aws.StringValue(entry.Description), - }) - } - - return !lastPage - }, - ) - - if err != nil { - return diag.Errorf("error listing EC2 Managed Prefix List (%s) entries: %s", d.Id(), err) - } - - if err := d.Set("entries", entries); err != nil { - return diag.FromErr(err) + return diag.Errorf("setting tags: %s", err) } return nil diff --git a/internal/service/ec2/vpc_managed_prefix_list_data_source_test.go b/internal/service/ec2/vpc_managed_prefix_list_data_source_test.go index 28e9ee06a4b7..29d12dda02b0 100644 --- a/internal/service/ec2/vpc_managed_prefix_list_data_source_test.go +++ b/internal/service/ec2/vpc_managed_prefix_list_data_source_test.go @@ -159,7 +159,7 @@ func TestAccVPCManagedPrefixListDataSource_matchesTooMany(t *testing.T) { Steps: []resource.TestStep{ { Config: testAccVPCManagedPrefixListDataSourceConfig_matchesTooMany, - ExpectError: regexp.MustCompile(`more than 1 prefix list matched the given criteria`), + ExpectError: regexp.MustCompile(`multiple EC2 Managed Prefix Lists matched`), }, }, })