/
interfaces.go
154 lines (145 loc) · 4.59 KB
/
interfaces.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
package server
import (
"context"
"errors"
"fmt"
"net/netip"
"github.com/UpCloudLtd/upcloud-go-api/v8/upcloud"
"github.com/UpCloudLtd/upcloud-go-api/v8/upcloud/request"
"github.com/UpCloudLtd/upcloud-go-api/v8/upcloud/service"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)
func reconfigureServerNetworkInterfaces(ctx context.Context, svc *service.Service, d *schema.ResourceData) error {
// assert server is stopped
s, err := svc.GetServerDetails(ctx, &request.GetServerDetailsRequest{
UUID: d.Id(),
})
if err != nil {
return err
}
if s.State != upcloud.ServerStateStopped {
return errors.New("server needs to be stopped to alter networks")
}
reqs, err := networkInterfacesFromResourceData(ctx, svc, d)
if err != nil {
return err
}
// Try to preserve public (IPv4 or IPv6) and utility network interfaces so that IPs doesn't change
preserveInterfaces := make(map[int]bool, 0)
// flush interfaces
for i, n := range s.Networking.Interfaces {
if (n.Type == upcloud.NetworkTypePublic || n.Type == upcloud.NetworkTypeUtility) && len(reqs) > i && interfacesEquals(n, reqs[i]) {
preserveInterfaces[n.Index] = true
continue
}
if err := svc.DeleteNetworkInterface(ctx, &request.DeleteNetworkInterfaceRequest{
ServerUUID: d.Id(),
Index: n.Index,
}); err != nil {
return fmt.Errorf("unable to delete interface #%d; %w", n.Index, err)
}
}
// apply interfaces from state
for _, r := range reqs {
if _, ok := preserveInterfaces[r.Index]; ok && (r.Type == upcloud.NetworkTypePublic || r.Type == upcloud.NetworkTypeUtility) {
continue
}
if _, err := svc.CreateNetworkInterface(ctx, &r); err != nil {
return fmt.Errorf("unable to create interface #%d; %w", r.Index, err)
}
}
return nil
}
func networkInterfacesFromResourceData(ctx context.Context, svc *service.Service, d *schema.ResourceData) ([]request.CreateNetworkInterfaceRequest, error) {
rs := make([]request.CreateNetworkInterfaceRequest, 0)
nInf, ok := d.Get("network_interface.#").(int)
if !ok {
return rs, errors.New("unable read network_interface count")
}
for i := 0; i < nInf; i++ {
key := fmt.Sprintf("network_interface.%d", i)
val, ok := d.Get(key).(map[string]interface{})
if !ok {
return rs, fmt.Errorf("unable to read '%s' value", key)
}
r := request.CreateNetworkInterfaceRequest{
ServerUUID: d.Id(),
Index: i + 1,
IPAddresses: make(request.CreateNetworkInterfaceIPAddressSlice, 0),
}
if v, ok := val["type"].(string); ok {
r.Type = v
}
ip := request.CreateNetworkInterfaceIPAddress{}
if v, ok := val["ip_address_family"].(string); ok && v != "" {
ip.Family = v
}
if r.Type == upcloud.NetworkTypePrivate {
if v, ok := val["network"].(string); ok && v != "" {
r.NetworkUUID = v
}
if v, ok := val["ip_address"].(string); ok && v != "" {
ip.Address = v
// If network has changed but ip hasn't, check if network contains IP or leave IP empty if network has DHCP is enabled.
if d.HasChange(key+".network") && !d.HasChange(key+".ip_address") {
network, err := svc.GetNetworkDetails(ctx, &request.GetNetworkDetailsRequest{UUID: r.NetworkUUID})
if err != nil {
return rs, err
}
ip.Address, err = resolveInterfaceIPAddress(network, v)
if err != nil {
return rs, err
}
}
}
if v, ok := val["source_ip_filtering"].(bool); ok {
r.SourceIPFiltering = upcloud.FromBool(v)
}
if v, ok := val["bootable"].(bool); ok {
r.Bootable = upcloud.FromBool(v)
}
}
r.IPAddresses = append(r.IPAddresses, ip)
rs = append(rs, r)
}
return rs, nil
}
func resolveInterfaceIPAddress(network *upcloud.Network, ipAddress string) (string, error) {
ip, err := netip.ParseAddr(ipAddress)
if err != nil {
return ipAddress, err
}
var dhcpEnabled bool
for _, n := range network.IPNetworks {
ipNet, err := netip.ParsePrefix(n.Address)
if err != nil {
return ipAddress, err
}
if ipNet.Contains(ip) {
return ipAddress, nil
}
if n.DHCP.Bool() {
dhcpEnabled = true
}
}
// We didn't find suitable network for IP address but there was DHCP service enabled which we can use.
if dhcpEnabled {
return "", nil
}
return "", fmt.Errorf("IP address %s is not valid for network %s (%s) which doesn't have DHCP enabled", ipAddress, network.Name, network.UUID)
}
func interfacesEquals(a upcloud.ServerInterface, b request.CreateNetworkInterfaceRequest) bool {
if a.Type != b.Type {
return false
}
if a.Index != b.Index {
return false
}
if len(a.IPAddresses) != 1 || len(b.IPAddresses) != 1 {
return false
}
if a.IPAddresses[0].Family != b.IPAddresses[0].Family {
return false
}
return true
}