Initial commit

rh-pre-commit.version: 2.3.2
rh-pre-commit.check-secrets: ENABLED

Author: bradmwilliams

Makefile

@@ -14,6 +14,8 @@ version=v${build_date}-${git_commit}
 
 SOURCE_GIT_TAG=v1.0.0+$(shell git rev-parse --short=7 HEAD)
 
+GOLINT=golangci-lint
+
 GO_LD_EXTRAFLAGS=-X github.com/openshift/release-controller/vendor/k8s.io/client-go/pkg/version.gitCommit=$(shell git rev-parse HEAD) -X github.com/openshift/release-controller/vendor/k8s.io/client-go/pkg/version.gitVersion=${SOURCE_GIT_TAG} -X k8s.io/test-infra/prow/version.Name=release-controller -X k8s.io/test-infra/prow/version.Version=${version}
 GO_TEST_FLAGS=
 export CGO_ENABLED := 0
@@ -34,6 +36,15 @@ sonar-reports:
 	golangci-lint run ./... --verbose --no-config --out-format checkstyle --issues-exit-code 0 > golangci-lint.out
 .PHONY: sonar-reports
 
+lint:
+	@echo "Running linter..."
+	@if command -v $(GOLINT) >/dev/null 2>&1; then \
+		$(GOLINT) run ./$(BINARY_PATH)/...; \
+	else \
+		echo "golangci-lint not installed. Install with: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest"; \
+	fi
+.PHONY: lint
+
 # Legacy targets
 image:
 	imagebuilder -t openshift/release-controller:latest .

cmd/release-controller/config_validate.go

@@ -9,12 +9,22 @@ import (
 	"time"
 
 	releasecontroller "github.com/openshift/release-controller/pkg/release-controller"
-
+	"github.com/openshift/release-controller/pkg/releasequalifiers"
 	"gopkg.in/robfig/cron.v2"
+	"gopkg.in/yaml.v2"
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
 )
 
-func validateConfigs(configDir string) error {
+func validateConfigs(options *options) error {
+	errors := []error{}
+	errors = append(errors, validateReleaseConfigs(options.validateConfigs))
+	if len(options.ReleaseQualifiersConfigPath) > 0 {
+		errors = append(errors, validateReleaseQualifiersConfig(options.ReleaseQualifiersConfigPath)...)
+	}
+	return utilerrors.NewAggregate(errors)
+}
+
+func validateReleaseConfigs(configDir string) error {
 	errors := []error{}
 	releaseConfigs := []releasecontroller.ReleaseConfig{}
 	err := filepath.Walk(configDir, func(path string, info os.FileInfo, err error) error {
@@ -37,8 +47,10 @@ func validateConfigs(configDir string) error {
 	if err != nil {
 		return fmt.Errorf("error encountered while trying to read config files: %w", err)
 	}
+	errors = append(errors, validateUpgradeJobs(releaseConfigs)...)
 	errors = append(errors, verifyPeriodicFields(releaseConfigs)...)
 	errors = append(errors, findDuplicatePeriodics(releaseConfigs)...)
+	errors = append(errors, validateQualifiers(releaseConfigs)...)
 	return utilerrors.NewAggregate(errors)
 }
 
@@ -105,3 +117,46 @@ func findDuplicatePeriodics(releaseConfigs []releasecontroller.ReleaseConfig) []
 	}
 	return duplicates
 }
+
+// validateQualifiers validates the contents of releasequalifiers.ReleaseQualifiers defined in releasecontroller.ReleaseConfig
+func validateQualifiers(releaseConfigs []releasecontroller.ReleaseConfig) []error {
+	errors := []error{}
+	for _, config := range releaseConfigs {
+		for verificationName, verification := range config.Verify {
+			for qualifierId, overrides := range verification.Qualifiers {
+				if err := validateQualifier(qualifierId, overrides); err != nil {
+					errors = append(errors, fmt.Errorf("unable to validate %q release qualifier %s: %v", verificationName, qualifierId, err))
+				}
+			}
+		}
+	}
+	return errors
+}
+
+// validateReleaseQualifiersConfig validates the contents of the file located at options.ReleaseQualifiersConfigPath
+func validateReleaseQualifiersConfig(configPath string) []error {
+	errors := []error{}
+	raw, err := os.ReadFile(configPath)
+	if err != nil {
+		return errors
+	}
+	config := releasecontroller.ReleaseQualifiersConfig{}
+	dec := yaml.NewDecoder(bytes.NewReader(raw))
+	dec.SetStrict(true)
+	if err = dec.Decode(&config); err != nil {
+		errors = append(errors, fmt.Errorf("failed to unmarshal release qualifier configuration file %s: %v", configPath, err))
+		return errors
+	}
+	for qualifierId, overrides := range config.Qualifiers {
+		errors = append(errors, validateQualifier(qualifierId, overrides))
+	}
+	return errors
+}
+
+func validateQualifier(name releasequalifiers.QualifierId, qualifier releasequalifiers.ReleaseQualifier) error {
+	err := qualifier.Validate()
+	if err != nil {
+		return fmt.Errorf("unable to validate qualifier %s: %v", name, err)
+	}
+	return nil
+}

cmd/release-controller/config_validate_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	releasecontroller "github.com/openshift/release-controller/pkg/release-controller"
-
+	"github.com/openshift/release-controller/pkg/releasequalifiers"
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
 )
 
@@ -356,3 +356,102 @@ func TestValidateUpgradeJobs(t *testing.T) {
 		}
 	}
 }
