chore: support the available condition with role (#9500)

Author: leon-ape

apis/apps/v1/componentdefinition_types.go

@@ -1243,6 +1243,13 @@ type ComponentAvailable struct {
 	// +optional
 	WithPhases *string `json:"withPhases,omitempty"`
 
+	// Specifies the role that the component will go through to be considered available.
+	//
+	// This field is immutable once set.
+	//
+	// +optional
+	WithRole *string `json:"withRole,omitempty"`
+
 	// Specifies the strategies for determining whether the component is available based on the available probe.
 	//
 	// This field is immutable once set.

apis/apps/v1/zz_generated.deepcopy.go

@@ -4214,6 +4214,13 @@ spec:
                         format: int32
                         type: integer
                     type: object
+                  withRole:
+                    description: |-
+                      Specifies the role that the component will go through to be considered available.
+
+
+                      This field is immutable once set.
+                    type: string
                 type: object
               configs:
                 description: |-

config/crd/bases/apps.kubeblocks.io_componentdefinitions.yaml

@@ -344,23 +344,36 @@ func (t *componentStatusTransformer) reconcileStatusCondition(transCtx *componen
 
 func (t *componentStatusTransformer) reconcileAvailableCondition(transCtx *componentTransformContext) error {
 	policy := component.GetComponentAvailablePolicy(transCtx.CompDef)
-	if policy.WithPhases == nil {
+	if policy.WithPhases == nil && policy.WithRole == nil {
 		return nil
 	}
 
 	var (
-		comp = transCtx.Component
+		comp                        = transCtx.Component
+		status, status1, status2    metav1.ConditionStatus
+		reason, reason1, reason2    string
+		message, message1, message2 string
 	)
-	status, reason, message := func() (metav1.ConditionStatus, string, string) {
-		if comp.Status.Phase == "" {
-			return metav1.ConditionUnknown, "Unknown", "the component phase is unknown"
-		}
-		phases := sets.New[string](strings.Split(strings.ToLower(*policy.WithPhases), ",")...)
-		if phases.Has(strings.ToLower(string(comp.Status.Phase))) {
-			return metav1.ConditionTrue, "Available", fmt.Sprintf("the component phase is %s", comp.Status.Phase)
+	if policy.WithPhases != nil {
+		status1, reason1, message1 = t.availableWithPhases(transCtx, comp, policy)
+	}
+	if policy.WithRole != nil {
+		status2, reason2, message2 = t.availableWithRole(transCtx, comp, policy)
+	}
+
+	// merge conditions
+	switch {
+	case policy.WithPhases != nil && policy.WithRole == nil:
+		status, reason, message = status1, reason1, message1
+	case policy.WithPhases == nil && policy.WithRole != nil:
+		status, reason, message = status2, reason2, message2
+	default: // both are not nil
+		if status1 != metav1.ConditionTrue {
+			status, reason, message = status1, reason1, message1
+		} else {
+			status, reason, message = status2, reason2, message2
 		}
-		return metav1.ConditionFalse, "Unavailable", fmt.Sprintf("the component phase is %s", comp.Status.Phase)
-	}()
+	}
 
 	cond := metav1.Condition{
 		Type:               appsv1.ConditionTypeAvailable,
@@ -373,10 +386,40 @@ func (t *componentStatusTransformer) reconcileAvailableCondition(transCtx *compo
 	if meta.SetStatusCondition(&comp.Status.Conditions, cond) {
 		transCtx.EventRecorder.Event(comp, corev1.EventTypeNormal, reason, message)
 	}
-
 	return nil
 }
 
+func (t *componentStatusTransformer) availableWithPhases(_ *componentTransformContext,
+	comp *appsv1.Component, policy appsv1.ComponentAvailable) (metav1.ConditionStatus, string, string) {
+	if comp.Status.Phase == "" {
+		return metav1.ConditionUnknown, "Unknown", "the component phase is unknown"
+	}
+	phases := sets.New[string](strings.Split(strings.ToLower(*policy.WithPhases), ",")...)
+	if phases.Has(strings.ToLower(string(comp.Status.Phase))) {
+		return metav1.ConditionTrue, "Available", fmt.Sprintf("the component phase is %s", comp.Status.Phase)
+	}
+	return metav1.ConditionFalse, "Unavailable", fmt.Sprintf("the component phase is %s", comp.Status.Phase)
+}
+
+func (t *componentStatusTransformer) availableWithRole(transCtx *componentTransformContext,
+	_ *appsv1.Component, policy appsv1.ComponentAvailable) (metav1.ConditionStatus, string, string) {
+	var its *workloads.InstanceSet
+	if transCtx.RunningWorkload != nil {
+		its = transCtx.RunningWorkload.(*workloads.InstanceSet)
+	}
+	if its == nil {
+		return metav1.ConditionFalse, "Unavailable", "the workload is not present"
+	}
+	for _, member := range its.Status.MembersStatus {
+		if member.ReplicaRole != nil {
+			if strings.EqualFold(member.ReplicaRole.Name, *policy.WithRole) {
+				return metav1.ConditionTrue, "Available", fmt.Sprintf("the role %s is present", *policy.WithRole)
+			}
+		}
+	}
+	return metav1.ConditionFalse, "Unavailable", fmt.Sprintf("the role %s is not present", *policy.WithRole)
+}
+
 func getRunningVolumes(ctx context.Context, cli client.Client, synthesizedComp *component.SynthesizedComponent,
 	itsObj *workloads.InstanceSet, vctName string) ([]*corev1.PersistentVolumeClaim, error) {
 	pvcs, err := component.ListOwnedPVCs(ctx, cli, synthesizedComp.Namespace, synthesizedComp.ClusterName, synthesizedComp.Name)

controllers/apps/component/transformer_component_status.go

@@ -393,10 +393,20 @@ func (r *ComponentDefinitionReconciler) validateAvailable(cli client.Client, rct
 	if cmpd.Spec.Available == nil {
 		return nil
 	}
-	if cmpd.Spec.Available.WithPhases != nil && cmpd.Spec.Available.WithProbe == nil {
-		return r.validateAvailableWithPhases(cmpd)
+	if cmpd.Spec.Available.WithProbe != nil {
+		return r.validateAvailableWithProbe(cmpd)
 	}
-	return r.validateAvailableWithProbe(cmpd)
+	if cmpd.Spec.Available.WithPhases != nil {
+		if err := r.validateAvailableWithPhases(cmpd); err != nil {
+			return err
+		}
+	}
+	if cmpd.Spec.Available.WithRole != nil {
+		if err := r.validateAvailableWithRole(cmpd); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func (r *ComponentDefinitionReconciler) validateAvailableWithPhases(cmpd *appsv1.ComponentDefinition) error {
@@ -418,6 +428,16 @@ func (r *ComponentDefinitionReconciler) validateAvailableWithPhases(cmpd *appsv1
 	return nil
 }
 
+func (r *ComponentDefinitionReconciler) validateAvailableWithRole(cmpd *appsv1.ComponentDefinition) error {
+	role := strings.ToLower(*cmpd.Spec.Available.WithRole)
+	for _, r := range cmpd.Spec.Roles {
+		if strings.ToLower(r.Name) == role {
+			return nil
+		}
+	}
+	return fmt.Errorf("the role that available with role used is not defined: %s", role)
+}
+
 func (r *ComponentDefinitionReconciler) validateAvailableWithProbe(cmpd *appsv1.ComponentDefinition) error {
 	withProbe := cmpd.Spec.Available.WithProbe
 	if withProbe == nil {

controllers/apps/componentdefinition_controller.go

@@ -427,6 +427,33 @@ var _ = Describe("ComponentDefinition Controller", func() {
 			checkObjectStatus(componentDefObj, kbappsv1.UnavailablePhase)
 		})
 
+		It("with role - ok", func() {
+			By("create a ComponentDefinition obj")
+			componentDefObj := testapps.NewComponentDefinitionFactory(componentDefName).
+				SetRuntime(nil).
+				AddRole("leader").
+				SetAvailable(&kbappsv1.ComponentAvailable{
+					WithRole: pointer.String("leader"),
+				}).
+				Create(&testCtx).
+				GetObject()
+
+			checkObjectStatus(componentDefObj, kbappsv1.AvailablePhase)
+		})
+
+		It("with role - fail", func() {
+			By("create a ComponentDefinition obj")
+			componentDefObj := testapps.NewComponentDefinitionFactory(componentDefName).
+				SetRuntime(nil).
+				SetAvailable(&kbappsv1.ComponentAvailable{
+					WithRole: pointer.String("leader"), // leader role is not defined
+				}).
+				Create(&testCtx).
+				GetObject()
+
+			checkObjectStatus(componentDefObj, kbappsv1.UnavailablePhase)
+		})
+
 		It("with probe - ok", func() {
 			By("create a ComponentDefinition obj")
 			componentDefObj := testapps.NewComponentDefinitionFactory(componentDefName).

controllers/apps/componentdefinition_controller_test.go

@@ -4214,6 +4214,13 @@ spec:
                         format: int32
                         type: integer
                     type: object
+                  withRole:
+                    description: |-
+                      Specifies the role that the component will go through to be considered available.
+
+
+                      This field is immutable once set.
+                    type: string
                 type: object
               configs:
                 description: |-

deploy/helm/crds/apps.kubeblocks.io_componentdefinitions.yaml

@@ -4471,6 +4471,19 @@ string
 </tr>
 <tr>
 <td>
+<code>withRole</code><br/>
+<em>
+string
+</em>
+</td>
+<td>
+<em>(Optional)</em>
+<p>Specifies the role that the component will go through to be considered available.</p>
+<p>This field is immutable once set.</p>
+</td>
+</tr>
+<tr>
+<td>
 <code>withProbe</code><br/>
 <em>
 <a href="#apps.kubeblocks.io/v1.ComponentAvailableWithProbe">

docs/developer_docs/api-reference/cluster.md

@@ -137,7 +137,7 @@ func (h *AvailableEventHandler) status(ctx context.Context, cli client.Client, r
 func (h *AvailableEventHandler) handleEvent(event probeEvent, comp *appsv1.Component, compDef *appsv1.ComponentDefinition, its *workloads.InstanceSet) (*bool, string, error) {
 	policy := GetComponentAvailablePolicy(compDef)
 	if policy.WithProbe == nil || policy.WithProbe.Condition == nil {
-		if policy.WithPhases != nil {
+		if policy.WithPhases != nil || policy.WithRole != nil {
 			return nil, "", nil
 		}
 		return nil, "", fmt.Errorf("the referenced ComponentDefinition does not have available probe defined, but we got a probe event? %s", compDef.Name)