Skip to content

Commit 64ef9dd

Browse files
sbueringersbueringer
committed
test/e2e: Implement ClusterCLass rollout e2e test
Signed-off-by: Stefan Büringer buringerst@vmware.com
1 parent 13158ae commit 64ef9dd

16 files changed

+1750
-144
lines changed

‎internal/contract/bootstrap_config_template.go

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
/*
2+
Copyright 2022 The Kubernetes Authors.
3+
4+
Licensed under the Apache License, Version 2.0 (the "License");
5+
you may not use this file except in compliance with the License.
6+
You may obtain a copy of the License at
7+
8+
http://www.apache.org/licenses/LICENSE-2.0
9+
10+
Unless required by applicable law or agreed to in writing, software
11+
distributed under the License is distributed on an "AS IS" BASIS,
12+
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
See the License for the specific language governing permissions and
14+
limitations under the License.
15+
*/
16+
17+
package contract
18+
19+
import (
20+
"sync"
21+
)
22+
23+
// BootstrapConfigTemplateContract encodes information about the Cluster API contract for BootstrapConfigTemplate objects
24+
// like KubeadmConfigTemplate, etc.
25+
type BootstrapConfigTemplateContract struct{}
26+
27+
var bootstrapConfigTemplate *BootstrapConfigTemplateContract
28+
var onceBootstrapConfigTemplate sync.Once
29+
30+
// BootstrapConfigTemplate provide access to the information about the Cluster API contract for BootstrapConfigTemplate objects.
31+
func BootstrapConfigTemplate() *BootstrapConfigTemplateContract {
32+
onceBootstrapConfigTemplate.Do(func() {
33+
bootstrapConfigTemplate = &BootstrapConfigTemplateContract{}
34+
})
35+
return bootstrapConfigTemplate
36+
}
37+
38+
// Template provides access to the template.
39+
func (c *BootstrapConfigTemplateContract) Template() *BootstrapConfigTemplateTemplate {
40+
return &BootstrapConfigTemplateTemplate{}
41+
}
42+
43+
// BootstrapConfigTemplateTemplate provides a helper struct for working with the template in an BootstrapConfigTemplate.
44+
type BootstrapConfigTemplateTemplate struct{}
45+
46+
// Metadata provides access to the metadata of a template.
47+
func (c *BootstrapConfigTemplateTemplate) Metadata() *Metadata {
48+
return &Metadata{
49+
path: Path{"spec", "template", "metadata"},
50+
}
51+
}

‎internal/contract/controlplane_template.go

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,3 +42,54 @@ func (c *ControlPlaneTemplateContract) InfrastructureMachineTemplate() *Ref {
4242
path: Path{"spec", "template", "spec", "machineTemplate", "infrastructureRef"},
4343
}
4444
}
45+
46+
// Template provides access to the template.
47+
func (c *ControlPlaneTemplateContract) Template() *ControlPlaneTemplateTemplate {
48+
return &ControlPlaneTemplateTemplate{}
49+
}
50+
51+
// ControlPlaneTemplateTemplate provides a helper struct for working with the template in an ControlPlaneTemplate.
52+
type ControlPlaneTemplateTemplate struct{}
53+
54+
// Metadata provides access to the metadata of a template.
55+
func (c *ControlPlaneTemplateTemplate) Metadata() *Metadata {
56+
return &Metadata{
57+
path: Path{"spec", "template", "metadata"},
58+
}
59+
}
60+
61+
// MachineTemplate provides access to MachineTemplate in a ControlPlaneTemplate object, if any.
62+
func (c *ControlPlaneTemplateTemplate) MachineTemplate() *ControlPlaneTemplateMachineTemplate {
63+
return &ControlPlaneTemplateMachineTemplate{}
64+
}
65+
66+
// ControlPlaneTemplateMachineTemplate provides a helper struct for working with MachineTemplate.
67+
type ControlPlaneTemplateMachineTemplate struct{}
68+
69+
// Metadata provides access to the metadata of the MachineTemplate of a ControlPlaneTemplate.
70+
func (c *ControlPlaneTemplateMachineTemplate) Metadata() *Metadata {
71+
return &Metadata{
72+
path: Path{"spec", "template", "spec", "machineTemplate", "metadata"},
73+
}
74+
}
75+
76+
// NodeDrainTimeout provides access to the nodeDrainTimeout of a MachineTemplate.
77+
func (c *ControlPlaneTemplateMachineTemplate) NodeDrainTimeout() *Duration {
78+
return &Duration{
79+
path: Path{"spec", "template", "spec", "machineTemplate", "nodeDrainTimeout"},
80+
}
81+
}
82+
83+
// NodeVolumeDetachTimeout provides access to the nodeVolumeDetachTimeout of a MachineTemplate.
84+
func (c *ControlPlaneTemplateMachineTemplate) NodeVolumeDetachTimeout() *Duration {
85+
return &Duration{
86+
path: Path{"spec", "template", "spec", "machineTemplate", "nodeVolumeDetachTimeout"},
87+
}
88+
}
89+
90+
// NodeDeletionTimeout provides access to the nodeDeletionTimeout of a MachineTemplate.
91+
func (c *ControlPlaneTemplateMachineTemplate) NodeDeletionTimeout() *Duration {
92+
return &Duration{
93+
path: Path{"spec", "template", "spec", "machineTemplate", "nodeDeletionTimeout"},
94+
}
95+
}

