Add status to Inference Pools (#4005)

Add status to Inference Pools

Problem: Users want to see the current status of their Inference pools

Solution: Add status for inference pools

Author: salonichf5

internal/controller/handler.go

@@ -368,17 +368,19 @@ func (h *eventHandlerImpl) updateStatuses(ctx context.Context, gr *graph.Graph,
 		transitionTime,
 		h.cfg.gatewayCtlrName,
 	)
+	inferencePoolReqs := status.PrepareInferencePoolRequests(gr.ReferencedInferencePools, transitionTime)
 
 	reqs := make(
 		[]status.UpdateRequest,
 		0,
-		len(gcReqs)+len(routeReqs)+len(polReqs)+len(ngfPolReqs)+len(snippetsFilterReqs),
+		len(gcReqs)+len(routeReqs)+len(polReqs)+len(ngfPolReqs)+len(snippetsFilterReqs)+len(inferencePoolReqs),
 	)
 	reqs = append(reqs, gcReqs...)
 	reqs = append(reqs, routeReqs...)
 	reqs = append(reqs, polReqs...)
 	reqs = append(reqs, ngfPolReqs...)
 	reqs = append(reqs, snippetsFilterReqs...)
+	reqs = append(reqs, inferencePoolReqs...)
 
 	h.cfg.statusUpdater.UpdateGroup(ctx, groupAllExceptGateways, reqs...)
 

internal/controller/state/conditions/conditions.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	inference "sigs.k8s.io/gateway-api-inference-extension/api/v1"
 	v1 "sigs.k8s.io/gateway-api/apis/v1"
 	"sigs.k8s.io/gateway-api/apis/v1alpha2"
 
@@ -1138,3 +1139,55 @@ func NewBackendTLSPolicyNoValidCACertificate(message string) Condition {
 		Message: message,
 	}
 }
+
+// NewInferencePoolAccepted returns a Condition that indicates that the InferencePool is accepted by the Gateway.
+func NewInferencePoolAccepted() Condition {
+	return Condition{
+		Type:    string(inference.InferencePoolConditionAccepted),
+		Status:  metav1.ConditionTrue,
+		Reason:  string(inference.InferencePoolConditionAccepted),
+		Message: "InferencePool is accepted by the Gateway.",
+	}
+}
+
+// NewInferencePoolResolvedRefs returns a Condition that
+// indicates that all references in the InferencePool are resolved.
+func NewInferencePoolResolvedRefs() Condition {
+	return Condition{
+		Type:    string(inference.InferencePoolConditionResolvedRefs),
+		Status:  metav1.ConditionTrue,
+		Reason:  string(inference.InferencePoolConditionResolvedRefs),
+		Message: "Inference pool references a valid ExtensionRef.",
+	}
+}
+
+// NewDefaultInferenceConditions returns the default Conditions
+// that must be present in the status of an InferencePool.
+func NewDefaultInferenceConditions() []Condition {
+	return []Condition{
+		NewInferencePoolAccepted(),
+		NewInferencePoolResolvedRefs(),
+	}
+}
+
+// NewInferencePoolInvalidHTTPRouteNotAccepted returns a Condition that indicates that the InferencePool is not
+// accepted because the associated HTTPRoute is not accepted by the Gateway.
+func NewInferencePoolInvalidHTTPRouteNotAccepted(msg string) Condition {
+	return Condition{
+		Type:    string(inference.InferencePoolConditionAccepted),
+		Status:  metav1.ConditionFalse,
+		Reason:  string(inference.InferencePoolReasonHTTPRouteNotAccepted),
+		Message: msg,
+	}
+}
+
+// NewInferencePoolInvalidExtensionref returns a Condition that indicates that the InferencePool is not
+// accepted because the ExtensionRef is invalid.
+func NewInferencePoolInvalidExtensionref(msg string) Condition {
+	return Condition{
+		Type:    string(inference.InferencePoolConditionResolvedRefs),
+		Status:  metav1.ConditionFalse,
+		Reason:  string(inference.InferencePoolReasonInvalidExtensionRef),
+		Message: msg,
+	}
+}

internal/controller/state/graph/graph.go

@@ -260,7 +260,8 @@ func BuildGraph(
 		processedSnippetsFilters,
 		state.InferencePools,
 	)
