use JSON merge patch to update labels/annotations (#4838)

Signed-off-by: zhangzujian <[email protected]>

charts/kube-ovn/templates/ovn-CR.yaml

@@ -107,6 +107,7 @@ rules:
       - get
       - list
       - update
+      - patch
       - create
       - delete
       - watch

cmd/daemon/cniserver.go

@@ -181,9 +181,9 @@ func initChassisAnno(cfg *daemon.Configuration) error {
 		klog.Error(err)
 		return err
 	}
-	annotations := map[string]any{util.ChassisAnnotation: chassesName}
-	if err = util.UpdateNodeAnnotations(cfg.KubeClient.CoreV1().Nodes(), cfg.NodeName, annotations); err != nil {
-		klog.Errorf("failed to update chassis annotation of node %s: %v", cfg.NodeName, err)
+	patch := util.KVPatch{util.ChassisAnnotation: chassesName}
+	if err = util.PatchAnnotations(cfg.KubeClient.CoreV1().Nodes(), cfg.NodeName, patch); err != nil {
+		klog.Errorf("failed to patch chassis annotation of node %s: %v", cfg.NodeName, err)
 		return err
 	}
 

dist/images/install.sh

@@ -2985,6 +2985,7 @@ rules:
       - get
       - list
       - update
+      - patch
       - create
       - delete
       - watch

pkg/controller/endpoint.go

@@ -257,12 +257,9 @@ func (c *Controller) handleUpdateEndpoint(key string) error {
 	}
 
 	if svcVpc = svc.Annotations[util.VpcAnnotation]; svcVpc != vpcName {
-		if svc.Annotations == nil {
-			svc.Annotations = make(map[string]string, 1)
-		}
-		svc.Annotations[util.VpcAnnotation] = vpcName
-		if _, err = c.config.KubeClient.CoreV1().Services(namespace).Update(context.Background(), svc, metav1.UpdateOptions{}); err != nil {
-			klog.Errorf("failed to update service %s/%s: %v", namespace, svc.Name, err)
+		patch := util.KVPatch{util.VpcAnnotation: vpcName}
+		if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Services(namespace), svc.Name, patch); err != nil {
+			klog.Errorf("failed to patch service %s: %v", key, err)
 			return err
 		}
 	}

pkg/controller/external_gw.go

@@ -80,8 +80,8 @@ func (c *Controller) removeExternalGateway() error {
 		return err
 	}
 	for _, node := range nodes {
-		labels := map[string]any{util.ExGatewayLabel: "false"}
-		if err = util.UpdateNodeLabels(c.config.KubeClient.CoreV1().Nodes(), node.Name, labels); err != nil {
+		patch := util.KVPatch{util.ExGatewayLabel: "false"}
+		if err = util.PatchLabels(c.config.KubeClient.CoreV1().Nodes(), node.Name, patch); err != nil {
 			klog.Errorf("failed to patch external gw node %s: %v", node.Name, err)
 			return err
 		}
@@ -230,9 +230,9 @@ func (c *Controller) getGatewayChassis(config map[string]string) ([]string, erro
 			klog.Errorf("failed to get gw node %s, %v", gw, err)
 			return nil, err
 		}
-		labels := map[string]any{util.ExGatewayLabel: "true"}
-		if err = util.UpdateNodeLabels(c.config.KubeClient.CoreV1().Nodes(), node.Name, labels); err != nil {
-			klog.Errorf("failed to update annotations of node %s: %v", node.Name, err)
+		patch := util.KVPatch{util.ExGatewayLabel: "true"}
+		if err = util.PatchLabels(c.config.KubeClient.CoreV1().Nodes(), node.Name, patch); err != nil {
+			klog.Errorf("failed to patch annotations of node %s: %v", node.Name, err)
 			return nil, err
 		}
 

pkg/controller/init.go

@@ -485,16 +485,15 @@ func (c *Controller) initDefaultProviderNetwork() error {
 
 	excludeAnno := fmt.Sprintf(util.ProviderNetworkExcludeTemplate, c.config.DefaultProviderName)
 	interfaceAnno := fmt.Sprintf(util.ProviderNetworkInterfaceTemplate, c.config.DefaultProviderName)
-	newNodes := make([]*v1.Node, 0, len(nodes))
+	patchNodes := make([]string, 0, len(nodes))
 	for _, node := range nodes {
 		if len(node.Annotations) == 0 {
 			continue
 		}
 
-		var newNode *v1.Node
 		if node.Annotations[excludeAnno] == "true" {
 			pn.Spec.ExcludeNodes = append(pn.Spec.ExcludeNodes, node.Name)
-			newNode = node.DeepCopy()
+			patchNodes = append(patchNodes, node.Name)
 		} else if s := node.Annotations[interfaceAnno]; s != "" {
 			var index *int
 			for i := range pn.Spec.CustomInterfaces {
@@ -509,12 +508,7 @@ func (c *Controller) initDefaultProviderNetwork() error {
 				ci := kubeovnv1.CustomInterface{Interface: s, Nodes: []string{node.Name}}
 				pn.Spec.CustomInterfaces = append(pn.Spec.CustomInterfaces, ci)
 			}
-			newNode = node.DeepCopy()
-		}
-		if newNode != nil {
-			delete(newNode.Annotations, excludeAnno)
-			delete(newNode.Annotations, interfaceAnno)
-			newNodes = append(newNodes, newNode)
+			patchNodes = append(patchNodes, node.Name)
 		}
 	}
 
@@ -524,9 +518,10 @@ func (c *Controller) initDefaultProviderNetwork() error {
 		}
 
 		// update nodes only when provider network has been created successfully
-		for _, node := range newNodes {
-			if _, err := c.config.KubeClient.CoreV1().Nodes().Update(context.Background(), node, metav1.UpdateOptions{}); err != nil {
-				klog.Errorf("failed to update node %s: %v", node.Name, err)
+		patch := util.KVPatch{excludeAnno: nil, interfaceAnno: nil}
+		for _, node := range patchNodes {
+			if err := util.PatchAnnotations(c.config.KubeClient.CoreV1().Nodes(), node, patch); err != nil {
+				klog.Errorf("failed to patch node %s: %v", node, err)
 			}
 		}
 	}()

pkg/controller/inspection.go

@@ -1,13 +1,10 @@
 package controller
 
 import (
-	"context"
 	"fmt"
 
 	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/klog/v2"
 
 	"github.com/kubeovn/kube-ovn/pkg/ovs"
@@ -48,15 +45,11 @@ func (c *Controller) inspectPod() error {
 				}
 
 				if !exists { // pod exists but not lsp
-					delete(pod.Annotations, fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName))
-					delete(pod.Annotations, fmt.Sprintf(util.RoutedAnnotationTemplate, podNet.ProviderName))
-					patch, err := util.GenerateStrategicMergePatchPayload(oriPod, pod)
-					if err != nil {
-						klog.Errorf("failed to generate patch payload, %v", err)
-						return err
+					patch := util.KVPatch{
+						fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName): nil,
+						fmt.Sprintf(util.RoutedAnnotationTemplate, podNet.ProviderName):    nil,
 					}
-					if _, err := c.config.KubeClient.CoreV1().Pods(pod.Namespace).Patch(context.Background(), pod.Name,
-						types.StrategicMergePatchType, patch, metav1.PatchOptions{}, ""); err != nil {
+					if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Pods(pod.Namespace), pod.Name, patch); err != nil {
 						klog.Errorf("patch pod %s/%s failed %v during inspection", pod.Name, pod.Namespace, err)
 						return err
 					}

pkg/controller/namespace.go

@@ -1,16 +1,13 @@
 package controller
 
 import (
-	"context"
 	"fmt"
 	"reflect"
 	"strings"
 
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/types"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/klog/v2"
@@ -183,31 +180,25 @@ func (c *Controller) handleAddNamespace(key string) error {
 		excludeIps = append(excludeIps, strings.Join(subnet.Spec.ExcludeIps, ","))
 	}
 
-	if len(namespace.Annotations) == 0 {
-		namespace.Annotations = map[string]string{}
-	} else if namespace.Annotations[util.LogicalSwitchAnnotation] == strings.Join(lss, ",") &&
+	if namespace.Annotations[util.LogicalSwitchAnnotation] == strings.Join(lss, ",") &&
 		namespace.Annotations[util.CidrAnnotation] == strings.Join(cidrs, ";") &&
 		namespace.Annotations[util.ExcludeIpsAnnotation] == strings.Join(excludeIps, ";") &&
 		namespace.Annotations[util.IPPoolAnnotation] == ippool {
 		return nil
 	}
 
-	namespace.Annotations[util.LogicalSwitchAnnotation] = strings.Join(lss, ",")
-	namespace.Annotations[util.CidrAnnotation] = strings.Join(cidrs, ";")
-	namespace.Annotations[util.ExcludeIpsAnnotation] = strings.Join(excludeIps, ";")
-
+	patch := util.KVPatch{
+		util.LogicalSwitchAnnotation: strings.Join(lss, ","),
+		util.CidrAnnotation:          strings.Join(cidrs, ";"),
+		util.ExcludeIpsAnnotation:    strings.Join(excludeIps, ";"),
+	}
 	if ippool == "" {
-		delete(namespace.Annotations, util.IPPoolAnnotation)
+		patch[util.IPPoolAnnotation] = nil
 	} else {
-		namespace.Annotations[util.IPPoolAnnotation] = ippool
+		patch[util.IPPoolAnnotation] = ippool
 	}
 
-	patch, err := util.GenerateStrategicMergePatchPayload(cachedNs, namespace)
-	if err != nil {
-		return err
-	}
-	if _, err = c.config.KubeClient.CoreV1().Namespaces().Patch(context.Background(), key,
-		types.StrategicMergePatchType, patch, metav1.PatchOptions{}, ""); err != nil {
+	if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Namespaces(), key, patch); err != nil {
 		klog.Errorf("patch namespace %s failed %v", key, err)
 	}
 	return err

pkg/controller/node.go

@@ -322,7 +322,7 @@ func (c *Controller) handleAddNode(key string) error {
 		return err
 	}
 
-	annotations := map[string]any{
+	patch := util.KVPatch{
 		util.IPAddressAnnotation:     ipStr,
 		util.MacAddressAnnotation:    mac,
 		util.CidrAnnotation:          subnet.Spec.CIDRBlock,
@@ -331,7 +331,7 @@ func (c *Controller) handleAddNode(key string) error {
 		util.AllocatedAnnotation:     "true",
 		util.PortNameAnnotation:      portName,
 	}
-	if err = util.UpdateNodeAnnotations(c.config.KubeClient.CoreV1().Nodes(), node.Name, annotations); err != nil {
+	if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Nodes(), node.Name, patch); err != nil {
 		klog.Errorf("failed to update annotations of node %s: %v", node.Name, err)
 		return err
 	}
@@ -432,14 +432,10 @@ func (c *Controller) handleNodeAnnotationsForProviderNetworks(node *v1.Node) err
 		}
 
 		if len(node.Annotations) != 0 {
-			newNode := node.DeepCopy()
-			delete(newNode.Annotations, excludeAnno)
-			delete(newNode.Annotations, interfaceAnno)
-			if len(newNode.Annotations) != len(node.Annotations) {
-				if _, err = c.config.KubeClient.CoreV1().Nodes().Update(context.Background(), newNode, metav1.UpdateOptions{}); err != nil {
-					klog.Errorf("failed to update node %s: %v", node.Name, err)
-					return err
-				}
+			patch := util.KVPatch{excludeAnno: nil, interfaceAnno: nil}
+			if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Nodes(), node.Name, patch); err != nil {
+				klog.Errorf("failed to patch node %s: %v", node.Name, err)
+				return err
 			}
 		}