guard preemptive reclaim by realCapability

Signed-off-by: zhoujinyu <2319109590@qq.com>

Author: FAUST-BENCHOU

pkg/scheduler/plugins/capacity/capacity.go

@@ -180,6 +180,13 @@ func (cp *capacityPlugin) OnSessionOpen(ssn *framework.Session) {
 		attr := cp.queueOpts[queue.UID]
 		futureUsed := attr.allocated.Clone().Add(task.Resreq)
 
+		if allocatable, _ := futureUsed.LessEqualWithDimensionAndResourcesName(attr.realCapability, task.Resreq); !allocatable {
+			klog.V(3).Infof("Queue <%v> cannot reclaim for <%s/%s> because futureUsed <%v> exceeds realCapability <%v>.",
+				queue.Name, task.Namespace, task.Name, futureUsed, attr.realCapability)
+			metrics.UpdateQueueOverused(attr.name, true)
+			return false
+		}
+
 		// If there is a single dimension whose deserved is greater than allocated, current task can reclaim by preempt others.
 		isPreemptive, resourceNames := futureUsed.LessEqualPartlyWithDimensionZeroFiltered(attr.deserved, task.Resreq)
 		if isPreemptive {

pkg/scheduler/plugins/capacity/capacity_test.go

@@ -958,3 +958,53 @@ func Test_updateQueueAttrShare(t *testing.T) {
 		})
 	}
 }
+
+func TestPreemptiveFn_RespectsCapability(t *testing.T) {
+	// Queue has deserved and capability both {cpu: 8, mem: 100Gi}, allocated {cpu: 7, mem: 90Gi}.
+	// A task requesting {cpu: 2, mem: 5Gi} would keep memory below deserved but push CPU above capability.
+	// preemptiveFn should reject preemption in this case.
+
+	deserved := api.NewResource(api.BuildResourceList("8", "100Gi"))
+	allocated := api.NewResource(api.BuildResourceList("7", "90Gi"))
+	capability := api.NewResource(api.BuildResourceList("8", "100Gi"))
+
+	attr := &queueAttr{
+		queueID:        "q-test",
+		name:           "q-test",
+		deserved:       deserved,
+		allocated:      allocated,
+		capability:     capability,
+		realCapability: capability.Clone(),
+	}
+
+	taskRes := api.NewResource(api.BuildResourceList("2", "5Gi"))
+	task := &api.TaskInfo{
+		Resreq:     taskRes,
+		InitResreq: taskRes,
+	}
+
+	queue := &api.QueueInfo{
+		UID:  "q-test",
+		Name: "q-test",
+	}
+
+	futureUsed := attr.allocated.Clone().Add(task.Resreq)
+	if allocatable, _ := futureUsed.LessEqualWithDimensionAndResourcesName(attr.realCapability, task.Resreq); allocatable {
+		t.Fatalf("precondition error: futureUsed %v should exceed capability %v", futureUsed, attr.realCapability)
+	}
+
+	// Simulate the logic in preemptiveFn after our fix: first capability, then deserved.
+	allocatable, _ := futureUsed.LessEqualWithDimensionAndResourcesName(attr.realCapability, task.Resreq)
+	if allocatable {
+		t.Fatalf("expected allocatable=false when futureUsed exceeds capability, got true")
+	}
+
+	// For completeness, check that even though memory is below deserved, we still don't allow reclaim
+	// because capability check fails.
+	isPreemptive, _ := futureUsed.LessEqualPartlyWithDimensionZeroFiltered(attr.deserved, task.Resreq)
+	if isPreemptive {
+		t.Logf("deserved check alone would allow reclaim, but capability check must block it")
+	}
+
+	_ = queue // queue is only needed to mirror function signature; logic above is independent of it.
+}