/
machinepool_types.go
241 lines (192 loc) · 9.19 KB
/
machinepool_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
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
/*
Copyright 2019 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package v1alpha4
import (
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
clusterv1alpha4 "sigs.k8s.io/cluster-api/api/v1alpha4"
capierrors "sigs.k8s.io/cluster-api/errors"
)
const (
// MachinePoolFinalizer is used to ensure deletion of dependencies (nodes, infra).
MachinePoolFinalizer = "machinepool.cluster.x-k8s.io"
)
// ANCHOR: MachinePoolSpec
// MachinePoolSpec defines the desired state of MachinePool.
type MachinePoolSpec struct {
// ClusterName is the name of the Cluster this object belongs to.
// +kubebuilder:validation:MinLength=1
ClusterName string `json:"clusterName"`
// Number of desired machines. Defaults to 1.
// This is a pointer to distinguish between explicit zero and not specified.
Replicas *int32 `json:"replicas,omitempty"`
// Template describes the machines that will be created.
Template clusterv1alpha4.MachineTemplateSpec `json:"template"`
// Minimum number of seconds for which a newly created machine instances should
// be ready.
// Defaults to 0 (machine instance will be considered available as soon as it
// is ready)
// +optional
MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`
// ProviderIDList are the identification IDs of machine instances provided by the provider.
// This field must match the provider IDs as seen on the node objects corresponding to a machine pool's machine instances.
// +optional
ProviderIDList []string `json:"providerIDList,omitempty"`
// FailureDomains is the list of failure domains this MachinePool should be attached to.
FailureDomains []string `json:"failureDomains,omitempty"`
}
// ANCHOR_END: MachinePoolSpec
// ANCHOR: MachinePoolStatus
// MachinePoolStatus defines the observed state of MachinePool.
type MachinePoolStatus struct {
// NodeRefs will point to the corresponding Nodes if it they exist.
// +optional
NodeRefs []corev1.ObjectReference `json:"nodeRefs,omitempty"`
// Replicas is the most recently observed number of replicas.
// +optional
Replicas int32 `json:"replicas"`
// The number of ready replicas for this MachinePool. A machine is considered ready when the node has been created and is "Ready".
// +optional
ReadyReplicas int32 `json:"readyReplicas,omitempty"`
// The number of available replicas (ready for at least minReadySeconds) for this MachinePool.
// +optional
AvailableReplicas int32 `json:"availableReplicas,omitempty"`
// Total number of unavailable machine instances targeted by this machine pool.
// This is the total number of machine instances that are still required for
// the machine pool to have 100% available capacity. They may either
// be machine instances that are running but not yet available or machine instances
// that still have not been created.
// +optional
UnavailableReplicas int32 `json:"unavailableReplicas,omitempty"`
// FailureReason indicates that there is a problem reconciling the state, and
// will be set to a token value suitable for programmatic interpretation.
// +optional
FailureReason *capierrors.MachinePoolStatusFailure `json:"failureReason,omitempty"`
// FailureMessage indicates that there is a problem reconciling the state,
// and will be set to a descriptive error message.
// +optional
FailureMessage *string `json:"failureMessage,omitempty"`
// Phase represents the current phase of cluster actuation.
// E.g. Pending, Running, Terminating, Failed etc.
// +optional
Phase string `json:"phase,omitempty"`
// BootstrapReady is the state of the bootstrap provider.
// +optional
BootstrapReady bool `json:"bootstrapReady"`
// InfrastructureReady is the state of the infrastructure provider.
// +optional
InfrastructureReady bool `json:"infrastructureReady"`
// ObservedGeneration is the latest generation observed by the controller.
// +optional
ObservedGeneration int64 `json:"observedGeneration,omitempty"`
// Conditions define the current service state of the MachinePool.
// +optional
Conditions clusterv1alpha4.Conditions `json:"conditions,omitempty"`
}
// ANCHOR_END: MachinePoolStatus
// MachinePoolPhase is a string representation of a MachinePool Phase.
//
// This type is a high-level indicator of the status of the MachinePool as it is provisioned,
// from the API user’s perspective.
//
// The value should not be interpreted by any software components as a reliable indication
// of the actual state of the MachinePool, and controllers should not use the MachinePool Phase field
// value when making decisions about what action to take.
//
// Controllers should always look at the actual state of the MachinePool’s fields to make those decisions.
type MachinePoolPhase string
const (
// MachinePoolPhasePending is the first state a MachinePool is assigned by
// Cluster API MachinePool controller after being created.
MachinePoolPhasePending = MachinePoolPhase("Pending")
// MachinePoolPhaseProvisioning is the state when the
// MachinePool infrastructure is being created or updated.
MachinePoolPhaseProvisioning = MachinePoolPhase("Provisioning")
// MachinePoolPhaseProvisioned is the state when its
// infrastructure has been created and configured.
MachinePoolPhaseProvisioned = MachinePoolPhase("Provisioned")
// MachinePoolPhaseRunning is the MachinePool state when its instances
// have become Kubernetes Nodes in the Ready state.
MachinePoolPhaseRunning = MachinePoolPhase("Running")
// MachinePoolPhaseScalingUp is the MachinePool state when the
// MachinePool infrastructure is scaling up.
MachinePoolPhaseScalingUp = MachinePoolPhase("ScalingUp")
// MachinePoolPhaseScalingDown is the MachinePool state when the
// MachinePool infrastructure is scaling down.
MachinePoolPhaseScalingDown = MachinePoolPhase("ScalingDown")
// MachinePoolPhaseDeleting is the MachinePool state when a delete
// request has been sent to the API Server,
// but its infrastructure has not yet been fully deleted.
MachinePoolPhaseDeleting = MachinePoolPhase("Deleting")
// MachinePoolPhaseFailed is the MachinePool state when the system
// might require user intervention.
MachinePoolPhaseFailed = MachinePoolPhase("Failed")
// MachinePoolPhaseUnknown is returned if the MachinePool state cannot be determined.
MachinePoolPhaseUnknown = MachinePoolPhase("Unknown")
)
// SetTypedPhase sets the Phase field to the string representation of MachinePoolPhase.
func (m *MachinePoolStatus) SetTypedPhase(p MachinePoolPhase) {
m.Phase = string(p)
}
// GetTypedPhase attempts to parse the Phase field and return
// the typed MachinePoolPhase representation as described in `machinepool_phase_types.go`.
func (m *MachinePoolStatus) GetTypedPhase() MachinePoolPhase {
switch phase := MachinePoolPhase(m.Phase); phase {
case
MachinePoolPhasePending,
MachinePoolPhaseProvisioning,
MachinePoolPhaseProvisioned,
MachinePoolPhaseRunning,
MachinePoolPhaseScalingUp,
MachinePoolPhaseScalingDown,
MachinePoolPhaseDeleting,
MachinePoolPhaseFailed:
return phase
default:
return MachinePoolPhaseUnknown
}
}
// +kubebuilder:object:root=true
// +kubebuilder:resource:path=machinepools,shortName=mp,scope=Namespaced,categories=cluster-api
// +kubebuilder:subresource:status
// +kubebuilder:subresource:scale:specpath=.spec.replicas,statuspath=.status.replicas
// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp",description="Time duration since creation of MachinePool"
// +kubebuilder:printcolumn:name="Replicas",type="string",JSONPath=".status.replicas",description="MachinePool replicas count"
// +kubebuilder:printcolumn:name="Phase",type="string",JSONPath=".status.phase",description="MachinePool status such as Terminating/Pending/Provisioning/Running/Failed etc"
// +kubebuilder:printcolumn:name="Version",type="string",JSONPath=".spec.template.spec.version",description="Kubernetes version associated with this MachinePool"
// +k8s:conversion-gen=false
// MachinePool is the Schema for the machinepools API.
type MachinePool struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec MachinePoolSpec `json:"spec,omitempty"`
Status MachinePoolStatus `json:"status,omitempty"`
}
// GetConditions returns the set of conditions for this object.
func (m *MachinePool) GetConditions() clusterv1alpha4.Conditions {
return m.Status.Conditions
}
// SetConditions sets the conditions on this object.
func (m *MachinePool) SetConditions(conditions clusterv1alpha4.Conditions) {
m.Status.Conditions = conditions
}
// +kubebuilder:object:root=true
// MachinePoolList contains a list of MachinePool.
type MachinePoolList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []MachinePool `json:"items"`
}
func init() {
SchemeBuilder.Register(&MachinePool{}, &MachinePoolList{})
}