Skip to content

Commit 7745567

Browse files
remyleoneremyleone
authored
chore(vpc): add support for quick retries with cassettes (#1198)
1 parent 8345648 commit 7745567

13 files changed

+3470
-2727
lines changed

‎scaleway/helpers_vpcgw.go

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

33
import (
4+
"context"
45
"time"
56

67
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
@@ -9,8 +10,8 @@ import (
910
)
1011

1112
const (
12-
gatewayWaitForTimeout = 10 * time.Minute
1313
defaultVPCGatewayTimeout = 10 * time.Minute
14+
defaultVPCGatewayRetry = 5 * time.Second
1415
)
1516

1617
// vpcgwAPIWithZone returns a new VPC API and the zone for a Create request
@@ -36,3 +37,35 @@ func vpcgwAPIWithZoneAndID(m interface{}, id string) (*vpcgw.API, scw.Zone, stri
3637
}
3738
return vpcgwAPI, zone, ID, nil
3839
}
40+
41+
func waitForVPCPublicGateway(ctx context.Context, api *vpcgw.API, zone scw.Zone, id string, timeout time.Duration) (*vpcgw.Gateway, error) {
42+
retryInterval := defaultVPCGatewayRetry
43+
if DefaultWaitRetryInterval != nil {
44+
retryInterval = *DefaultWaitRetryInterval
45+
}
46+
47+
gateway, err := api.WaitForGateway(&vpcgw.WaitForGatewayRequest{
48+
Timeout: scw.TimeDurationPtr(timeout),
49+
GatewayID: id,
50+
RetryInterval: &retryInterval,
51+
Zone: zone,
52+
}, scw.WithContext(ctx))
53+
54+
return gateway, err
55+
}
56+
57+
func waitForVPCGatewayNetwork(ctx context.Context, api *vpcgw.API, zone scw.Zone, id string, timeout time.Duration) (*vpcgw.GatewayNetwork, error) {
58+
retryIntervalGWNetwork := defaultVPCGatewayRetry
59+
if DefaultWaitRetryInterval != nil {
60+
retryIntervalGWNetwork = *DefaultWaitRetryInterval
61+
}
62+
63+
gatewayNetwork, err := api.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
64+
GatewayNetworkID: id,
65+
Timeout: scw.TimeDurationPtr(timeout),
66+
RetryInterval: &retryIntervalGWNetwork,
67+
Zone: zone,
68+
}, scw.WithContext(ctx))
69+
70+
return gatewayNetwork, err
71+
}

‎scaleway/resource_vpc_gateway_network.go

+24-125
Original file line numberDiff line numberDiff line change
@@ -11,11 +11,6 @@ import (
1111
"github.com/scaleway/scaleway-sdk-go/scw"
1212
)
1313

14-
const (
15-
retryIntervalVPCGatewayNetwork = 1 * time.Minute
16-
retryGWTimeout = 2 * time.Minute
17-
)
18-
1914
func resourceScalewayVPCGatewayNetwork() *schema.Resource {
2015
return &schema.Resource{
2116
CreateContext: resourceScalewayVPCGatewayNetworkCreate,
@@ -91,27 +86,21 @@ func resourceScalewayVPCGatewayNetwork() *schema.Resource {
9186
}
9287

9388
func resourceScalewayVPCGatewayNetworkCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
94-
vpcgwNetworkAPI, zone, err := vpcgwAPIWithZone(d, meta)
89+
vpcgwAPI, zone, err := vpcgwAPIWithZone(d, meta)
9590
if err != nil {
9691
return diag.FromErr(err)
9792
}
9893

99-
retryInterval := retryGWTimeout
10094
gatewayID := expandZonedID(d.Get("gateway_id").(string)).ID
101-
gw, err := vpcgwNetworkAPI.WaitForGateway(&vpcgw.WaitForGatewayRequest{
102-
GatewayID: gatewayID,
103-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
104-
RetryInterval: &retryInterval,
105-
Zone: zone,
106-
}, scw.WithContext(ctx))
107-
// check err waiting process
95+
96+
gateway, err := waitForVPCPublicGateway(ctx, vpcgwAPI, zone, gatewayID, d.Timeout(schema.TimeoutCreate))
10897
if err != nil {
10998
return diag.FromErr(err)
11099
}
111100

112101
req := &vpcgw.CreateGatewayNetworkRequest{
113102
Zone: zone,
114-
GatewayID: gw.ID,
103+
GatewayID: gateway.ID,
115104
PrivateNetworkID: expandZonedID(d.Get("private_network_id").(string)).ID,
116105
EnableMasquerade: *expandBoolPtr(d.Get("enable_masquerade")),
117106
EnableDHCP: expandBoolPtr(d.Get("enable_dhcp")),
@@ -131,63 +120,37 @@ func resourceScalewayVPCGatewayNetworkCreate(ctx context.Context, d *schema.Reso
131120
req.DHCPID = &dhcpZoned.ID
132121
}
133122

134-
gatewayNetwork, err := vpcgwNetworkAPI.CreateGatewayNetwork(req, scw.WithContext(ctx))
123+
gatewayNetwork, err := vpcgwAPI.CreateGatewayNetwork(req, scw.WithContext(ctx))
135124
if err != nil {
136125
return diag.FromErr(err)
137126
}
138127

139-
gw, err = vpcgwNetworkAPI.WaitForGateway(&vpcgw.WaitForGatewayRequest{
140-
GatewayID: gatewayID,
141-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
142-
RetryInterval: &retryInterval,
143-
Zone: zone,
144-
}, scw.WithContext(ctx))
145-
// check err waiting process
128+
d.SetId(newZonedIDString(zone, gatewayNetwork.ID))
129+
130+
_, err = waitForVPCPublicGateway(ctx, vpcgwAPI, zone, gatewayNetwork.GatewayID, d.Timeout(schema.TimeoutCreate))
146131
if err != nil {
147132
return diag.FromErr(err)
148133
}
149134

150-
retryInterval = retryIntervalVPCGatewayNetwork
151-
gatewayNetwork, err = vpcgwNetworkAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
152-
GatewayNetworkID: gatewayNetwork.ID,
153-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
154-
RetryInterval: &retryInterval,
155-
Zone: zone,
156-
}, scw.WithContext(ctx))
135+
_, err = waitForVPCGatewayNetwork(ctx, vpcgwAPI, zone, gatewayNetwork.ID, d.Timeout(schema.TimeoutCreate))
157136
if err != nil {
158137
return diag.FromErr(err)
159138
}
160139

161-
d.SetId(newZonedIDString(zone, gatewayNetwork.ID))
162-
163140
return resourceScalewayVPCGatewayNetworkRead(ctx, d, meta)
164141
}
165142

