pkg:types: add featuregates pkg

Adds a featuregate package to allow feature gating
based on openshift/api.

This commit copies code from other repos (acknowledged
in the headers) rather than importing because the sources
are well-contained and we want to minimize imports to
pkg/types as pkg/types is intended to be imported by other
codebases and by doing this we minimize their dependencies.

This code is mostly borrowed from:
https://github.com/openshift/cluster-config-operator/blob/636a2dc303037e2561a243ae1ab5c5b953ddad04/pkg/cmd/render/render.go#L153

Author: patrickdillon

pkg/asset/manifests/featuregate.go

@@ -2,8 +2,6 @@ package manifests
 
 import (
 	"path/filepath"
-	"strconv"
-	"strings"
 
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -12,6 +10,7 @@ import (
 	configv1 "github.com/openshift/api/config/v1"
 	"github.com/openshift/installer/pkg/asset"
 	"github.com/openshift/installer/pkg/asset/installconfig"
+	"github.com/openshift/installer/pkg/types/featuregates"
 )
 
 var fgFileName = filepath.Join(openshiftManifestDir, "99_feature-gate.yaml")
@@ -62,7 +61,7 @@ func (f *FeatureGate) Generate(dependencies asset.Parents) error {
 			return errors.Errorf("custom features can only be used with the CustomNoUpgrade feature set")
 		}
 
-		customFeatures, err := generateCustomFeatures(installConfig.Config.FeatureGates)
+		customFeatures, err := featuregates.GenerateCustomFeatures(installConfig.Config.FeatureGates)
 		if err != nil {
 			return errors.Wrapf(err, "failed to generate custom features")
 		}
@@ -93,45 +92,3 @@ func (f *FeatureGate) Files() []*asset.File {
 func (f *FeatureGate) Load(ff asset.FileFetcher) (bool, error) {
 	return false, nil
 }
-
-// generateCustomFeatures generates the custom feature gates from the install config.
-func generateCustomFeatures(features []string) (*configv1.CustomFeatureGates, error) {
-	customFeatures := &configv1.CustomFeatureGates{}
-
-	for _, feature := range features {
-		featureName, enabled, err := parseCustomFeatureGate(feature)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to parse custom feature %s", feature)
-		}
-
-		if enabled {
-			customFeatures.Enabled = append(customFeatures.Enabled, featureName)
-		} else {
-			customFeatures.Disabled = append(customFeatures.Disabled, featureName)
-		}
-	}
-
-	return customFeatures, nil
-}
-
-// parseCustomFeatureGates parses the custom feature gate string into the feature name and whether it is enabled.
-// The expected format is <FeatureName>=<Enabled>.
-func parseCustomFeatureGate(rawFeature string) (configv1.FeatureGateName, bool, error) {
-	var featureName string
-	var enabled bool
-
-	featureParts := strings.Split(rawFeature, "=")
-	if len(featureParts) != 2 {
-		return "", false, errors.Errorf("feature not in expected format %s", rawFeature)
-	}
-
-	featureName = featureParts[0]
-
-	var err error
-	enabled, err = strconv.ParseBool(featureParts[1])
-	if err != nil {
-		return "", false, errors.Wrapf(err, "feature not in expected format %s, could not parse boolean value", rawFeature)
-	}
-
-	return configv1.FeatureGateName(featureName), enabled, nil
-}

pkg/types/featuregates/featuregate.go

@@ -0,0 +1,57 @@
+package featuregates
+
+// source: https://github.com/openshift/library-go/blob/c515269de16e5e239bd6e93e1f9821a976bb460b/pkg/operator/configobserver/featuregates/featuregate.go#L23-L28
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+
+	configv1 "github.com/openshift/api/config/v1"
+)
+
+// FeatureGate indicates whether a given feature is enabled or not
+// This interface is heavily influenced by k8s.io/component-base, but not exactly compatible.
+type FeatureGate interface {
+	// Enabled returns true if the key is enabled.
+	Enabled(key configv1.FeatureGateName) bool
+}
+
+type featureGate struct {
+	enabled  sets.Set[configv1.FeatureGateName]
+	disabled sets.Set[configv1.FeatureGateName]
+}
+
+// GatedInstallConfigFeature contains fields that will be used to validate
+// that required feature gates are enabled when gated install config fields
+// are used.
+// FeatureGateName: openshift/api feature gate required to enable the use of Field
+// Condition: the check which determines whether the install config field is used,
+// if Condition evaluates to True, FeatureGateName must be enabled  to pass validation.
+// Field: the gated install config field, Field is used in the error message.
+type GatedInstallConfigFeature struct {
+	FeatureGateName configv1.FeatureGateName
+	Condition       bool
+	Field           *field.Path
+}
+
+func newFeatureGate(enabled, disabled []configv1.FeatureGateName) FeatureGate {
+	return &featureGate{
+		enabled:  sets.New[configv1.FeatureGateName](enabled...),
+		disabled: sets.New[configv1.FeatureGateName](disabled...),
+	}
+}
+
+// Enabled returns true if the provided feature gate is enabled
+// in the active feature sets.
+func (f *featureGate) Enabled(key configv1.FeatureGateName) bool {
+	if f.enabled.Has(key) {
+		return true
+	}
+	if f.disabled.Has(key) {
+		return false
+	}
+
+	panic(fmt.Errorf("feature %q is not registered in FeatureGates", key))
+}