-	referencedInferencePools := buildReferencedInferencePools(routes, gws, state.InferencePools)
+
+	referencedInferencePools := buildReferencedInferencePools(routes, gws, state.InferencePools, state.Services)
 
 	l4routes := buildL4RoutesForGateways(
 		state.TLSRoutes,

internal/controller/state/graph/graph_test.go

@@ -223,12 +223,15 @@ func TestBuildGraph(t *testing.T) {
 					Namespace: testNs,
 					Name:      controller.CreateInferencePoolServiceName("ipool"),
 				},
-				ServicePort:          v1.ServicePort{Port: 80},
-				Valid:                true,
-				Weight:               1,
-				InvalidForGateways:   map[types.NamespacedName]conditions.Condition{},
-				IsInferencePool:      true,
-				EndpointPickerConfig: &inference.EndpointPickerRef{},
+				ServicePort:        v1.ServicePort{Port: 80},
+				Valid:              true,
+				Weight:             1,
+				InvalidForGateways: map[types.NamespacedName]conditions.Condition{},
+				IsInferencePool:    true,
+				EndpointPickerConfig: &inference.EndpointPickerRef{
+					Kind: kinds.Service,
+					Name: inference.ObjectName(controller.CreateInferencePoolServiceName("ipool")),
+				},
 			},
 		}
 		rbrs := []RouteBackendRef{
@@ -389,6 +392,10 @@ func TestBuildGraph(t *testing.T) {
 			TargetPorts: []inference.Port{
 				{Number: 80},
 			},
+			EndpointPickerRef: inference.EndpointPickerRef{
+				Kind: kinds.Service,
+				Name: inference.ObjectName(controller.CreateInferencePoolServiceName("ipool")),
+			},
 		},
 	}
 
