update

Author: leon-inf

pkg/controller/instanceset2/in_place_update_util.go

@@ -115,7 +115,7 @@ func copyRequestsNLimitsFields(container *corev1.Container) (corev1.ResourceList
 	return requests, limits
 }
 
-func mergeInPlaceFields(src, dst *corev1.Pod) {
+func mergeInPlaceFields(src, dst *corev1.PodTemplateSpec) {
 	mergeMap(&src.Annotations, &dst.Annotations)
 	mergeMap(&src.Labels, &dst.Labels)
 	dst.Spec.ActiveDeadlineSeconds = src.Spec.ActiveDeadlineSeconds

pkg/controller/instanceset2/instance_util.go

@@ -29,7 +29,7 @@ import (
 
 	"github.com/klauspost/compress/zstd"
 	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	rbacv1 "k8s.io/api/rbac/v1"
 	"k8s.io/apimachinery/pkg/util/runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
@@ -228,101 +228,133 @@ func buildInstanceByTemplate(tree *kubebuilderx.ObjectTree, name string, templat
 	return inst, nil
 }
 
-// copyAndMerge merges two objects for updating:
-// 1. new an object targetObj by copying from oldObj
-// 2. merge all fields can be updated from newObj into targetObj
-func copyAndMerge(oldObj, newObj client.Object) client.Object {
-	if reflect.TypeOf(oldObj) != reflect.TypeOf(newObj) {
-		return nil
-	}
+func copyAndMergeInstance(oldInst, newInst *workloads.Instance) *workloads.Instance {
+	targetInst := oldInst.DeepCopyObject().(*workloads.Instance)
 
-	copyAndMergeSvc := func(oldSvc *corev1.Service, newSvc *corev1.Service) client.Object {
-		intctrlutil.MergeList(&newSvc.Finalizers, &oldSvc.Finalizers, func(finalizer string) func(string) bool {
-			return func(item string) bool {
-				return finalizer == item
-			}
-		})
-		intctrlutil.MergeList(&newSvc.OwnerReferences, &oldSvc.OwnerReferences, func(reference metav1.OwnerReference) func(metav1.OwnerReference) bool {
-			return func(item metav1.OwnerReference) bool {
-				return reference.UID == item.UID
-			}
-		})
-		mergeMap(&newSvc.Annotations, &oldSvc.Annotations)
-		mergeMap(&newSvc.Labels, &oldSvc.Labels)
-		oldSvc.Spec.Selector = newSvc.Spec.Selector
-		oldSvc.Spec.Type = newSvc.Spec.Type
-		oldSvc.Spec.PublishNotReadyAddresses = newSvc.Spec.PublishNotReadyAddresses
-		// ignore NodePort&LB svc here, instanceSet only supports default headless svc
-		oldSvc.Spec.Ports = newSvc.Spec.Ports
-		return oldSvc
-	}
+	// merge pod
+	mergeInPlaceFields(&newInst.Spec.Template, &targetInst.Spec.Template)
+	targetInst.Spec.Selector = newInst.Spec.Selector
+	targetInst.Spec.MinReadySeconds = newInst.Spec.MinReadySeconds
 
-	copyAndMergeCm := func(oldCm, newCm *corev1.ConfigMap) client.Object {
-		intctrlutil.MergeList(&newCm.Finalizers, &oldCm.Finalizers, func(finalizer string) func(string) bool {
-			return func(item string) bool {
-				return finalizer == item
-			}
-		})
-		intctrlutil.MergeList(&newCm.OwnerReferences, &oldCm.OwnerReferences, func(reference metav1.OwnerReference) func(metav1.OwnerReference) bool {
-			return func(item metav1.OwnerReference) bool {
-				return reference.UID == item.UID
-			}
-		})
-		oldCm.Data = newCm.Data
-		oldCm.BinaryData = newCm.BinaryData
-		return oldCm
-	}
-
-	copyAndMergePod := func(oldPod, newPod *corev1.Pod) client.Object {
-		mergeInPlaceFields(newPod, oldPod)
-		return oldPod
-	}
-
-	copyAndMergePVC := func(oldPVC, newPVC *corev1.PersistentVolumeClaim) client.Object {
-		mergeMap(&newPVC.Annotations, &oldPVC.Annotations)
+	// merge pvcs
+	for i := range newInst.Spec.VolumeClaimTemplates {
+		newPVC := &newInst.Spec.VolumeClaimTemplates[i]
+		oldPVC := &targetInst.Spec.VolumeClaimTemplates[i]
 		mergeMap(&newPVC.Labels, &oldPVC.Labels)
+		mergeMap(&newPVC.Annotations, &oldPVC.Annotations)
 		// resources.request.storage and accessModes support in-place update.
 		// resources.request.storage only supports volume expansion.
 		if reflect.DeepEqual(oldPVC.Spec.AccessModes, newPVC.Spec.AccessModes) &&
 			oldPVC.Spec.Resources.Requests.Storage().Cmp(*newPVC.Spec.Resources.Requests.Storage()) >= 0 {
-			return oldPVC
+			continue
 		}
 		oldPVC.Spec.AccessModes = newPVC.Spec.AccessModes
 		if newPVC.Spec.Resources.Requests == nil {
-			return oldPVC
+			continue
 		}
 		if _, ok := newPVC.Spec.Resources.Requests[corev1.ResourceStorage]; !ok {
-			return oldPVC
+			continue
 		}
 		requests := oldPVC.Spec.Resources.Requests
 		if requests == nil {
 			requests = make(corev1.ResourceList)
 		}
 		requests[corev1.ResourceStorage] = *newPVC.Spec.Resources.Requests.Storage()
 		oldPVC.Spec.Resources.Requests = requests
-		return oldPVC
 	}
+	targetInst.Spec.PersistentVolumeClaimRetentionPolicy = newInst.Spec.PersistentVolumeClaimRetentionPolicy
 
-	copyAndMergeInstance := func(oldInst, newInst *workloads.Instance) client.Object {
-		// TODO: impl
-		return newInst
+	copyAndMergeSvc := func(oldSvc, newSvc *corev1.Service) client.Object {
+		mergeMap(&newSvc.Labels, &oldSvc.Labels)
+		mergeMap(&newSvc.Annotations, &oldSvc.Annotations)
+		oldSvc.Spec.Selector = newSvc.Spec.Selector
+		oldSvc.Spec.Type = newSvc.Spec.Type
+		oldSvc.Spec.PublishNotReadyAddresses = newSvc.Spec.PublishNotReadyAddresses
+		// ignore NodePort&LB svc here, instanceSet only supports default headless svc
+		oldSvc.Spec.Ports = newSvc.Spec.Ports
+		return oldSvc
+	}
+
+	copyAndMergeCM := func(old, new *corev1.ConfigMap) client.Object {
+		mergeMap(&new.Labels, &old.Labels)
+		mergeMap(&new.Annotations, &old.Annotations)
+		old.Data = new.Data
+		old.BinaryData = new.BinaryData
+		return old
+	}
+
+	copyAndMergeSecret := func(old, new *corev1.Secret) client.Object {
+		mergeMap(&new.Labels, &old.Labels)
+		mergeMap(&new.Annotations, &old.Annotations)
+		old.Data = new.Data
+		old.StringData = new.StringData
+		return old
+	}
+
+	copyAndMergeSA := func(old, new *corev1.ServiceAccount) client.Object {
+		mergeMap(&new.Labels, &old.Labels)
+		mergeMap(&new.Annotations, &old.Annotations)
+		old.Secrets = new.Secrets
+		return old
+	}
+
+	copyAndMergeRole := func(old, new *rbacv1.Role) client.Object {
+		mergeMap(&new.Labels, &old.Labels)
+		mergeMap(&new.Annotations, &old.Annotations)
+		old.Rules = new.Rules
+		return old
+	}
+
+	copyAndMergeRoleBinding := func(old, new *rbacv1.RoleBinding) client.Object {
+		mergeMap(&new.Labels, &old.Labels)
+		mergeMap(&new.Annotations, &old.Annotations)
+		old.Subjects = new.Subjects
+		old.RoleRef = new.RoleRef
+		return old
+	}
+
+	copyNMergeAssistantObjects := func() {
+		for i := range newInst.Spec.AssistantObjects {
+			oldObj := &targetInst.Spec.AssistantObjects[i]
+			newObj := &newInst.Spec.AssistantObjects[i]
+			if newObj.ConfigMap != nil {
+				copyAndMergeCM(oldObj.ConfigMap, newObj.ConfigMap)
+			}
+			if newObj.Secret != nil {
+				copyAndMergeSecret(oldObj.Secret, newObj.Secret)
+			}
+			if newObj.Service != nil {
+				copyAndMergeSvc(oldObj.Service, newObj.Service)
+			}
+			if newObj.ServiceAccount != nil {
+				copyAndMergeSA(oldObj.ServiceAccount, newObj.ServiceAccount)
+			}
+			if newObj.Role != nil {
+				copyAndMergeRole(oldObj.Role, newObj.Role)
+			}
+			if newObj.RoleBinding != nil {
+				copyAndMergeRoleBinding(oldObj.RoleBinding, newObj.RoleBinding)
+			}
+		}
 	}
 
-	targetObj := oldObj.DeepCopyObject()
-	switch o := newObj.(type) {
-	case *workloads.Instance:
-		return copyAndMergeInstance(targetObj.(*workloads.Instance), o)
-	case *corev1.Service:
-		return copyAndMergeSvc(targetObj.(*corev1.Service), o)
-	case *corev1.ConfigMap:
-		return copyAndMergeCm(targetObj.(*corev1.ConfigMap), o)
-	case *corev1.Pod:
-		return copyAndMergePod(targetObj.(*corev1.Pod), o)
-	case *corev1.PersistentVolumeClaim:
-		return copyAndMergePVC(targetObj.(*corev1.PersistentVolumeClaim), o)
-	default:
-		return newObj
+	// merge assistant objects
+	if len(targetInst.Spec.AssistantObjects) == 0 {
+		targetInst.Spec.AssistantObjects = newInst.Spec.AssistantObjects
+	} else {
+		copyNMergeAssistantObjects()
 	}
+
+	// other fields
+	targetInst.Spec.InstanceTemplateName = newInst.Spec.InstanceTemplateName
+	targetInst.Spec.InstanceUpdateStrategyType = newInst.Spec.InstanceUpdateStrategyType
+	targetInst.Spec.PodUpdatePolicy = newInst.Spec.PodUpdatePolicy
+	targetInst.Spec.DisableDefaultHeadlessService = newInst.Spec.DisableDefaultHeadlessService
+	targetInst.Spec.Roles = newInst.Spec.Roles
+	// targetInst.Spec.MembershipReconfiguration = newInst.Spec.MembershipReconfiguration
+	targetInst.Spec.TemplateVars = newInst.Spec.TemplateVars
+
+	return targetInst
 }
 
 func buildInstanceTemplateRevision(template *corev1.PodTemplateSpec, parent *workloads.InstanceSet) (string, error) {

pkg/controller/instanceset2/reconciler_update.go

@@ -177,7 +177,7 @@ func (r *updateReconciler) Reconcile(tree *kubebuilderx.ObjectTree) (kubebuilder
 			if err != nil {
 				return kubebuilderx.Continue, err
 			}
-			mergedInst := copyAndMerge(inst, newInst)
+			mergedInst := copyAndMergeInstance(inst, newInst)
 			if mergedInst != nil {
 				err = tree.Update(mergedInst)
 				if err != nil {