+
+func TestValidateQualifiersConfiguration(t *testing.T) {
+	testCases := []struct {
+		name        string
+		configs     []releasecontroller.ReleaseConfig
+		expectedErr bool
+	}{
+		{
+			name: "Good config with no qualifiers",
+			configs: []releasecontroller.ReleaseConfig{{
+				Name: "4.19.0-0.nightly",
+				Verify: map[string]releasecontroller.ReleaseVerification{
+					"osd-aws": {
+						Optional:   true,
+						MaxRetries: 2,
+						ProwJob: &releasecontroller.ProwJobVerification{
+							Name: "periodic-ci-openshift-release-master-nightly-4.19-osd-aws",
+						},
+					},
+				},
+			},
+			},
+			expectedErr: false,
+		},
+		{
+			name: "Good config with nil qualifier",
+			configs: []releasecontroller.ReleaseConfig{{
+				Name: "4.19.0-0.nightly",
+				Verify: map[string]releasecontroller.ReleaseVerification{
+					"osd-aws": {
+						Optional:   true,
+						MaxRetries: 2,
+						ProwJob: &releasecontroller.ProwJobVerification{
+							Name: "periodic-ci-openshift-release-master-nightly-4.19-osd-aws",
+						},
+						Qualifiers: releasequalifiers.ReleaseQualifiers{
+							"rosa": {},
+						},
+					},
+				},
+			},
+			},
+			expectedErr: false,
+		},
+		{
+			name: "Good config with empty qualifier",
+			configs: []releasecontroller.ReleaseConfig{{
+				Name: "4.19.0-0.nightly",
+				Verify: map[string]releasecontroller.ReleaseVerification{
+					"osd-aws": {
+						Optional:   true,
+						MaxRetries: 2,
+						ProwJob: &releasecontroller.ProwJobVerification{
+							Name: "periodic-ci-openshift-release-master-nightly-4.19-osd-aws",
+						},
+						Qualifiers: releasequalifiers.ReleaseQualifiers{
+							"rosa": {},
+						},
+					},
+				},
+			},
+			},
+			expectedErr: false,
+		},
+		{
+			name: "Good config with simple overrides",
+			configs: []releasecontroller.ReleaseConfig{{
+				Name: "4.19.0-0.nightly",
+				Verify: map[string]releasecontroller.ReleaseVerification{
+					"osd-aws": {
+						Optional:   true,
+						MaxRetries: 2,
+						ProwJob: &releasecontroller.ProwJobVerification{
+							Name: "periodic-ci-openshift-release-master-nightly-4.19-osd-aws",
+						},
+						Qualifiers: releasequalifiers.ReleaseQualifiers{
+							"hcm": {
+								Enabled:      releasequalifiers.BoolPtr(false),
+								BadgeName:    "HCM Updated",
+								Description:  "An updated description when displaying badge details",
+								PayloadBadge: releasequalifiers.PayloadBadgeNo,
+							},
+						},
+					},
+				},
+			}},
+			expectedErr: false,
+		},
+	}
+	for _, testCase := range testCases {
+		errs := validateQualifiers(testCase.configs)
+		if len(errs) > 0 && !testCase.expectedErr {
+			t.Errorf("%s: got error when error was not expected: %v", testCase.name, errs)
+		}
+		if len(errs) == 0 && testCase.expectedErr {
+			t.Errorf("%s: did not get error when error was expected", testCase.name)
+		}
+	}
+}

