mce rework

Signed-off-by: Daniel Osypenko <[email protected]>

Author: DanielOsypenko

ocs_ci/deployment/deployment.py

@@ -462,15 +462,8 @@ def do_deploy_mce(self):
 
         """
         if config.DEPLOYMENT.get("deploy_mce"):
-            if config.ENV_DATA.get("skip_mce_check_if_present"):
-                check_mce_deployed = False
-                check_mce_ready = False
-            else:
-                check_mce_deployed = True
-                check_mce_ready = True
             mce_installer = MCEInstaller()
-            mce_installer.deploy_mce(check_mce_deployed, check_mce_ready)
-            mce_installer.validate_mce_deployment()
+            mce_installer.deploy_mce()
 
     def do_deploy_oadp(self):
         """

ocs_ci/deployment/hosted_cluster.py

@@ -534,7 +534,6 @@ def deploy_dependencies(
             self.update_hcp_binary()
         if deploy_mce and not deploy_acm_hub:
             self.deploy_mce()
-            self.validate_mce_deployment()
 
         # Enable central infrastructure management service for agent
         if config.DEPLOYMENT.get("hosted_cluster_platform") == "agent":

ocs_ci/deployment/mce.py

@@ -5,17 +5,19 @@
 import logging
 import tempfile
 
-from ocs_ci.framework import config
-from ocs_ci.ocs.resources.ocs import OCS
+from ocs_ci.deployment.qe_app_registry import QeAppRegistry
+from ocs_ci.ocs import ocp
 from ocs_ci.ocs.ocp import OCP
+from ocs_ci.ocs.resources.ocs import OCS
+from ocs_ci.framework import config
 from ocs_ci.utility import templating
 from ocs_ci.ocs import constants
 from ocs_ci.utility.utils import (
     run_cmd,
     exec_cmd,
 )
 from ocs_ci.ocs.resources.catalog_source import CatalogSource
-from ocs_ci.ocs import ocp
+from ocs_ci.ocs.resources.deployment import Deployment
 from ocs_ci.utility.utils import get_running_ocp_version
 from ocs_ci.ocs.exceptions import CommandFailed, UnavailableResourceException
 
@@ -28,22 +30,30 @@ class MCEInstaller(object):
     """
 
     def __init__(self):
-        self.namespace = constants.MCE_NAMESPACE
+        self.mce_namespace = constants.MCE_NAMESPACE
         self.ns_obj = ocp.OCP(kind=constants.NAMESPACES)
         self.hypershift_override_image_cm = "hypershift-override-images-new"
         self.multicluster_engine = ocp.OCP(
             kind="MultiClusterEngine",
             resource_name=constants.MULTICLUSTER_ENGINE,
+            namespace=self.mce_namespace,
         )
         self.catsrc = ocp.OCP(
             kind=constants.CATSRC, namespace=constants.MARKETPLACE_NAMESPACE
         )
         self.subs = ocp.OCP(kind=constants.PROVIDER_SUBSCRIPTION)
 
-    def create_mce_catalog_source(self):
+    def _create_mce_catalog_source(self):
         """
         Creates a catalogsource for mce operator.
 
+        We use qe-app-registry catalog source to install latest version
+        In future if we want to install particular image we can use subscription.spec.startingCSV:<image> like
+        quay.io:443/acm-d/mce-custom-registry:2.13.0-DOWNSTREAM-2025-03-02-02-49-35
+        In this case we don't need another channel in subscription but may reuse stable-2.8 channel
+
+        ! Important. This catalog source does not work without ICSP, this catsrc is not used in a moment.
+        ! This method was left for reference only.
         """
         if not self.catsrc.is_exist(
             resource_name=constants.MCE_CATSRC_NAME,
@@ -79,15 +89,13 @@ def create_mce_namespace(self):
             CommandFailed: If the 'oc create' command fails.
         """
         if not self.ns_obj.is_exist(
-            resource_name=self.namespace,
+            resource_name=self.mce_namespace,
         ):
-            logger.info(f"Creating namespace {self.namespace} for mce resources")
+            logger.info(f"Creating namespace {self.mce_namespace} for mce resources")
             namespace_yaml_file = templating.load_yaml(constants.MCE_NAMESPACE_YAML)
             namespace_yaml = OCS(**namespace_yaml_file)
             namespace_yaml.create()
-            logger.info(f"MCE namespace {self.namespace} was created successfully")
-        else:
-            logger.info(f"{self.namespace} already exists")
+            logger.info(f"MCE namespace {self.mce_namespace} was created successfully")
 
     def create_multiclusterengine_operatorgroup(self):
         """
@@ -98,14 +106,12 @@ def create_multiclusterengine_operatorgroup(self):
         if not self.multicluster_engine.is_exist(
             resource_name=constants.MULTICLUSTER_ENGINE
         ):
-
             operatorgroup_yaml_file = templating.load_yaml(
                 constants.MCE_OPERATOR_GROUP_YAML
             )
             operatorgroup_yaml = OCS(**operatorgroup_yaml_file)
             operatorgroup_yaml.create()
             logger.info("mce OperatorGroup created successfully")
-        self.multicluster_engine.wait_for_phase("Available")
 
     def create_multiclusterengine_resource(self):
         """
@@ -128,26 +134,23 @@ def create_mce_subscription(self):
                 constants.MCE_SUBSCRIPTION_YAML
             )
 
