Changes due to type name changes

Signed-off-by: Shmuel Kallner <[email protected]>

Author: shmuelk

pkg/epp/scheduling/framework/plugins/scorer/running.go

@@ -71,13 +71,13 @@ func (s *RunningRequestsSizeScorer) WithName(name string) *RunningRequestsSizeSc
 }
 
 // Score returns the scoring result for the given list of pods based on context.
-func (s *RunningRequestsSizeScorer) Score(_ context.Context, _ *types.CycleState, _ *types.LLMRequest, pods []types.Pod) map[types.Pod]float64 {
+func (s *RunningRequestsSizeScorer) Score(_ context.Context, _ *types.CycleState, _ *types.LLMRequest, endpoints []types.Endpoint) map[types.Endpoint]float64 {
 	minQueueSize := math.MaxInt
 	maxQueueSize := math.MinInt
 
 	// Iterate through the remaining pods to find min and max
-	for _, pod := range pods {
-		queueSize := pod.GetMetrics().RunningRequestsSize
+	for _, endpoint := range endpoints {
+		queueSize := endpoint.GetMetrics().RunningRequestsSize
 		if queueSize < minQueueSize {
 			minQueueSize = queueSize
 		}
@@ -86,19 +86,19 @@ func (s *RunningRequestsSizeScorer) Score(_ context.Context, _ *types.CycleState
 		}
 	}
 
-	// podScoreFunc calculates the score based on the queue size of each pod. Longer queue gets a lower score.
-	podScoreFunc := func(pod types.Pod) float64 {
+	// endpointScoreFunc calculates the score based on the queue size of each pod. Longer queue gets a lower score.
+	endpointScoreFunc := func(endpoint types.Endpoint) float64 {
 		if maxQueueSize == minQueueSize {
 			// If all pods have the same queue size, return a neutral score
 			return 1.0
 		}
-		return float64(maxQueueSize-pod.GetMetrics().RunningRequestsSize) / float64(maxQueueSize-minQueueSize)
+		return float64(maxQueueSize-endpoint.GetMetrics().RunningRequestsSize) / float64(maxQueueSize-minQueueSize)
 	}
 
 	// Create a map to hold the scores for each pod
-	scores := make(map[types.Pod]float64, len(pods))
-	for _, pod := range pods {
-		scores[pod] = podScoreFunc(pod)
+	scores := make(map[types.Endpoint]float64, len(endpoints))
+	for _, endpoint := range endpoints {
+		scores[endpoint] = endpointScoreFunc(endpoint)
 	}
 	return scores
 }

pkg/epp/scheduling/framework/plugins/scorer/running_test.go

@@ -22,23 +22,23 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/backend"
 	backendmetrics "sigs.k8s.io/gateway-api-inference-extension/pkg/epp/backend/metrics"
+	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/datalayer"
 	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/scheduling/types"
 )
 
 func TestRunningRequestsSizeScorer(t *testing.T) {
 	tests := []struct {
 		name              string
-		pods              []types.Pod
+		endpoints         []types.Endpoint
 		expectedScoresPod map[int]float64 // Map of pod index to expected score
 	}{
 		{
 			name: "Different running queue sizes",
-			pods: []types.Pod{
-				&types.PodMetrics{Pod: &backend.Pod{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 10}},
-				&types.PodMetrics{Pod: &backend.Pod{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 5}},
-				&types.PodMetrics{Pod: &backend.Pod{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 0}},
+			endpoints: []types.Endpoint{
+				&types.PodMetrics{EndpointMetadata: &datalayer.EndpointMetadata{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 10}},
+				&types.PodMetrics{EndpointMetadata: &datalayer.EndpointMetadata{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 5}},
+				&types.PodMetrics{EndpointMetadata: &datalayer.EndpointMetadata{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 0}},
 			},
 			expectedScoresPod: map[int]float64{
 				0: 0.0, // Longest queue (10) gets lowest score
@@ -48,9 +48,9 @@ func TestRunningRequestsSizeScorer(t *testing.T) {
 		},
 		{
 			name: "Same running queue sizes",
-			pods: []types.Pod{
-				&types.PodMetrics{Pod: &backend.Pod{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 5}},
-				&types.PodMetrics{Pod: &backend.Pod{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 5}},
+			endpoints: []types.Endpoint{
+				&types.PodMetrics{EndpointMetadata: &datalayer.EndpointMetadata{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 5}},
+				&types.PodMetrics{EndpointMetadata: &datalayer.EndpointMetadata{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 5}},
 			},
 			expectedScoresPod: map[int]float64{
 				0: 1.0, // When all pods have the same queue size, they get the same neutral score
@@ -59,9 +59,9 @@ func TestRunningRequestsSizeScorer(t *testing.T) {
 		},
 		{
 			name: "Zero running queue sizes",
-			pods: []types.Pod{
-				&types.PodMetrics{Pod: &backend.Pod{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 0}},
-				&types.PodMetrics{Pod: &backend.Pod{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 0}},
+			endpoints: []types.Endpoint{
+				&types.PodMetrics{EndpointMetadata: &datalayer.EndpointMetadata{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 0}},
+				&types.PodMetrics{EndpointMetadata: &datalayer.EndpointMetadata{}, MetricsState: &backendmetrics.MetricsState{RunningRequestsSize: 0}},
 			},
 			expectedScoresPod: map[int]float64{
 				0: 1.0,
@@ -74,9 +74,9 @@ func TestRunningRequestsSizeScorer(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			scores := scorer.Score(context.Background(), types.NewCycleState(), &types.LLMRequest{}, test.pods)
+			scores := scorer.Score(context.Background(), types.NewCycleState(), &types.LLMRequest{}, test.endpoints)
 
-			for i, pod := range test.pods {
+			for i, pod := range test.endpoints {
 				expectedScore := test.expectedScoresPod[i]
 				assert.InDelta(t, expectedScore, scores[pod], 0.0001, "Pod %d should have score %f", i, expectedScore)
 			}