File: nodebalancer.go

package info (click to toggle)
golang-github-linode-linodego 1.55.0-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 13,112 kB
  • sloc: makefile: 96; sh: 52; python: 24
file content (169 lines) | stat: -rw-r--r-- 6,445 bytes parent folder | download
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
package linodego

import (
	"context"
	"encoding/json"
	"time"

	"github.com/linode/linodego/internal/parseabletime"
)

// NodeBalancer represents a NodeBalancer object
type NodeBalancer struct {
	// This NodeBalancer's unique ID.
	ID int `json:"id"`
	// This NodeBalancer's label. These must be unique on your Account.
	Label *string `json:"label"`
	// The Region where this NodeBalancer is located. NodeBalancers only support backends in the same Region.
	Region string `json:"region"`
	// This NodeBalancer's hostname, ending with .nodebalancer.linode.com
	Hostname *string `json:"hostname"`
	// This NodeBalancer's public IPv4 address.
	IPv4 *string `json:"ipv4"`
	// This NodeBalancer's public IPv6 address.
	IPv6 *string `json:"ipv6"`
	// Throttle connections per second (0-20). Set to 0 (zero) to disable throttling.
	ClientConnThrottle int `json:"client_conn_throttle"`

	// ClientUDPSessThrottle throttles UDP sessions per second. Set to 0 (zero) to disable throttling.
	// NOTE: ClientUDPSessThrottle may not currently be available to all users.
	ClientUDPSessThrottle int `json:"client_udp_sess_throttle"`

	// Information about the amount of transfer this NodeBalancer has had so far this month.
	Transfer NodeBalancerTransfer `json:"transfer"`
	// This NodeBalancer's plan Type
	Type NodeBalancerPlanType `json:"type"`

	// An array of tags applied to this object. Tags are for organizational purposes only.
	Tags []string `json:"tags"`

	Created *time.Time `json:"-"`
	Updated *time.Time `json:"-"`
}

// NodeBalancerTransfer contains information about the amount of transfer a NodeBalancer has had in the current month
type NodeBalancerTransfer struct {
	// The total transfer, in MB, used by this NodeBalancer this month.
	Total *float64 `json:"total"`
	// The total inbound transfer, in MB, used for this NodeBalancer this month.
	Out *float64 `json:"out"`
	// The total outbound transfer, in MB, used for this NodeBalancer this month.
	In *float64 `json:"in"`
}

type NodeBalancerVPCOptions struct {
	IPv4Range           string `json:"ipv4_range,omitempty"`
	IPv6Range           string `json:"ipv6_range,omitempty"`
	SubnetID            int    `json:"subnet_id"`
	IPv4RangeAutoAssign bool   `json:"ipv4_range_auto_assign,omitempty"`
}

// NodeBalancerCreateOptions are the options permitted for CreateNodeBalancer
type NodeBalancerCreateOptions struct {
	Label              *string `json:"label,omitempty"`
	Region             string  `json:"region,omitempty"`
	ClientConnThrottle *int    `json:"client_conn_throttle,omitempty"`

	// NOTE: ClientUDPSessThrottle may not currently be available to all users.
	ClientUDPSessThrottle *int `json:"client_udp_sess_throttle,omitempty"`

	Configs    []*NodeBalancerConfigCreateOptions `json:"configs,omitempty"`
	Tags       []string                           `json:"tags"`
	FirewallID int                                `json:"firewall_id,omitempty"`
	Type       NodeBalancerPlanType               `json:"type,omitempty"`
	VPCs       []NodeBalancerVPCOptions           `json:"vpcs,omitempty"`
	IPv4       *string                            `json:"ipv4,omitempty"`
}

// NodeBalancerUpdateOptions are the options permitted for UpdateNodeBalancer
type NodeBalancerUpdateOptions struct {
	Label              *string `json:"label,omitempty"`
	ClientConnThrottle *int    `json:"client_conn_throttle,omitempty"`

	// NOTE: ClientUDPSessThrottle may not currently be available to all users.
	ClientUDPSessThrottle *int `json:"client_udp_sess_throttle,omitempty"`

	Tags *[]string `json:"tags,omitempty"`
}

// NodeBalancerPlanType constants start with NBType and include Linode API NodeBalancer's plan types
type NodeBalancerPlanType string

// NodeBalancerPlanType constants reflect the plan type used by a NodeBalancer Config
const (
	NBTypePremium NodeBalancerPlanType = "premium"
	NBTypeCommon  NodeBalancerPlanType = "common"
)

// UnmarshalJSON implements the json.Unmarshaler interface
func (i *NodeBalancer) UnmarshalJSON(b []byte) error {
	type Mask NodeBalancer

	p := struct {
		*Mask

		Created *parseabletime.ParseableTime `json:"created"`
		Updated *parseabletime.ParseableTime `json:"updated"`
	}{
		Mask: (*Mask)(i),
	}

	if err := json.Unmarshal(b, &p); err != nil {
		return err
	}

	i.Created = (*time.Time)(p.Created)
	i.Updated = (*time.Time)(p.Updated)

	return nil
}

// GetCreateOptions converts a NodeBalancer to NodeBalancerCreateOptions for use in CreateNodeBalancer
func (i NodeBalancer) GetCreateOptions() NodeBalancerCreateOptions {
	return NodeBalancerCreateOptions{
		Label:                 i.Label,
		Region:                i.Region,
		ClientConnThrottle:    &i.ClientConnThrottle,
		ClientUDPSessThrottle: &i.ClientUDPSessThrottle,
		Type:                  i.Type,
		Tags:                  i.Tags,
	}
}

// GetUpdateOptions converts a NodeBalancer to NodeBalancerUpdateOptions for use in UpdateNodeBalancer
func (i NodeBalancer) GetUpdateOptions() NodeBalancerUpdateOptions {
	return NodeBalancerUpdateOptions{
		Label:                 i.Label,
		ClientConnThrottle:    &i.ClientConnThrottle,
		ClientUDPSessThrottle: &i.ClientUDPSessThrottle,
		Tags:                  &i.Tags,
	}
}

// ListNodeBalancers lists NodeBalancers
func (c *Client) ListNodeBalancers(ctx context.Context, opts *ListOptions) ([]NodeBalancer, error) {
	return getPaginatedResults[NodeBalancer](ctx, c, "nodebalancers", opts)
}

// GetNodeBalancer gets the NodeBalancer with the provided ID
func (c *Client) GetNodeBalancer(ctx context.Context, nodebalancerID int) (*NodeBalancer, error) {
	e := formatAPIPath("nodebalancers/%d", nodebalancerID)
	return doGETRequest[NodeBalancer](ctx, c, e)
}

// CreateNodeBalancer creates a NodeBalancer
func (c *Client) CreateNodeBalancer(ctx context.Context, opts NodeBalancerCreateOptions) (*NodeBalancer, error) {
	return doPOSTRequest[NodeBalancer](ctx, c, "nodebalancers", opts)
}

// UpdateNodeBalancer updates the NodeBalancer with the specified id
func (c *Client) UpdateNodeBalancer(ctx context.Context, nodebalancerID int, opts NodeBalancerUpdateOptions) (*NodeBalancer, error) {
	e := formatAPIPath("nodebalancers/%d", nodebalancerID)
	return doPUTRequest[NodeBalancer](ctx, c, e, opts)
}

// DeleteNodeBalancer deletes the NodeBalancer with the specified id
func (c *Client) DeleteNodeBalancer(ctx context.Context, nodebalancerID int) error {
	e := formatAPIPath("nodebalancers/%d", nodebalancerID)
	return doDELETERequest(ctx, c, e)
}