Merge pull request #6477 from zhzhuang-zju/frq

Use rbSpec.clusters and rbSpec.ReplicaRequirements to calculate rb' resource usage

Author: karmada-bot

pkg/controllers/federatedresourcequota/federated_resource_quota_enforcement_controller.go

@@ -266,34 +266,52 @@ func (c *QuotaEnforcementController) collectQuotaStatus(quota *policyv1alpha1.Fe
 func calculateUsedWithResourceBinding(resourceBindings []workv1alpha2.ResourceBinding, overall corev1.ResourceList) corev1.ResourceList {
 	overallUsed := corev1.ResourceList{}
 	for _, binding := range resourceBindings {
-		if binding.Spec.ReplicaRequirements == nil || binding.Spec.Clusters == nil {
-			continue
-		}
-		used := binding.Spec.ReplicaRequirements.ResourceRequest
-		replicas := binding.Spec.Replicas
-
-		for name, quantity := range used {
-			// Update quantity to reflect number of replicas in resource
-			q := quantity.DeepCopy()
-			q.Mul(int64(replicas))
-
-			// Update quantity to reflect the number of clusters resource is duplicated to
-			if binding.Spec.Placement != nil && binding.Spec.Placement.ReplicaSchedulingType() == policyv1alpha1.ReplicaSchedulingTypeDuplicated {
-				q.Mul(int64(len(binding.Spec.Clusters)))
-			}
-
+		usage := calculateResourceUsage(&binding)
+		for name, quantity := range usage {
 			existing, found := overallUsed[name]
 			if found {
-				existing.Add(q)
+				existing.Add(quantity)
 				overallUsed[name] = existing
 			} else {
-				overallUsed[name] = q
+				overallUsed[name] = quantity
 			}
 		}
 	}
 	return filterResourceListByOverall(overallUsed, overall)
 }
 
+// calculateResourceUsage calculates the total resource usage based on the ResourceBinding.
+func calculateResourceUsage(rb *workv1alpha2.ResourceBinding) corev1.ResourceList {
+	if rb == nil || rb.Spec.ReplicaRequirements == nil || len(rb.Spec.ReplicaRequirements.ResourceRequest) == 0 || len(rb.Spec.Clusters) == 0 {
+		return corev1.ResourceList{}
+	}
+
+	totalReplicas := int32(0)
+	for _, cluster := range rb.Spec.Clusters {
+		totalReplicas += cluster.Replicas
+	}
+
+	if totalReplicas == 0 {
+		return corev1.ResourceList{}
+	}
+
+	usage := corev1.ResourceList{}
+	replicaCount := int64(totalReplicas)
+
+	for resourceName, quantityPerReplica := range rb.Spec.ReplicaRequirements.ResourceRequest {
+		if quantityPerReplica.IsZero() {
+			continue
+		}
+
+		totalQuantity := quantityPerReplica.DeepCopy()
+		totalQuantity.Mul(replicaCount)
+
+		usage[resourceName] = totalQuantity
+	}
+
+	return usage
+}
+
 // Filters source ResourceList using the keys provided by reference
 func filterResourceListByOverall(source, reference corev1.ResourceList) corev1.ResourceList {
 	filteredUsed := corev1.ResourceList{}

pkg/controllers/federatedresourcequota/federated_resource_quota_enforcement_controller_test.go

@@ -23,7 +23,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 
-	policyv1alpha1 "github.com/karmada-io/karmada/pkg/apis/policy/v1alpha1"
 	workv1alpha2 "github.com/karmada-io/karmada/pkg/apis/work/v1alpha2"
 )
 
@@ -35,9 +34,18 @@ func TestCalculateUsedWithResourceBinding(t *testing.T) {
 		expected corev1.ResourceList
 	}{
 		{
-			name: "single binding, 3 replicas",
+			name: "single binding",
 			bindings: []workv1alpha2.ResourceBinding{
-				makeBinding("500m", "128Mi", int32(3), policyv1alpha1.ReplicaSchedulingTypeDivided),
+				makeBinding("500m", "128Mi", []workv1alpha2.TargetCluster{
+					{
+						Name:     "Cluster1",
+						Replicas: int32(1),
+					},
+					{
+						Name:     "Cluster2",
+						Replicas: int32(2),
+					},
+				}),
 			},
 			overall: makeResourceRequest("2000m", "1Gi"),
 			expected: corev1.ResourceList{
@@ -46,11 +54,38 @@ func TestCalculateUsedWithResourceBinding(t *testing.T) {
 			},
 		},
 		{
-			name: "multiple bindings, mixed scheduling strategies",
+			name: "multiple bindings",
 			bindings: []workv1alpha2.ResourceBinding{
-				makeBinding("1", "2Gi", 2, policyv1alpha1.ReplicaSchedulingTypeDivided),
-				makeBinding("500m", "500Mi", 2, policyv1alpha1.ReplicaSchedulingTypeDuplicated),
-				makeBinding("2", "1Gi", 2, policyv1alpha1.ReplicaSchedulingTypeDivided),
+				makeBinding("1", "2Gi", []workv1alpha2.TargetCluster{
+					{
+						Name:     "Cluster1",
+						Replicas: int32(1),
+					},
+					{
+						Name:     "Cluster2",
+						Replicas: int32(1),
+					},
+				}),
+				makeBinding("500m", "500Mi", []workv1alpha2.TargetCluster{
+					{
+						Name:     "Cluster1",
+						Replicas: int32(2),
+					},
+					{
+						Name:     "Cluster2",
+						Replicas: int32(2),
+					},
+				}),
+				makeBinding("2", "1Gi", []workv1alpha2.TargetCluster{
+					{
+						Name:     "Cluster1",
+						Replicas: int32(1),
+					},
+					{
+						Name:     "Cluster2",
+						Replicas: int32(1),
+					},
+				}),
 			},
 			overall: makeResourceRequest("10", "10Gi"),
 			expected: corev1.ResourceList{
@@ -61,7 +96,16 @@ func TestCalculateUsedWithResourceBinding(t *testing.T) {
 		{
 			name: "single binding, overall only includes cpu",
 			bindings: []workv1alpha2.ResourceBinding{
-				makeBinding("500m", "1Gi", int32(3), policyv1alpha1.ReplicaSchedulingTypeDivided),
+				makeBinding("500m", "1Gi", []workv1alpha2.TargetCluster{
+					{
+						Name:     "Cluster1",
+						Replicas: int32(1),
+					},
+					{
+						Name:     "Cluster2",
+						Replicas: int32(2),
+					},
+				}),
 			},
 			overall: makeResourceRequest("10", ""),
 			expected: corev1.ResourceList{
@@ -80,15 +124,18 @@ func TestCalculateUsedWithResourceBinding(t *testing.T) {
 						ReplicaRequirements: &workv1alpha2.ReplicaRequirements{
 							ResourceRequest: nil,
 						},
-						Replicas: 2,
-						Placement: &policyv1alpha1.Placement{
-							ReplicaScheduling: &policyv1alpha1.ReplicaSchedulingStrategy{
-								ReplicaSchedulingType: policyv1alpha1.ReplicaSchedulingTypeDuplicated,
-							},
-						},
 					},
 				},
-				makeBinding("200m", "128Mi", 2, policyv1alpha1.ReplicaSchedulingTypeDivided),
+				makeBinding("200m", "128Mi", []workv1alpha2.TargetCluster{
+					{
+						Name:     "Cluster1",
+						Replicas: int32(1),
+					},
+					{
+						Name:     "Cluster2",
+						Replicas: int32(1),
+					},
+				}),
 			},
 			overall: makeResourceRequest("10", "10Gi"),
 			expected: corev1.ResourceList{
@@ -118,23 +165,13 @@ func TestCalculateUsedWithResourceBinding(t *testing.T) {
 	}
 }
 
-func makeBinding(cpu string, memory string, replicas int32, strategy policyv1alpha1.ReplicaSchedulingType) workv1alpha2.ResourceBinding {
-	schedulingStrategy := &policyv1alpha1.ReplicaSchedulingStrategy{
-		ReplicaSchedulingType: strategy,
-	}
+func makeBinding(cpu string, memory string, clusters []workv1alpha2.TargetCluster) workv1alpha2.ResourceBinding {
 	return workv1alpha2.ResourceBinding{
 		Spec: workv1alpha2.ResourceBindingSpec{
-			Clusters: []workv1alpha2.TargetCluster{
-				{Name: "cluster1"},
-				{Name: "cluster2"},
-			},
+			Clusters: clusters,
 			ReplicaRequirements: &workv1alpha2.ReplicaRequirements{
 				ResourceRequest: makeResourceRequest(cpu, memory),
 			},
-			Replicas: replicas,
-			Placement: &policyv1alpha1.Placement{
-				ReplicaScheduling: schedulingStrategy,
-			},
 		},
 	}
 }