cmd/release-controller/controller.go

@@ -147,6 +147,8 @@ type Controller struct {
 	releasePayloadLister *releasecontroller.MultiReleasePayloadLister
 
 	manifestListMode bool
+
+	releaseQualifierConfig *releasecontroller.ReleaseQualifiersConfig
 }
 
 // NewController instantiates a Controller to manage release objects.
@@ -168,6 +170,7 @@ func NewController(
 	artSuffix string,
 	releasePayloadClient releasepayloadclient.ReleasePayloadsGetter,
 	manifestListMode bool,
+	releaseQualifierConfig *releasecontroller.ReleaseQualifiersConfig,
 ) *Controller {
 
 	// log events at v2 and send them to the server
@@ -184,16 +187,16 @@ func NewController(
 
 	c := &Controller{
 		eventRecorder: recorder,
-		queue:         workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "releases"),
-		gcQueue:       workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "gc"),
+		queue:         workqueue.NewRateLimitingQueueWithConfig(workqueue.DefaultControllerRateLimiter(), workqueue.RateLimitingQueueConfig{Name: "releases"}),
+		gcQueue:       workqueue.NewRateLimitingQueueWithConfig(workqueue.DefaultControllerRateLimiter(), workqueue.RateLimitingQueueConfig{Name: "gc"}),
 
 		// rate limit the audit queue severely
-		auditQueue: workqueue.NewNamedRateLimitingQueue(workqueue.NewMaxOfRateLimiter(
+		auditQueue: workqueue.NewRateLimitingQueueWithConfig(workqueue.NewMaxOfRateLimiter(
 			workqueue.NewItemExponentialFailureRateLimiter(5*time.Second, 2*time.Hour),
 			&workqueue.BucketRateLimiter{Limiter: rate.NewLimiter(rate.Every(5), 2)},
-		), "audit"),
+		), workqueue.RateLimitingQueueConfig{Name: "audit"}),
 
-		jiraQueue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "jira"),
+		jiraQueue: workqueue.NewRateLimitingQueueWithConfig(workqueue.DefaultControllerRateLimiter(), workqueue.RateLimitingQueueConfig{Name: "jira"}),
 
 		expectations:     newExpectations(),
 		expectationDelay: 2 * time.Second,
@@ -229,9 +232,11 @@ func NewController(
 		releasePayloadClient: releasePayloadClient,
 		releasePayloadLister: &releasecontroller.MultiReleasePayloadLister{Listers: make(map[string]v1alpha1.ReleasePayloadNamespaceLister)},
 
-		legacyResultsQueue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "legacyResults"),
+		legacyResultsQueue: workqueue.NewRateLimitingQueueWithConfig(workqueue.DefaultControllerRateLimiter(), workqueue.RateLimitingQueueConfig{Name: "legacyResults"}),
 
 		manifestListMode: manifestListMode,
+
+		releaseQualifierConfig: releaseQualifierConfig,
 	}
 
 	c.auditTracker = NewAuditTracker(c.auditQueue)

cmd/release-controller/legacy_results.go