pkg/types/featuregates/featuregates.go

@@ -0,0 +1,101 @@
+package featuregates
+
+// source: https://github.com/openshift/cluster-config-operator/blob/636a2dc303037e2561a243ae1ab5c5b953ddad04/pkg/cmd/render/render.go#L153
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/pkg/errors"
+	"k8s.io/apimachinery/pkg/util/sets"
+
+	configv1 "github.com/openshift/api/config/v1"
+)
+
+func toFeatureGateNames(in []configv1.FeatureGateDescription) []configv1.FeatureGateName {
+	out := []configv1.FeatureGateName{}
+	for _, curr := range in {
+		out = append(out, curr.FeatureGateAttributes.Name)
+	}
+
+	return out
+}
+
+// completeFeatureGates identifies every known feature and ensures that is explicitly on or explicitly off.
+func completeFeatureGates(knownFeatureSets map[configv1.FeatureSet]*configv1.FeatureGateEnabledDisabled, enabled, disabled []configv1.FeatureGateName) ([]configv1.FeatureGateName, []configv1.FeatureGateName) {
+	specificallyEnabledFeatureGates := sets.New[configv1.FeatureGateName]()
+	specificallyEnabledFeatureGates.Insert(enabled...)
+
+	knownFeatureGates := sets.New[configv1.FeatureGateName]()
+	knownFeatureGates.Insert(enabled...)
+	knownFeatureGates.Insert(disabled...)
+	for _, known := range knownFeatureSets {
+		for _, curr := range known.Disabled {
+			knownFeatureGates.Insert(curr.FeatureGateAttributes.Name)
+		}
+		for _, curr := range known.Enabled {
+			knownFeatureGates.Insert(curr.FeatureGateAttributes.Name)
+		}
+	}
+
+	return enabled, knownFeatureGates.Difference(specificallyEnabledFeatureGates).UnsortedList()
+}
+
+// FeatureGateFromFeatureSets creates a FeatureGate from the active feature sets.
+func FeatureGateFromFeatureSets(knownFeatureSets map[configv1.FeatureSet]*configv1.FeatureGateEnabledDisabled, fs configv1.FeatureSet, customFS *configv1.CustomFeatureGates) (FeatureGate, error) {
+	if customFS != nil {
+		completeEnabled, completeDisabled := completeFeatureGates(knownFeatureSets, customFS.Enabled, customFS.Disabled)
+		return newFeatureGate(completeEnabled, completeDisabled), nil
+	}
+
+	featureSet, ok := knownFeatureSets[fs]
+	if !ok {
+		return nil, fmt.Errorf(".spec.featureSet %q not found", featureSet)
+	}
+
+	completeEnabled, completeDisabled := completeFeatureGates(knownFeatureSets, toFeatureGateNames(featureSet.Enabled), toFeatureGateNames(featureSet.Disabled))
+	return newFeatureGate(completeEnabled, completeDisabled), nil
+}
+
+// GenerateCustomFeatures generates the custom feature gates from the install config.
+func GenerateCustomFeatures(features []string) (*configv1.CustomFeatureGates, error) {
+	customFeatures := &configv1.CustomFeatureGates{}
+
+	for _, feature := range features {
+		featureName, enabled, err := parseCustomFeatureGate(feature)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to parse custom feature %s", feature)
+		}
+
+		if enabled {
+			customFeatures.Enabled = append(customFeatures.Enabled, featureName)
+		} else {
+			customFeatures.Disabled = append(customFeatures.Disabled, featureName)
+		}
+	}
+
+	return customFeatures, nil
+}
+
+// parseCustomFeatureGates parses the custom feature gate string into the feature name and whether it is enabled.
+// The expected format is <FeatureName>=<Enabled>.
+func parseCustomFeatureGate(rawFeature string) (configv1.FeatureGateName, bool, error) {
+	var featureName string
+	var enabled bool
+
+	featureParts := strings.Split(rawFeature, "=")
+	if len(featureParts) != 2 {
+		return "", false, errors.Errorf("feature not in expected format %s", rawFeature)
+	}
+
+	featureName = featureParts[0]
+
+	var err error
+	enabled, err = strconv.ParseBool(featureParts[1])
+	if err != nil {
+		return "", false, errors.Wrapf(err, "feature not in expected format %s, could not parse boolean value", rawFeature)
+	}
+
+	return configv1.FeatureGateName(featureName), enabled, nil
+}