Refactor Merging Strategy #6 (#292)

Author: chatton

pkg/kube/podtemplatespec/podspec_template.go

@@ -3,7 +3,6 @@ package podtemplatespec
 import (
 	"github.com/mongodb/mongodb-kubernetes-operator/pkg/util/merge"
 
-	"github.com/imdario/mergo"
 	"github.com/mongodb/mongodb-kubernetes-operator/pkg/kube/container"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -228,43 +227,8 @@ func WithVolumeMounts(containerName string, volumeMounts ...corev1.VolumeMount)
 }
 
 func MergePodTemplateSpecs(defaultTemplate, overrideTemplate corev1.PodTemplateSpec) (corev1.PodTemplateSpec, error) {
-
-	mergedContainers := merge.Containers(defaultTemplate.Spec.Containers, overrideTemplate.Spec.Containers)
-	mergedTolerations := merge.Tolerations(defaultTemplate.Spec.Tolerations, overrideTemplate.Spec.Tolerations)
-	mergedInitContainers := merge.Containers(defaultTemplate.Spec.InitContainers, overrideTemplate.Spec.InitContainers)
-	mergedAffinity, err := mergeAffinity(defaultTemplate.Spec.Affinity, overrideTemplate.Spec.Affinity)
-	if err != nil {
-		return corev1.PodTemplateSpec{}, err
-	}
-
-	mergedVolumes := merge.Volumes(defaultTemplate.Spec.Volumes, overrideTemplate.Spec.Volumes)
-
-	// Everything else can be merged with mergo
-	mergedPodTemplateSpec := *defaultTemplate.DeepCopy()
-	if err = mergo.Merge(&mergedPodTemplateSpec, overrideTemplate, mergo.WithOverride, mergo.WithAppendSlice); err != nil {
-		return corev1.PodTemplateSpec{}, err
-	}
-
-	mergedPodTemplateSpec.Spec.Containers = mergedContainers
-	mergedPodTemplateSpec.Spec.Tolerations = mergedTolerations
-	mergedPodTemplateSpec.Spec.InitContainers = mergedInitContainers
-	mergedPodTemplateSpec.Spec.Affinity = mergedAffinity
-	mergedPodTemplateSpec.Spec.Volumes = mergedVolumes
-	return mergedPodTemplateSpec, nil
-}
-
-func mergeAffinity(defaultAffinity, overrideAffinity *corev1.Affinity) (*corev1.Affinity, error) {
-	if defaultAffinity == nil {
-		return overrideAffinity, nil
-	}
-	if overrideAffinity == nil {
-		return defaultAffinity, nil
-	}
-	mergedAffinity := defaultAffinity.DeepCopy()
-	if err := mergo.Merge(mergedAffinity, *overrideAffinity, mergo.WithOverride); err != nil {
-		return nil, err
-	}
-	return mergedAffinity, nil
+	// TODO: remove in place of direct call to merge.PodTemplateSpecs
+	return merge.PodTemplateSpecs(defaultTemplate, overrideTemplate), nil
 }
 
 // findContainerByName will find either a container or init container by name in a pod template spec

pkg/kube/podtemplatespec/podspec_template_test.go

@@ -155,7 +155,23 @@ func TestMerge(t *testing.T) {
 			Affinity: affinity("zone", "custom"),
 		},
 	}