166143
func resourceScalewayVPCGatewayNetworkRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
167-
vpcgwNetworkAPI, zone, ID, err := vpcgwAPIWithZoneAndID(meta, d.Id())
144+
vpcgwAPI, zone, ID, err := vpcgwAPIWithZoneAndID(meta, d.Id())
168145
if err != nil {
169146
return diag.FromErr(err)
170147
}
171148

172-
readGWNetwork := &vpcgw.GetGatewayNetworkRequest{
173-
GatewayNetworkID: ID,
174-
Zone: zone,
175-
}
176-
177-
gatewayID := expandZonedID(d.Get("gateway_id").(string)).ID
178-
retryInterval := retryGWTimeout
179-
_, err = vpcgwNetworkAPI.WaitForGateway(&vpcgw.WaitForGatewayRequest{
180-
GatewayID: gatewayID,
181-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
182-
RetryInterval: &retryInterval,
183-
Zone: zone,
184-
}, scw.WithContext(ctx))
185-
// check err waiting process
149+
gatewayNetwork, err := waitForVPCGatewayNetwork(ctx, vpcgwAPI, zone, ID, d.Timeout(schema.TimeoutRead))
186150
if err != nil {
187151
return diag.FromErr(err)
188152
}
189-
190-
gatewayNetwork, err := vpcgwNetworkAPI.GetGatewayNetwork(readGWNetwork, scw.WithContext(ctx))
153+
_, err = waitForVPCPublicGateway(ctx, vpcgwAPI, zone, gatewayNetwork.GatewayID, d.Timeout(schema.TimeoutRead))
191154
if err != nil {
192155
return diag.FromErr(err)
193156
}
@@ -218,13 +181,7 @@ func resourceScalewayVPCGatewayNetworkRead(ctx context.Context, d *schema.Resour
218181
cleanUpDHCPValue = *expandBoolPtr(cleanUpDHCP)
219182
}
220183

221-
retryInterval = retryIntervalVPCGatewayNetwork
222-
gatewayNetwork, err = vpcgwNetworkAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
223-
GatewayNetworkID: gatewayNetwork.ID,
224-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
225-
RetryInterval: &retryInterval,
226-
Zone: zone,
227-
}, scw.WithContext(ctx))
184+
gatewayNetwork, err = waitForVPCGatewayNetwork(ctx, vpcgwAPI, zone, gatewayNetwork.ID, d.Timeout(schema.TimeoutRead))
228185
if err != nil {
229186
return diag.FromErr(err)
230187
}
@@ -246,26 +203,7 @@ func resourceScalewayVPCGatewayNetworkUpdate(ctx context.Context, d *schema.Reso
246203
return diag.FromErr(err)
247204
}
248205

