MGMT-15425: Change chosen mce release to match openshift version (#5716)

Makefile

@@ -141,6 +141,7 @@ REPORTS ?= $(ROOT_DIR)/reports
 GO_TEST_FORMAT = pkgname
 DEFAULT_RELEASE_IMAGES = $(shell (tr -d '\n\t ' < ${ROOT_DIR}/data/default_release_images.json))
 DEFAULT_OS_IMAGES = $(shell (tr -d '\n\t ' < ${ROOT_DIR}/data/default_os_images.json))
+DEFAULT_OCP_MCE_VERSION_MAP = $(shell (tr -d '\n\t ' < ${ROOT_DIR}/data/default_ocp_mce_version_map.json))
 
 # Support all Release/OS images for CI
 ifeq ($(CI), true)
@@ -149,6 +150,7 @@ endif
 
 RELEASE_IMAGES := $(or ${RELEASE_IMAGES},${DEFAULT_RELEASE_IMAGES})
 OS_IMAGES := $(or ${OS_IMAGES},${DEFAULT_OS_IMAGES})
+OCP_MCE_VERSION_MAP := $(or ${OCP_MCE_VERSION_MAP},${DEFAULT_OCP_MCE_VERSION_MAP})
 
 # Support given Release/OS images.
 ifdef OPENSHIFT_VERSION
@@ -323,7 +325,7 @@ deploy-service-requirements: | deploy-namespace deploy-inventory-service-file
 		--disk-encryption-support $(DISK_ENCRYPTION_SUPPORT) --hw-requirements '$(subst ",\",$(HW_REQUIREMENTS))' \
 		--disabled-host-validations "$(DISABLED_HOST_VALIDATIONS)" --disabled-steps "$(DISABLED_STEPS)" \
 		--enable-org-tenancy $(ENABLE_ORG_TENANCY) --enable-org-based-feature-gate $(ENABLE_ORG_BASED_FEATURE_GATES) \
-		$(ALLOW_CONVERGED_FLOW_CMD) $(DISABLE_TLS_CMD)
+		--ocp-mce-version-map '$(subst ",\",$(OCP_MCE_VERSION_MAP))' $(ALLOW_CONVERGED_FLOW_CMD) $(DISABLE_TLS_CMD)
 ifeq ($(MIRROR_REGISTRY_SUPPORT), True)
 	python3 ./tools/deploy_assisted_installer_configmap_registry_ca.py  --target "$(TARGET)" \
 		--namespace "$(NAMESPACE)"  --apply-manifest $(APPLY_MANIFEST) --ca-file-path $(MIRROR_REG_CA_FILE) --registries-file-path $(REGISTRIES_FILE_PATH)

data/default_ocp_mce_version_map.json

@@ -0,0 +1,7 @@
+[
+    {"openshift_version": "4.11", "mce_channel": "stable-2.3"},
+    {"openshift_version": "4.12", "mce_channel": "stable-2.4"},
+    {"openshift_version": "4.13", "mce_channel": "stable-2.4"},
+    {"openshift_version": "4.14", "mce_channel": "stable-2.4"},
+    {"openshift_version": "4.15", "mce_channel": "stable-2.4"}
+]

deploy/assisted-service-configmap.yaml

@@ -26,3 +26,5 @@ data:
   DISABLED_HOST_VALIDATIONS: REPLACE_DISABLED_HOST_VALIDATIONS
   DISABLED_STEPS: REPLACE_DISABLED_STEPS
   ISO_IMAGE_TYPE: REPLACE_ISO_IMAGE_TYPE
+  OCP_MCE_VERSION_MAP: REPLACE_OCP_MCE_VERSION_MAP
+

deploy/podman/configmap.yml

@@ -30,3 +30,4 @@ data:
   SERVICE_BASE_URL: http://127.0.0.1:8090
   STORAGE: filesystem
   ENABLE_UPGRADE_AGENT: "true"
+  OCP_MCE_VERSION_MAP: '[{"openshift_version": "4.11", "mce_channel": "stable-2.3"}, {"openshift_version": "4.12", "mce_channel": "stable-2.4"}, {"openshift_version": "4.13", "mce_channel": "stable-2.3"}, {"openshift_version": "4.14", "mce_channel": "stable-2.4"}, {"openshift_version": "4.15", "mce_channel": "stable-2.4"}]'

internal/common/common_test.go

@@ -230,7 +230,7 @@ var _ = Describe("get hosts by role", func() {
 	})
 })
 
