forked from vmware/go-vcloud-director
/
lbserverpool.go
247 lines (205 loc) · 8.68 KB
/
lbserverpool.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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
/*
* Copyright 2019 VMware, Inc. All rights reserved. Licensed under the Apache v2 License.
*/
package govcd
import (
"fmt"
"net/http"
"github.com/vmware/go-vcloud-director/v2/types/v56"
)
// CreateLbServerPool creates a load balancer server pool based on mandatory fields. It is a synchronous
// operation. It returns created object with all fields (including ID) populated or an error.
// Name and Algorithm fields must be populated.
func (egw *EdgeGateway) CreateLbServerPool(lbPoolConfig *types.LbPool) (*types.LbPool, error) {
if err := validateCreateLbServerPool(lbPoolConfig, egw); err != nil {
return nil, err
}
httpPath, err := egw.buildProxiedEdgeEndpointURL(types.LbServerPoolPath)
if err != nil {
return nil, fmt.Errorf("could not get Edge Gateway API endpoint: %s", err)
}
// We expect to get http.StatusCreated or if not an error of type types.NSXError
resp, err := egw.client.ExecuteRequestWithCustomError(httpPath, http.MethodPost, types.AnyXMLMime,
"error creating load balancer server pool: %s", lbPoolConfig, &types.NSXError{})
if err != nil {
return nil, err
}
// Location header should look similar to:
// Location: [/network/edges/edge-3/loadbalancer/config/pools/pool-7]
lbPoolID, err := extractNsxObjectIdFromPath(resp.Header.Get("Location"))
if err != nil {
return nil, err
}
readPool, err := egw.GetLbServerPoolById(lbPoolID)
if err != nil {
return nil, fmt.Errorf("unable to retrieve lb server pool with ID (%s) after creation: %s", lbPoolID, err)
}
return readPool, nil
}
// getLbServerPool is able to find the types.LbPool type by Name and/or ID.
// If both - Name and ID are specified it performs a lookup by ID and returns an error if the specified name and found
// name do not match.
func (egw *EdgeGateway) getLbServerPool(lbPoolConfig *types.LbPool) (*types.LbPool, error) {
if err := validateGetLbServerPool(lbPoolConfig, egw); err != nil {
return nil, err
}
pools, err := egw.GetLbServerPools()
if err != nil {
return nil, err
}
// Search for pool by ID or by Name
for _, pool := range pools {
// If ID was specified for lookup - look for the same ID
if lbPoolConfig.ID != "" && pool.ID == lbPoolConfig.ID {
return pool, nil
}
// If Name was specified for lookup - look for the same Name
if lbPoolConfig.Name != "" && pool.Name == lbPoolConfig.Name {
// We found it by name. Let's verify if search ID was specified and it matches the lookup object
if lbPoolConfig.ID != "" && pool.ID != lbPoolConfig.ID {
return nil, fmt.Errorf("load balancer server pool was found by name (%s), but its ID (%s) does not match specified ID (%s)",
pool.Name, pool.ID, lbPoolConfig.ID)
}
return pool, nil
}
}
return nil, ErrorEntityNotFound
}
// GetLbServerPools return all created server pools without filtering.
func (egw *EdgeGateway) GetLbServerPools() ([]*types.LbPool, error) {
httpPath, err := egw.buildProxiedEdgeEndpointURL(types.LbServerPoolPath)
if err != nil {
return nil, fmt.Errorf("could not get Edge Gateway API endpoint: %s", err)
}
// Anonymous struct to unwrap "server pool response"
lbPoolResponse := &struct {
LBPools []*types.LbPool `xml:"pool"`
}{}
// This query returns all server pools as the API does not have filtering options
_, err = egw.client.ExecuteRequest(httpPath, http.MethodGet, types.AnyXMLMime,
"unable to read load lalancer server pool: %s", nil, lbPoolResponse)
if err != nil {
return nil, err
}
return lbPoolResponse.LBPools, nil
}
// GetLbServerPoolByName wraps getLbServerPool and needs only an ID for lookup
func (egw *EdgeGateway) GetLbServerPoolById(id string) (*types.LbPool, error) {
return egw.getLbServerPool(&types.LbPool{ID: id})
}
// GetLbServerPoolByName wraps getLbServerPool and needs only a Name for lookup
func (egw *EdgeGateway) GetLbServerPoolByName(name string) (*types.LbPool, error) {
return egw.getLbServerPool(&types.LbPool{Name: name})
}
// UpdateLbServerPool updates types.LbPool with all fields. At least name or ID must be specified.
// If both - Name and ID are specified it performs a lookup by ID and returns an error if the specified name and found
// name do not match.
// Name and Algorithm fields must be populated.
func (egw *EdgeGateway) UpdateLbServerPool(lbPoolConfig *types.LbPool) (*types.LbPool, error) {
err := validateUpdateLbServerPool(lbPoolConfig, egw)
if err != nil {
return nil, err
}
lbPoolConfig.ID, err = egw.getLbServerPoolIdByNameId(lbPoolConfig.Name, lbPoolConfig.ID)
if err != nil {
return nil, fmt.Errorf("cannot update load balancer server pool: %s", err)
}
httpPath, err := egw.buildProxiedEdgeEndpointURL(types.LbServerPoolPath + lbPoolConfig.ID)
if err != nil {
return nil, fmt.Errorf("could not get Edge Gateway API endpoint: %s", err)
}
// Result should be 204, if not we expect an error of type types.NSXError
_, err = egw.client.ExecuteRequestWithCustomError(httpPath, http.MethodPut, types.AnyXMLMime,
"error while updating load balancer server pool : %s", lbPoolConfig, &types.NSXError{})
if err != nil {
return nil, err
}
readPool, err := egw.GetLbServerPoolById(lbPoolConfig.ID)
if err != nil {
return nil, fmt.Errorf("unable to retrieve server pool with ID (%s) after update: %s", lbPoolConfig.ID, err)
}
return readPool, nil
}
// DeleteLbServerPool is able to delete the types.LbPool type by Name and/or ID.
// If both - Name and ID are specified it performs a lookup by ID and returns an error if the specified name and found
// name do not match.
func (egw *EdgeGateway) DeleteLbServerPool(lbPoolConfig *types.LbPool) error {
err := validateDeleteLbServerPool(lbPoolConfig, egw)
if err != nil {
return err
}
lbPoolConfig.ID, err = egw.getLbServerPoolIdByNameId(lbPoolConfig.Name, lbPoolConfig.ID)
if err != nil {
return fmt.Errorf("cannot delete load balancer server pool: %s", err)
}
httpPath, err := egw.buildProxiedEdgeEndpointURL(types.LbServerPoolPath + lbPoolConfig.ID)
if err != nil {
return fmt.Errorf("could not get Edge Gateway API endpoint: %s", err)
}
_, err = egw.client.ExecuteRequestWithCustomError(httpPath, http.MethodDelete, types.AnyXMLMime,
"unable to delete server pool: %s", nil, &types.NSXError{})
if err != nil {
return err
}
return nil
}
// DeleteLbServerPoolById wraps DeleteLbServerPool and requires only ID for deletion
func (egw *EdgeGateway) DeleteLbServerPoolById(id string) error {
return egw.DeleteLbServerPool(&types.LbPool{ID: id})
}
// DeleteLbServerPoolByName wraps DeleteLbServerPool and requires only Name for deletion
func (egw *EdgeGateway) DeleteLbServerPoolByName(name string) error {
return egw.DeleteLbServerPool(&types.LbPool{Name: name})
}
func validateCreateLbServerPool(lbPoolConfig *types.LbPool, egw *EdgeGateway) error {
if !egw.HasAdvancedNetworking() {
return fmt.Errorf("only advanced edge gateways support load balancers")
}
if lbPoolConfig.Name == "" {
return fmt.Errorf("load balancer server pool Name cannot be empty")
}
if lbPoolConfig.Algorithm == "" {
return fmt.Errorf("load balancer server pool Algorithm cannot be empty")
}
for _, member := range lbPoolConfig.Members {
if member.Condition == "" {
return fmt.Errorf("load balancer server pool Member must have Condition set")
}
}
return nil
}
func validateGetLbServerPool(lbPoolConfig *types.LbPool, egw *EdgeGateway) error {
if !egw.HasAdvancedNetworking() {
return fmt.Errorf("only advanced edge gateways support load balancers")
}
if lbPoolConfig.ID == "" && lbPoolConfig.Name == "" {
return fmt.Errorf("to read load balancer server pool at least one of `ID`, `Name` fields must be specified")
}
return nil
}
func validateUpdateLbServerPool(lbPoolConfig *types.LbPool, egw *EdgeGateway) error {
// Update and create have the same requirements for now
return validateCreateLbServerPool(lbPoolConfig, egw)
}
func validateDeleteLbServerPool(lbPoolConfig *types.LbPool, egw *EdgeGateway) error {
// Read and delete have the same requirements for now
return validateGetLbServerPool(lbPoolConfig, egw)
}
// getLbServerPoolIdByNameId checks if at least name or ID is set and returns the ID.
// If the ID is specified - it passes through the ID. If only name was specified
// it will lookup the object by name and return the ID.
func (egw *EdgeGateway) getLbServerPoolIdByNameId(name, id string) (string, error) {
if name == "" && id == "" {
return "", fmt.Errorf("at least Name or ID must be specific to find load balancer "+
"server pool got name (%s) ID (%s)", name, id)
}
if id != "" {
return id, nil
}
// if only name was specified, ID must be found, because only ID can be used in request path
readlbServerPool, err := egw.GetLbServerPoolByName(name)
if err != nil {
return "", fmt.Errorf("unable to find load balancer server pool by name: %s", err)
}
return readlbServerPool.ID, nil
}