update

Signed-off-by: bitliu <[email protected]>

Author: Xunzhuo

e2e/pkg/helpers/kubernetes.go

@@ -0,0 +1,213 @@
+package helpers
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/portforward"
+	"k8s.io/client-go/transport/spdy"
+)
+
+// CheckDeployment checks if a deployment is healthy (ready replicas > 0)
+func CheckDeployment(ctx context.Context, client *kubernetes.Clientset, namespace, name string, verbose bool) error {
+	deployment, err := client.AppsV1().Deployments(namespace).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to get deployment: %w", err)
+	}
+
+	if deployment.Status.ReadyReplicas == 0 {
+		return fmt.Errorf("deployment has 0 ready replicas")
+	}
+
+	if verbose {
+		fmt.Printf("[Helper] Deployment %s/%s is healthy (%d/%d replicas ready)\n",
+			namespace, name, deployment.Status.ReadyReplicas, deployment.Status.Replicas)
+	}
+
+	return nil
+}
+
+// GetEnvoyServiceName finds the Envoy service name in the envoy-gateway-system namespace
+func GetEnvoyServiceName(ctx context.Context, client *kubernetes.Clientset, verbose bool) (string, error) {
+	services, err := client.CoreV1().Services("envoy-gateway-system").List(ctx, metav1.ListOptions{})
+	if err != nil {
+		return "", fmt.Errorf("failed to list services: %w", err)
+	}
+
+	for _, svc := range services.Items {
+		if strings.Contains(svc.Name, "envoy-gateway") && svc.Spec.Type == "LoadBalancer" {
+			if verbose {
+				fmt.Printf("[Helper] Found Envoy service: %s\n", svc.Name)
+			}
+			return svc.Name, nil
+		}
+	}
+
+	return "", fmt.Errorf("no Envoy LoadBalancer service found")
+}
+
+// VerifyServicePodsRunning verifies that exactly 1 pod exists for a service and it's running with all containers ready
+func VerifyServicePodsRunning(ctx context.Context, client *kubernetes.Clientset, namespace, serviceName string, verbose bool) error {
+	// Get the service
+	svc, err := client.CoreV1().Services(namespace).Get(ctx, serviceName, metav1.GetOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to get service: %w", err)
+	}
+
+	// Build label selector from service selector
+	var selectorParts []string
+	for key, value := range svc.Spec.Selector {
+		selectorParts = append(selectorParts, fmt.Sprintf("%s=%s", key, value))
+	}
+	labelSelector := strings.Join(selectorParts, ",")
+
+	// List pods matching the selector
+	pods, err := client.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{
+		LabelSelector: labelSelector,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to list pods: %w", err)
+	}
+
+	// Verify exactly 1 pod exists
+	if len(pods.Items) != 1 {
+		return fmt.Errorf("expected exactly 1 pod for service %s/%s, but found %d pods", namespace, serviceName, len(pods.Items))
+	}
+
+	// Check if all pods are running and ready
+	runningCount := 0
+	for _, pod := range pods.Items {
+		if pod.Status.Phase == "Running" {
+			// Also check if all containers are ready
+			allContainersReady := true
+			for _, containerStatus := range pod.Status.ContainerStatuses {
+				if !containerStatus.Ready {
+					allContainersReady = false
+					break
+				}
+			}
+			if allContainersReady {
+				runningCount++
+			}
+		}
+	}
+
+	// All pods must be running and ready (and we already verified count is 1)
+	if runningCount != len(pods.Items) {
+		return fmt.Errorf("not all pods are running for service %s/%s: %d/%d pods ready", namespace, serviceName, runningCount, len(pods.Items))
+	}
+
+	if verbose {
+		fmt.Printf("[Helper] Service %s/%s has all %d pod(s) running and ready\n",
+			namespace, serviceName, len(pods.Items))
+	}
+
+	return nil
+}
+
+// StartPortForward starts port forwarding to a service
+func StartPortForward(ctx context.Context, client *kubernetes.Clientset, restConfig *rest.Config, namespace, service, ports string, verbose bool) error {
+	// Parse ports (e.g., "8080:80" -> local=8080, remote=80)
+	portParts := strings.Split(ports, ":")
+	if len(portParts) != 2 {
+		return fmt.Errorf("invalid port format: %s (expected format: localPort:remotePort)", ports)
+	}
+	localPort := portParts[0]
+	remotePort := portParts[1]
+
+	// Get the service to find a pod
+	svc, err := client.CoreV1().Services(namespace).Get(ctx, service, metav1.GetOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to get service: %w", err)
+	}
+
+	// Get pods matching the service selector
+	var selectorParts []string
+	for key, value := range svc.Spec.Selector {
+		selectorParts = append(selectorParts, fmt.Sprintf("%s=%s", key, value))
+	}
+	labelSelector := strings.Join(selectorParts, ",")
+
+	pods, err := client.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{
+		LabelSelector: labelSelector,
+		FieldSelector: "status.phase=Running",
+	})
+	if err != nil {
+		return fmt.Errorf("failed to list pods: %w", err)
+	}
+
+	if len(pods.Items) == 0 {
+		return fmt.Errorf("no running pods found for service %s", service)
+	}
+
+	podName := pods.Items[0].Name
+
+	if verbose {
+		fmt.Printf("[Helper] Starting port-forward to pod %s/%s (%s:%s)\n", namespace, podName, localPort, remotePort)
+	}
+
+	// Create SPDY transport
+	transport, upgrader, err := spdy.RoundTripperFor(restConfig)
+	if err != nil {
+		return fmt.Errorf("failed to create SPDY transport: %w", err)
+	}
+
+	// Build the URL for port forwarding
+	url := client.CoreV1().RESTClient().Post().
+		Resource("pods").
+		Namespace(namespace).
+		Name(podName).
+		SubResource("portforward").
+		URL()
+
+	// Create dialer
+	dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", url)
+
+	// Setup channels
+	stopChan := make(chan struct{}, 1)
+	readyChan := make(chan struct{})
+	out := io.Discard
+	errOut := io.Discard
+	if verbose {
+		out = os.Stdout
+		errOut = os.Stderr
+	}
+
+	// Create port forwarder
+	forwarder, err := portforward.New(dialer, []string{fmt.Sprintf("%s:%s", localPort, remotePort)}, stopChan, readyChan, out, errOut)
+	if err != nil {
+		return fmt.Errorf("failed to create port forwarder: %w", err)
+	}
+
+	// Start port forwarding in background
+	go func() {
+		if err := forwarder.ForwardPorts(); err != nil {
+			if verbose {
+				fmt.Printf("[Helper] Port forwarding error: %v\n", err)
+			}
+		}
+	}()
+
+	// Wait for ready or timeout
+	select {
+	case <-readyChan:
+		if verbose {
+			fmt.Printf("[Helper] Port forwarding is ready\n")
+		}
+		return nil
+	case <-time.After(30 * time.Second):
+		close(stopChan)
+		return fmt.Errorf("timeout waiting for port forward to be ready")
+	case <-ctx.Done():
+		close(stopChan)
+		return ctx.Err()
+	}
+}