-var _ = Describe("compare OCP 4.10 versions", func() {
+var _ = Describe("compare OCP versions", func() {
 	It("GA release", func() {
 		is410Version, _ := VersionGreaterOrEqual("4.10.0", "4.10.0-0.alpha")
 		Expect(is410Version).Should(BeTrue())
@@ -289,6 +289,37 @@ var _ = Describe("compare OCP 4.10 versions", func() {
 	})
 })
 
+var _ = Describe("Get Major.Minor version", func() {
+	It("GA release", func() {
+		majorMinorVersion, err := GetMajorMinorVersion("4.10.0")
+		Expect(*majorMinorVersion).To(Equal("4.10"))
+		Expect(err).ToNot(HaveOccurred())
+	})
+	It("pre-release", func() {
+		majorMinorVersion, err := GetMajorMinorVersion("4.11.0-0.alpha")
+		Expect(*majorMinorVersion).To(Equal("4.11"))
+		Expect(err).ToNot(HaveOccurred())
+	})
+	It("nightly release", func() {
+		majorMinorVersion, err := GetMajorMinorVersion("4.12.0-0.nightly-2022-01-23-013716")
+		Expect(*majorMinorVersion).To(Equal("4.12"))
+		Expect(err).ToNot(HaveOccurred())
+	})
+	It("major minor release", func() {
+		majorMinorVersion, err := GetMajorMinorVersion("4.13")
+		Expect(*majorMinorVersion).To(Equal("4.13"))
+		Expect(err).ToNot(HaveOccurred())
+	})
+	It("empty versions", func() {
+		_, err := GetMajorMinorVersion("")
+		Expect(err).To(HaveOccurred())
+	})
+	It("small version", func() {
+		_, err := GetMajorMinorVersion("4")
+		Expect(err).To(HaveOccurred())
+	})
+})
+
 var _ = Describe("Test AreMastersSchedulable", func() {
 	Context("for every combination of schedulableMastersForcedTrue and schedulableMasters", func() {
 		for _, test := range []struct {

internal/common/version.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"errors"
+	"fmt"
 	"strings"
 
 	"github.com/hashicorp/go-version"
@@ -27,6 +28,7 @@ func VersionGreaterOrEqual(version1, version2 string) (bool, error) {
 	return v1.GreaterThanOrEqual(v2), nil
 }
 
+// BaseVersionGreaterOrEqual compare Major, Minor and Patch
 func BaseVersionGreaterOrEqual(version, versionMayGreaterThan string) (bool, error) {
 	// return version >= versionMayGreaterThan
 	version = strings.Split(version, "-")[0]
@@ -36,24 +38,35 @@ func BaseVersionGreaterOrEqual(version, versionMayGreaterThan string) (bool, err
 }
 
 func BaseVersionLessThan(version, versionMayLessThan string) (bool, error) {
-	isGraterOrEqual, err := BaseVersionGreaterOrEqual(version, versionMayLessThan)
+	isGreaterOrEqual, err := BaseVersionGreaterOrEqual(version, versionMayLessThan)
 	if err != nil {
 		return false, err
 	}
-	return !isGraterOrEqual, nil
+	return !isGreaterOrEqual, nil
 }
 
 // BaseVersionEqual Compare Major and Minor of 2 different versions
 func BaseVersionEqual(version1, versionMayEqual string) (bool, error) {
-	version1 = strings.Split(version1, "-")[0]
-	versionMayEqual = strings.Split(versionMayEqual, "-")[0]
+	majorMinorVersion1, err := GetMajorMinorVersion(version1)
+	if err != nil {
+		return false, err
+	}
+	majorMinorVersionMayEqual, err := GetMajorMinorVersion(versionMayEqual)
+	if err != nil {
+		return false, err
+	}
+
+	return *majorMinorVersion1 == *majorMinorVersionMayEqual, nil
+}
 
-	v1 := strings.Split(version1, ".")
-	v2 := strings.Split(versionMayEqual, ".")
+func GetMajorMinorVersion(version string) (*string, error) {
+	version = strings.Split(version, "-")[0]
+	splittedVersion := strings.Split(version, ".")
 
-	if len(v1) < 2 || len(v2) < 2 {
-		return false, errors.New("invalid version")
+	if len(splittedVersion) < 2 {
+		return nil, errors.New("invalid version")
 	}
 
-	return v1[0] == v2[0] && v1[1] == v2[1], nil
+	versionStr := fmt.Sprintf("%s.%s", splittedVersion[0], splittedVersion[1])
+	return &versionStr, nil
 }

internal/operators/builder.go

@@ -29,11 +29,12 @@ var OperatorConsole = models.MonitoredOperator{
 type Options struct {
 	CheckClusterVersion bool
 	CNVConfig           cnv.Config
+	MCEConfig           mce.EnvironmentalConfig
 }
 
 // NewManager creates new instance of an Operator Manager
 func NewManager(log logrus.FieldLogger, manifestAPI manifestsapi.ManifestsAPI, options Options, objectHandler s3wrapper.API, extracter oc.Extracter) *Manager {
-	return NewManagerWithOperators(log, manifestAPI, options, objectHandler, lso.NewLSOperator(), odf.NewOcsOperator(log), odf.NewOdfOperator(log, extracter), cnv.NewCNVOperator(log, options.CNVConfig, extracter), lvm.NewLvmOperator(log, extracter), mce.NewMceOperator(log))
+	return NewManagerWithOperators(log, manifestAPI, options, objectHandler, lso.NewLSOperator(), odf.NewOcsOperator(log), odf.NewOdfOperator(log, extracter), cnv.NewCNVOperator(log, options.CNVConfig, extracter), lvm.NewLvmOperator(log, extracter), mce.NewMceOperator(log, options.MCEConfig))
 }
 
 // NewManagerWithOperators creates new instance of an Operator Manager and configures it with given operators

internal/operators/manager_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/openshift/assisted-service/internal/operators/api"
 	"github.com/openshift/assisted-service/internal/operators/cnv"
 	"github.com/openshift/assisted-service/internal/operators/lso"
+	"github.com/openshift/assisted-service/internal/operators/mce"
 	"github.com/openshift/assisted-service/internal/operators/odf"
 	"github.com/openshift/assisted-service/models"
 	"github.com/openshift/assisted-service/pkg/conversions"
@@ -43,7 +44,7 @@ var _ = BeforeEach(func() {
 	cluster = &common.Cluster{
 		Cluster: models.Cluster{
 			ID:               &clusterID,
-			OpenshiftVersion: "4.8.1",
+			OpenshiftVersion: "4.14.0",
 		},
 	}
 	cluster.ImageInfo = &models.ImageInfo{}
@@ -59,7 +60,8 @@ var _ = BeforeEach(func() {
 	ctrl = gomock.NewController(GinkgoT())
 	manifestsAPI = manifestsapi.NewMockManifestsAPI(ctrl)
 	mockS3Api = s3wrapper.NewMockAPI(ctrl)
-	manager = operators.NewManager(log, manifestsAPI, operators.Options{}, mockS3Api, nil)
+	defaultocpMceVersionMap := "[{\"openshift_version\": \"4.10\", \"mce_channel\": \"stable-2.3\"}, {\"openshift_version\": \"4.11\", \"mce_channel\": \"stable-2.3\"}, {\"openshift_version\": \"4.12\", \"mce_channel\": \"stable-2.4\"}, {\"openshift_version\": \"4.13\", \"mce_channel\": \"stable-2.4\"}, {\"openshift_version\": \"4.14\", \"mce_channel\": \"stable-2.4\"}, {\"openshift_version\": \"4.15\", \"mce_channel\": \"stable-2.4\"}]"
+	manager = operators.NewManager(log, manifestsAPI, operators.Options{MCEConfig: mce.EnvironmentalConfig{OCPMCEVersionMap: defaultocpMceVersionMap}}, mockS3Api, nil)
 })
 
 var _ = AfterEach(func() {

internal/operators/mce/config.go

@@ -1,9 +1,27 @@
 package mce
 
-const (
-	MceMinOpenshiftVersion string = "4.10.0"
-	MceChannel             string = "stable-2.3"
+import (
+	_ "embed"
+	"encoding/json"
+	"fmt"
+
+	"github.com/openshift/assisted-service/internal/common"
+)
 
+type EnvironmentalConfig struct {
+	OCPMCEVersionMap string `envconfig:"OCP_MCE_VERSION_MAP" default:"[{\"openshift_version\": \"4.11\", \"mce_channel\": \"stable-2.3\"}, {\"openshift_version\": \"4.12\", \"mce_channel\": \"stable-2.4\"}, {\"openshift_version\": \"4.14\", \"mce_channel\": \"stable-2.4\"}, {\"openshift_version\": \"4.14\", \"mce_channel\": \"stable-2.4\"}, {\"openshift_version\": \"4.15\", \"mce_channel\": \"stable-2.4\"}]"`
+}
+
+type OcpMceVersionMap struct {
+	OpenshiftVersion string `json:"openshift_version"`
+	MceChannel       string `json:"mce_channel"`
+}
+
+type Config struct {
+	OcpMceVersionMap []OcpMceVersionMap
+}
+
+const (
 	// Memory value provided in GiB
 	MinimumMemory int64 = 16
 	MinimumCPU    int64 = 4
@@ -13,6 +31,48 @@ const (
 	SNOMinimumCpu    int64 = 8
 )
 
-type Config struct {
-	MceMinOpenshiftVersion string `envconfig:"MCE_MIN_OPENSHIFT_VERSION" default:"4.10.0"`
+func getMinMceOpenshiftVersion(ocpMceVersionMap []OcpMceVersionMap) (*string, error) {
+	lowestVersion := ocpMceVersionMap[0].OpenshiftVersion
+	for _, version := range ocpMceVersionMap {
+		isLower, err := common.BaseVersionLessThan(lowestVersion, version.OpenshiftVersion)
+		if err != nil {
+			return nil, err
+		}
+		if isLower {
+			lowestVersion = version.OpenshiftVersion
+		}
+	}
+
+	return &lowestVersion, nil
+}
+
+func parseMCEConfig(config EnvironmentalConfig) (*Config, error) {
+	var parsedConfig []OcpMceVersionMap
+	if err := json.Unmarshal([]byte(config.OCPMCEVersionMap), &parsedConfig); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal ocp mce release config: %w", err)
+	}
+
+	return &Config{
+		OcpMceVersionMap: parsedConfig,
+	}, nil
+}
+
+func getMCEVersion(openshiftVersion string, ocpMceVersionMap []OcpMceVersionMap) (*string, error) {
+	baseVersion, err := common.GetMajorMinorVersion(openshiftVersion)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get base version of %s", openshiftVersion)
+	}
+
+	var mceChannel string
+	for _, record := range ocpMceVersionMap {
+		if record.OpenshiftVersion == *baseVersion {
+			mceChannel = record.MceChannel
+		}
+	}
+
+	if mceChannel == "" {
+		return nil, fmt.Errorf("failed to find mce channel for the given openshift version %s", openshiftVersion)
+	}
+
+	return &mceChannel, nil
 }

internal/operators/mce/manifest.go

@@ -6,7 +6,7 @@ import (
 )
 
 // Manifests returns manifests needed to deploy MCE.
-func Manifests() (openshiftManifests map[string][]byte, customManifests []byte, err error) {
+func Manifests(openshiftVersion string, config *Config) (openshiftManifests map[string][]byte, customManifests []byte, err error) {
 	// Generate the OpenShift manifests:
 	namespaceManifest, err := getNamespace()
 	if err != nil {
@@ -16,7 +16,7 @@ func Manifests() (openshiftManifests map[string][]byte, customManifests []byte,
 	if err != nil {
 		return
 	}
-	operatorSubscriptionManifest, err := getSubscription()
+	operatorSubscriptionManifest, err := getSubscription(openshiftVersion, config)
 	if err != nil {
 		return
 	}
@@ -34,11 +34,16 @@ func Manifests() (openshiftManifests map[string][]byte, customManifests []byte,
 	return openshiftManifests, mceManifest, nil
 }
 
-func getSubscription() ([]byte, error) {
+func getSubscription(openshiftVersion string, config *Config) ([]byte, error) {
+	mceChannel, err := getMCEVersion(openshiftVersion, config.OcpMceVersionMap)
+	if err != nil {
+		return nil, err
+	}
+
 	data := map[string]string{
 		"OPERATOR_NAMESPACE":            Operator.Namespace,
 		"OPERATOR_SUBSCRIPTION_NAME":    Operator.SubscriptionName,
-		"OPERATOR_SUBSCRIPTION_CHANNEL": MceChannel,
+		"OPERATOR_SUBSCRIPTION_CHANNEL": *mceChannel,
 	}
 	return executeTemplate(data, operatorSubscriptionManifestTemplate)
 }

internal/operators/mce/manifest_test.go

@@ -9,7 +9,33 @@ import (
 )
 
 var _ = Describe("MCE manifest generation", func() {
-	operator := NewMceOperator(common.GetTestLog())
+
+	config := Config{
+		OcpMceVersionMap: []OcpMceVersionMap{
+			{
+				OpenshiftVersion: "4.11",
+				MceChannel:       "stable-2.3",
+			},
+			{
+				OpenshiftVersion: "4.12",
+				MceChannel:       "stable-2.4",
+			},
+			{
+				OpenshiftVersion: "4.13",
+				MceChannel:       "stable-2.4",
+			},
+			{
+				OpenshiftVersion: "4.14",
+				MceChannel:       "stable-2.4",
+			},
+			{
+				OpenshiftVersion: "4.15",
+				MceChannel:       "stable-2.4",
+			},
+		},
+	}
+
+	operator := NewMceOperator(common.GetTestLog(), EnvironmentalConfig{})
 	var cluster *common.Cluster
 
 	getCluster := func(openshiftVersion string) *common.Cluster {
@@ -20,8 +46,46 @@ var _ = Describe("MCE manifest generation", func() {
 	}
 
 	Context("MCE Manifest", func() {
+		It("Get MCE channel", func() {
+			var (
+				version *string
+				err     error
+			)
+
+			version, err = getMCEVersion("4.15", config.OcpMceVersionMap)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(*version).To(Equal("stable-2.4"))
+
+			version, err = getMCEVersion("4.14", config.OcpMceVersionMap)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(*version).To(Equal("stable-2.4"))
+
+			version, err = getMCEVersion("4.13", config.OcpMceVersionMap)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(*version).To(Equal("stable-2.4"))
+
+			version, err = getMCEVersion("4.12", config.OcpMceVersionMap)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(*version).To(Equal("stable-2.4"))
+
+			version, err = getMCEVersion("4.11", config.OcpMceVersionMap)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(*version).To(Equal("stable-2.3"))
+
+			_, err = getMCEVersion("4.10", config.OcpMceVersionMap)
+			Expect(err).To(HaveOccurred())
+
+			version, err = getMCEVersion("4.12.0-0.nightly-2022-10-25-210451", config.OcpMceVersionMap)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(*version).To(Equal("stable-2.4"))
+
+			version, err = getMCEVersion("4.11.0-ec.3", config.OcpMceVersionMap)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(*version).To(Equal("stable-2.3"))
+		})
+
 		It("Check YAMLs of MCE", func() {
-			cluster = getCluster("4.10.17")
+			cluster = getCluster("4.11.0")
 			openshiftManifests, manifest, err := operator.GenerateManifests(cluster)
 
 			Expect(err).ShouldNot(HaveOccurred())