TRT-2134: Inform compatible extensions of enabled feature gates and API groups (#29837)

* Inform compatible extensions of enabled feature gates and API groups

* Skip featuregate detection on Microshift

Author: stbenjam

pkg/test/extensions/binary.go

@@ -106,7 +106,7 @@ func (b *TestBinary) ListTests(ctx context.Context, envFlags EnvironmentFlags) (
 	binLogger.Infof("OTE API version is: %s", b.info.APIVersion)
 	envFlags = b.filterToApplicableEnvironmentFlags(envFlags)
 	command := exec.Command(b.binaryPath, "list", "-o", "jsonl")
-	binLogger.Infof("adding the following applicable flags to the list command: %s", envFlags.String())
+	binLogger.Infof("Adding the following applicable flags to the list command: %s", envFlags.String())
 	command.Args = append(command.Args, envFlags.ArgStrings()...)
 	testList, err := runWithTimeout(ctx, command, 10*time.Minute)
 	if err != nil {

pkg/test/extensions/types.go

@@ -5,9 +5,9 @@ import (
 	"strings"
 	"time"
 
-	"k8s.io/apimachinery/pkg/util/sets"
-
 	configv1 "github.com/openshift/api/config/v1"
+	"github.com/sirupsen/logrus"
+	"k8s.io/apimachinery/pkg/util/sets"
 )
 
 // ExtensionInfo represents an extension to openshift-tests.
@@ -199,12 +199,27 @@ const (
 	optionalCapability   EnvironmentFlagName = "optional-capability"
 	fact                 EnvironmentFlagName = "fact"
 	version              EnvironmentFlagName = "version"
+	featureGate          EnvironmentFlagName = "feature-gate"
+	apiGroup             EnvironmentFlagName = "api-group"
 )
 
 type EnvironmentFlagsBuilder struct {
 	flags EnvironmentFlags
 }
 
+func (e *EnvironmentFlagsBuilder) AddAPIGroups(values ...string) *EnvironmentFlagsBuilder {
+	for _, value := range values {
+		e.flags = append(e.flags, newEnvironmentFlag(apiGroup, value))
+	}
+	return e
+}
+
+func (e *EnvironmentFlagsBuilder) AddFeatureGates(values ...string) *EnvironmentFlagsBuilder {
+	for _, value := range values {
+		e.flags = append(e.flags, newEnvironmentFlag(featureGate, value))
+	}
+	return e
+}
 func (e *EnvironmentFlagsBuilder) AddPlatform(value string) *EnvironmentFlagsBuilder {
 	e.flags = append(e.flags, newEnvironmentFlag(platform, value))
 	return e
@@ -290,11 +305,28 @@ func (ef EnvironmentFlags) ArgStrings() []string {
 }
 
 func (ef EnvironmentFlags) String() string {
-	return strings.Join(ef.ArgStrings(), ", ")
+	return strings.Join(ef.ArgStrings(), " ")
+}
+
+func (ef EnvironmentFlags) LogFields() logrus.Fields {
+	fields := logrus.Fields{}
+
+	for _, flag := range ef {
+		name := string(flag.Name)
+		if val, ok := fields[name]; ok {
+			fields[name] = append(val.([]string), flag.Value)
+		} else {
+			fields[name] = []string{flag.Value}
+		}
+	}
+
+	return fields
 }
 
 // EnvironmentFlagVersions holds the "Since" version metadata for each flag.
 var EnvironmentFlagVersions = map[EnvironmentFlagName]string{
+	featureGate:          "v1.1",
+	apiGroup:             "v1.1",
 	platform:             "v1.0",
 	network:              "v1.0",
 	networkStack:         "v1.0",

pkg/test/ginkgo/cmd_runsuite.go

@@ -19,9 +19,12 @@ import (
 
 	"github.com/onsi/ginkgo/v2"
 	configv1 "github.com/openshift/api/config/v1"
+	clientconfigv1 "github.com/openshift/client-go/config/clientset/versioned"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 	"golang.org/x/mod/semver"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 	"k8s.io/client-go/discovery"
@@ -30,6 +33,7 @@ import (
 
 	"github.com/openshift/origin/pkg/clioptions/clusterdiscovery"
 	"github.com/openshift/origin/pkg/clioptions/clusterinfo"
+	"github.com/openshift/origin/pkg/clioptions/kubeconfig"
 	"github.com/openshift/origin/pkg/defaultmonitortests"
 	"github.com/openshift/origin/pkg/monitor"
 	monitorserialization "github.com/openshift/origin/pkg/monitor/serialization"
@@ -192,11 +196,11 @@ func (o *GinkgoRunSuiteOptions) Run(suite *TestSuite, junitSuiteName string, mon
 		listContext, listContextCancel := context.WithTimeout(context.Background(), 10*time.Minute)
 		defer listContextCancel()
 
-		envFlags, err := determineEnvironmentFlags(upgrade, o.DryRun)
+		envFlags, err := determineEnvironmentFlags(ctx, upgrade, o.DryRun)
 		if err != nil {
 			return fmt.Errorf("could not determine environment flags: %w", err)
 		}
-		logrus.WithField("flags", envFlags.String()).Infof("Determined all potential environment flags")
+		logrus.WithFields(envFlags.LogFields()).Infof("Determined all potential environment flags")
 
 		externalTestSpecs, err := externalBinaries.ListTests(listContext, defaultBinaryParallelism, envFlags)
 		if err != nil {
@@ -753,13 +757,13 @@ outerLoop:
 	return matches, nil
 }
 
-func determineEnvironmentFlags(upgrade bool, dryRun bool) (extensions.EnvironmentFlags, error) {
-	clientConfig, err := e2e.LoadConfig(true)
+func determineEnvironmentFlags(ctx context.Context, upgrade bool, dryRun bool) (extensions.EnvironmentFlags, error) {
+	restConfig, err := e2e.LoadConfig(true)
 	if err != nil {
 		logrus.WithError(err).Error("error calling e2e.LoadConfig")
 		return nil, err
 	}
-	clusterState, err := clusterdiscovery.DiscoverClusterState(clientConfig)
+	clusterState, err := clusterdiscovery.DiscoverClusterState(restConfig)
 	if err != nil {
 		logrus.WithError(err).Warn("error Discovering Cluster State, flags requiring it will not be present")
 	}
@@ -780,6 +784,29 @@ func determineEnvironmentFlags(upgrade bool, dryRun bool) (extensions.Environmen
 		AddNetworkStack(config.IPFamily).
 		AddExternalConnectivity(determineExternalConnectivity(config))
 
+	clientConfig, err := clientconfigv1.NewForConfig(restConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	discoveryClient, err := kubeconfig.NewDiscoveryGetter(restConfig).GetDiscoveryClient()
+	if err != nil {
+		return nil, err
+	}
+	apiGroups, err := determineEnabledAPIGroups(discoveryClient)
+	if err != nil {
+		return nil, errors.WithMessage(err, "couldn't determine api groups")
+	}
+	envFlagBuilder.AddAPIGroups(apiGroups.UnsortedList()...)
+
+	if apiGroups.Has("config.openshift.io") {
+		featureGates, err := determineEnabledFeatureGates(ctx, clientConfig)
+		if err != nil {
+			return nil, errors.WithMessage(err, "couldn't determine feature gates")
+		}
+		envFlagBuilder.AddFeatureGates(featureGates...)
+	}
+
 	//Additional flags can only be determined if we are able to obtain the clusterState
 	if clusterState != nil {
 		upgradeType := "None"
@@ -836,3 +863,55 @@ func determineExternalConnectivity(clusterConfig *clusterdiscovery.ClusterConfig
 	}
 	return "Direct"
 }
+
+func determineEnabledAPIGroups(discoveryClient discovery.AggregatedDiscoveryInterface) (sets.Set[string], error) {
+	groups, err := discoveryClient.ServerGroups()
+	if err != nil {
+		return nil, fmt.Errorf("unable to retrieve served resources: %v", err)
+	}
+	apiGroups := sets.New[string]()
+	for _, apiGroup := range groups.Groups {
+		// ignore the empty group
+		if apiGroup.Name == "" {
+			continue
+		}
+		apiGroups.Insert(apiGroup.Name)
+	}
+
+	return apiGroups, nil
+}
+
+func determineEnabledFeatureGates(ctx context.Context, configClient clientconfigv1.Interface) ([]string, error) {
+	featureGate, err := configClient.ConfigV1().FeatureGates().Get(ctx, "cluster", metav1.GetOptions{})
+	if err != nil {
+		return nil, err
+	}
+	clusterVersion, err := configClient.ConfigV1().ClusterVersions().Get(ctx, "version", metav1.GetOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	desiredVersion := clusterVersion.Status.Desired.Version
+	if len(desiredVersion) == 0 && len(clusterVersion.Status.History) > 0 {
+		desiredVersion = clusterVersion.Status.History[0].Version
+	}
+
+	ret := sets.NewString()
+	found := false
+	for _, featureGateValues := range featureGate.Status.FeatureGates {
+		if featureGateValues.Version != desiredVersion {
+			continue
+		}
+		found = true
+		for _, enabled := range featureGateValues.Enabled {
+			ret.Insert(string(enabled.Name))
+		}
+		break
+	}
+	if !found {
+		logrus.Warning("no feature gates found")
+		return nil, nil
+	}
+
+	return ret.List(), nil
+}