435c0d9fc8
This PR switches the Nomad repository from using govendor to Go modules for managing dependencies. Aspects of the Nomad workflow remain pretty much the same. The usual Makefile targets should continue to work as they always did. The API submodule simply defers to the parent Nomad version on the repository, keeping the semantics of API versioning that currently exists.
335 lines
12 KiB
Go
335 lines
12 KiB
Go
package linodego
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
)
|
|
|
|
// NodeBalancerConfig objects allow a NodeBalancer to accept traffic on a new port
|
|
type NodeBalancerConfig struct {
|
|
ID int `json:"id"`
|
|
Port int `json:"port"`
|
|
Protocol ConfigProtocol `json:"protocol"`
|
|
Algorithm ConfigAlgorithm `json:"algorithm"`
|
|
Stickiness ConfigStickiness `json:"stickiness"`
|
|
Check ConfigCheck `json:"check"`
|
|
CheckInterval int `json:"check_interval"`
|
|
CheckAttempts int `json:"check_attempts"`
|
|
CheckPath string `json:"check_path"`
|
|
CheckBody string `json:"check_body"`
|
|
CheckPassive bool `json:"check_passive"`
|
|
CheckTimeout int `json:"check_timeout"`
|
|
CipherSuite ConfigCipher `json:"cipher_suite"`
|
|
NodeBalancerID int `json:"nodebalancer_id"`
|
|
SSLCommonName string `json:"ssl_commonname"`
|
|
SSLFingerprint string `json:"ssl_fingerprint"`
|
|
SSLCert string `json:"ssl_cert"`
|
|
SSLKey string `json:"ssl_key"`
|
|
NodesStatus *NodeBalancerNodeStatus `json:"nodes_status"`
|
|
}
|
|
|
|
// ConfigAlgorithm constants start with Algorithm and include Linode API NodeBalancer Config Algorithms
|
|
type ConfigAlgorithm string
|
|
|
|
// ConfigAlgorithm constants reflect the NodeBalancer Config Algorithm
|
|
const (
|
|
AlgorithmRoundRobin ConfigAlgorithm = "roundrobin"
|
|
AlgorithmLeastConn ConfigAlgorithm = "leastconn"
|
|
AlgorithmSource ConfigAlgorithm = "source"
|
|
)
|
|
|
|
// ConfigStickiness constants start with Stickiness and include Linode API NodeBalancer Config Stickiness
|
|
type ConfigStickiness string
|
|
|
|
// ConfigStickiness constants reflect the node stickiness method for a NodeBalancer Config
|
|
const (
|
|
StickinessNone ConfigStickiness = "none"
|
|
StickinessTable ConfigStickiness = "table"
|
|
StickinessHTTPCookie ConfigStickiness = "http_cookie"
|
|
)
|
|
|
|
// ConfigCheck constants start with Check and include Linode API NodeBalancer Config Check methods
|
|
type ConfigCheck string
|
|
|
|
// ConfigCheck constants reflect the node health status checking method for a NodeBalancer Config
|
|
const (
|
|
CheckNone ConfigCheck = "none"
|
|
CheckConnection ConfigCheck = "connection"
|
|
CheckHTTP ConfigCheck = "http"
|
|
CheckHTTPBody ConfigCheck = "http_body"
|
|
)
|
|
|
|
// ConfigProtocol constants start with Protocol and include Linode API Nodebalancer Config protocols
|
|
type ConfigProtocol string
|
|
|
|
// ConfigProtocol constants reflect the protocol used by a NodeBalancer Config
|
|
const (
|
|
ProtocolHTTP ConfigProtocol = "http"
|
|
ProtocolHTTPS ConfigProtocol = "https"
|
|
ProtocolTCP ConfigProtocol = "tcp"
|
|
)
|
|
|
|
// ConfigCipher constants start with Cipher and include Linode API NodeBalancer Config Cipher values
|
|
type ConfigCipher string
|
|
|
|
// ConfigCipher constants reflect the preferred cipher set for a NodeBalancer Config
|
|
const (
|
|
CipherRecommended ConfigCipher = "recommended"
|
|
CipherLegacy ConfigCipher = "legacy"
|
|
)
|
|
|
|
// NodeBalancerNodeStatus represents the total number of nodes whose status is Up or Down
|
|
type NodeBalancerNodeStatus struct {
|
|
Up int `json:"up"`
|
|
Down int `json:"down"`
|
|
}
|
|
|
|
// NodeBalancerConfigCreateOptions are permitted by CreateNodeBalancerConfig
|
|
type NodeBalancerConfigCreateOptions struct {
|
|
Port int `json:"port"`
|
|
Protocol ConfigProtocol `json:"protocol,omitempty"`
|
|
Algorithm ConfigAlgorithm `json:"algorithm,omitempty"`
|
|
Stickiness ConfigStickiness `json:"stickiness,omitempty"`
|
|
Check ConfigCheck `json:"check,omitempty"`
|
|
CheckInterval int `json:"check_interval,omitempty"`
|
|
CheckAttempts int `json:"check_attempts,omitempty"`
|
|
CheckPath string `json:"check_path,omitempty"`
|
|
CheckBody string `json:"check_body,omitempty"`
|
|
CheckPassive *bool `json:"check_passive,omitempty"`
|
|
CheckTimeout int `json:"check_timeout,omitempty"`
|
|
CipherSuite ConfigCipher `json:"cipher_suite,omitempty"`
|
|
SSLCert string `json:"ssl_cert,omitempty"`
|
|
SSLKey string `json:"ssl_key,omitempty"`
|
|
Nodes []NodeBalancerNodeCreateOptions `json:"nodes,omitempty"`
|
|
}
|
|
|
|
// NodeBalancerConfigRebuildOptions used by RebuildNodeBalancerConfig
|
|
type NodeBalancerConfigRebuildOptions struct {
|
|
Port int `json:"port"`
|
|
Protocol ConfigProtocol `json:"protocol,omitempty"`
|
|
Algorithm ConfigAlgorithm `json:"algorithm,omitempty"`
|
|
Stickiness ConfigStickiness `json:"stickiness,omitempty"`
|
|
Check ConfigCheck `json:"check,omitempty"`
|
|
CheckInterval int `json:"check_interval,omitempty"`
|
|
CheckAttempts int `json:"check_attempts,omitempty"`
|
|
CheckPath string `json:"check_path,omitempty"`
|
|
CheckBody string `json:"check_body,omitempty"`
|
|
CheckPassive *bool `json:"check_passive,omitempty"`
|
|
CheckTimeout int `json:"check_timeout,omitempty"`
|
|
CipherSuite ConfigCipher `json:"cipher_suite,omitempty"`
|
|
SSLCert string `json:"ssl_cert,omitempty"`
|
|
SSLKey string `json:"ssl_key,omitempty"`
|
|
Nodes []NodeBalancerNodeCreateOptions `json:"nodes"`
|
|
}
|
|
|
|
// NodeBalancerConfigUpdateOptions are permitted by UpdateNodeBalancerConfig
|
|
type NodeBalancerConfigUpdateOptions NodeBalancerConfigCreateOptions
|
|
|
|
// GetCreateOptions converts a NodeBalancerConfig to NodeBalancerConfigCreateOptions for use in CreateNodeBalancerConfig
|
|
func (i NodeBalancerConfig) GetCreateOptions() NodeBalancerConfigCreateOptions {
|
|
return NodeBalancerConfigCreateOptions{
|
|
Port: i.Port,
|
|
Protocol: i.Protocol,
|
|
Algorithm: i.Algorithm,
|
|
Stickiness: i.Stickiness,
|
|
Check: i.Check,
|
|
CheckInterval: i.CheckInterval,
|
|
CheckAttempts: i.CheckAttempts,
|
|
CheckTimeout: i.CheckTimeout,
|
|
CheckPath: i.CheckPath,
|
|
CheckBody: i.CheckBody,
|
|
CheckPassive: copyBool(&i.CheckPassive),
|
|
CipherSuite: i.CipherSuite,
|
|
SSLCert: i.SSLCert,
|
|
SSLKey: i.SSLKey,
|
|
}
|
|
}
|
|
|
|
// GetUpdateOptions converts a NodeBalancerConfig to NodeBalancerConfigUpdateOptions for use in UpdateNodeBalancerConfig
|
|
func (i NodeBalancerConfig) GetUpdateOptions() NodeBalancerConfigUpdateOptions {
|
|
return NodeBalancerConfigUpdateOptions{
|
|
Port: i.Port,
|
|
Protocol: i.Protocol,
|
|
Algorithm: i.Algorithm,
|
|
Stickiness: i.Stickiness,
|
|
Check: i.Check,
|
|
CheckInterval: i.CheckInterval,
|
|
CheckAttempts: i.CheckAttempts,
|
|
CheckPath: i.CheckPath,
|
|
CheckBody: i.CheckBody,
|
|
CheckPassive: copyBool(&i.CheckPassive),
|
|
CheckTimeout: i.CheckTimeout,
|
|
CipherSuite: i.CipherSuite,
|
|
SSLCert: i.SSLCert,
|
|
SSLKey: i.SSLKey,
|
|
}
|
|
}
|
|
|
|
// GetRebuildOptions converts a NodeBalancerConfig to NodeBalancerConfigRebuildOptions for use in RebuildNodeBalancerConfig
|
|
func (i NodeBalancerConfig) GetRebuildOptions() NodeBalancerConfigRebuildOptions {
|
|
return NodeBalancerConfigRebuildOptions{
|
|
Port: i.Port,
|
|
Protocol: i.Protocol,
|
|
Algorithm: i.Algorithm,
|
|
Stickiness: i.Stickiness,
|
|
Check: i.Check,
|
|
CheckInterval: i.CheckInterval,
|
|
CheckAttempts: i.CheckAttempts,
|
|
CheckTimeout: i.CheckTimeout,
|
|
CheckPath: i.CheckPath,
|
|
CheckBody: i.CheckBody,
|
|
CheckPassive: copyBool(&i.CheckPassive),
|
|
CipherSuite: i.CipherSuite,
|
|
SSLCert: i.SSLCert,
|
|
SSLKey: i.SSLKey,
|
|
Nodes: make([]NodeBalancerNodeCreateOptions, 0),
|
|
}
|
|
}
|
|
|
|
// NodeBalancerConfigsPagedResponse represents a paginated NodeBalancerConfig API response
|
|
type NodeBalancerConfigsPagedResponse struct {
|
|
*PageOptions
|
|
Data []NodeBalancerConfig `json:"data"`
|
|
}
|
|
|
|
// endpointWithID gets the endpoint URL for NodeBalancerConfig
|
|
func (NodeBalancerConfigsPagedResponse) endpointWithID(c *Client, id int) string {
|
|
endpoint, err := c.NodeBalancerConfigs.endpointWithID(id)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return endpoint
|
|
}
|
|
|
|
// appendData appends NodeBalancerConfigs when processing paginated NodeBalancerConfig responses
|
|
func (resp *NodeBalancerConfigsPagedResponse) appendData(r *NodeBalancerConfigsPagedResponse) {
|
|
resp.Data = append(resp.Data, r.Data...)
|
|
}
|
|
|
|
// ListNodeBalancerConfigs lists NodeBalancerConfigs
|
|
func (c *Client) ListNodeBalancerConfigs(ctx context.Context, nodebalancerID int, opts *ListOptions) ([]NodeBalancerConfig, error) {
|
|
response := NodeBalancerConfigsPagedResponse{}
|
|
err := c.listHelperWithID(ctx, &response, nodebalancerID, opts)
|
|
for i := range response.Data {
|
|
response.Data[i].fixDates()
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return response.Data, nil
|
|
}
|
|
|
|
// fixDates converts JSON timestamps to Go time.Time values
|
|
func (i *NodeBalancerConfig) fixDates() *NodeBalancerConfig {
|
|
return i
|
|
}
|
|
|
|
// GetNodeBalancerConfig gets the template with the provided ID
|
|
func (c *Client) GetNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int) (*NodeBalancerConfig, error) {
|
|
e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
e = fmt.Sprintf("%s/%d", e, configID)
|
|
r, err := coupleAPIErrors(c.R(ctx).SetResult(&NodeBalancerConfig{}).Get(e))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return r.Result().(*NodeBalancerConfig).fixDates(), nil
|
|
}
|
|
|
|
// CreateNodeBalancerConfig creates a NodeBalancerConfig
|
|
func (c *Client) CreateNodeBalancerConfig(ctx context.Context, nodebalancerID int, nodebalancerConfig NodeBalancerConfigCreateOptions) (*NodeBalancerConfig, error) {
|
|
var body string
|
|
e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
req := c.R(ctx).SetResult(&NodeBalancerConfig{})
|
|
|
|
if bodyData, err := json.Marshal(nodebalancerConfig); err == nil {
|
|
body = string(bodyData)
|
|
} else {
|
|
return nil, NewError(err)
|
|
}
|
|
|
|
r, err := coupleAPIErrors(req.
|
|
SetHeader("Content-Type", "application/json").
|
|
SetBody(body).
|
|
Post(e))
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return r.Result().(*NodeBalancerConfig).fixDates(), nil
|
|
}
|
|
|
|
// UpdateNodeBalancerConfig updates the NodeBalancerConfig with the specified id
|
|
func (c *Client) UpdateNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int, updateOpts NodeBalancerConfigUpdateOptions) (*NodeBalancerConfig, error) {
|
|
var body string
|
|
e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
e = fmt.Sprintf("%s/%d", e, configID)
|
|
|
|
req := c.R(ctx).SetResult(&NodeBalancerConfig{})
|
|
|
|
if bodyData, err := json.Marshal(updateOpts); err == nil {
|
|
body = string(bodyData)
|
|
} else {
|
|
return nil, NewError(err)
|
|
}
|
|
|
|
r, err := coupleAPIErrors(req.
|
|
SetBody(body).
|
|
Put(e))
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return r.Result().(*NodeBalancerConfig).fixDates(), nil
|
|
}
|
|
|
|
// DeleteNodeBalancerConfig deletes the NodeBalancerConfig with the specified id
|
|
func (c *Client) DeleteNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int) error {
|
|
e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
e = fmt.Sprintf("%s/%d", e, configID)
|
|
|
|
_, err = coupleAPIErrors(c.R(ctx).Delete(e))
|
|
return err
|
|
}
|
|
|
|
// RebuildNodeBalancerConfig updates the NodeBalancer with the specified id
|
|
func (c *Client) RebuildNodeBalancerConfig(ctx context.Context, nodeBalancerID int, configID int, rebuildOpts NodeBalancerConfigRebuildOptions) (*NodeBalancerConfig, error) {
|
|
var body string
|
|
e, err := c.NodeBalancerConfigs.endpointWithID(nodeBalancerID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
e = fmt.Sprintf("%s/%d/rebuild", e, configID)
|
|
|
|
req := c.R(ctx).SetResult(&NodeBalancerConfig{})
|
|
|
|
if bodyData, err := json.Marshal(rebuildOpts); err == nil {
|
|
body = string(bodyData)
|
|
} else {
|
|
return nil, NewError(err)
|
|
}
|
|
|
|
r, err := coupleAPIErrors(req.
|
|
SetBody(body).
|
|
Post(e))
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return r.Result().(*NodeBalancerConfig).fixDates(), nil
|
|
}
|