MLE-22946: Fix the bug of cluster level labels propagate

pkg/k8sutil/common.go

@@ -9,9 +9,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
-var CustomLabels = map[string]string{}
-var CustomAnnotations = map[string]string{}
-
 // generateTypeMeta generates the TyeMeta
 func generateTypeMeta(resourceKind string, apiVersion string) metav1.TypeMeta {
 	return metav1.TypeMeta{
@@ -49,15 +46,6 @@ func LabelSelectors(labels map[string]string) *metav1.LabelSelector {
 	return &metav1.LabelSelector{MatchLabels: labels}
 }
 
-func SetCommonLabels(labels map[string]string) {
-	CustomLabels = labels
-}
-
-func SetCommonAnnotations(annotations map[string]string) {
-	delete(annotations, "kubectl.kubernetes.io/last-applied-configuration")
-	CustomAnnotations = annotations
-}
-
 func getSelectorLabels(name string) map[string]string {
 	selectorLabels := map[string]string{
 		"app.kubernetes.io/name":       "marklogic",
@@ -78,46 +66,6 @@ func getHAProxySelectorLabels(name string) map[string]string {
 	return selectorLabels
 }
 
-func getHAProxyLabels(name string) map[string]string {
-	defaultHaproxyLabels := getHAProxySelectorLabels(name)
-	mergedLabels := map[string]string{}
-	if len(CustomLabels) > 0 {
-		for k, v := range defaultHaproxyLabels {
-			mergedLabels[k] = v
-		}
-		for k, v := range CustomLabels {
-			if _, ok := defaultHaproxyLabels[k]; !ok {
-				mergedLabels[k] = v
-			}
-		}
-	} else {
-		return defaultHaproxyLabels
-	}
-	return mergedLabels
-}
-
-func getCommonLabels(name string) map[string]string {
-	defaultLabels := getSelectorLabels(name)
-	mergedLabels := map[string]string{}
-	if len(CustomLabels) > 0 {
-		for k, v := range defaultLabels {
-			mergedLabels[k] = v
-		}
-		for k, v := range CustomLabels {
-			if _, ok := defaultLabels[k]; !ok {
-				mergedLabels[k] = v
-			}
-		}
-	} else {
-		return defaultLabels
-	}
-	return mergedLabels
-}
-
-func getCommonAnnotations() map[string]string {
-	return CustomAnnotations
-}
-
 func getFluentBitLabels(name string) map[string]string {
 	return map[string]string{
 		"app.kubernetes.io/name":     "fluent-bit",

pkg/k8sutil/configmap.go

@@ -19,8 +19,8 @@ func (oc *OperatorContext) ReconcileConfigMap() result.ReconcileResult {
 	cr := oc.MarklogicGroup
 
 	logger.Info("Reconciling MarkLogic ConfigMap")
-	labels := getCommonLabels(cr.Spec.Name)
-	annotations := getCommonAnnotations()
+	labels := oc.GetOperatorLabels(cr.Spec.Name)
+	annotations := oc.GetOperatorAnnotations()
 	configMapName := cr.Spec.Name + "-scripts"
 	objectMeta := generateObjectMeta(configMapName, cr.Namespace, labels, annotations)
 	nsName := types.NamespacedName{Name: objectMeta.Name, Namespace: objectMeta.Namespace}

pkg/k8sutil/context.go

@@ -15,22 +15,23 @@ import (
 )
 
 type OperatorContext struct {
-	Ctx context.Context
-
+	Ctx            context.Context
+	Labels         map[string]string
+	Annotations    map[string]string
 	Request        *reconcile.Request
 	Client         controllerClient.Client
 	Scheme         *runtime.Scheme
 	MarklogicGroup *marklogicv1.MarklogicGroup
 	ReqLogger      logr.Logger
 	Recorder       record.EventRecorder
-
-	Services     []*corev1.Service
-	StatefulSets []*appsv1.StatefulSet
+	Services       []*corev1.Service
+	StatefulSets   []*appsv1.StatefulSet
 }
 
 type ClusterContext struct {
-	Ctx context.Context
-
+	Ctx              context.Context
+	Labels           map[string]string
+	Annotations      map[string]string
 	Request          *reconcile.Request
 	Client           controllerClient.Client
 	Scheme           *runtime.Scheme
@@ -57,17 +58,16 @@ func CreateOperatorContext(
 	oc.Scheme = scheme
 	oc.ReqLogger = reqLogger
 	oc.Recorder = rec
+	oc.Labels = map[string]string{}
+	oc.Annotations = map[string]string{}
 	mlg := &marklogicv1.MarklogicGroup{}
 	if err := retrieveMarkLogicGroup(oc, request, mlg); err != nil {
 		oc.ReqLogger.Error(err, "Failed to retrieve MarkLogicServer")
 		return nil, err
 	}
-	// if err := retrieveMarklogicCluster(oc, request, mlc); err != nil {
-	// 	oc.ReqLogger.Error(err, "Failed to retrieve MarkLogicCluster")
-	// 	return nil, err
-	// }
 	oc.MarklogicGroup = mlg
-	// oc.MarklogicCluster = mlc
+	oc.SetOperatorLabels(oc.MarklogicGroup.GetLabels())
+	oc.SetOperatorAnnotations(oc.MarklogicGroup.GetAnnotations())
 
 	oc.ReqLogger.Info("==== CreateOperatorContext")
 
@@ -92,14 +92,16 @@ func CreateClusterContext(
 	cc.Scheme = scheme
 	cc.ReqLogger = reqLogger
 	cc.Recorder = rec
+	cc.Labels = map[string]string{}
+	cc.Annotations = map[string]string{}
 	mlc := &marklogicv1.MarklogicCluster{}
-
 	if err := retrieveMarklogicCluster(cc, request, mlc); err != nil {
 		cc.ReqLogger.Error(err, "Failed to retrieve MarkLogicCluster")
 		return nil, err
 	}
 	cc.MarklogicCluster = mlc
-
+	cc.SetClusterLabels(cc.MarklogicCluster.GetLabels())
+	cc.SetClusterAnnotations(cc.MarklogicCluster.GetAnnotations())
 	cc.ReqLogger.Info("==== CreateOperatorContext")
 
 	// cc.ReqLogger = cc.ReqLogger.WithValues("ML server name")
@@ -137,3 +139,83 @@ func (oc *OperatorContext) GetClient() controllerClient.Client {
 func (oc *OperatorContext) GetContext() context.Context {
 	return oc.Ctx
 }
+
+func (cc *ClusterContext) GetClusterLabels(name string) map[string]string {
+	defaultLabels := getSelectorLabels(name)
+	mergedLabels := map[string]string{}
+	if len(cc.Labels) > 0 {
+		for k, v := range defaultLabels {
+			mergedLabels[k] = v
+		}
+		for k, v := range cc.Labels {
+			if _, ok := defaultLabels[k]; !ok {
+				mergedLabels[k] = v
+			}
+		}
+	} else {
+		return defaultLabels
+	}
+	return mergedLabels
+}
+
+func (cc *ClusterContext) GetHAProxyLabels(name string) map[string]string {
+	defaultHaproxyLabels := getHAProxySelectorLabels(name)
+	mergedLabels := map[string]string{}
+	if len(cc.Labels) > 0 {
+		for k, v := range defaultHaproxyLabels {
+			mergedLabels[k] = v
+		}
+		for k, v := range cc.Labels {
+			if _, ok := defaultHaproxyLabels[k]; !ok {
+				mergedLabels[k] = v
+			}
+		}
+	} else {
+		return defaultHaproxyLabels
+	}
+	return mergedLabels
+}
+
+func (cc *ClusterContext) GetClusterAnnotations() map[string]string {
+	return cc.Annotations
+}
+
+func (cc *ClusterContext) SetClusterLabels(labels map[string]string) {
+	cc.Labels = labels
+}
+
+func (cc *ClusterContext) SetClusterAnnotations(annotations map[string]string) {
+	delete(annotations, "kubectl.kubernetes.io/last-applied-configuration")
+	cc.Annotations = annotations
+}
+
+func (oc *OperatorContext) GetOperatorLabels(name string) map[string]string {
+	defaultLabels := getSelectorLabels(name)
+	mergedLabels := map[string]string{}
+	if len(oc.Labels) > 0 {
+		for k, v := range defaultLabels {
+			mergedLabels[k] = v
+		}
+		for k, v := range oc.Labels {
+			if _, ok := defaultLabels[k]; !ok {
+				mergedLabels[k] = v
+			}
+		}
+	} else {
+		return defaultLabels
+	}
+	return mergedLabels
+}
+
+func (oc *OperatorContext) GetOperatorAnnotations() map[string]string {
+	return oc.Annotations
+}
+
+func (oc *OperatorContext) SetOperatorLabels(labels map[string]string) {
+	oc.Labels = labels
+}
+
+func (oc *OperatorContext) SetOperatorAnnotations(annotations map[string]string) {
+	delete(annotations, "kubectl.kubernetes.io/last-applied-configuration")
+	oc.Annotations = annotations
+}

pkg/k8sutil/haProxy.go

@@ -24,8 +24,8 @@ func (cc *ClusterContext) ReconcileHAProxy() result.ReconcileResult {
 
 	logger.Info("Reconciling HAProxy Config")
 
-	labels := getHAProxyLabels(cr.GetObjectMeta().GetName())
-	annotations := getCommonAnnotations()
+	labels := cc.GetHAProxyLabels(cr.GetObjectMeta().GetName())
+	annotations := cc.GetClusterAnnotations()
 	configMapName := "marklogic-haproxy"
 	objectMeta := generateObjectMeta(configMapName, cr.Namespace, labels, annotations)
 	nsName := types.NamespacedName{Name: objectMeta.Name, Namespace: objectMeta.Namespace}
@@ -363,7 +363,7 @@ func (cc *ClusterContext) generateHaproxyServiceDef(meta metav1.ObjectMeta) *cor
 			Port: cr.Spec.HAProxy.Stats.Port,
 		})
 	}
-	selectorLabels := getHAProxyLabels(cr.GetObjectMeta().GetName())
+	selectorLabels := getHAProxySelectorLabels(cr.GetObjectMeta().GetName())
 	serviceDef := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        "marklogic-haproxy",

pkg/k8sutil/handler.go

@@ -28,8 +28,6 @@ func (oc *OperatorContext) ReconsileMarklogicGroupHandler() (reconcile.Result, e
 }
 
 func (cc *ClusterContext) ReconsileMarklogicClusterHandler() (reconcile.Result, error) {
-	SetCommonAnnotations(cc.MarklogicCluster.GetAnnotations())
-	SetCommonLabels(cc.MarklogicCluster.GetLabels())
 	if result := cc.ReconcileServiceAccount(); result.Completed() {
 		return result.Output()
 	}

pkg/k8sutil/ingress.go

@@ -72,8 +72,8 @@ func (cc *ClusterContext) getIngress(namespace string, ingressName string) (*net
 	return ingress, nil
 }
 
-func generateIngress(ingressName string, cr *marklogicv1.MarklogicCluster) *networkingv1.Ingress {
-	labels := getCommonLabels(cr.GetObjectMeta().GetName())
+func (cc *ClusterContext) generateIngress(ingressName string, cr *marklogicv1.MarklogicCluster) *networkingv1.Ingress {
+	labels := cc.GetClusterLabels(cr.GetObjectMeta().GetName())
 	annotations := cr.Spec.HAProxy.Ingress.Annotations
 	ingressObjectMeta := generateObjectMeta(ingressName, cr.Namespace, labels, annotations)
 	ingress := generateIngressDef(ingressObjectMeta, marklogicClusterAsOwner(cr), cr)
@@ -87,7 +87,7 @@ func (cc *ClusterContext) ReconcileIngress() result.ReconcileResult {
 	cr := cc.MarklogicCluster
 	ingressName := cr.ObjectMeta.Name
 	currentIngress, err := cc.getIngress(cr.Namespace, ingressName)
-	ingressDef := generateIngress(ingressName, cr)
+	ingressDef := cc.generateIngress(ingressName, cr)
 	if err != nil {
 		if errors.IsNotFound(err) {
 			logger.Info("MarkLogic Ingress not found, creating a new one")
@@ -133,7 +133,7 @@ func (cc *ClusterContext) createIngress(namespace string) error {
 	client := cc.Client
 	cr := cc.MarklogicCluster
 	ingressName := cr.ObjectMeta.Name + "-ingress"
-	ingress := generateIngress(ingressName, cr)
+	ingress := cc.generateIngress(ingressName, cr)
 	err := client.Create(cc.Ctx, ingress)
 	if err != nil {
 		logger.Error(err, "MarkLogic ingress creation has failed")

pkg/k8sutil/marklogicServer.go

@@ -86,11 +86,11 @@ func MarkLogicGroupLogger(namespace string, name string) logr.Logger {
 	return reqLogger
 }
 
-func GenerateMarkLogicGroupDef(cr *marklogicv1.MarklogicCluster, index int, params *MarkLogicGroupParameters) *marklogicv1.MarklogicGroup {
+func (cc *ClusterContext) GenerateMarkLogicGroupDef(cr *marklogicv1.MarklogicCluster, index int, params *MarkLogicGroupParameters) *marklogicv1.MarklogicGroup {
 	logger := MarkLogicGroupLogger(cr.Namespace, cr.ObjectMeta.Name)
 	logger.Info("ReconcileMarkLogicCluster")
-	labels := getCommonLabels(cr.ObjectMeta.Name)
-	annotations := getCommonAnnotations()
+	labels := cc.GetClusterLabels(cr.ObjectMeta.Name)
+	annotations := cc.GetClusterAnnotations()
 	if params.Labels != nil {
 		for key, value := range params.Labels {
 			labels[key] = value
@@ -172,7 +172,7 @@ func (cc *ClusterContext) ReconsileMarklogicCluster() (reconcile.Result, error)
 		namespacedName := types.NamespacedName{Name: name, Namespace: namespace}
 		clusterParams := generateMarkLogicClusterParams(cr)
 		params := generateMarkLogicGroupParams(cr, i, clusterParams)
-		markLogicGroupDef := GenerateMarkLogicGroupDef(operatorCR, i, params)
+		markLogicGroupDef := cc.GenerateMarkLogicGroupDef(operatorCR, i, params)
 		err := cc.Client.Get(cc.Ctx, namespacedName, currentMlg)
 		if err != nil {
 			if apierrors.IsNotFound(err) {

pkg/k8sutil/networkPolicy.go

@@ -44,9 +44,9 @@ func (cc *ClusterContext) getNetworkPolicy(namespace string, networkPolicyName s
 	return networkPolicy, nil
 }
 
-func generateNetworkPolicy(networkPolicyName string, cr *marklogicv1.MarklogicCluster) *networkingv1.NetworkPolicy {
-	labels := getCommonLabels(cr.GetObjectMeta().GetName())
-	annotations := getCommonAnnotations()
+func (cc *ClusterContext) generateNetworkPolicy(networkPolicyName string, cr *marklogicv1.MarklogicCluster) *networkingv1.NetworkPolicy {
+	labels := cc.GetClusterLabels(cr.GetObjectMeta().GetName())
+	annotations := cc.GetClusterAnnotations()
 	netObjectMeta := generateObjectMeta(networkPolicyName, cr.Namespace, labels, annotations)
 	networkPolicy := generateNetworkPolicyDef(netObjectMeta, marklogicClusterAsOwner(cr), cr)
 	return networkPolicy
@@ -59,7 +59,7 @@ func (cc *ClusterContext) ReconcileNetworkPolicy() result.ReconcileResult {
 	cr := cc.MarklogicCluster
 	networkPolicyName := cr.ObjectMeta.Name
 	currentNetworkPolicy, err := cc.getNetworkPolicy(cr.Namespace, networkPolicyName)
-	networkPolicyDef := generateNetworkPolicy(networkPolicyName, cr)
+	networkPolicyDef := cc.generateNetworkPolicy(networkPolicyName, cr)
 	if err != nil {
 		if errors.IsNotFound(err) {
 			logger.Info("MarkLogic NetworkPolicy not found, creating a new one")

pkg/k8sutil/secret.go

@@ -19,8 +19,8 @@ func (cc *ClusterContext) ReconcileSecret() result.ReconcileResult {
 	}
 
 	logger.Info("Reconciling MarkLogic Secret")
-	labels := getCommonLabels(mlc.ObjectMeta.Name)
-	annotations := getCommonAnnotations()
+	labels := cc.GetClusterLabels(mlc.ObjectMeta.Name)
+	annotations := cc.GetClusterAnnotations()
 	secretName := mlc.ObjectMeta.Name + "-admin"
 	objectMeta := generateObjectMeta(secretName, mlc.Namespace, labels, annotations)
 	nsName := types.NamespacedName{Name: objectMeta.Name, Namespace: objectMeta.Namespace}

pkg/k8sutil/service.go

@@ -95,13 +95,11 @@ func generateServiceDef(serviceMeta metav1.ObjectMeta, ownerRef metav1.OwnerRefe
 	return service
 }
 
-func generateService(svcName string, cr *marklogicv1.MarklogicGroup) *corev1.Service {
-	labels := getCommonLabels(cr.Spec.Name)
+func (oc *OperatorContext) generateService(svcName string, cr *marklogicv1.MarklogicGroup) *corev1.Service {
+	labels := oc.GetOperatorLabels(cr.Spec.Name)
 	groupLabels := cr.Spec.Labels
-	if groupLabels != nil {
-		for key, value := range groupLabels {
-			labels[key] = value
-		}
+	for key, value := range groupLabels {
+		labels[key] = value
 	}
 	var svcParams serviceParameters = serviceParameters{}
 	svcParams = generateServiceParams(cr)
@@ -122,7 +120,7 @@ func (oc *OperatorContext) ReconcileServices() result.ReconcileResult {
 	for _, service := range services {
 		svcNsName := types.NamespacedName{Name: service, Namespace: cr.Namespace}
 		err := client.Get(oc.Ctx, svcNsName, currentSvc)
-		svcDef := generateService(service, cr)
+		svcDef := oc.generateService(service, cr)
 		if err != nil {
 			if errors.IsNotFound(err) {
 				logger.Info("MarkLogic service not found, creating a new one")

test/e2e/2_marklogic_cluster_test.go

@@ -344,7 +344,7 @@ func TestMarklogicCluster(t *testing.T) {
 			if err := client.Resources().Get(ctx, "marklogicclusters", mlNamespace, &mlcluster); err != nil {
 				t.Fatal(err)
 			}
-			
+
 			mlcluster.Spec.MarkLogicGroups[0].Resources = &resources
 			if err := client.Resources().Update(ctx, &mlcluster); err != nil {
 				t.Log("Failed to update MarkLogic group resources")