/
resolver_types.go
196 lines (169 loc) · 6.03 KB
/
resolver_types.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
package v1alpha1
import (
"github.com/go-openapi/strfmt"
"github.com/haproxytech/client-native/v5/configuration"
"github.com/haproxytech/client-native/v5/models"
parser "github.com/haproxytech/config-parser/v5"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/utils/ptr"
)
// ResolverSpec defines the desired state of Resolver
type ResolverSpec struct {
// Nameservers used to configure a nameservers.
Nameservers []Nameserver `json:"nameservers,omitempty"`
// AcceptedPayloadSize defines the maximum payload size accepted by HAProxy and announced to all the name servers
// configured in this resolver.
// +kubebuilder:validation:Maximum=8192
// +kubebuilder:validation:Minimum=512
// +optional
AcceptedPayloadSize *int64 `json:"acceptedPayloadSize,omitempty"`
// ParseResolvConf if true, adds all nameservers found in /etc/resolv.conf to this resolvers nameservers list.
// +optional
ParseResolvConf *bool `json:"parseResolvConf,omitempty"`
// ResolveRetries defines the number <nb> of queries to send to resolve a server name before giving up. Default value: 3
// +kubebuilder:validation:Minimum=1
// +optional
ResolveRetries *int64 `json:"resolveRetries,omitempty"`
// Hold defines the period during which the last name resolution should be kept based on the last resolution status.
// +optional
Hold *Hold `json:"hold,omitempty"`
// Timeouts defines timeouts related to name resolution.
// +optional
Timeouts *Timeouts `json:"timeouts,omitempty"`
}
type Nameserver struct {
// Name specifies a unique name of the nameserver.
// +kubebuilder:validation:Pattern="^[A-Za-z0-9-_.:]+$"
Name string `json:"name"`
// Address
// +kubebuilder:validation:Pattern=^[^\s]+$
Address string `json:"address"`
// Port
// +kubebuilder:validation:Maximum=65535
// +kubebuilder:validation:Minimum=1
Port int64 `json:"port,omitempty"`
}
func (n *Nameserver) Model() (models.Nameserver, error) {
model := models.Nameserver{
Name: n.Name,
Address: ptr.To(n.Address),
Port: ptr.To(n.Port),
}
return model, model.Validate(strfmt.Default)
}
type Hold struct {
// Nx defines interval between two successive name resolution when the last answer was nx.
Nx *metav1.Duration `json:"nx,omitempty"`
// Obsolete defines interval between two successive name resolution when the last answer was obsolete.
Obsolete *metav1.Duration `json:"obsolete,omitempty"`
// Other defines interval between two successive name resolution when the last answer was other.
Other *metav1.Duration `json:"other,omitempty"`
// Refused defines interval between two successive name resolution when the last answer was nx.
Refused *metav1.Duration `json:"refused,omitempty"`
// Timeout defines interval between two successive name resolution when the last answer was timeout.
Timeout *metav1.Duration `json:"timeout,omitempty"`
// Valid defines interval between two successive name resolution when the last answer was valid.
Valid *metav1.Duration `json:"valid,omitempty"`
}
type Timeouts struct {
// Resolve time to trigger name resolutions when no other time applied. Default value: 1s
// +optional
Resolve *metav1.Duration `json:"resolve,omitempty"`
// Retry time between two DNS queries, when no valid response have been received. Default value: 1s
// +optional
Retry *metav1.Duration `json:"retry,omitempty"`
}
//+kubebuilder:object:root=true
//+kubebuilder:subresource:status
//+kubebuilder:printcolumn:name=Mode,type=string,JSONPath=`.spec.mode`
//+kubebuilder:printcolumn:name=Phase,type=string,JSONPath=`.status.phase`
// Resolver is the Schema for the Resolver API
type Resolver struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec ResolverSpec `json:"spec,omitempty"`
Status Status `json:"status,omitempty"`
}
var _ Object = &Resolver{}
func (r *Resolver) SetStatus(status Status) {
r.Status = status
}
func (r *Resolver) GetStatus() Status {
return r.Status
}
func (r *Resolver) Model() (models.Resolver, error) {
model := models.Resolver{
Name: r.Name,
ParseResolvConf: ptr.Deref(r.Spec.ParseResolvConf, false),
ResolveRetries: ptr.Deref(r.Spec.ResolveRetries, 3),
TimeoutResolve: 1000,
TimeoutRetry: 1000,
}
if r.Spec.AcceptedPayloadSize != nil {
model.AcceptedPayloadSize = *r.Spec.AcceptedPayloadSize
}
if r.Spec.Hold != nil {
if r.Spec.Hold.Nx != nil {
model.HoldNx = ptr.To(r.Spec.Hold.Nx.Milliseconds())
}
if r.Spec.Hold.Obsolete != nil {
model.HoldObsolete = ptr.To(r.Spec.Hold.Obsolete.Milliseconds())
}
if r.Spec.Hold.Other != nil {
model.HoldOther = ptr.To(r.Spec.Hold.Other.Milliseconds())
}
if r.Spec.Hold.Refused != nil {
model.HoldRefused = ptr.To(r.Spec.Hold.Refused.Milliseconds())
}
if r.Spec.Hold.Timeout != nil {
model.HoldTimeout = ptr.To(r.Spec.Hold.Timeout.Milliseconds())
}
if r.Spec.Hold.Valid != nil {
model.HoldValid = ptr.To(r.Spec.Hold.Valid.Milliseconds())
}
}
if r.Spec.Timeouts != nil {
if r.Spec.Timeouts.Resolve != nil {
model.TimeoutResolve = r.Spec.Timeouts.Resolve.Milliseconds()
}
if r.Spec.Timeouts.Retry != nil {
model.TimeoutRetry = r.Spec.Timeouts.Retry.Milliseconds()
}
}
return model, model.Validate(strfmt.Default)
}
func (r *Resolver) AddToParser(p parser.Parser) error {
err := p.SectionsCreate(parser.Resolvers, r.Name)
if err != nil {
return err
}
var resolver models.Resolver
resolver, err = r.Model()
if err != nil {
return err
}
if err := configuration.SerializeResolverSection(p, &resolver); err != nil {
return err
}
for idx, nameserver := range r.Spec.Nameservers {
model, err := nameserver.Model()
if err != nil {
return err
}
err = p.Insert(parser.Resolvers, r.Name, "nameserver", configuration.SerializeNameserver(model), idx)
if err != nil {
return err
}
}
return nil
}
//+kubebuilder:object:root=true
// ResolverList contains a list of Resolver
type ResolverList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []Resolver `json:"items"`
}
func init() {
SchemeBuilder.Register(&Resolver{}, &ResolverList{})
}