-	assert.Equal(t, expected, mergedSpec)
+	assert.Equal(t, expected.Name, mergedSpec.Name)
+	assert.Equal(t, expected.Namespace, mergedSpec.Namespace)
+	assert.Equal(t, expected.Labels["app"], mergedSpec.Labels["app"])
+	assert.Equal(t, expected.Labels["custom"], mergedSpec.Labels["custom"])
+	assert.Equal(t, expected.Spec.NodeSelector["node-0"], mergedSpec.Spec.NodeSelector["node-0"])
+	assert.Equal(t, expected.Spec.NodeSelector["node-1"], mergedSpec.Spec.NodeSelector["node-1"])
+	assert.Equal(t, expected.Spec.ServiceAccountName, mergedSpec.Spec.ServiceAccountName)
+	assert.Equal(t, expected.Spec.TerminationGracePeriodSeconds, mergedSpec.Spec.TerminationGracePeriodSeconds)
+	assert.Equal(t, expected.Spec.ActiveDeadlineSeconds, mergedSpec.Spec.ActiveDeadlineSeconds)
+	assert.Equal(t, expected.Spec.NodeName, mergedSpec.Spec.NodeName)
+	assert.Equal(t, expected.Spec.RestartPolicy, mergedSpec.Spec.RestartPolicy)
+	assert.Equal(t, expected.Spec.Volumes, mergedSpec.Spec.Volumes)
+	assert.Equal(t, expected.Spec.Affinity.PodAntiAffinity, mergedSpec.Spec.Affinity.PodAntiAffinity)
+	assert.Equal(t, expected.Spec.Affinity.PodAffinity, mergedSpec.Spec.Affinity.PodAffinity)
+	assert.Equal(t, expected.Spec.Affinity.NodeAffinity, mergedSpec.Spec.Affinity.NodeAffinity)
+	assert.Equal(t, expected.Spec.Containers, mergedSpec.Spec.Containers)
+	assert.Equal(t, expected.Spec.InitContainers, mergedSpec.Spec.InitContainers)
 }
 
 func TestMergeFromEmpty(t *testing.T) {

pkg/util/merge/merge.go

@@ -20,6 +20,19 @@ func StringSlices(slice1, slice2 []string) []string {
 	return mergedStrings
 }
 
+// StringToStringMap merges two string maps together with the second map
+// overriding any values also specified in the first.
+func StringToStringMap(map1, map2 map[string]string) map[string]string {
+	mergedMap := make(map[string]string)
+	for k, v := range map1 {
+		mergedMap[k] = v
+	}
+	for k, v := range map2 {
+		mergedMap[k] = v
+	}
+	return mergedMap
+}
+
 // Containers merges two slices of containers merging each item by container name.
 func Containers(defaultContainers, overrideContainers []corev1.Container) []corev1.Container {
 	mergedContainerMap := map[string]corev1.Container{}
@@ -629,3 +642,24 @@ func createKeyToPathMap(items []corev1.KeyToPath) map[string]corev1.KeyToPath {
 	}
 	return itemsMap
 }
+
+// Affinity merges two corev1.Affinity types.
+func Affinity(defaultAffinity, overrideAffinity *corev1.Affinity) *corev1.Affinity {
+	if defaultAffinity == nil {
+		return overrideAffinity
+	}
+	if overrideAffinity == nil {
+		return defaultAffinity
+	}
+	mergedAffinity := defaultAffinity.DeepCopy()
+	if overrideAffinity.NodeAffinity != nil {
+		mergedAffinity.NodeAffinity = overrideAffinity.NodeAffinity
+	}
+	if overrideAffinity.PodAffinity != nil {
+		mergedAffinity.PodAffinity = overrideAffinity.PodAffinity
+	}
+	if overrideAffinity.PodAntiAffinity != nil {
+		mergedAffinity.PodAntiAffinity = overrideAffinity.PodAntiAffinity
+	}
+	return mergedAffinity
+}

pkg/util/merge/merge_ephemeral_container.go

@@ -0,0 +1,109 @@
+package merge
+
+import (
+	"sort"
+
+	corev1 "k8s.io/api/core/v1"
+)
+
+// EphemeralContainers merges two slices of EphemeralContainers merging each item by container name.
+func EphemeralContainers(defaultContainers, overrideContainers []corev1.EphemeralContainer) []corev1.EphemeralContainer {
+	mergedContainerMap := map[string]corev1.EphemeralContainer{}
+
+	originalMap := createEphemeralContainerMap(defaultContainers)
+	overrideMap := createEphemeralContainerMap(overrideContainers)
+
+	for k, v := range originalMap {
+		mergedContainerMap[k] = v
+	}
+
+	for k, v := range overrideMap {
+		if orig, ok := originalMap[k]; ok {
+			mergedContainerMap[k] = EphemeralContainer(orig, v)
+		} else {
+			mergedContainerMap[k] = v
+		}
+	}
+
+	var mergedContainers []corev1.EphemeralContainer
+	for _, v := range mergedContainerMap {
+		mergedContainers = append(mergedContainers, v)
+	}
+
+	sort.SliceStable(mergedContainers, func(i, j int) bool {
+		return mergedContainers[i].Name < mergedContainers[j].Name
+	})
+	return mergedContainers
+
+}
+
+// EphemeralContainer merges two EphemeralContainers together.
+func EphemeralContainer(defaultContainer, overrideContainer corev1.EphemeralContainer) corev1.EphemeralContainer {
+	merged := defaultContainer
+
+	if overrideContainer.Name != "" {
+		merged.Name = overrideContainer.Name
+	}
+
+	if overrideContainer.Image != "" {
+		merged.Image = overrideContainer.Image
+	}
+
+	merged.Command = StringSlices(defaultContainer.Command, overrideContainer.Command)
+	merged.Args = StringSlices(defaultContainer.Args, overrideContainer.Args)
+
+	if overrideContainer.WorkingDir != "" {
+		merged.WorkingDir = overrideContainer.WorkingDir
+	}
+
+	merged.Ports = ContainerPortSlicesByName(defaultContainer.Ports, overrideContainer.Ports)
+	merged.Env = Envs(defaultContainer.Env, overrideContainer.Env)
+	merged.Resources = ResourceRequirements(defaultContainer.Resources, overrideContainer.Resources)
+	merged.VolumeMounts = VolumeMounts(defaultContainer.VolumeMounts, overrideContainer.VolumeMounts)
+	merged.VolumeDevices = VolumeDevices(defaultContainer.VolumeDevices, overrideContainer.VolumeDevices)
+	merged.LivenessProbe = Probe(defaultContainer.LivenessProbe, overrideContainer.LivenessProbe)
+	merged.ReadinessProbe = Probe(defaultContainer.ReadinessProbe, overrideContainer.ReadinessProbe)
+	merged.StartupProbe = Probe(defaultContainer.StartupProbe, overrideContainer.StartupProbe)
+	merged.Lifecycle = LifeCycle(defaultContainer.Lifecycle, overrideContainer.Lifecycle)
+
+	if overrideContainer.TerminationMessagePath != "" {
+		merged.TerminationMessagePath = overrideContainer.TerminationMessagePath
+	}
+
+	if overrideContainer.TerminationMessagePolicy != "" {
+		merged.TerminationMessagePolicy = overrideContainer.TerminationMessagePolicy
+	}
+
+	if overrideContainer.ImagePullPolicy != "" {
+		merged.ImagePullPolicy = overrideContainer.ImagePullPolicy
+	}
+
+	merged.SecurityContext = SecurityContext(defaultContainer.SecurityContext, overrideContainer.SecurityContext)
+
+	if overrideContainer.Stdin {
+		merged.Stdin = overrideContainer.Stdin
+	}
+
+	if overrideContainer.StdinOnce {
+		merged.StdinOnce = overrideContainer.StdinOnce
+	}
+
+	if overrideContainer.TTY {
+		merged.TTY = overrideContainer.TTY
+	}
+
+	// EphemeralContainer only fields
+	if overrideContainer.TargetContainerName != "" {
+		merged.TargetContainerName = overrideContainer.TargetContainerName
+	}
+
+	return merged
+}
+
+func createEphemeralContainerMap(containers []corev1.EphemeralContainer) map[string]corev1.EphemeralContainer {
+	m := make(map[string]corev1.EphemeralContainer)
+	for _, v := range containers {
+		m[v.Name] = v
+	}
+	return m
+}