Skip to content

Commit 0bc5198

Browse files
ewbankkitewbankkit
committed
r/aws_efs_file_system: Switch to 'WithoutTimeout' CRUD handlers (#15090).
Acceptance test output: % make testacc TESTARGS='-run=TestAccEFSFileSystem_' PKG=efs ACCTEST_PARALLELISM=2 ==> Checking that code complies with gofmt requirements... TF_ACC=1 go test ./internal/service/efs/... -v -count 1 -parallel 2 -run=TestAccEFSFileSystem_ -timeout 180m === RUN TestAccEFSFileSystem_basic === PAUSE TestAccEFSFileSystem_basic === RUN TestAccEFSFileSystem_disappears === PAUSE TestAccEFSFileSystem_disappears === RUN TestAccEFSFileSystem_performanceMode === PAUSE TestAccEFSFileSystem_performanceMode === RUN TestAccEFSFileSystem_availabilityZoneName === PAUSE TestAccEFSFileSystem_availabilityZoneName === RUN TestAccEFSFileSystem_tags === PAUSE TestAccEFSFileSystem_tags === RUN TestAccEFSFileSystem_kmsKey === PAUSE TestAccEFSFileSystem_kmsKey === RUN TestAccEFSFileSystem_kmsWithoutEncryption === PAUSE TestAccEFSFileSystem_kmsWithoutEncryption === RUN TestAccEFSFileSystem_provisionedThroughputInMibps === PAUSE TestAccEFSFileSystem_provisionedThroughputInMibps === RUN TestAccEFSFileSystem_throughputMode === PAUSE TestAccEFSFileSystem_throughputMode === RUN TestAccEFSFileSystem_lifecyclePolicy === PAUSE TestAccEFSFileSystem_lifecyclePolicy === CONT TestAccEFSFileSystem_basic === CONT TestAccEFSFileSystem_kmsKey --- PASS: TestAccEFSFileSystem_basic (29.08s) === CONT TestAccEFSFileSystem_throughputMode --- PASS: TestAccEFSFileSystem_kmsKey (30.19s) === CONT TestAccEFSFileSystem_lifecyclePolicy --- PASS: TestAccEFSFileSystem_throughputMode (46.36s) === CONT TestAccEFSFileSystem_provisionedThroughputInMibps --- PASS: TestAccEFSFileSystem_lifecyclePolicy (73.86s) === CONT TestAccEFSFileSystem_kmsWithoutEncryption --- PASS: TestAccEFSFileSystem_kmsWithoutEncryption (10.34s) === CONT TestAccEFSFileSystem_availabilityZoneName --- PASS: TestAccEFSFileSystem_provisionedThroughputInMibps (46.52s) === CONT TestAccEFSFileSystem_tags --- PASS: TestAccEFSFileSystem_availabilityZoneName (30.14s) === CONT TestAccEFSFileSystem_performanceMode --- PASS: TestAccEFSFileSystem_performanceMode (23.37s) === CONT TestAccEFSFileSystem_disappears --- PASS: TestAccEFSFileSystem_disappears (21.22s) --- PASS: TestAccEFSFileSystem_tags (81.64s) PASS ok github.com/hashicorp/terraform-provider-aws/internal/service/efs 208.223s
1 parent 18e6b89 commit 0bc5198

File tree

2 files changed

+69
-73
lines changed

2 files changed

+69
-73
lines changed

‎internal/service/efs/file_system.go

+62-66
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
package efs
22

33
import (
4+
"context"
45
"errors"
56
"fmt"
67
"log"
@@ -9,6 +10,7 @@ import (
910
"github.com/aws/aws-sdk-go/aws"
1011
"github.com/aws/aws-sdk-go/service/efs"
1112
"github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr"
13+
"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
1214
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
1315
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
1416
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
@@ -20,10 +22,10 @@ import (
2022

2123
func ResourceFileSystem() *schema.Resource {
2224
return &schema.Resource{
23-
Create: resourceFileSystemCreate,
24-
Read: resourceFileSystemRead,
25-
Update: resourceFileSystemUpdate,
26-
Delete: resourceFileSystemDelete,
25+
CreateWithoutTimeout: resourceFileSystemCreate,
26+
ReadWithoutTimeout: resourceFileSystemRead,
27+
UpdateWithoutTimeout: resourceFileSystemUpdate,
28+
DeleteWithoutTimeout: resourceFileSystemDelete,
2729

2830
Importer: &schema.ResourceImporter{
2931
State: schema.ImportStatePassthrough,
@@ -141,7 +143,7 @@ func ResourceFileSystem() *schema.Resource {
141143
}
142144
}
143145

144-
func resourceFileSystemCreate(d *schema.ResourceData, meta interface{}) error {
146+
func resourceFileSystemCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
145147
conn := meta.(*conns.AWSClient).EFSConn
146148
defaultTagsConfig := meta.(*conns.AWSClient).DefaultTagsConfig
147149
tags := defaultTagsConfig.MergeTags(tftags.New(d.Get("tags").(map[string]interface{})))
@@ -154,73 +156,71 @@ func resourceFileSystemCreate(d *schema.ResourceData, meta interface{}) error {
154156
}
155157
throughputMode := d.Get("throughput_mode").(string)
156158

157-
createOpts := &efs.CreateFileSystemInput{
159+
input := &efs.CreateFileSystemInput{
158160
CreationToken: aws.String(creationToken),
159161
Tags: Tags(tags.IgnoreAWS()),
160162
ThroughputMode: aws.String(throughputMode),
161163
}
162164

163165
if v, ok := d.GetOk("availability_zone_name"); ok {
164-
createOpts.AvailabilityZoneName = aws.String(v.(string))
166+
input.AvailabilityZoneName = aws.String(v.(string))
165167
}
166168

167169
if v, ok := d.GetOk("performance_mode"); ok {
168-
createOpts.PerformanceMode = aws.String(v.(string))
170+
input.PerformanceMode = aws.String(v.(string))
169171
}
170172

171173
if throughputMode == efs.ThroughputModeProvisioned {
172-
createOpts.ProvisionedThroughputInMibps = aws.Float64(d.Get("provisioned_throughput_in_mibps").(float64))
174+
input.ProvisionedThroughputInMibps = aws.Float64(d.Get("provisioned_throughput_in_mibps").(float64))
173175
}
174176

175177
encrypted, hasEncrypted := d.GetOk("encrypted")
176178
kmsKeyId, hasKmsKeyId := d.GetOk("kms_key_id")
177179

178180
if hasEncrypted {
179-
createOpts.Encrypted = aws.Bool(encrypted.(bool))
181+
input.Encrypted = aws.Bool(encrypted.(bool))
180182
}
181183

182184
if hasKmsKeyId {
183-
createOpts.KmsKeyId = aws.String(kmsKeyId.(string))
185+
input.KmsKeyId = aws.String(kmsKeyId.(string))
184186
}
185187

186188
if encrypted == false && hasKmsKeyId {
187-
return errors.New("encrypted must be set to true when kms_key_id is specified")
189+
return diag.FromErr(errors.New("encrypted must be set to true when kms_key_id is specified"))
188190
}
189191

190-
log.Printf("[DEBUG] Creating EFS file system: %s", createOpts)
191-
fs, err := conn.CreateFileSystem(createOpts)
192+
output, err := conn.CreateFileSystemWithContext(ctx, input)
192193

193194
if err != nil {
194-
return fmt.Errorf("error creating EFS file system: %w", err)
195+
return diag.Errorf("creating EFS file system: %s", err)
195196
}
196197

197-
d.SetId(aws.StringValue(fs.FileSystemId))
198+
d.SetId(aws.StringValue(output.FileSystemId))
198199

199-
if _, err := waitFileSystemAvailable(conn, d.Id()); err != nil {
200-
return fmt.Errorf("error waiting for EFS file system (%s) to be available: %w", d.Id(), err)
200+
if _, err := waitFileSystemAvailable(ctx, conn, d.Id()); err != nil {
201+
return diag.Errorf("waiting for EFS file system (%s) create: %s", d.Id(), err)
201202
}
202203

203-
_, hasLifecyclePolicy := d.GetOk("lifecycle_policy")
204-
if hasLifecyclePolicy {
205-
_, err := conn.PutLifecycleConfiguration(&efs.PutLifecycleConfigurationInput{
204+
if v, ok := d.GetOk("lifecycle_policy"); ok {
205+
_, err := conn.PutLifecycleConfigurationWithContext(ctx, &efs.PutLifecycleConfigurationInput{
206206
FileSystemId: aws.String(d.Id()),
207-
LifecyclePolicies: expandFileSystemLifecyclePolicies(d.Get("lifecycle_policy").([]interface{})),
207+
LifecyclePolicies: expandFileSystemLifecyclePolicies(v.([]interface{})),
208208
})
209209

210210
if err != nil {
211-
return fmt.Errorf("error creating EFS file system (%s) lifecycle configuration: %w", d.Id(), err)
211+
return diag.Errorf("putting EFS file system (%s) lifecycle configuration: %s", d.Id(), err)
212212
}
213213
}
214214

215-
return resourceFileSystemRead(d, meta)
215+
return resourceFileSystemRead(ctx, d, meta)
216216
}
217217

218-
func resourceFileSystemRead(d *schema.ResourceData, meta interface{}) error {
218+
func resourceFileSystemRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
219219
conn := meta.(*conns.AWSClient).EFSConn
220220
defaultTagsConfig := meta.(*conns.AWSClient).DefaultTagsConfig
221221
ignoreTagsConfig := meta.(*conns.AWSClient).IgnoreTagsConfig
222222

223-
fs, err := FindFileSystemByID(conn, d.Id())
223+
fs, err := FindFileSystemByID(ctx, conn, d.Id())
224224

225225
if !d.IsNewResource() && tfresource.NotFound(err) {
226226
log.Printf("[WARN] EFS file system (%s) not found, removing from state", d.Id())
@@ -229,54 +229,53 @@ func resourceFileSystemRead(d *schema.ResourceData, meta interface{}) error {
229229
}
230230

231231
if err != nil {
232-
return fmt.Errorf("error reading EFS file system (%s): %w", d.Id(), err)
232+
return diag.Errorf("reading EFS file system (%s): %s", d.Id(), err)
233233
}
234234

235235
d.Set("arn", fs.FileSystemArn)
236236
d.Set("availability_zone_id", fs.AvailabilityZoneId)
237237
d.Set("availability_zone_name", fs.AvailabilityZoneName)
238238
d.Set("creation_token", fs.CreationToken)
239+
d.Set("dns_name", meta.(*conns.AWSClient).RegionalHostname(fmt.Sprintf("%s.efs", aws.StringValue(fs.FileSystemId))))
239240
d.Set("encrypted", fs.Encrypted)
240241
d.Set("kms_key_id", fs.KmsKeyId)
242+
d.Set("number_of_mount_targets", fs.NumberOfMountTargets)
243+
d.Set("owner_id", fs.OwnerId)
241244
d.Set("performance_mode", fs.PerformanceMode)
242245
d.Set("provisioned_throughput_in_mibps", fs.ProvisionedThroughputInMibps)
243246
d.Set("throughput_mode", fs.ThroughputMode)
244-
d.Set("owner_id", fs.OwnerId)
245-
d.Set("number_of_mount_targets", fs.NumberOfMountTargets)
246247

247248
tags := KeyValueTags(fs.Tags).IgnoreAWS().IgnoreConfig(ignoreTagsConfig)
248249

249250
//lintignore:AWSR002
250251
if err := d.Set("tags", tags.RemoveDefaultConfig(defaultTagsConfig).Map()); err != nil {
251-
return fmt.Errorf("error setting tags: %w", err)
252+
return diag.Errorf("setting tags: %s", err)
252253
}
253254

254255
if err := d.Set("tags_all", tags.Map()); err != nil {
255-
return fmt.Errorf("error setting tags_all: %w", err)
256+
return diag.Errorf("setting tags_all: %s", err)
256257
}
257258

258259
if err := d.Set("size_in_bytes", flattenFileSystemSizeInBytes(fs.SizeInBytes)); err != nil {
259-
return fmt.Errorf("error setting size_in_bytes: %w", err)
260+
return diag.Errorf("setting size_in_bytes: %s", err)
260261
}
261262

262-
d.Set("dns_name", meta.(*conns.AWSClient).RegionalHostname(fmt.Sprintf("%s.efs", aws.StringValue(fs.FileSystemId))))
263-
264-
res, err := conn.DescribeLifecycleConfiguration(&efs.DescribeLifecycleConfigurationInput{
263+
output, err := conn.DescribeLifecycleConfigurationWithContext(ctx, &efs.DescribeLifecycleConfigurationInput{
265264
FileSystemId: aws.String(d.Id()),
266265
})
267266

268267
if err != nil {
269-
return fmt.Errorf("error reading EFS file system (%s) lifecycle configuration: %w", d.Id(), err)
268+
return diag.Errorf("reading EFS file system (%s) lifecycle configuration: %s", d.Id(), err)
270269
}
271270

272-
if err := d.Set("lifecycle_policy", flattenFileSystemLifecyclePolicies(res.LifecyclePolicies)); err != nil {
273-
return fmt.Errorf("error setting lifecycle_policy: %w", err)
271+
if err := d.Set("lifecycle_policy", flattenFileSystemLifecyclePolicies(output.LifecyclePolicies)); err != nil {
272+
return diag.Errorf("setting lifecycle_policy: %s", err)
274273
}
275274

276275
return nil
277276
}
278277

279-
func resourceFileSystemUpdate(d *schema.ResourceData, meta interface{}) error {
278+
func resourceFileSystemUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
280279
conn := meta.(*conns.AWSClient).EFSConn
281280

282281
if d.HasChanges("provisioned_throughput_in_mibps", "throughput_mode") {
@@ -291,14 +290,14 @@ func resourceFileSystemUpdate(d *schema.ResourceData, meta interface{}) error {
291290
input.ProvisionedThroughputInMibps = aws.Float64(d.Get("provisioned_throughput_in_mibps").(float64))
292291
}
293292

294-
_, err := conn.UpdateFileSystem(input)
293+
_, err := conn.UpdateFileSystemWithContext(ctx, input)
295294

296295
if err != nil {
297-
return fmt.Errorf("error updating EFS file system (%s): %w", d.Id(), err)
296+
return diag.Errorf("updating EFS file system (%s): %s", d.Id(), err)
298297
}
299298

300-
if _, err := waitFileSystemAvailable(conn, d.Id()); err != nil {
301-
return fmt.Errorf("error waiting for EFS file system (%s) to be available: %w", d.Id(), err)
299+
if _, err := waitFileSystemAvailable(ctx, conn, d.Id()); err != nil {
300+
return diag.Errorf("waiting for EFS file system (%s) update: %s", d.Id(), err)
302301
}
303302
}
304303

@@ -315,29 +314,29 @@ func resourceFileSystemUpdate(d *schema.ResourceData, meta interface{}) error {
315314
input.LifecyclePolicies = []*efs.LifecyclePolicy{}
316315
}
317316

318-
_, err := conn.PutLifecycleConfiguration(input)
317+
_, err := conn.PutLifecycleConfigurationWithContext(ctx, input)
319318

320319
if err != nil {
321-
return fmt.Errorf("error updating EFS file system (%s) lifecycle configuration: %w", d.Id(), err)
320+
return diag.Errorf("putting EFS file system (%s) lifecycle configuration: %s", d.Id(), err)
322321
}
323322
}
324323

325324
if d.HasChange("tags_all") {
326325
o, n := d.GetChange("tags_all")
327326

328-
if err := UpdateTags(conn, d.Id(), o, n); err != nil {
329-
return fmt.Errorf("error updating EFS file system (%s) tags: %w", d.Id(), err)
327+
if err := UpdateTagsWithContext(ctx, conn, d.Id(), o, n); err != nil {
328+
return diag.Errorf("updating EFS file system (%s) tags: %s", d.Id(), err)
330329
}
331330
}
332331

333-
return resourceFileSystemRead(d, meta)
332+
return resourceFileSystemRead(ctx, d, meta)
334333
}
335334

336-
func resourceFileSystemDelete(d *schema.ResourceData, meta interface{}) error {
335+
func resourceFileSystemDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
337336
conn := meta.(*conns.AWSClient).EFSConn
338337

339338
log.Printf("[DEBUG] Deleting EFS file system: %s", d.Id())
340-
_, err := conn.DeleteFileSystem(&efs.DeleteFileSystemInput{
339+
_, err := conn.DeleteFileSystemWithContext(ctx, &efs.DeleteFileSystemInput{
341340
FileSystemId: aws.String(d.Id()),
342341
})
343342

@@ -346,25 +345,22 @@ func resourceFileSystemDelete(d *schema.ResourceData, meta interface{}) error {
346345
}
347346

348347
if err != nil {
349-
return fmt.Errorf("error deleting EFS file system (%s): %w", d.Id(), err)
348+
return diag.Errorf("deleting EFS file system (%s): %s", d.Id(), err)
350349
}
351350

352-
if _, err := waitFileSystemDeleted(conn, d.Id()); err != nil {
353-
if tfawserr.ErrCodeEquals(err, efs.ErrCodeFileSystemNotFound) {
354-
return nil
355-
}
356-
return fmt.Errorf("error waiting for EFS file system (%s) deletion: %w", d.Id(), err)
351+
if _, err := waitFileSystemDeleted(ctx, conn, d.Id()); err != nil {
352+
return diag.Errorf("waiting for EFS file system (%s) delete: %s", d.Id(), err)
357353
}
358354

359355
return nil
360356
}
361357

362-
func FindFileSystemByID(conn *efs.EFS, id string) (*efs.FileSystemDescription, error) {
358+
func FindFileSystemByID(ctx context.Context, conn *efs.EFS, id string) (*efs.FileSystemDescription, error) {
363359
input := &efs.DescribeFileSystemsInput{
364360
FileSystemId: aws.String(id),
365361
}
366362

367-
output, err := conn.DescribeFileSystems(input)
363+
output, err := conn.DescribeFileSystemsWithContext(ctx, input)
368364

369365
if tfawserr.ErrCodeEquals(err, efs.ErrCodeFileSystemNotFound) {
370366
return nil, &resource.NotFoundError{
@@ -384,9 +380,9 @@ func FindFileSystemByID(conn *efs.EFS, id string) (*efs.FileSystemDescription, e
384380
return output.FileSystems[0], nil
385381
}
386382

387-
func statusFileSystemLifeCycleState(conn *efs.EFS, id string) resource.StateRefreshFunc {
383+
func statusFileSystemLifeCycleState(ctx context.Context, conn *efs.EFS, id string) resource.StateRefreshFunc {
388384
return func() (interface{}, string, error) {
389-
output, err := FindFileSystemByID(conn, id)
385+
output, err := FindFileSystemByID(ctx, conn, id)
390386

391387
if tfresource.NotFound(err) {
392388
return nil, "", nil
@@ -409,17 +405,17 @@ const (
409405
fileSystemDeletedMinTimeout = 3 * time.Second
410406
)
411407

412-
func waitFileSystemAvailable(conn *efs.EFS, fileSystemID string) (*efs.FileSystemDescription, error) { //nolint:unparam
408+
func waitFileSystemAvailable(ctx context.Context, conn *efs.EFS, fileSystemID string) (*efs.FileSystemDescription, error) { //nolint:unparam
413409
stateConf := &resource.StateChangeConf{
414410
Pending: []string{efs.LifeCycleStateCreating, efs.LifeCycleStateUpdating},
415411
Target: []string{efs.LifeCycleStateAvailable},
416-
Refresh: statusFileSystemLifeCycleState(conn, fileSystemID),
412+
Refresh: statusFileSystemLifeCycleState(ctx, conn, fileSystemID),
417413
Timeout: fileSystemAvailableTimeout,
418414
Delay: fileSystemAvailableDelayTimeout,
419415
MinTimeout: fileSystemAvailableMinTimeout,
420416
}
421417

422-
outputRaw, err := stateConf.WaitForState()
418+
outputRaw, err := stateConf.WaitForStateContext(ctx)
423419

424420
if output, ok := outputRaw.(*efs.FileSystemDescription); ok {
425421
return output, err
@@ -428,17 +424,17 @@ func waitFileSystemAvailable(conn *efs.EFS, fileSystemID string) (*efs.FileSyste
428424
return nil, err
429425
}
430426

431-
func waitFileSystemDeleted(conn *efs.EFS, fileSystemID string) (*efs.FileSystemDescription, error) {
427+
func waitFileSystemDeleted(ctx context.Context, conn *efs.EFS, fileSystemID string) (*efs.FileSystemDescription, error) {
432428
stateConf := &resource.StateChangeConf{
433429
Pending: []string{efs.LifeCycleStateAvailable, efs.LifeCycleStateDeleting},
434430
Target: []string{},
435-
Refresh: statusFileSystemLifeCycleState(conn, fileSystemID),
431+
Refresh: statusFileSystemLifeCycleState(ctx, conn, fileSystemID),
436432
Timeout: fileSystemDeletedTimeout,
437433
Delay: fileSystemDeletedDelayTimeout,
438434
MinTimeout: fileSystemDeletedMinTimeout,
439435
}
440436

441-
outputRaw, err := stateConf.WaitForState()
437+
outputRaw, err := stateConf.WaitForStateContext(ctx)
442438

443439
if output, ok := outputRaw.(*efs.FileSystemDescription); ok {
444440
return output, err

‎internal/service/efs/file_system_test.go

+7-7
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
package efs_test
22

33
import (
4+
"context"
45
"fmt"
56
"regexp"
67
"testing"
@@ -384,7 +385,7 @@ func testAccCheckFileSystemDestroy(s *terraform.State) error {
384385
continue
385386
}
386387

387-
_, err := tfefs.FindFileSystemByID(conn, rs.Primary.ID)
388+
_, err := tfefs.FindFileSystemByID(context.Background(), conn, rs.Primary.ID)
388389

389390
if tfresource.NotFound(err) {
390391
continue
@@ -400,26 +401,25 @@ func testAccCheckFileSystemDestroy(s *terraform.State) error {
400401
return nil
401402
}
402403

403-
func testAccCheckFileSystem(resourceID string, fDesc *efs.FileSystemDescription) resource.TestCheckFunc {
404+
func testAccCheckFileSystem(n string, v *efs.FileSystemDescription) resource.TestCheckFunc {
404405
return func(s *terraform.State) error {
405-
rs, ok := s.RootModule().Resources[resourceID]
406+
rs, ok := s.RootModule().Resources[n]
406407
if !ok {
407-
return fmt.Errorf("Not found: %s", resourceID)
408+
return fmt.Errorf("Not found: %s", n)
408409
}
409-
410410
if rs.Primary.ID == "" {
411411
return fmt.Errorf("No EFS file system ID is set")
412412
}
413413

414414
conn := acctest.Provider.Meta().(*conns.AWSClient).EFSConn
415415

416-
fs, err := tfefs.FindFileSystemByID(conn, rs.Primary.ID)
416+
output, err := tfefs.FindFileSystemByID(context.Background(), conn, rs.Primary.ID)
417417

418418
if err != nil {
419419
return err
420420
}
421421

422-
*fDesc = *fs
422+
*v = *output
423423

424424
return nil
425425
}

0 commit comments

Comments
 (0)