‎internal/contract/infrastructure_cluster_template.go

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
/*
2+
Copyright 2021 The Kubernetes Authors.
3+
4+
Licensed under the Apache License, Version 2.0 (the "License");
5+
you may not use this file except in compliance with the License.
6+
You may obtain a copy of the License at
7+
8+
http://www.apache.org/licenses/LICENSE-2.0
9+
10+
Unless required by applicable law or agreed to in writing, software
11+
distributed under the License is distributed on an "AS IS" BASIS,
12+
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
See the License for the specific language governing permissions and
14+
limitations under the License.
15+
*/
16+
17+
package contract
18+
19+
import (
20+
"sync"
21+
)
22+
23+
// InfrastructureClusterTemplateContract encodes information about the Cluster API contract for InfrastructureClusterTemplate objects
24+
// like DockerClusterTemplates, AWSClusterTemplates, etc.
25+
type InfrastructureClusterTemplateContract struct{}
26+
27+
var infrastructureClusterTemplate *InfrastructureClusterTemplateContract
28+
var onceInfrastructureClusterTemplate sync.Once
29+
30+
// InfrastructureClusterTemplate provides access to the information about the Cluster API contract for InfrastructureClusterTemplate objects.
31+
func InfrastructureClusterTemplate() *InfrastructureClusterTemplateContract {
32+
onceInfrastructureClusterTemplate.Do(func() {
33+
infrastructureClusterTemplate = &InfrastructureClusterTemplateContract{}
34+
})
35+
return infrastructureClusterTemplate
36+
}
37+
38+
// Template provides access to the template.
39+
func (c *InfrastructureClusterTemplateContract) Template() *InfrastructureClusterTemplateTemplate {
40+
return &InfrastructureClusterTemplateTemplate{}
41+
}
42+
43+
// InfrastructureClusterTemplateTemplate provides a helper struct for working with the template in an InfrastructureClusterTemplate..
44+
type InfrastructureClusterTemplateTemplate struct{}
45+
46+
// Metadata provides access to the metadata of a template.
47+
func (c *InfrastructureClusterTemplateTemplate) Metadata() *Metadata {
48+
return &Metadata{
49+
path: Path{"spec", "template", "metadata"},
50+
}
51+
}

‎internal/contract/infrastructure_machine.go

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -27,14 +27,14 @@ import (
2727
clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
2828
)
2929

30-
// InfrastructureMachineContract encodes information about the Machine API contract for InfrastructureMachine objects
30+
// InfrastructureMachineContract encodes information about the Cluster API contract for InfrastructureMachine objects
3131
// like DockerMachines, AWS Machines, etc.
3232
type InfrastructureMachineContract struct{}
3333

3434
var infrastructureMachine *InfrastructureMachineContract
3535
var onceInfrastructureMachine sync.Once
3636