@@ -1325,6 +1332,13 @@ func TestBuildGraph(t *testing.T) {
 			ReferencedInferencePools: map[types.NamespacedName]*ReferencedInferencePool{
 				client.ObjectKeyFromObject(inferencePool): {
 					Source: inferencePool,
+					Gateways: []*gatewayv1.Gateway{
+						gw1.Source,
+					},
+					HTTPRoutes: []*L7Route{
+						inferenceRoute,
+					},
+					Conditions: []conditions.Condition{},
 				},
 			},
 			ReferencedCaCertConfigMaps: map[types.NamespacedName]*CaCertConfigMap{

internal/controller/state/graph/inferencepools.go

@@ -1,10 +1,15 @@
 package graph
 
 import (
+	"fmt"
+
+	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	inference "sigs.k8s.io/gateway-api-inference-extension/api/v1"
+	apiv1 "sigs.k8s.io/gateway-api/apis/v1"
 
+	"github.com/nginx/nginx-gateway-fabric/v2/internal/controller/state/conditions"
 	"github.com/nginx/nginx-gateway-fabric/v2/internal/framework/controller"
 	"github.com/nginx/nginx-gateway-fabric/v2/internal/framework/kinds"
 )
@@ -14,6 +19,12 @@ import (
 type ReferencedInferencePool struct {
 	// Source is the original InferencePool that this ReferencedInferencePool is based on.
 	Source *inference.InferencePool
+	// Gateways are the Gateways that this ReferencedInferencePool is attached to.
+	Gateways []*apiv1.Gateway
+	// HTTPRoutes are the HTTPRoutes that reference this InferencePool.
+	HTTPRoutes []*L7Route
+	// Conditions contains the conditions that should be applied to the InferencePool.
+	Conditions []conditions.Condition
 }
 
 // buildReferencedInferencePools builds a map of InferencePools that are referenced by HTTPRoutes
@@ -22,8 +33,9 @@ func buildReferencedInferencePools(
 	routes map[RouteKey]*L7Route,
 	gws map[types.NamespacedName]*Gateway,
 	inferencePools map[types.NamespacedName]*inference.InferencePool,
+	services map[types.NamespacedName]*v1.Service,
 ) map[types.NamespacedName]*ReferencedInferencePool {
-	referencedInferencePools := make(map[types.NamespacedName]*ReferencedInferencePool)
+	referencedInferencePools := make(map[types.NamespacedName]*ReferencedInferencePool, len(inferencePools))
 
 	for _, gw := range gws {
 		if gw == nil {
@@ -37,6 +49,17 @@ func buildReferencedInferencePools(
 		return nil
 	}
 
+	// validate each referenced InferencePool and add conditions.
+	for _, refPool := range referencedInferencePools {
+		if routeCond := validateInferencePoolRoutesAcceptance(refPool.Source, refPool.HTTPRoutes); routeCond != nil {
+			refPool.Conditions = append(refPool.Conditions, *routeCond)
+		}
+
+		if extensionRefCond := validateInferencePoolExtensionRef(refPool.Source, services); extensionRefCond != nil {
+			refPool.Conditions = append(refPool.Conditions, *extensionRefCond)
+		}
+	}
+
 	return referencedInferencePools
 }
 
@@ -48,8 +71,9 @@ func processInferencePoolsForGateway(
 	inferencePools map[types.NamespacedName]*inference.InferencePool,
 ) {
 	gwKey := client.ObjectKeyFromObject(gw.Source)
+
 	for _, route := range routes {
-		if !route.Valid || !routeBelongsToGateway(route.ParentRefs, gwKey) {
+		if !routeBelongsToGateway(route.ParentRefs, gwKey) {
 			continue
 		}
 
@@ -70,13 +94,83 @@ func processInferencePoolsForGateway(
 				}
 
 				if _, referenced := referencedInferencePools[poolName]; !referenced {
-					referencedInferencePools[poolName] = &ReferencedInferencePool{}
+					referencedInferencePools[poolName] = &ReferencedInferencePool{
+						Conditions: make([]conditions.Condition, 0, 2),
+						Gateways:   make([]*apiv1.Gateway, 0),
+						HTTPRoutes: make([]*L7Route, 0),
+					}
 				}
 
 				if pool, exists := inferencePools[poolName]; exists {
 					referencedInferencePools[poolName].Source = pool
+					referencedInferencePools[poolName].Gateways = append(
+						referencedInferencePools[poolName].Gateways,
+						gw.Source,
+					)
+					referencedInferencePools[poolName].HTTPRoutes = append(
+						referencedInferencePools[poolName].HTTPRoutes,
+						route,
+					)
 				}
 			}
 		}
 	}
 }
+
+// validateInferencePoolExtensionRef validates the ExtensionRef of the InferencePool.
+func validateInferencePoolExtensionRef(
+	ip *inference.InferencePool,
+	svc map[types.NamespacedName]*v1.Service,
+) *conditions.Condition {
+	var failingCond conditions.Condition
+	if ip == nil {
+		return nil
+	}
+
+	// if kind is empty, it defaults to Service
+	kind := string(ip.Spec.EndpointPickerRef.Kind)
+	if kind == "" {
+		kind = kinds.Service
+	}
+
+	if kind != kinds.Service {
+		failingCond = conditions.NewInferencePoolInvalidExtensionref("Invalid ExtensionRef kind: " + kind)
+		return &failingCond
+	}
+
+	eppNsName := types.NamespacedName{
+		Name:      string(ip.Spec.EndpointPickerRef.Name),
+		Namespace: ip.GetNamespace(),
+	}
+
+	if _, ok := svc[eppNsName]; !ok {
+		failingCond = conditions.NewInferencePoolInvalidExtensionref("ExtensionRef Service not found: " + eppNsName.String())
+		return &failingCond
+	}
+
+	return nil
+}
+
+// validateInferencePoolRoutesAcceptance checks if the routes that reference the InferencePool
+// are accepted by the Gateway.
+func validateInferencePoolRoutesAcceptance(ip *inference.InferencePool, routes []*L7Route) *conditions.Condition {
+	if ip == nil || len(routes) == 0 {
+		return nil
+	}
+
+	// we do not need to validate that the route belongs to the gateway or not
+	// we only process routes that belong to the gateway in the first place
+	for _, route := range routes {
+		if !route.Valid {
+			cond := conditions.NewInferencePoolInvalidHTTPRouteNotAccepted(
+				fmt.Sprintf("Referenced HTTPRoute %s/%s is not accepted by the Gateway",
+					route.Source.GetNamespace(),
+					route.Source.GetName(),
+				),
+			)
+			return &cond
+		}
+	}
+
+	return nil
+}