fix(disruption): Using correct internal LB of apiserver for monitor test on ARO and Baremetal Hypershift

Author: wangke19

pkg/monitortests/kubeapiserver/disruptioninclusterapiserver/monitortest.go

@@ -75,8 +75,9 @@ type InvariantInClusterDisruption struct {
 	replicas                    int32
 	controlPlaneNodes           int32
 
-	isHypershift    bool
-	isAROHCPCluster bool
+	isHypershift          bool
+	isAROHCPCluster       bool
+	isBareMetalHypershift bool
 
 	adminRESTConfig *rest.Config
 	kubeClient      kubernetes.Interface
@@ -88,6 +89,68 @@ func NewInvariantInClusterDisruption(info monitortestframework.MonitorTestInitia
 	}
 }
 
+// parseAdminRESTConfigHost parses the adminRESTConfig.Host URL and returns hostname and port
+func (i *InvariantInClusterDisruption) parseAdminRESTConfigHost() (hostname, port string, err error) {
+	parsedURL, err := url.Parse(i.adminRESTConfig.Host)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to parse adminRESTConfig.Host %q: %v", i.adminRESTConfig.Host, err)
+	}
+
+	hostname = parsedURL.Hostname()
+	if hostname == "" {
+		return "", "", fmt.Errorf("no hostname found in adminRESTConfig.Host %q", i.adminRESTConfig.Host)
+	}
+
+	port = parsedURL.Port()
+	if port == "" {
+		port = "6443" // default port
+	}
+
+	return hostname, port, nil
+}
+
+// setKubernetesServiceEnvVars sets the KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT environment variables
+// based on the cluster type (ARO HCP, bare metal HyperShift, or standard)
+func (i *InvariantInClusterDisruption) setKubernetesServiceEnvVars(envVars []corev1.EnvVar, apiIntHost, apiIntPort string) []corev1.EnvVar {
+	// Parse adminRESTConfig.Host once for bare metal HyperShift
+	var bareMetalHost, bareMetalPort string
+	var bareMetalErr error
+	if i.isHypershift && i.isBareMetalHypershift {
+		bareMetalHost, bareMetalPort, bareMetalErr = i.parseAdminRESTConfigHost()
+		if bareMetalErr != nil {
+			logrus.WithError(bareMetalErr).Errorf("Failed to parse adminRESTConfig.Host for bare metal HyperShift")
+		}
+	}
+
+	for j, env := range envVars {
+		switch env.Name {
+		case "KUBERNETES_SERVICE_HOST":
+			if i.isHypershift && i.isBareMetalHypershift {
+				if bareMetalErr != nil {
+					envVars[j].Value = apiIntHost
+				} else {
+					envVars[j].Value = bareMetalHost
+				}
+			} else {
+				envVars[j].Value = apiIntHost
+			}
+		case "KUBERNETES_SERVICE_PORT":
+			if i.isHypershift && i.isAROHCPCluster {
+				envVars[j].Value = "7443"
+			} else if i.isHypershift && i.isBareMetalHypershift {
+				if bareMetalErr != nil {
+					envVars[j].Value = apiIntPort
+				} else {
+					envVars[j].Value = bareMetalPort
+				}
+			} else {
+				envVars[j].Value = apiIntPort
+			}
+		}
+	}
+	return envVars
+}
+
 func (i *InvariantInClusterDisruption) createDeploymentAndWaitToRollout(ctx context.Context, deploymentObj *appsv1.Deployment) error {
 	deploymentID := uuid.New().String()
 	deploymentObj = disruptionlibrary.UpdateDeploymentENVs(deploymentObj, deploymentID, "")
@@ -119,23 +182,14 @@ func (i *InvariantInClusterDisruption) createDeploymentAndWaitToRollout(ctx cont
 func (i *InvariantInClusterDisruption) createInternalLBDeployment(ctx context.Context, apiIntHost, apiIntPort string) error {
 	deploymentObj := resourceread.ReadDeploymentV1OrDie(internalLBDeploymentYaml)
 	deploymentObj.SetNamespace(i.namespaceName)
-	deploymentObj.Spec.Template.Spec.Containers[0].Env[0].Value = apiIntHost
 	// set amount of deployment replicas to make sure it runs on all nodes
 	deploymentObj.Spec.Replicas = &i.replicas
 	// we need to use the openshift-tests image of the destination during an upgrade.
 	deploymentObj.Spec.Template.Spec.Containers[0].Image = i.openshiftTestsImagePullSpec
 
-	// Set the correct port for internal API server
-	for j, env := range deploymentObj.Spec.Template.Spec.Containers[0].Env {
-		if env.Name == "KUBERNETES_SERVICE_PORT" {
-			if i.isHypershift && i.isAROHCPCluster {
-				deploymentObj.Spec.Template.Spec.Containers[0].Env[j].Value = "7443"
-			} else {
-				deploymentObj.Spec.Template.Spec.Containers[0].Env[j].Value = apiIntPort
-			}
-			break
-		}
-	}
+	// Set the correct host and port for internal API server based on cluster type
+	deploymentObj.Spec.Template.Spec.Containers[0].Env = i.setKubernetesServiceEnvVars(
+		deploymentObj.Spec.Template.Spec.Containers[0].Env, apiIntHost, apiIntPort)
 
 	err := i.createDeploymentAndWaitToRollout(ctx, deploymentObj)
 	if err != nil {
@@ -335,6 +389,13 @@ func (i *InvariantInClusterDisruption) StartCollection(ctx context.Context, admi
 			logrus.WithError(err).Warning("Failed to check if ARO HCP, assuming it's not")
 			i.isAROHCPCluster = false // Assume not ARO HCP on error
 		}
+
+		// Check if this is a bare metal HyperShift cluster
+		i.isBareMetalHypershift, err = exutil.IsBareMetalHyperShiftCluster(ctx, managementOC)
+		if err != nil {
+			logrus.WithError(err).Warning("Failed to check if bare metal HyperShift, assuming it's not")
+			i.isBareMetalHypershift = false // Assume not bare metal HyperShift on error
+		}
 	}
 
 	if len(i.payloadImagePullSpec) == 0 {
@@ -392,15 +453,9 @@ func (i *InvariantInClusterDisruption) StartCollection(ctx context.Context, admi
 	var apiIntHost string
 	var apiIntPort string
 	if i.isHypershift {
-		parsedURL, err := url.Parse(i.adminRESTConfig.Host)
+		apiIntHost, apiIntPort, err = i.parseAdminRESTConfigHost()
 		if err != nil {
-			return fmt.Errorf("failed to parse adminRESTConfig.Host %q: %v", i.adminRESTConfig.Host, err)
-		}
-		apiIntHost = parsedURL.Hostname()
-		if parsedURL.Port() != "" {
-			apiIntPort = parsedURL.Port()
-		} else {
-			apiIntPort = "6443" // default port
+			return fmt.Errorf("failed to parse adminRESTConfig.Host: %v", err)
 		}
 	} else {
 		internalAPI, err := url.Parse(infra.Status.APIServerInternalURL)

test/extended/util/managed_services.go

@@ -2,6 +2,8 @@ package util
 
 import (
 	"context"
+	"fmt"
+	"strings"
 
 	"github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -95,3 +97,39 @@ func IsAroHCP(ctx context.Context, namespace string, kubeClient kubernetes.Inter
 	logrus.Infof("No deployment found with control-plane-operator container in namespace %s", namespace)
 	return false, nil
 }
+
+// IsBareMetalHyperShiftCluster checks if the HyperShift cluster is running on bare metal
+// by checking the platform type of the hosted cluster. It uses kubectl commands to query
+// the hosted cluster's platform type and returns true if it's "None" or "Agent".
+func IsBareMetalHyperShiftCluster(ctx context.Context, managementOC *CLI) (bool, error) {
+	// Get the hosted cluster namespace
+	_, hcpNamespace, err := GetHypershiftManagementClusterConfigAndNamespace()
+	if err != nil {
+		return false, fmt.Errorf("failed to get hypershift management cluster config and namespace: %v", err)
+	}
+
+	// Get the first hosted cluster name
+	clusterNames, err := managementOC.AsAdmin().WithoutNamespace().Run("get").Args(
+		"-n", hcpNamespace, "hostedclusters", "-o=jsonpath={.items[*].metadata.name}").Output()
+	if err != nil {
+		return false, fmt.Errorf("failed to get hosted cluster names: %v", err)
+	}
+	
+	if len(clusterNames) == 0 {
+		return false, fmt.Errorf("no hosted clusters found")
+	}
+
+	// Get the first hosted cluster name
+	clusterName := strings.Split(strings.TrimSpace(clusterNames), " ")[0]
+	
+	// Get the platform type of the hosted cluster
+	platformType, err := managementOC.AsAdmin().WithoutNamespace().Run("get").Args(
+		"hostedcluster", clusterName, "-n", hcpNamespace, `-ojsonpath={.spec.platform.type}`).Output()
+	if err != nil {
+		return false, fmt.Errorf("failed to get hosted cluster platform type: %v", err)
+	}
+
+	// Check if it's bare metal (None or Agent platform)
+	platformTypeStr := strings.TrimSpace(platformType)
+	return platformTypeStr == "None" || platformTypeStr == "Agent", nil
+}