-            if config.DEPLOYMENT.get("mce_latest_stable"):
-                mce_subscription_yaml_data["spec"][
-                    "source"
-                ] = constants.OPERATOR_CATALOG_SOURCE_NAME
-                mce_channel = "stable"
-            else:
-                mce_channel = config.DEPLOYMENT.get("mce_channel")
+            # ! Important, channel-2.8 becomes available after OCP 4.18 release
+            if config.DEPLOYMENT.get("mce_channel"):
+                mce_subscription_yaml_data["spec"]["channel"] = config.DEPLOYMENT.get(
+                    "mce_channel"
+                )
 
-            mce_subscription_yaml_data["spec"]["channel"] = mce_channel
             mce_subscription_manifest = tempfile.NamedTemporaryFile(
                 mode="w+", prefix="mce_subscription_manifest", delete=False
             )
             templating.dump_data_to_temp_yaml(
                 mce_subscription_yaml_data, mce_subscription_manifest.name
             )
-            logger.info("Creating subscription for mce operator")
-            run_cmd(f"oc create -f {mce_subscription_manifest.name}")
+            logger.info("Creating subscription for the mce operator")
+            exec_cmd(f"oc create -f {mce_subscription_manifest.name}")
             OCP(
                 kind=constants.SUBSCRIPTION_COREOS,
-                namespace=self.namespace,
+                namespace=self.mce_namespace,
                 resource_name=constants.MCE_OPERATOR,
             ).check_resource_existence(
                 should_exist=True, resource_name=constants.MCE_OPERATOR
@@ -160,7 +163,9 @@ def check_hypershift_namespace(self):
         Check hypershift namespace created
 
         """
-        logger.info(f"hypershift namespace {self.namespace} was created successfully")
+        logger.info(
+            f"hypershift namespace {self.mce_namespace} was created successfully"
+        )
         is_hypershift_ns_available = self.ns_obj.is_exist(
             resource_name=constants.HYPERSHIFT_NAMESPACE,
         )
@@ -176,15 +181,20 @@ def check_supported_versions(self):
             namespace=constants.HYPERSHIFT_NAMESPACE,
         )
 
-        if not configmaps_obj.is_exist(
-            resource_name=constants.SUPPORTED_VERSIONS_CONFIGMAP
+        if not configmaps_obj.check_resource_existence(
+            should_exist=True,
+            timeout=60,
+            resource_name=constants.SUPPORTED_VERSIONS_CONFIGMAP,
         ):
             raise UnavailableResourceException(
-                f"Configmap {constants.SUPPORTED_VERSIONS_CONFIGMAP} does not exist in hypershift namespace"
+                f"Configmap {constants.SUPPORTED_VERSIONS_CONFIGMAP} does not exist "
+                f"in {constants.HYPERSHIFT_NAMESPACE} namespace"
             )
 
-        cmd = "oc get cm -n hypershift supported-versions -o jsonpath='{.data.supported-versions}'"
+        cmd = f"oc get cm -n {constants.HYPERSHIFT_NAMESPACE} supported-versions "
+        cmd += "-o jsonpath='{.data.supported-versions}'"
         cmd_res = exec_cmd(cmd, shell=True)
+        supported_versions = ""
         if cmd_res.returncode == 0:
             supported_versions = cmd_res.stdout.decode("utf-8")
             logger.info(f"Supported versions: {supported_versions}")
@@ -199,7 +209,7 @@ def create_image_override(self):
         # Create image override configmap using the image override json
         cmd = (
             f"oc create cm {self.hypershift_override_image_cm} --from-file={constants.IMAGE_OVERRIDE_JSON}"
-            "-n {self.namespace}"
+            f"-n {self.mce_namespace}"
         )
         cmd_res = exec_cmd(cmd, shell=True)
         if cmd_res.returncode:
@@ -211,43 +221,36 @@ def create_image_override(self):
         )
         self.multicluster_engine.wait_until_running()
 
-    def deploy_mce(self, check_mce_deployed=False, check_mce_ready=False):
+    def deploy_mce(self):
         """
         Installs mce enabling software emulation.
 
-        Args:
-            check_mce_deployed (bool): If True, check if mce is already deployed. If so, skip the deployment.
-            check_mce_ready (bool): If True, check if mce is ready. If so, skip the deployment.
         """
-        if check_mce_deployed:
-            if self.mce_installed():
-                logger.info("mce operator is already deployed, skipping the deployment")
-                return
-
-        if check_mce_ready:
-            if self.post_install_verification(raise_exception=False):
-                logger.info("mce operator ready, skipping the deployment")
-                return
-
-        logger.info("Installing mce")
-        # we create catsrc with nightly builds only if config.DEPLOYMENT does not have mce_latest_stable
-        if not config.DEPLOYMENT.get("mce_latest_stable"):
-            # Create mce catalog source
-            self.create_mce_catalog_source()
-        # Create multicluster-engine namespace
-        self.create_mce_namespace()
-        # create mce subscription
-        self.create_mce_subscription()
-        # Deploy the multiclusterengine operatorgroup
-        self.create_multiclusterengine_operatorgroup()
-        # Create mce resource
-        self.create_multiclusterengine_resource()
-        # Check hypershift ns created
-        if not self.check_hypershift_namespace():
-            cmd = f"oc create namespace {constants.HYPERSHIFT_NAMESPACE}"
-            cmd_res = exec_cmd(cmd, shell=True)
-            if cmd_res.returncode:
-                raise CommandFailed("Failed to create hypershift namespace")
+
+        if not self.mce_installed():
+            logger.info("Installing mce")
+            # we create catsrc with nightly builds only if config.DEPLOYMENT does not have mce_latest_stable
+            qe_app_registry = QeAppRegistry()
+            qe_app_registry.icsp()
+            qe_app_registry.catalog_source()
+            self.create_mce_namespace()
+            self.create_mce_subscription()
+            self.create_multiclusterengine_operatorgroup()
+
+        # check whether mce instance is created, if it is installed but mce don't pass validation we can not heal it in
+        # script here, hence no sense for full validation of mce
+        if not self.mce_exists():
+
+            # Create mce resource
+            self.create_multiclusterengine_resource()
+            # Check hypershift ns created
+            if not self.check_hypershift_namespace():
+                cmd = f"oc create namespace {constants.HYPERSHIFT_NAMESPACE}"
+                cmd_res = exec_cmd(cmd, shell=True)
+                if cmd_res.returncode:
+                    raise CommandFailed("Failed to create hypershift namespace")
+
+        self.wait_mce_resources()
         # Check supported versions in supported-versions configmap
         self.check_supported_versions()
 
@@ -258,36 +261,48 @@ def mce_installed(self):
         Returns:
              bool: True if MCE is installed, False otherwise
         """
-        ocp = OCP(kind=constants.ROOK_OPERATOR, namespace=self.namespace)
-        return ocp.check_resource_existence(
-            timeout=12, should_exist=True, resource_name=constants.MCE_OPERATOR
+        ocp_obj = OCP(kind=constants.ROOK_OPERATOR)
+        # unlike other k8s resources, operators are OLM manager resources that identified by merged name.namespace
+        return ocp_obj.check_resource_existence(
+            timeout=12,
+            should_exist=True,
+            resource_name=constants.MCE_OPERATOR_OPERATOR_NAME_WITH_NS,
         )
 
-    def post_install_verification(self, raise_exception=False):
+    def mce_exists(self):
         """
-        Performs MCE post-installation verification, with raise_exception = False may be used safely to run on
-        clusters with MCE installed or not installed.
-
-        Args:
-            raise_exception: If True, allow function to fail the job and raise an exception. If false, return False
-        instead of raising an exception.
+        Check if MCE exists
 
         Returns:
-            bool: True if the verification conditions are met, False otherwise
-        Raises:
-            TimeoutExpiredError: If the verification conditions are not met within the timeout
-            and raise_exception is True.
-            ResourceNotFoundError if the namespace does not exist and raise_exception is True.
-            ResourceWrongStatusException if the nodes are not ready, verification fails and raise_exception
-            is True.
+            bool: True if MCE exists, False otherwise
         """
-        # TODO: implement
-        pass
+        return self.multicluster_engine.is_exist(
+            resource_name=constants.MULTICLUSTER_ENGINE
+        )
 
-    def validate_mce_deployment(self):
+    def wait_mce_resources(self):
         """
-        Validate mce operator installation
+        Wait for mce Available state and deployments Ready state
+
+        Raises:
+            TimeoutExpiredError: If the deployment is not in the 'Available' state within the timeout
         """
-        if self.mce_hyperconverged_installed():
-            logger.info("mce operator is already deployed")
-            return
+        if not self.mce_exists():
+            raise UnavailableResourceException("MCE resource is not created")
+        deployments = [
+            "multicluster-engine-operator",
+            "ocm-controller",
+            "cluster-manager",
+            "ocm-webhook",
+        ]
+
+        for resource_name in deployments:
+            depl_ocp_obj = OCP(
+                kind=constants.DEPLOYMENT,
+                namespace=self.mce_namespace,
+                resource_name=resource_name,
+            )
+            deployment_obj = Deployment(
+                **depl_ocp_obj.get(retry=60, wait=10, dont_raise=True)
+            )
+            deployment_obj.wait_for_available_replicas(timeout=600)

ocs_ci/framework/conf/default_config.yaml

@@ -123,6 +123,10 @@ DEPLOYMENT:
   rosa_cli_version: '1.2.49'
   # Multicluster engine
   deploy_mce: false
+  # ! Pay attention. stable-2.8 is not available until OCP 4.18 becomes available
+  mce_channel: "stable-2.8"
+  # catalogsource format of image with tag; latest unreleased, that is supported by OCP 4.18
+  mce_image: ""
 
 
 
@@ -232,9 +236,6 @@ ENV_DATA:
   rhel7.9_worker_ami: 'ami-058a93d58c5797698'
   rhel8.4_worker_ami: 'ami-074bab065c112399f'
   cluster_type: ""
-  # Provider mode dependencies checks during deployment for presence
-  skip_mce_check_if_present: false
-  skip_cnv_check_if_present: false
 
   # RHEL template which are used for vSphere platform
   rhel7_template: 'rhel79_ocs4qe'
@@ -243,8 +244,6 @@ ENV_DATA:
   deploy_acm_hub_cluster: false
   # HyperConverged deployment
   deploy_hyperconverged: false
-  # mce deployment
-  deploy_mce: false
 
   # Managed service git stat  default configurations
   # Managed StorageCluster size in TiB

ocs_ci/ocs/constants.py

@@ -2806,6 +2806,7 @@
     TEMPLATE_DEPLOYMENT_DIR_MCE, "mce_subscription.yaml"
 )
 MCE_OPERATOR = "multicluster-engine"
+MCE_OPERATOR_OPERATOR_NAME_WITH_NS = f"{MCE_OPERATOR}.{MCE_NAMESPACE}"
 MCE_RESOURCE_YAML = os.path.join(TEMPLATE_DEPLOYMENT_DIR_MCE, "mce_resource.yaml")
 MCE_OPERATOR_GROUP_YAML = os.path.join(
     TEMPLATE_DEPLOYMENT_DIR_MCE, "mce_operatorgroup.yaml"

ocs_ci/templates/mce-deployment/mce_catsrc.yaml

@@ -4,5 +4,6 @@ metadata:
   name: mce-catalogsource
   namespace: openshift-marketplace
 spec:
-  image: quay.io:443/acm-d/mce-custom-registry:2.13.0-DOWNSTREAM-2025-02-25-05-34-41
+  # latest version of the catalog image for OCP 4.18
+  image: quay.io:443/acm-d/mce-custom-registry:2.8-latest
   sourceType: grpc

ocs_ci/templates/mce-deployment/mce_subscription.yaml

@@ -4,8 +4,8 @@ metadata:
   name: multicluster-engine
   namespace: multicluster-engine
 spec:
-  channel: stable
+  channel: stable-2.8
   installPlanApproval: Automatic
   name: multicluster-engine
-  source: mce-catalogsource
+  source: qe-app-registry
   sourceNamespace: openshift-marketplace