249-
gatewayID := expandZonedID(d.Get("gateway_id").(string)).ID
250-
retryInterval := retryGWTimeout
251-
_, err = vpcgwAPI.WaitForGateway(&vpcgw.WaitForGatewayRequest{
252-
GatewayID: gatewayID,
253-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
254-
RetryInterval: &retryInterval,
255-
Zone: zone,
256-
}, scw.WithContext(ctx))
257-
// check err waiting process
258-
if err != nil {
259-
return diag.FromErr(err)
260-
}
261-
262-
retryInterval = retryIntervalVPCGatewayNetwork
263-
_, err = vpcgwAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
264-
GatewayNetworkID: ID,
265-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
266-
RetryInterval: &retryInterval,
267-
Zone: zone,
268-
}, scw.WithContext(ctx))
206+
_, err = waitForVPCGatewayNetwork(ctx, vpcgwAPI, zone, ID, d.Timeout(schema.TimeoutUpdate))
269207
if err != nil {
270208
return diag.FromErr(err)
271209
}
@@ -294,24 +232,7 @@ func resourceScalewayVPCGatewayNetworkUpdate(ctx context.Context, d *schema.Reso
294232
}
295233
}
296234

297-
_, err = vpcgwAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
298-
GatewayNetworkID: ID,
299-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
300-
RetryInterval: &retryInterval,
301-
Zone: zone,
302-
}, scw.WithContext(ctx))
303-
if err != nil {
304-
return diag.FromErr(err)
305-
}
306-
307-
retryInterval = retryGWTimeout
308-
_, err = vpcgwAPI.WaitForGateway(&vpcgw.WaitForGatewayRequest{
309-
GatewayID: gatewayID,
310-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
311-
RetryInterval: &retryInterval,
312-
Zone: zone,
313-
}, scw.WithContext(ctx))
314-
// check err waiting process
235+
_, err = waitForVPCGatewayNetwork(ctx, vpcgwAPI, zone, ID, d.Timeout(schema.TimeoutUpdate))
315236
if err != nil {
316237
return diag.FromErr(err)
317238
}
@@ -320,54 +241,32 @@ func resourceScalewayVPCGatewayNetworkUpdate(ctx context.Context, d *schema.Reso
320241
}
321242

322243
func resourceScalewayVPCGatewayNetworkDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
323-
vpcgwAPI, zone, ID, err := vpcgwAPIWithZoneAndID(meta, d.Id())
244+
vpcgwAPI, zone, id, err := vpcgwAPIWithZoneAndID(meta, d.Id())
324245
if err != nil {
325246
return diag.FromErr(err)
326247
}
327248

328-
gatewayID := expandZonedID(d.Get("gateway_id").(string)).ID
329-
retryInterval := retryGWTimeout
330-
_, err = vpcgwAPI.WaitForGateway(&vpcgw.WaitForGatewayRequest{
331-
GatewayID: gatewayID,
332-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
333-
RetryInterval: &retryInterval,
334-
Zone: zone,
335-
}, scw.WithContext(ctx))
336-
// check err waiting process
337-
if err != nil {
338-
return diag.FromErr(err)
339-
}
340-
341-
retryInterval = retryIntervalVPCGatewayNetwork
342-
gwNetwork, err := vpcgwAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
343-
GatewayNetworkID: ID,
344-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
345-
RetryInterval: &retryInterval,
346-
Zone: zone,
347-
}, scw.WithContext(ctx))
249+
gwNetwork, err := waitForVPCGatewayNetwork(ctx, vpcgwAPI, zone, id, d.Timeout(schema.TimeoutDelete))
348250
if err != nil {
349251
return diag.FromErr(err)
350252
}
351253

352254
req := &vpcgw.DeleteGatewayNetworkRequest{
353255
GatewayNetworkID: gwNetwork.ID,
354-
Zone: zone,
256+
Zone: gwNetwork.Zone,
355257
CleanupDHCP: *expandBoolPtr(d.Get("cleanup_dhcp")),
356258
}
357-
358259
err = vpcgwAPI.DeleteGatewayNetwork(req, scw.WithContext(ctx))
359260
if err != nil {
360261
return diag.FromErr(err)
361262
}
362263

363-
//check gateway is in stable state.
364-
retryInterval = retryGWTimeout
365-
_, err = vpcgwAPI.WaitForGateway(&vpcgw.WaitForGatewayRequest{
366-
GatewayID: gatewayID,
367-
Timeout: scw.TimeDurationPtr(defaultVPCGatewayTimeout),
368-
RetryInterval: &retryInterval,
369-
Zone: zone,
370-
}, scw.WithContext(ctx))
264+
_, err = waitForVPCGatewayNetwork(ctx, vpcgwAPI, zone, id, d.Timeout(schema.TimeoutDelete))
265+
if err != nil && !is404Error(err) {
266+
return diag.FromErr(err)
267+
}
268+
269+
_, err = waitForVPCPublicGateway(ctx, vpcgwAPI, zone, gwNetwork.GatewayID, d.Timeout(schema.TimeoutDelete))
371270
if err != nil && !is404Error(err) {
372271
return diag.FromErr(err)
373272
}

0 commit comments

Comments
 (0)