e2e/profiles/ai-gateway/basic_health_check.go

@@ -0,0 +1,47 @@
+package aigateway
+
+import (
+	"context"
+	"fmt"
+
+	"k8s.io/client-go/kubernetes"
+
+	"github.com/vllm-project/semantic-router/e2e/pkg/helpers"
+	"github.com/vllm-project/semantic-router/e2e/pkg/testcases"
+)
+
+func init() {
+	testcases.Register("basic-health-check", testcases.TestCase{
+		Description: "Verify that all components are deployed and healthy",
+		Tags:        []string{"ai-gateway", "health"},
+		Fn:          testBasicHealthCheck,
+	})
+}
+
+func testBasicHealthCheck(ctx context.Context, client *kubernetes.Clientset, opts testcases.TestCaseOptions) error {
+	if opts.Verbose {
+		fmt.Println("[Test] Running basic health check")
+	}
+
+	// Check semantic-router deployment
+	if err := helpers.CheckDeployment(ctx, client, "vllm-semantic-router-system", "semantic-router", opts.Verbose); err != nil {
+		return fmt.Errorf("semantic-router deployment not healthy: %w", err)
+	}
+
+	// Check envoy-gateway deployment
+	if err := helpers.CheckDeployment(ctx, client, "envoy-gateway-system", "envoy-gateway", opts.Verbose); err != nil {
+		return fmt.Errorf("envoy-gateway deployment not healthy: %w", err)
+	}
+
+	// Check ai-gateway-controller deployment
+	if err := helpers.CheckDeployment(ctx, client, "envoy-ai-gateway-system", "ai-gateway-controller", opts.Verbose); err != nil {
+		return fmt.Errorf("ai-gateway-controller deployment not healthy: %w", err)
+	}
+
+	if opts.Verbose {
+		fmt.Println("[Test] ✅ All deployments are healthy")
+	}
+
+	return nil
+}
+