@@ -91,7 +91,7 @@ func (c *Controller) syncLegacyResults(key queueKey) error {
 
 		// Ensure the existing state is preserved.  This is a big hammer, but it's the only way we have to guarantee that
 		// the ReleasePayload's status matches the status of the ImageStream's Annotation.
-		releasePayload := newReleasePayload(release, tag.Name, c.jobNamespace, c.prowNamespace, verificationJobs, release.Config.Upgrade, v1alpha1.PayloadVerificationDataSourceImageStream)
+		releasePayload := newReleasePayload(release, tag.Name, c.jobNamespace, c.prowNamespace, verificationJobs, release.Config.Upgrade, v1alpha1.PayloadVerificationDataSourceImageStream, c.releaseQualifierConfig)
 		setPayloadOverride(tag, releasePayload)
 
 		// Create the payload

cmd/release-controller/main.go

@@ -11,10 +11,11 @@ import (
 	"strings"
 	"time"
 
+	releasepayloadinformers "github.com/openshift/release-controller/pkg/client/informers/externalversions"
+	"github.com/openshift/release-controller/pkg/releasequalifiers"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
-
-	releasepayloadinformers "github.com/openshift/release-controller/pkg/client/informers/externalversions"
+	"gopkg.in/yaml.v2"
 
 	releasepayloadclient "github.com/openshift/release-controller/pkg/client/clientset/versioned"
 	"github.com/openshift/release-controller/pkg/jira"
@@ -112,6 +113,8 @@ type options struct {
 
 	ProcessLegacyResults bool
 	ManifestListMode     bool
+
+	ReleaseQualifiersConfigPath string
 }
 
 // Add metrics for jira verifier errors
@@ -221,6 +224,8 @@ func main() {
 	flagset.BoolVar(&opt.ProcessLegacyResults, "process-legacy-results", opt.ProcessLegacyResults, "enable the migration of imagestream based results to ReleasePayloads")
 	flagset.BoolVar(&opt.ManifestListMode, "manifest-list-mode", opt.ManifestListMode, "enable manifest list support for oc operations")
 
+	flagset.StringVar(&opt.ReleaseQualifiersConfigPath, "release-qualifiers-config-path", "", "Path to release qualifiers config file")
+
 	goFlagSet := flag.NewFlagSet("prowflags", flag.ContinueOnError)
 	opt.github.AddFlags(goFlagSet)
 	opt.jira.AddFlags(goFlagSet)
@@ -241,7 +246,7 @@ func (o *options) Run() error {
 	// report liveness on default prow health port 8081
 	health := pjutil.NewHealthOnPort(flagutil.DefaultHealthPort)
 	if o.validateConfigs != "" {
-		return validateConfigs(o.validateConfigs)
+		return validateConfigs(o)
 	}
 	tagParts := strings.Split(o.ToolsImageStreamTag, ":")
 	if len(tagParts) != 2 || len(tagParts[1]) == 0 {
@@ -391,6 +396,11 @@ func (o *options) Run() error {
 		klog.Fatal(err)
 	}
 
+	releaseQualifierConfig := releasecontroller.ReleaseQualifiersConfig{}
+	if len(o.ReleaseQualifiersConfigPath) > 0 {
+		go manageReleaseQualifierConfig(o.ReleaseQualifiersConfigPath, &releaseQualifierConfig)
+	}
+
 	c := NewController(
 		client.CoreV1(),
 		imageClient.ImageV1(),
@@ -409,6 +419,7 @@ func (o *options) Run() error {
 		o.ARTSuffix,
 		releasePayloadClient.ReleaseV1alpha1(),
 		o.ManifestListMode,
+		&releaseQualifierConfig,
 	)
 
 	if o.VerifyJira {
@@ -714,3 +725,28 @@ func setupKubeconfigWatches(o *options) error {
 
 	return nil
 }
+
+func manageReleaseQualifierConfig(path string, qualifiers *releasecontroller.ReleaseQualifiersConfig) {
+	for {
+		// To prevent the release-controller from crashlooping due to a bad config change,
+		// we will only log that the config is broken and set the qualifiers to an empty map.
+		// To prevent broken configs in the future, a presubmit should be creating for
+		// openshift/release that verifies this config.
+		var config releasecontroller.ReleaseQualifiersConfig
+		rawConfig, err := os.ReadFile(path)
+		if err != nil {
+			klog.Errorf("Failed to load release qualifier config file at %s: %v", path, err)
+		} else if err := yaml.Unmarshal(rawConfig, &config); err != nil {
+			klog.Errorf("Failed to unmarshal release qualifier config: %v", err)
+		}
+
+		qualifiers.Mutex.Lock()
+		if config.Qualifiers != nil {
+			qualifiers.Qualifiers = config.Qualifiers
+		} else {
+			qualifiers.Qualifiers = make(map[releasequalifiers.QualifierId]releasequalifiers.ReleaseQualifier)
+		}
+		qualifiers.Mutex.Unlock()
+		time.Sleep(2 * time.Minute)
+	}
+}