Skip to content

Commit 534995a

Browse files
MonitobMonitob
authored
fix(rdb): private network update from ipam service (#2068)
* fix(rdb): private network update from ipam service * fix(rdb): remove useless test on private networks * fix(rdb): remove useless test on private networks * fix(rdb): remove useless method
1 parent 7494313 commit 534995a

5 files changed

+1412
-200
lines changed

‎scaleway/helpers_rdb.go

-60
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,6 @@ package scaleway
33
import (
44
"context"
55
"fmt"
6-
"reflect"
76
"strings"
87
"time"
98

@@ -148,65 +147,6 @@ func expandLoadBalancer() []*rdb.EndpointSpec {
148147
return res
149148
}
150149

151-
func endpointsToRemove(endPoints []*rdb.Endpoint, updates interface{}) (map[string]bool, error) {
152-
actions := make(map[string]bool)
153-
endpoints := make(map[string]*rdb.Endpoint)
154-
for _, e := range endPoints {
155-
// skip load balancer
156-
if e.PrivateNetwork != nil {
157-
actions[e.ID] = true
158-
endpoints[newZonedIDString(e.PrivateNetwork.Zone, e.PrivateNetwork.PrivateNetworkID)] = e
159-
}
160-
}
161-
162-
// compare if private networks are persisted
163-
for _, raw := range updates.([]interface{}) {
164-
r := raw.(map[string]interface{})
165-
pnZonedID := r["pn_id"].(string)
166-
locality, id, err := parseLocalizedID(pnZonedID)
167-
if err != nil {
168-
return nil, err
169-
}
170-
171-
pnUpdated, err := newEndPointPrivateNetworkDetails(id, r["ip_net"].(string), locality)
172-
if err != nil {
173-
return nil, err
174-
}
175-
endpoint, exist := endpoints[pnZonedID]
176-
if !exist {
177-
continue
178-
}
179-
// match the endpoint id for a private network
180-
actions[endpoint.ID] = !isEndPointEqual(endpoints[pnZonedID].PrivateNetwork, pnUpdated)
181-
}
182-
183-
return actions, nil
184-
}
185-
186-
func newEndPointPrivateNetworkDetails(id, ip, locality string) (*rdb.EndpointPrivateNetworkDetails, error) {
187-
serviceIP, err := expandIPNet(ip)
188-
if err != nil {
189-
return nil, err
190-
}
191-
return &rdb.EndpointPrivateNetworkDetails{
192-
PrivateNetworkID: id,
193-
ServiceIP: serviceIP,
194-
Zone: scw.Zone(locality),
195-
}, nil
196-
}
197-
198-
func isEndPointEqual(a, b interface{}) bool {
199-
// Find out the diff Private Network or not
200-
if _, ok := a.(*rdb.EndpointPrivateNetworkDetails); ok {
201-
if _, ok := b.(*rdb.EndpointPrivateNetworkDetails); ok {
202-
detailsA := a.(*rdb.EndpointPrivateNetworkDetails)
203-
detailsB := b.(*rdb.EndpointPrivateNetworkDetails)
204-
return reflect.DeepEqual(detailsA, detailsB)
205-
}
206-
}
207-
return false
208-
}
209-
210150
func flattenPrivateNetwork(endpoints []*rdb.Endpoint) (interface{}, bool) {
211151
pnI := []map[string]interface{}(nil)
212152
for _, endpoint := range endpoints {

‎scaleway/helpers_rdb_test.go

-132
Original file line numberDiff line numberDiff line change
@@ -2,142 +2,10 @@ package scaleway
22

33
import (
44
"context"
5-
"net"
65
"reflect"
76
"testing"
8-
9-
"github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
10-
"github.com/scaleway/scaleway-sdk-go/scw"
11-
"github.com/stretchr/testify/assert"
127
)
138

14-
func TestIsEndPointEqual(t *testing.T) {
15-
tests := []struct {
16-
name string
17-
A *rdb.EndpointPrivateNetworkDetails
18-
B *rdb.EndpointPrivateNetworkDetails
19-
expected bool
20-
}{
21-
{
22-
name: "isEqualPrivateNetworkDetails",
23-
A: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
24-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
25-
}}, Zone: scw.ZoneFrPar1},
26-
B: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
27-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
28-
}}, Zone: scw.ZoneFrPar1},
29-
expected: true,
30-
},
31-
{
32-
name: "notEqualIP",
33-
A: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
34-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
35-
}}, Zone: scw.ZoneFrPar1},
36-
B: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
37-
IP: net.IPv4(1, 1, 1, 2), Mask: net.CIDRMask(24, 32),
38-
}}, Zone: scw.ZoneFrPar1},
39-
expected: false,
40-
},
41-
{
42-
name: "notEqualZone",
43-
A: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
44-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
45-
}}, Zone: scw.ZoneFrPar1},
46-
B: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
47-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
48-
}}, Zone: scw.ZoneFrPar2},
49-
expected: false,
50-
},
51-
{
52-
name: "notEqualMask",
53-
A: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
54-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(25, 32),
55-
}}, Zone: scw.ZoneFrPar1},
56-
B: &rdb.EndpointPrivateNetworkDetails{PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8", ServiceIP: scw.IPNet{IPNet: net.IPNet{
57-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
58-
}}, Zone: scw.ZoneFrPar1},
59-
expected: false,
60-
},
61-
}
62-
for _, tt := range tests {
63-
t.Run(tt.name, func(t *testing.T) {
64-
assert.Equal(t, tt.expected, isEndPointEqual(tt.A, tt.B))
65-
})
66-
}
67-
}
68-
69-
func TestEndpointsToRemove(t *testing.T) {
70-
tests := []struct {
71-
name string
72-
Endpoints []*rdb.Endpoint
73-
Updates []interface{}
74-
Expected map[string]bool
75-
}{
76-
{
77-
name: "removeAll",
78-
Endpoints: []*rdb.Endpoint{{
79-
ID: "6ba7b810-9dad-11d1-80b4-00c04fd430c1",
80-
PrivateNetwork: &rdb.EndpointPrivateNetworkDetails{
81-
PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
82-
ServiceIP: scw.IPNet{IPNet: net.IPNet{
83-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
84-
}},
85-
Zone: scw.ZoneFrPar1,
86-
},
87-
}},
88-
Expected: map[string]bool{
89-
"6ba7b810-9dad-11d1-80b4-00c04fd430c1": true,
90-
},
91-
},
92-
{
93-
name: "shouldUpdatePrivateNetwork",
94-
Endpoints: []*rdb.Endpoint{{
95-
ID: "6ba7b810-9dad-11d1-80b4-00c04fd430c1",
96-
PrivateNetwork: &rdb.EndpointPrivateNetworkDetails{
97-
PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
98-
ServiceIP: scw.IPNet{IPNet: net.IPNet{
99-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
100-
}},
101-
Zone: scw.ZoneFrPar1,
102-
},
103-
}},
104-
Updates: []interface{}{map[string]interface{}{"pn_id": "fr-par-1/6ba7b810-9dad-11d1-80b4-00c04fd430c8", "ip_net": "192.168.1.43/24"}},
105-
Expected: map[string]bool{
106-
"6ba7b810-9dad-11d1-80b4-00c04fd430c1": true,
107-
},
108-
},
109-
{
110-
name: "shouldNotUpdatePrivateNetwork",
111-
Endpoints: []*rdb.Endpoint{{
112-
ID: "6ba7b810-9dad-11d1-80b4-00c04fd430c1",
113-
PrivateNetwork: &rdb.EndpointPrivateNetworkDetails{
114-
PrivateNetworkID: "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
115-
ServiceIP: scw.IPNet{IPNet: net.IPNet{
116-
IP: net.IPv4(1, 1, 1, 1), Mask: net.CIDRMask(24, 32),
117-
}},
118-
Zone: scw.ZoneFrPar1,
119-
},
120-
}},
121-
Updates: []interface{}{map[string]interface{}{"pn_id": "fr-par-1/6ba7b810-9dad-11d1-80b4-00c04fd430c8", "ip_net": "1.1.1.1/24"}},
122-
Expected: map[string]bool{
123-
"6ba7b810-9dad-11d1-80b4-00c04fd430c1": false,
124-
},
125-
},
126-
{
127-
name: "shouldAddPrivateNetwork",
128-
Updates: []interface{}{map[string]interface{}{"pn_id": "fr-par-1/6ba7b810-9dad-11d1-80b4-00c04fd430c8", "ip_net": "1.1.1.1/24"}},
129-
Expected: map[string]bool{},
130-
},
131-
}
132-
for _, tt := range tests {
133-
t.Run(tt.name, func(t *testing.T) {
134-
result, err := endpointsToRemove(tt.Endpoints, tt.Updates)
135-
assert.NoError(t, err)
136-
assert.Equal(t, tt.Expected, result)
137-
})
138-
}
139-
}
140-
1419
func TestRDBPrivilegeV1SchemaUpgradeFunc(t *testing.T) {
14210
v0Schema := map[string]interface{}{
14311
"id": "fr-par/11111111-1111-1111-1111-111111111111",

‎scaleway/resource_rdb_instance.go

+3-8
Original file line numberDiff line numberDiff line change
@@ -611,16 +611,11 @@ func resourceScalewayRdbInstanceUpdate(ctx context.Context, d *schema.ResourceDa
611611
return diag.FromErr(err)
612612
}
613613

614-
// get endpoints to detach. It will handle only private networks
615-
endPointsToRemove, err := endpointsToRemove(res.Endpoints, d.Get("private_network"))
616-
if err != nil {
617-
diag.FromErr(err)
618-
}
619-
for endPointID, remove := range endPointsToRemove {
620-
if remove {
614+
for _, e := range res.Endpoints {
615+
if e.PrivateNetwork != nil {
621616
err := rdbAPI.DeleteEndpoint(
622617
&rdb.DeleteEndpointRequest{
623-
EndpointID: endPointID, Region: region,
618+
EndpointID: e.ID, Region: region,
624619
},
625620
scw.WithContext(ctx))
626621
if err != nil {

‎scaleway/resource_rdb_instance_test.go

+82
Original file line numberDiff line numberDiff line change
@@ -444,6 +444,88 @@ func TestAccScalewayRdbInstance_PrivateNetwork(t *testing.T) {
444444
})
445445
}
446446

447+
func TestAccScalewayRdbInstance_PrivateNetworkUpdate(t *testing.T) {
448+
tt := NewTestTools(t)
449+
defer tt.Cleanup()
450+
resource.ParallelTest(t, resource.TestCase{
451+
PreCheck: func() { testAccPreCheck(t) },
452+
ProviderFactories: tt.ProviderFactories,
453+
CheckDestroy: testAccCheckScalewayRdbInstanceDestroy(tt),
454+
Steps: []resource.TestStep{
455+
{
456+
Config: `
457+
resource scaleway_vpc_private_network pn01 {
458+
name = "my_private_network"
459+
}
460+
`,
461+
Check: resource.ComposeTestCheckFunc(
462+
resource.TestCheckResourceAttr("scaleway_vpc_private_network.pn01", "name", "my_private_network"),
463+
),
464+
},
465+
{
466+
Config: `
467+
resource scaleway_vpc_private_network pn01 {
468+
name = "my_private_network"
469+
}
470+
471+
resource scaleway_rdb_instance main {
472+
name = "test-rdb"
473+
node_type = "db-dev-s"
474+
engine = "PostgreSQL-11"
475+
is_ha_cluster = false
476+
disable_backup = true
477+
user_name = "my_initial_user"
478+
password = "thiZ_is_v&ry_s3cret"
479+
tags = [ "terraform-test", "scaleway_rdb_instance", "volume", "rdb_pn" ]
480+
volume_type = "bssd"
481+
volume_size_in_gb = 10
482+
private_network {
483+
pn_id = "${scaleway_vpc_private_network.pn01.id}"
484+
}
485+
}
486+
`,
487+
Check: resource.ComposeTestCheckFunc(
488+
testAccCheckScalewayRdbExists(tt, "scaleway_rdb_instance.main"),
489+
resource.TestCheckResourceAttr("scaleway_rdb_instance.main", "private_network.#", "1"),
490+
),
491+
},
492+
{
493+
Config: `
494+
resource scaleway_vpc_private_network pn01 {
495+
name = "my_private_network"
496+
}
497+
498+
locals {
499+
ip_address = cidrhost(scaleway_vpc_private_network.pn01.ipv4_subnet.0.subnet, 4)
500+
cidr_prefix = split("/", scaleway_vpc_private_network.pn01.ipv4_subnet.0.subnet)[1]
501+
}
502+
503+
resource scaleway_rdb_instance main {
504+
name = "test-rdb"
505+
node_type = "db-dev-s"
506+
engine = "PostgreSQL-11"
507+
is_ha_cluster = false
508+
disable_backup = true
509+
user_name = "my_initial_user"
510+
password = "thiZ_is_v&ry_s3cret"
511+
tags = [ "terraform-test", "scaleway_rdb_instance", "volume", "rdb_pn" ]
512+
volume_type = "bssd"
513+
volume_size_in_gb = 10
514+
private_network {
515+
ip_net = format("%s/%s", local.ip_address, local.cidr_prefix)
516+
pn_id = scaleway_vpc_private_network.pn01.id
517+
}
518+
}
519+
`,
520+
Check: resource.ComposeTestCheckFunc(
521+
testAccCheckScalewayRdbExists(tt, "scaleway_rdb_instance.main"),
522+
resource.TestCheckResourceAttr("scaleway_rdb_instance.main", "private_network.#", "1"),
523+
),
524+
},
525+
},
526+
})
527+
}
528+
447529
func TestAccScalewayRdbInstance_PrivateNetwork_DHCP(t *testing.T) {
448530
tt := NewTestTools(t)
449531
defer tt.Cleanup()

0 commit comments

Comments
 (0)