37-
// InfrastructureMachine provide access to the information about the Machine API contract for InfrastructureMachine objects.
37+
// InfrastructureMachine provide access to the information about the Cluster API contract for InfrastructureMachine objects.
3838
func InfrastructureMachine() *InfrastructureMachineContract {
3939
onceInfrastructureMachine.Do(func() {
4040
infrastructureMachine = &InfrastructureMachineContract{}

‎internal/contract/infrastructure_machine_template.go

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
/*
2+
Copyright 2022 The Kubernetes Authors.
3+
4+
Licensed under the Apache License, Version 2.0 (the "License");
5+
you may not use this file except in compliance with the License.
6+
You may obtain a copy of the License at
7+
8+
http://www.apache.org/licenses/LICENSE-2.0
9+
10+
Unless required by applicable law or agreed to in writing, software
11+
distributed under the License is distributed on an "AS IS" BASIS,
12+
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
See the License for the specific language governing permissions and
14+
limitations under the License.
15+
*/
16+
17+
package contract
18+
19+
import (
20+
"sync"
21+
)
22+
23+
// InfrastructureMachineTemplateContract encodes information about the Cluster API contract for InfrastructureMachineTemplate objects
24+
// like DockerMachineTemplates, AWSMachineTemplates, etc.
25+
type InfrastructureMachineTemplateContract struct{}
26+
27+
var infrastructureMachineTemplate *InfrastructureMachineTemplateContract
28+
var onceInfrastructureMachineTemplate sync.Once
29+
30+
// InfrastructureMachineTemplate provide access to the information about the Cluster API contract for InfrastructureMachineTemplate objects.
31+
func InfrastructureMachineTemplate() *InfrastructureMachineTemplateContract {
32+
onceInfrastructureMachineTemplate.Do(func() {
33+
infrastructureMachineTemplate = &InfrastructureMachineTemplateContract{}
34+
})
35+
return infrastructureMachineTemplate
36+
}
37+
38+
// Template provides access to the template.
39+
func (c *InfrastructureMachineTemplateContract) Template() *InfrastructureMachineTemplateTemplate {
40+
return &InfrastructureMachineTemplateTemplate{}
41+
}
42+
43+
// InfrastructureMachineTemplateTemplate provides a helper struct for working with the template in an InfrastructureMachineTemplate.
44+
type InfrastructureMachineTemplateTemplate struct{}
45+
46+
// Metadata provides access to the metadata of a template.
47+
func (c *InfrastructureMachineTemplateTemplate) Metadata() *Metadata {
48+
return &Metadata{
49+
path: Path{"spec", "template", "metadata"},
50+
}
51+
}

‎internal/controllers/topology/cluster/desired_state.go

Lines changed: 19 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -241,11 +241,20 @@ func (r *Reconciler) computeControlPlane(ctx context.Context, s *scope.Scope, in
241241
return nil, errors.Wrap(err, "failed to spec.machineTemplate.infrastructureRef in the ControlPlane object")
242242
}
243243

244-
// Apply the ControlPlane labels and annotations to the ControlPlane machines as well.
244+
// Add the ControlPlane labels and annotations to the ControlPlane machines as well.
245+
// Note: We have to ensure the machine template metadata copied from the control plane template is not overwritten.
246+
controlPlaneMachineTemplateMetadata, err := contract.ControlPlane().MachineTemplate().Metadata().Get(controlPlane)
247+
if err != nil {
248+
return nil, errors.Wrap(err, "failed to get spec.machineTemplate.metadata from the ControlPlane object")
249+
}
250+
251+
controlPlaneMachineTemplateMetadata.Labels = mergeMap(controlPlaneLabels, controlPlaneMachineTemplateMetadata.Labels)
252+
controlPlaneMachineTemplateMetadata.Annotations = mergeMap(controlPlaneAnnotations, controlPlaneMachineTemplateMetadata.Annotations)
253+
245254
if err := contract.ControlPlane().MachineTemplate().Metadata().Set(controlPlane,
246255
&clusterv1.ObjectMeta{
247-
Labels: controlPlaneLabels,
248-
Annotations: controlPlaneAnnotations,
256+
Labels: controlPlaneMachineTemplateMetadata.Labels,
257+
Annotations: controlPlaneMachineTemplateMetadata.Annotations,
249258
}); err != nil {
250259
return nil, errors.Wrap(err, "failed to set spec.machineTemplate.metadata in the ControlPlane object")
251260
}
@@ -990,15 +999,14 @@ func templateToTemplate(in templateToInput) *unstructured.Unstructured {
990999
return template
9911000
}
9921001

993-
// mergeMap merges two maps into another one.
994-
// NOTE: In case a key exists in both maps, the value in the first map is preserved.
995-
func mergeMap(a, b map[string]string) map[string]string {
1002+
// mergeMap merges maps.
1003+
// NOTE: In case a key exists in multiple maps, the value of the first map is preserved.
1004+
func mergeMap(maps ...map[string]string) map[string]string {
9961005
m := make(map[string]string)
997-
for k, v := range b {
998-
m[k] = v
999-
}
1000-
for k, v := range a {
1001-
m[k] = v
1006+
for i := len(maps) - 1; i >= 0; i-- {
1007+
for k, v := range maps[i] {
1008+
m[k] = v
1009+
}
10021010
}
10031011

10041012
// Nil the result if the map is empty, thus avoiding triggering infinite reconcile

‎internal/controllers/topology/cluster/desired_state_test.go

Lines changed: 23 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -252,6 +252,17 @@ func TestComputeControlPlane(t *testing.T) {
252252

253253
controlPlaneTemplate := builder.ControlPlaneTemplate(metav1.NamespaceDefault, "template1").
254254
Build()
255+
controlPlaneMachineTemplateLabels := map[string]string{
256+
"machineTemplateLabel": "machineTemplateLabelValue",
257+
}
258+
controlPlaneMachineTemplateAnnotations := map[string]string{
259+
"machineTemplateAnnotation": "machineTemplateAnnotationValue",
260+
}
261+
controlPlaneTemplateWithMachineTemplate := controlPlaneTemplate.DeepCopy()
262+
_ = contract.ControlPlaneTemplate().Template().MachineTemplate().Metadata().Set(controlPlaneTemplateWithMachineTemplate, &clusterv1.ObjectMeta{
263+
Labels: controlPlaneMachineTemplateLabels,
264+
Annotations: controlPlaneMachineTemplateAnnotations,
265+
})
255266
clusterClassDuration := 20 * time.Second
256267
clusterClass := builder.ClusterClass(metav1.NamespaceDefault, "class1").
257268
WithControlPlaneMetadata(labels, annotations).
@@ -423,15 +434,15 @@ func TestComputeControlPlane(t *testing.T) {
423434
infrastructureMachineTemplate := builder.InfrastructureMachineTemplate(metav1.NamespaceDefault, "template1").Build()
424435
clusterClass := builder.ClusterClass(metav1.NamespaceDefault, "class1").
425436
WithControlPlaneMetadata(labels, annotations).
426-
WithControlPlaneTemplate(controlPlaneTemplate).
437+
WithControlPlaneTemplate(controlPlaneTemplateWithMachineTemplate).
427438
WithControlPlaneInfrastructureMachineTemplate(infrastructureMachineTemplate).Build()
428439

429440
// aggregating templates and cluster class into a blueprint (simulating getBlueprint)
430441
blueprint := &scope.ClusterBlueprint{
431442
Topology: cluster.Spec.Topology,
432443
ClusterClass: clusterClass,
433444
ControlPlane: &scope.ControlPlaneBlueprint{
434-
Template: controlPlaneTemplate,
445+
Template: controlPlaneTemplateWithMachineTemplate,
435446
InfrastructureMachineTemplate: infrastructureMachineTemplate,
436447
},
437448
}
@@ -447,10 +458,17 @@ func TestComputeControlPlane(t *testing.T) {
447458
g.Expect(err).ToNot(HaveOccurred())
448459
g.Expect(obj).ToNot(BeNil())
449460

461+
// machineTemplate is removed from the template for assertion as we can't
462+
// simply compare the machineTemplate in template with the one in object as
463+
// computeControlPlane() adds additional fields like the timeouts to machineTemplate.
464+
// Note: machineTemplate ia asserted further down below instead.
465+
controlPlaneTemplateWithoutMachineTemplate := blueprint.ControlPlane.Template.DeepCopy()
466+
unstructured.RemoveNestedField(controlPlaneTemplateWithoutMachineTemplate.Object, "spec", "template", "spec", "machineTemplate")
467+
450468
assertTemplateToObject(g, assertTemplateInput{
451469
cluster: s.Current.Cluster,
452470
templateRef: blueprint.ClusterClass.Spec.ControlPlane.Ref,
453-
template: blueprint.ControlPlane.Template,
471+
template: controlPlaneTemplateWithoutMachineTemplate,
454472
currentRef: nil,
455473
obj: obj,
456474
labels: mergeMap(blueprint.Topology.ControlPlane.Metadata.Labels, blueprint.ClusterClass.Spec.ControlPlane.Metadata.Labels),
@@ -459,12 +477,12 @@ func TestComputeControlPlane(t *testing.T) {
459477
gotMetadata, err := contract.ControlPlane().MachineTemplate().Metadata().Get(obj)
460478
g.Expect(err).ToNot(HaveOccurred())
461479

462-
expectedLabels := mergeMap(s.Current.Cluster.Spec.Topology.ControlPlane.Metadata.Labels, blueprint.ClusterClass.Spec.ControlPlane.Metadata.Labels)
480+
expectedLabels := mergeMap(s.Current.Cluster.Spec.Topology.ControlPlane.Metadata.Labels, blueprint.ClusterClass.Spec.ControlPlane.Metadata.Labels, controlPlaneMachineTemplateLabels)
463481
expectedLabels[clusterv1.ClusterNameLabel] = cluster.Name
464482
expectedLabels[clusterv1.ClusterTopologyOwnedLabel] = ""
465483
g.Expect(gotMetadata).To(Equal(&clusterv1.ObjectMeta{
466484
Labels: expectedLabels,
467-
Annotations: mergeMap(s.Current.Cluster.Spec.Topology.ControlPlane.Metadata.Annotations, blueprint.ClusterClass.Spec.ControlPlane.Metadata.Annotations),
485+
Annotations: mergeMap(s.Current.Cluster.Spec.Topology.ControlPlane.Metadata.Annotations, blueprint.ClusterClass.Spec.ControlPlane.Metadata.Annotations, controlPlaneMachineTemplateAnnotations),
468486
}))
469487

470488
assertNestedField(g, obj, version, contract.ControlPlane().Version().Path()...)

0 commit comments

Comments
 (0)