persistent naming strategy

Author: ColdsteelRail

xset/api/xset_types.go

@@ -55,6 +55,10 @@ type XSetSpec struct {
 	// +optional
 	ScaleStrategy ScaleStrategy `json:"scaleStrategy,omitempty"`
 
+	// NamigPolicy indicates the strategy detail that will be used for replica naming
+	// +optional
+	NamingStrategy *NamingStrategy `json:"namingStrategy,omitempty"`
+
 	// Indicate the number of histories to be conserved
 	// If unspecified, defaults to 20
 	// +optional
@@ -120,6 +124,25 @@ type ScaleStrategy struct {
 	OperationDelaySeconds *int32 `json:"operationDelaySeconds,omitempty"`
 }
 
+// TargetNamingSuffixPolicy indicates how a new pod name suffix part is generated.
+type TargetNamingSuffixPolicy string
+
+const (
+	// TargetNamingSuffixPolicyPersistentSequence uses persistent sequential numbers as pod name suffix.
+	TargetNamingSuffixPolicyPersistentSequence TargetNamingSuffixPolicy = "PersistentSequence"
+	// TargetNamingSuffixPolicyRandom uses collaset name as pod generateName, which is the prefix
+	// of pod name. Kubernetes then adds a random string as suffix after the generateName.
+	// This is defaulting policy.
+	TargetNamingSuffixPolicyRandom TargetNamingSuffixPolicy = "Random"
+)
+
+type NamingStrategy struct {
+	// TargetNamingSuffixPolicy is a string enumeration that determaines how pod name suffix will be generated.
+	// A collaset pod name contains two parts to be placed in a string formation %s-%s; the prefix is collaset
+	// name, and the suffix is determined by TargetNamingSuffixPolicy.
+	TargetNamingSuffixPolicy TargetNamingSuffixPolicy `json:"TargetNamingSuffixPolicy,omitempty"`
+}
+
 // UpdateStrategyType is a string enumeration type that enumerates
 // all possible ways we can update a Target when updating application
 type UpdateStrategyType string

xset/revisionowner/revision_owner.go

@@ -66,7 +66,7 @@ func (r *revisionOwner) GetInUsedRevisions(parent metav1.Object) (sets.String, e
 	res.Insert(status.UpdatedRevision)
 	res.Insert(status.CurrentRevision)
 
-	targets, err := r.TargetControl.GetFilteredTargets(context.TODO(), spec.Selector, xSetObject)
+	targets, _, err := r.TargetControl.GetFilteredTargets(context.TODO(), spec.Selector, xSetObject)
 	if err != nil {
 		return nil, err
 	}

xset/synccontrols/sync_control.go

@@ -135,12 +135,19 @@ func (r *RealSyncControl) SyncTargets(ctx context.Context, instance api.XSetObje
 		return false, fmt.Errorf("fail to get XSetSpec")
 	}
 
-	var err error
-	syncContext.FilteredTarget, err = r.xControl.GetFilteredTargets(ctx, xspec.Selector, instance)
+	filteredTargets, allTargets, err := r.xControl.GetFilteredTargets(ctx, xspec.Selector, instance)
 	if err != nil {
 		return false, fmt.Errorf("fail to get filtered Targets: %w", err)
 	}
 
+	if IsTargetNamingSuffixPolicyPersistentSequence(xspec) {
+		// for naming with persistent sequences suffix, targets with same name should not exist at same time
+		syncContext.FilteredTarget = allTargets
+	} else {
+		// for naming with random suffix, targets with random names can be created at same time
+		syncContext.FilteredTarget = filteredTargets
+	}
+
 	// sync subresource
 	// 1. list pvcs using ownerReference
 	// 2. adopt and retain orphaned pvcs according to PVC retention policy
@@ -199,7 +206,8 @@ func (r *RealSyncControl) SyncTargets(ctx context.Context, instance api.XSetObje
 			}
 		}
 
-		if target.GetDeletionTimestamp() != nil {
+		// for naming with persistent sequences suffix, targets with same name should not exist at same time
+		if target.GetDeletionTimestamp() != nil && !IsTargetNamingSuffixPolicyPersistentSequence(xspec) {
 			// 1. Reclaim ID from Target which is scaling in and terminating.
 			if contextDetail, exist := ownedIDs[id]; exist && r.resourceContextControl.Contains(contextDetail, api.EnumScaleInContextDataKey, "true") {
 				idToReclaim.Insert(id)
@@ -897,7 +905,9 @@ func (r *RealSyncControl) CalculateStatus(_ context.Context, instance api.XSetOb
 
 	activeTargets := FilterOutActiveTargetWrappers(syncContext.TargetWrappers)
 	for _, targetWrapper := range activeTargets {
-		if targetWrapper.GetDeletionTimestamp() != nil {
+
+		// for naming with persistent sequences suffix, terminating targets can be shown in status
+		if targetWrapper.GetDeletionTimestamp() != nil && !IsTargetNamingSuffixPolicyPersistentSequence(r.xsetController.GetXSetSpec(instance)) {
 			continue
 		}
 

xset/synccontrols/x_replace.go

@@ -132,32 +132,13 @@ func (r *RealSyncControl) replaceOriginTargets(
 
 		replaceRevision := r.getReplaceRevision(originTarget, syncContext)
 
-		// create target using update revision if replaced by update, otherwise using current revision
-		newTarget, err := NewTargetFrom(r.xsetController, r.xsetLabelAnnoMgr, instance, replaceRevision, originTargetId,
-			r.xsetController.GetXSetTemplatePatcher(instance),
-			func(object client.Object) error {
-				if decorationAdapter, ok := r.xsetController.(api.DecorationAdapter); ok {
-					// get current decoration patcher from origin target, and patch new target
-					if fn, err := decorationAdapter.GetDecorationPatcherByRevisions(ctx, r.Client, originTarget, originWrapper.DecorationUpdatedRevisions); err != nil {
-						return err
-					} else {
-						return fn(object)
-					}
-				}
-				return nil
-			},
-		)
-		if err != nil {
-			return err
-		}
 		// add instance id and replace pair label
 		var newInstanceId string
 		var newTargetContext *api.ContextDetail
 		if contextDetail, exist := mapNewToOriginTargetContext[originTargetId]; exist && contextDetail != nil {
 			newTargetContext = contextDetail
 			// reuse targetContext ID if pair-relation exists
 			newInstanceId = fmt.Sprintf("%d", newTargetContext.ID)
-			r.xsetLabelAnnoMgr.Set(newTarget, api.XInstanceIdLabelKey, newInstanceId)
 			logger.Info("replaceOriginTargets", "try to reuse new pod resourceContext id", newInstanceId)
 		} else {
 			if availableContexts[i] == nil {
@@ -167,11 +148,30 @@ func (r *RealSyncControl) replaceOriginTargets(
 			newTargetContext = availableContexts[i]
 			// add replace pair-relation to targetContexts for originTarget and newTarget
 			newInstanceId = fmt.Sprintf("%d", newTargetContext.ID)
-			r.xsetLabelAnnoMgr.Set(newTarget, api.XInstanceIdLabelKey, newInstanceId)
 			r.resourceContextControl.Put(ownedIDs[originTargetId], api.EnumReplaceNewTargetIDContextDataKey, newInstanceId)
 			r.resourceContextControl.Put(ownedIDs[newTargetContext.ID], api.EnumReplaceOriginTargetIDContextDataKey, strconv.Itoa(originTargetId))
 			r.resourceContextControl.Remove(ownedIDs[newTargetContext.ID], api.EnumJustCreateContextDataKey)
 		}
+
+		// create target using update revision if replaced by update, otherwise using current revision
+		newTarget, err := NewTargetFrom(r.xsetController, r.xsetLabelAnnoMgr, instance, replaceRevision, originTargetId,
+			r.xsetController.GetXSetTemplatePatcher(instance),
+			func(object client.Object) error {
+				if decorationAdapter, ok := r.xsetController.(api.DecorationAdapter); ok {
+					// get current decoration patcher from origin target, and patch new target
+					if fn, err := decorationAdapter.GetDecorationPatcherByRevisions(ctx, r.Client, originTarget, originWrapper.DecorationUpdatedRevisions); err != nil {
+						return err
+					} else {
+						return fn(object)
+					}
+				}
+				return nil
+			},
+		)
+		if err != nil {
+			return err
+		}
+
 		r.xsetLabelAnnoMgr.Set(newTarget, api.XReplacePairOriginName, originTarget.GetName())
 		r.xsetLabelAnnoMgr.Set(newTarget, api.XCreatingLabel, strconv.FormatInt(time.Now().UnixNano(), 10))
 		r.resourceContextControl.Put(newTargetContext, api.EnumRevisionContextDataKey, replaceRevision.GetName())

xset/synccontrols/x_utils.go

@@ -65,6 +65,10 @@ func NewTargetFrom(setController api.XSetController, xsetLabelAnnoMgr api.XSetLa
 	targetObj.SetNamespace(owner.GetNamespace())
 	targetObj.SetGenerateName(GetTargetsPrefix(owner.GetName()))
 
+	if IsTargetNamingSuffixPolicyPersistentSequence(setController.GetXSetSpec(owner)) {
+		targetObj.SetName(fmt.Sprintf("%s%d", targetObj.GetGenerateName(), id))
+	}
+
 	xsetLabelAnnoMgr.Set(targetObj, api.XInstanceIdLabelKey, fmt.Sprintf("%d", id))
 	targetObj.GetLabels()[appsv1.ControllerRevisionHashLabelKey] = revision.GetName()
 	controlByXSet(xsetLabelAnnoMgr, targetObj)
@@ -172,3 +176,10 @@ func afterOrZero(t1, t2 *metav1.Time) bool {
 	}
 	return t1.After(t2.Time)
 }
+
+func IsTargetNamingSuffixPolicyPersistentSequence(xsetSpec *api.XSetSpec) bool {
+	if xsetSpec == nil || xsetSpec.NamingStrategy == nil {
+		return false
+	}
+	return xsetSpec.NamingStrategy.TargetNamingSuffixPolicy == api.TargetNamingSuffixPolicyPersistentSequence
+}

xset/xcontrol/target_control.go

@@ -39,7 +39,7 @@ const (
 )
 
 type TargetControl interface {
-	GetFilteredTargets(ctx context.Context, selector *metav1.LabelSelector, owner api.XSetObject) ([]client.Object, error)
+	GetFilteredTargets(ctx context.Context, selector *metav1.LabelSelector, owner api.XSetObject) ([]client.Object, []client.Object, error)
 	CreateTarget(ctx context.Context, target client.Object) (client.Object, error)
 	DeleteTarget(ctx context.Context, target client.Object) error
 	UpdateTarget(ctx context.Context, target client.Object) error
@@ -71,19 +71,19 @@ func NewTargetControl(mixin *mixin.ReconcilerMixin, xsetController api.XSetContr
 	}, nil
 }
 
-func (r *targetControl) GetFilteredTargets(ctx context.Context, selector *metav1.LabelSelector, owner api.XSetObject) ([]client.Object, error) {
+func (r *targetControl) GetFilteredTargets(ctx context.Context, selector *metav1.LabelSelector, owner api.XSetObject) ([]client.Object, []client.Object, error) {
 	targetList := r.xsetController.NewXObjectList()
 	if err := r.client.List(ctx, targetList, &client.ListOptions{
 		Namespace:     owner.GetNamespace(),
 		FieldSelector: fields.OneTermEqualSelector(FieldIndexOwnerRefUID, string(owner.GetUID())),
 	}); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	targetListVal := reflect.Indirect(reflect.ValueOf(targetList))
 	itemsVal := targetListVal.FieldByName("Items")
 	if !itemsVal.IsValid() {
-		return nil, fmt.Errorf("target list items is invalid")
+		return nil, nil, fmt.Errorf("target list items is invalid")
 	}
 
 	var items []client.Object
@@ -94,12 +94,18 @@ func (r *targetControl) GetFilteredTargets(ctx context.Context, selector *metav1
 			items[i] = itemVal.(client.Object)
 		}
 	} else {
-		return nil, fmt.Errorf("target list items is invalid")
+		return nil, nil, fmt.Errorf("target list items is invalid")
+	}
+
+	allTargets, err := r.getTargets(items, selector, owner)
+	if err != nil {
+		return nil, nil, err
 	}
 
 	items = filterOutInactiveTargets(r.xsetController, items)
-	targets, err := r.getTargets(items, selector, owner)
-	return targets, err
+	filteredTargets, err := r.getTargets(items, selector, owner)
+
+	return filteredTargets, allTargets, err
 }
 
 func (r *targetControl) CreateTarget(ctx context.Context, target client.Object) (client.Object, error) {

xset/xset_controller.go

@@ -296,7 +296,7 @@ func (r *xSetCommonReconciler) ensureReclaimPvcs(ctx context.Context, xset api.X
 
 func (r *xSetCommonReconciler) ensureReclaimTargetsDeletion(ctx context.Context, instance api.XSetObject) (bool, error) {
 	xSetSpec := r.XSetController.GetXSetSpec(instance)
-	targets, err := r.targetControl.GetFilteredTargets(ctx, xSetSpec.Selector, instance)
+	_, targets, err := r.targetControl.GetFilteredTargets(ctx, xSetSpec.Selector, instance)
 	if err != nil {
 		return false, fmt.Errorf("fail to get filtered Targets: %s", err.Error())
 	}
@@ -322,7 +322,7 @@ func (r *xSetCommonReconciler) ensureReclaimOwnerReferences(ctx context.Context,
 		return nil
 	}
 	xSetSpec := r.XSetController.GetXSetSpec(instance)
-	filteredTargets, err := r.targetControl.GetFilteredTargets(ctx, xSetSpec.Selector, instance)
+	_, filteredTargets, err := r.targetControl.GetFilteredTargets(ctx, xSetSpec.Selector, instance)
 	if err != nil {
 		return fmt.Errorf("fail to get filtered Targets: %s", err.Error())
 	}