def run_exporter_script(self, params): """ Runs the exporter script on RHCS cluster Args: params (str): Parameter to pass to exporter script Returns: str: output of exporter script """ # upload exporter script to external RHCS cluster script_path = self.upload_exporter_script() # get external RHCS rhel version rhel_version = self.get_rhel_version() python_version = "python3" if version.get_semantic_version( rhel_version) < version.get_semantic_version("8"): python_version = "python" # run the exporter script on external RHCS cluster cmd = f"{python_version} {script_path} {params}" retcode, out, err = self.rhcs_conn.exec_cmd(cmd) if retcode != 0: logger.error( f"Failed to run {script_path} with parameters {params}. Error: {err}" ) raise ExternalClusterExporterRunFailed return out
def configure_allowed_domains_in_proxy(): """ Configure squid proxy server - add domains which needs to be accessible from disconnected cluster for test execution. """ # configure proxy on INT_SVC_INSTANCE - allow access to required sites # import get_ocp_version here to avoid circular import from ocs_ci.utility.utils import get_ocp_version if get_semantic_version(get_ocp_version(), True) < VERSION_4_11: int_svc_user = constants.EC2_USER else: int_svc_user = "******" private_key = os.path.expanduser(config.DEPLOYMENT["ssh_key_private"]) ssh_int_svc = Connection(config.DEPLOYMENT.get("int_svc_instance"), int_svc_user, private_key) # as we are inserting the two lines before first line one by one, # we have to launch the sed commands in reverse order cmd = "sudo sed -i '1i http_access allow ocs_whitelist' /srv/squid/etc/squid.conf" logger.info(ssh_int_svc.exec_cmd(cmd=cmd)) cmd = ("""sudo sed -i '1i acl ocs_whitelist dstdomain """ f"""{" ".join(constants.DISCON_CL_PROXY_ALLOWED_DOMAINS)}' """ """/srv/squid/etc/squid.conf""") logger.info(ssh_int_svc.exec_cmd(cmd=cmd)) cmd = "sudo systemctl restart squid-proxy.service" logger.info(ssh_int_svc.exec_cmd(cmd=cmd))
def test_compare_from_get_semantic_version(): """ This teest is testing that semantic version comparison works as expected and version 4.5.11 is lower than 4.11. Which in the float will not work, but in semantic versions it should be fine. """ tested_version = version.get_semantic_version("4.5.11", only_major_minor=True) assert tested_version < Version.coerce("4.11")
def get_rgw_count(ocs_version, is_upgrade, version_before_upgrade): """ Get RGW Count RGW Count is 2 if: OCS 4.5 unless upgraded from a prior version OCS 4.6 Otherwise, RGW Count is 1 Args: ocs_version (str, float): OCS Version is_upgrade (bool): If cluster was upgraded to current version version_before_upgrade (str, float): OCS Version prior to upgrade Returns: int: RGW Count """ semantic_ocs_version = version.get_semantic_version( ocs_version, only_major_minor=True ) # Assume upgrade from prior version if one is not provided if is_upgrade: version_before_upgrade = version.get_semantic_version( f"{semantic_ocs_version.major}.{semantic_ocs_version.minor - 1}", only_major_minor=True, ) log.info( "version_before_upgrade not provided, assuming prior release is " f"{version_before_upgrade}", ) if ( semantic_ocs_version == version.VERSION_4_5 and not (is_upgrade and version_before_upgrade < version.VERSION_4_5) or semantic_ocs_version == version.VERSION_4_6 ): log.debug("RGW Count: 2") return 2 else: log.debug("RGW Count: 1") return 1
def test_get_semantic_version_string_values(product_version, only_major_minor, ignore_pre_release, expected): """ This test is suppose to test if the get_semantic_version returns expected values which after the sting formatting are the same as the expected. Testing all different combinations of parameters and values. """ tested_version = version.get_semantic_version(product_version, only_major_minor, ignore_pre_release) assert f"{tested_version}" == expected
def test_get_semantic_version(product_version, only_major_minor, ignore_pre_release, expected): """ This test is suppose to test if the get_semantic_version returns expected values for different combinations of paramters and different values of string version provided to that function. """ tested_version = version.get_semantic_version(product_version, only_major_minor, ignore_pre_release) assert tested_version == expected
def test_noobaa_service_mon_after_ocs_upgrade(): """ Verify 'noobaa-service-monitor' does not exist after OCS upgrade. Test Procedure: 1.Upgrade OCS version 2.Check servicemonitors 3.Verify 'noobaa-service-monitor' does not exist """ ocs_version = version.get_ocs_version_from_csv(only_major_minor=False, ignore_pre_release=True) if ocs_version <= version.get_semantic_version("4.7.4"): pytest.skip("The test is not supported on version less than 4.7.4") ocp_obj = ocp.OCP(kind=constants.SERVICE_MONITORS, namespace=defaults.ROOK_CLUSTER_NAMESPACE) servicemon = ocp_obj.get() servicemonitors = servicemon["items"] for servicemonitor in servicemonitors: assert (servicemonitor["metadata"]["name"] != "noobaa-service-monitor"), "noobaa-service-monitor exist" log.info("noobaa-service-monitor does not exist")
def test_hpa_noobaa_endpoint_metric(): """ Test to verify HPA noobaa-endpoint cpu metrics is available. Since 4.10, it uses horizontal-pod-autoscaler-v2 API. """ ocp_version = get_semantic_version(get_ocp_version(), only_major_minor=True) ocp_obj = ocp.OCP( kind=constants.HPA, resource_name="noobaa-endpoint", namespace=defaults.ROOK_CLUSTER_NAMESPACE, ) status = ocp_obj.get()["status"] logger.info("Looking for cpu utilization value for hpa/noobaa-endpoint") cpu_utilization = None if ocp_version < VERSION_4_10: logger.info("using horizontal-pod-autoscaler-v1 API") assert ( "currentCPUUtilizationPercentage" in status), "Failed: noobaa-endpoint cpu metrics is unavailable" cpu_utilization = status["currentCPUUtilizationPercentage"] else: logger.info("using horizontal-pod-autoscaler-v2 API") assert ("currentMetrics" in status), "Failed: metrics not provided in noobaa-endpoint" for metric in status["currentMetrics"]: if metric["type"] != "Resource": continue if metric["resource"]["name"] != "cpu": continue cpu_utilization = metric["resource"]["current"][ "averageUtilization"] assert (cpu_utilization is not None), "Failed: noobaa-endpoint cpu metrics not available" assert cpu_utilization >= 0 logger.info("Current resource cpu utilized: %d%%", cpu_utilization)
def run_ocs_upgrade(operation=None, *operation_args, **operation_kwargs): """ Run upgrade procedure of OCS cluster Args: operation: (function): Function to run operation_args: (iterable): Function's arguments operation_kwargs: (map): Function's keyword arguments """ ceph_cluster = CephCluster() original_ocs_version = config.ENV_DATA.get("ocs_version") upgrade_in_current_source = config.UPGRADE.get("upgrade_in_current_source", False) upgrade_ocs = OCSUpgrade( namespace=config.ENV_DATA["cluster_namespace"], version_before_upgrade=original_ocs_version, ocs_registry_image=config.UPGRADE.get("upgrade_ocs_registry_image"), upgrade_in_current_source=upgrade_in_current_source, ) upgrade_version = upgrade_ocs.get_upgrade_version() assert ( upgrade_ocs.get_parsed_versions()[1] >= upgrade_ocs.get_parsed_versions()[0]), ( f"Version you would like to upgrade to: {upgrade_version} " f"is not higher or equal to the version you currently running: " f"{upgrade_ocs.version_before_upgrade}") # create external cluster object if config.DEPLOYMENT["external_mode"]: host, user, password = get_external_cluster_client() external_cluster = ExternalCluster(host, user, password) # For external cluster , create the secrets if upgraded version is 4.8 if (config.DEPLOYMENT["external_mode"] and original_ocs_version == "4.7" and upgrade_version == "4.8"): external_cluster.create_object_store_user() access_key = config.EXTERNAL_MODE.get("access_key_rgw-admin-ops-user", "") secret_key = config.EXTERNAL_MODE.get("secret_key_rgw-admin-ops-user", "") if not (access_key and secret_key): raise ExternalClusterRGWAdminOpsUserException( "Access and secret key for rgw-admin-ops-user not found") cmd = ( f'oc create secret generic --type="kubernetes.io/rook"' f' "rgw-admin-ops-user" --from-literal=accessKey={access_key} --from-literal=secretKey={secret_key}' ) exec_cmd(cmd) csv_name_pre_upgrade = upgrade_ocs.get_csv_name_pre_upgrade() pre_upgrade_images = upgrade_ocs.get_pre_upgrade_image( csv_name_pre_upgrade) upgrade_ocs.load_version_config_file(upgrade_version) if config.DEPLOYMENT.get("disconnected") and not config.DEPLOYMENT.get( "disconnected_env_skip_image_mirroring"): upgrade_ocs.ocs_registry_image = prepare_disconnected_ocs_deployment( upgrade=True) log.info( f"Disconnected upgrade - new image: {upgrade_ocs.ocs_registry_image}" ) with CephHealthMonitor(ceph_cluster): channel = upgrade_ocs.set_upgrade_channel() upgrade_ocs.set_upgrade_images() live_deployment = config.DEPLOYMENT["live_deployment"] disable_addon = config.DEPLOYMENT.get("ibmcloud_disable_addon") if (config.ENV_DATA["platform"] == constants.IBMCLOUD_PLATFORM and live_deployment and not disable_addon): clustername = config.ENV_DATA.get("cluster_name") cmd = f"ibmcloud ks cluster addon disable openshift-data-foundation --cluster {clustername} -f" run_ibmcloud_cmd(cmd) time.sleep(120) cmd = ( f"ibmcloud ks cluster addon enable openshift-data-foundation --cluster {clustername} -f --version " f"{upgrade_version}.0 --param ocsUpgrade=true") run_ibmcloud_cmd(cmd) time.sleep(120) else: ui_upgrade_supported = False if config.UPGRADE.get("ui_upgrade"): if (version.get_semantic_ocp_version_from_config() == version.VERSION_4_9 and original_ocs_version == "4.8" and upgrade_version == "4.9"): ui_upgrade_supported = True else: log.warning( "UI upgrade combination is not supported. It will fallback to CLI upgrade" ) if ui_upgrade_supported: ocs_odf_upgrade_ui() else: if (config.ENV_DATA["platform"] == constants.IBMCLOUD_PLATFORM ) and not (upgrade_in_current_source): create_ocs_secret(config.ENV_DATA["cluster_namespace"]) if upgrade_version != "4.9": # In the case of upgrade to ODF 4.9, the ODF operator should upgrade # OCS automatically. upgrade_ocs.update_subscription(channel) if original_ocs_version == "4.8" and upgrade_version == "4.9": deployment = Deployment() deployment.subscribe_ocs() else: # In the case upgrade is not from 4.8 to 4.9 and we have manual approval strategy # we need to wait and approve install plan, otherwise it's approved in the # subscribe_ocs method. subscription_plan_approval = config.DEPLOYMENT.get( "subscription_plan_approval") if subscription_plan_approval == "Manual": wait_for_install_plan_and_approve( config.ENV_DATA["cluster_namespace"]) if (config.ENV_DATA["platform"] == constants.IBMCLOUD_PLATFORM ) and not (upgrade_in_current_source): for attempt in range(2): # We need to do it twice, because some of the SA are updated # after the first load of OCS pod after upgrade. So we need to # link updated SA again. log.info( f"Sleep 1 minute before attempt: {attempt + 1}/2 " "of linking secret/SAs") time.sleep(60) link_all_sa_and_secret_and_delete_pods( constants.OCS_SECRET, config.ENV_DATA["cluster_namespace"]) if operation: log.info(f"Calling test function: {operation}") _ = operation(*operation_args, **operation_kwargs) # Workaround for issue #2531 time.sleep(30) # End of workaround for sample in TimeoutSampler( timeout=725, sleep=5, func=upgrade_ocs.check_if_upgrade_completed, channel=channel, csv_name_pre_upgrade=csv_name_pre_upgrade, ): try: if sample: log.info("Upgrade success!") break except TimeoutException: raise TimeoutException("No new CSV found after upgrade!") old_image = upgrade_ocs.get_images_post_upgrade( channel, pre_upgrade_images, upgrade_version) verify_image_versions( old_image, upgrade_ocs.get_parsed_versions()[1], upgrade_ocs.version_before_upgrade, ) # update external secrets if config.DEPLOYMENT["external_mode"]: upgrade_version = version.get_semantic_version(upgrade_version, True) if upgrade_version >= version.VERSION_4_10: external_cluster.update_permission_caps() else: external_cluster.update_permission_caps(EXTERNAL_CLUSTER_USER) external_cluster.get_external_cluster_details() # update the external cluster details in secrets log.info("updating external cluster secret") external_cluster_details = NamedTemporaryFile( mode="w+", prefix="external-cluster-details-", delete=False, ) with open(external_cluster_details.name, "w") as fd: decoded_external_cluster_details = decode( config.EXTERNAL_MODE["external_cluster_details"]) fd.write(decoded_external_cluster_details) cmd = ( f"oc set data secret/rook-ceph-external-cluster-details -n {constants.OPENSHIFT_STORAGE_NAMESPACE} " f"--from-file=external_cluster_details={external_cluster_details.name}" ) exec_cmd(cmd) if config.ENV_DATA.get("mcg_only_deployment"): mcg_only_install_verification( ocs_registry_image=upgrade_ocs.ocs_registry_image) else: ocs_install_verification( timeout=600, skip_osd_distribution_check=True, ocs_registry_image=upgrade_ocs.ocs_registry_image, post_upgrade_verification=True, version_before_upgrade=upgrade_ocs.version_before_upgrade, )
def deploy_ocs_via_operator(self, image=None): """ Method for deploy OCS via OCS operator Args: image (str): Image of ocs registry. """ ui_deployment = config.DEPLOYMENT.get("ui_deployment") live_deployment = config.DEPLOYMENT.get("live_deployment") arbiter_deployment = config.DEPLOYMENT.get("arbiter_deployment") if ui_deployment and ui_deployment_conditions(): self.deployment_with_ui() # Skip the rest of the deployment when deploy via UI return else: logger.info("Deployment of OCS via OCS operator") self.label_and_taint_nodes() if not live_deployment: create_catalog_source(image) if config.DEPLOYMENT.get("local_storage"): setup_local_storage(storageclass=self.DEFAULT_STORAGECLASS_LSO) logger.info("Creating namespace and operator group.") run_cmd(f"oc create -f {constants.OLM_YAML}") # create multus network if config.ENV_DATA.get("is_multus_enabled"): logger.info("Creating multus network") multus_data = templating.load_yaml(constants.MULTUS_YAML) multus_config_str = multus_data["spec"]["config"] multus_config_dct = json.loads(multus_config_str) if config.ENV_DATA.get("multus_public_network_interface"): multus_config_dct["master"] = config.ENV_DATA.get( "multus_public_network_interface" ) multus_data["spec"]["config"] = json.dumps(multus_config_dct) multus_data_yaml = tempfile.NamedTemporaryFile( mode="w+", prefix="multus", delete=False ) templating.dump_data_to_temp_yaml(multus_data, multus_data_yaml.name) run_cmd(f"oc create -f {multus_data_yaml.name}") if config.ENV_DATA["platform"] == constants.IBMCLOUD_PLATFORM: ibmcloud.add_deployment_dependencies() if not live_deployment: create_ocs_secret(self.namespace) self.subscribe_ocs() operator_selector = get_selector_for_ocs_operator() subscription_plan_approval = config.DEPLOYMENT.get("subscription_plan_approval") ocs_version = version.get_semantic_ocs_version_from_config() if ocs_version >= version.VERSION_4_9: ocs_operator_names = [ defaults.ODF_OPERATOR_NAME, defaults.OCS_OPERATOR_NAME, ] build_number = version.get_semantic_version(get_ocs_build_number()) if build_number >= version.get_semantic_version("4.9.0-231"): ocs_operator_names.append(defaults.MCG_OPERATOR) else: ocs_operator_names.append(defaults.NOOBAA_OPERATOR) else: ocs_operator_names = [defaults.OCS_OPERATOR_NAME] channel = config.DEPLOYMENT.get("ocs_csv_channel") is_ibm_sa_linked = False for ocs_operator_name in ocs_operator_names: package_manifest = PackageManifest( resource_name=ocs_operator_name, selector=operator_selector, subscription_plan_approval=subscription_plan_approval, ) package_manifest.wait_for_resource(timeout=300) csv_name = package_manifest.get_current_csv(channel=channel) csv = CSV(resource_name=csv_name, namespace=self.namespace) if ( config.ENV_DATA["platform"] == constants.IBMCLOUD_PLATFORM and not live_deployment ): if not is_ibm_sa_linked: logger.info("Sleeping for 60 seconds before applying SA") time.sleep(60) link_all_sa_and_secret_and_delete_pods( constants.OCS_SECRET, self.namespace ) is_ibm_sa_linked = True csv.wait_for_phase("Succeeded", timeout=720) # create storage system if ocs_version >= version.VERSION_4_9: exec_cmd(f"oc apply -f {constants.STORAGE_SYSTEM_ODF_YAML}") ocp_version = version.get_semantic_ocp_version_from_config() if config.ENV_DATA["platform"] == constants.IBMCLOUD_PLATFORM: config_map = ocp.OCP( kind="configmap", namespace=self.namespace, resource_name=constants.ROOK_OPERATOR_CONFIGMAP, ) config_map.get(retry=10, wait=5) config_map_patch = ( '\'{"data": {"ROOK_CSI_KUBELET_DIR_PATH": "/var/data/kubelet"}}\'' ) logger.info("Patching config map to change KUBLET DIR PATH") exec_cmd( f"oc patch configmap -n {self.namespace} " f"{constants.ROOK_OPERATOR_CONFIGMAP} -p {config_map_patch}" ) if config.DEPLOYMENT.get("create_ibm_cos_secret", True): logger.info("Creating secret for IBM Cloud Object Storage") with open(constants.IBM_COS_SECRET_YAML, "r") as cos_secret_fd: cos_secret_data = yaml.load(cos_secret_fd, Loader=yaml.SafeLoader) key_id = config.AUTH["ibmcloud"]["ibm_cos_access_key_id"] key_secret = config.AUTH["ibmcloud"]["ibm_cos_secret_access_key"] cos_secret_data["data"]["IBM_COS_ACCESS_KEY_ID"] = key_id cos_secret_data["data"]["IBM_COS_SECRET_ACCESS_KEY"] = key_secret cos_secret_data_yaml = tempfile.NamedTemporaryFile( mode="w+", prefix="cos_secret", delete=False ) templating.dump_data_to_temp_yaml( cos_secret_data, cos_secret_data_yaml.name ) exec_cmd(f"oc create -f {cos_secret_data_yaml.name}") # Modify the CSV with custom values if required if all( key in config.DEPLOYMENT for key in ("csv_change_from", "csv_change_to") ): modify_csv( csv=csv_name, replace_from=config.DEPLOYMENT["csv_change_from"], replace_to=config.DEPLOYMENT["csv_change_to"], ) # create custom storage class for StorageCluster CR if necessary if self.CUSTOM_STORAGE_CLASS_PATH is not None: with open(self.CUSTOM_STORAGE_CLASS_PATH, "r") as custom_sc_fo: custom_sc = yaml.load(custom_sc_fo, Loader=yaml.SafeLoader) # set value of DEFAULT_STORAGECLASS to mach the custom storage cls self.DEFAULT_STORAGECLASS = custom_sc["metadata"]["name"] run_cmd(f"oc create -f {self.CUSTOM_STORAGE_CLASS_PATH}") # Set rook log level self.set_rook_log_level() # creating StorageCluster if config.DEPLOYMENT.get("kms_deployment"): kms = KMS.get_kms_deployment() kms.deploy() if config.ENV_DATA["mcg_only_deployment"]: mcg_only_deployment() return cluster_data = templating.load_yaml(constants.STORAGE_CLUSTER_YAML) # Figure out all the OCS modules enabled/disabled # CLI parameter --disable-components takes the precedence over # anything which comes from config file if config.ENV_DATA.get("disable_components"): for component in config.ENV_DATA["disable_components"]: config.COMPONENTS[f"disable_{component}"] = True logger.warning(f"disabling: {component}") # Update cluster_data with respective component enable/disable for key in config.COMPONENTS.keys(): comp_name = constants.OCS_COMPONENTS_MAP[key.split("_")[1]] if config.COMPONENTS[key]: if "noobaa" in key: merge_dict( cluster_data, { "spec": { "multiCloudGateway": {"reconcileStrategy": "ignore"} } }, ) else: merge_dict( cluster_data, { "spec": { "managedResources": { f"{comp_name}": {"reconcileStrategy": "ignore"} } } }, ) if arbiter_deployment: cluster_data["spec"]["arbiter"] = {} cluster_data["spec"]["nodeTopologies"] = {} cluster_data["spec"]["arbiter"]["enable"] = True cluster_data["spec"]["nodeTopologies"][ "arbiterLocation" ] = self.get_arbiter_location() cluster_data["spec"]["storageDeviceSets"][0]["replica"] = 4 cluster_data["metadata"]["name"] = config.ENV_DATA["storage_cluster_name"] deviceset_data = cluster_data["spec"]["storageDeviceSets"][0] device_size = int(config.ENV_DATA.get("device_size", defaults.DEVICE_SIZE)) logger.info( "Flexible scaling is available from version 4.7 on LSO cluster with less than 3 zones" ) zone_num = get_az_count() if ( config.DEPLOYMENT.get("local_storage") and ocs_version >= version.VERSION_4_7 and zone_num < 3 and not config.DEPLOYMENT.get("arbiter_deployment") ): cluster_data["spec"]["flexibleScaling"] = True # https://bugzilla.redhat.com/show_bug.cgi?id=1921023 cluster_data["spec"]["storageDeviceSets"][0]["count"] = 3 cluster_data["spec"]["storageDeviceSets"][0]["replica"] = 1 # set size of request for storage if self.platform.lower() == constants.BAREMETAL_PLATFORM: pv_size_list = helpers.get_pv_size( storageclass=self.DEFAULT_STORAGECLASS_LSO ) pv_size_list.sort() deviceset_data["dataPVCTemplate"]["spec"]["resources"]["requests"][ "storage" ] = f"{pv_size_list[0]}" else: deviceset_data["dataPVCTemplate"]["spec"]["resources"]["requests"][ "storage" ] = f"{device_size}Gi" # set storage class to OCS default on current platform if self.DEFAULT_STORAGECLASS: deviceset_data["dataPVCTemplate"]["spec"][ "storageClassName" ] = self.DEFAULT_STORAGECLASS # StorageCluster tweaks for LSO if config.DEPLOYMENT.get("local_storage"): cluster_data["spec"]["manageNodes"] = False cluster_data["spec"]["monDataDirHostPath"] = "/var/lib/rook" deviceset_data["name"] = constants.DEFAULT_DEVICESET_LSO_PVC_NAME deviceset_data["portable"] = False deviceset_data["dataPVCTemplate"]["spec"][ "storageClassName" ] = self.DEFAULT_STORAGECLASS_LSO lso_type = config.DEPLOYMENT.get("type") if ( self.platform.lower() == constants.AWS_PLATFORM and not lso_type == constants.AWS_EBS ): deviceset_data["count"] = 2 # setting resource limits for AWS i3 # https://access.redhat.com/documentation/en-us/red_hat_openshift_container_storage/4.6/html-single/deploying_openshift_container_storage_using_amazon_web_services/index#creating-openshift-container-storage-cluster-on-amazon-ec2_local-storage if ( ocs_version >= version.VERSION_4_5 and config.ENV_DATA.get("worker_instance_type") == constants.AWS_LSO_WORKER_INSTANCE ): deviceset_data["resources"] = { "limits": {"cpu": 2, "memory": "5Gi"}, "requests": {"cpu": 1, "memory": "5Gi"}, } if (ocp_version >= version.VERSION_4_6) and ( ocs_version >= version.VERSION_4_6 ): cluster_data["metadata"]["annotations"] = { "cluster.ocs.openshift.io/local-devices": "true" } count = config.DEPLOYMENT.get("local_storage_storagedeviceset_count") if count is not None: deviceset_data["count"] = count # Allow lower instance requests and limits for OCS deployment # The resources we need to change can be found here: # https://github.com/openshift/ocs-operator/blob/release-4.5/pkg/deploy-manager/storagecluster.go#L88-L116 if config.DEPLOYMENT.get("allow_lower_instance_requirements"): none_resources = {"Requests": None, "Limits": None} deviceset_data["resources"] = deepcopy(none_resources) resources = [ "mon", "mds", "rgw", "mgr", "noobaa-core", "noobaa-db", ] if ocs_version >= version.VERSION_4_5: resources.append("noobaa-endpoint") cluster_data["spec"]["resources"] = { resource: deepcopy(none_resources) for resource in resources } if ocs_version >= version.VERSION_4_5: cluster_data["spec"]["resources"]["noobaa-endpoint"] = { "limits": {"cpu": "100m", "memory": "100Mi"}, "requests": {"cpu": "100m", "memory": "100Mi"}, } else: local_storage = config.DEPLOYMENT.get("local_storage") platform = config.ENV_DATA.get("platform", "").lower() if local_storage and platform == "aws": resources = { "mds": { "limits": {"cpu": 3, "memory": "8Gi"}, "requests": {"cpu": 1, "memory": "8Gi"}, } } if ocs_version < version.VERSION_4_5: resources["noobaa-core"] = { "limits": {"cpu": 2, "memory": "8Gi"}, "requests": {"cpu": 1, "memory": "8Gi"}, } resources["noobaa-db"] = { "limits": {"cpu": 2, "memory": "8Gi"}, "requests": {"cpu": 1, "memory": "8Gi"}, } cluster_data["spec"]["resources"] = resources # Enable host network if enabled in config (this require all the # rules to be enabled on underlaying platform). if config.DEPLOYMENT.get("host_network"): cluster_data["spec"]["hostNetwork"] = True cluster_data["spec"]["storageDeviceSets"] = [deviceset_data] if self.platform == constants.IBMCLOUD_PLATFORM: mon_pvc_template = { "spec": { "accessModes": ["ReadWriteOnce"], "resources": {"requests": {"storage": "20Gi"}}, "storageClassName": self.DEFAULT_STORAGECLASS, "volumeMode": "Filesystem", } } cluster_data["spec"]["monPVCTemplate"] = mon_pvc_template # Need to check if it's needed for ibm cloud to set manageNodes cluster_data["spec"]["manageNodes"] = False if config.ENV_DATA.get("encryption_at_rest"): if ocs_version < version.VERSION_4_6: error_message = "Encryption at REST can be enabled only on OCS >= 4.6!" logger.error(error_message) raise UnsupportedFeatureError(error_message) logger.info("Enabling encryption at REST!") cluster_data["spec"]["encryption"] = { "enable": True, } if config.DEPLOYMENT.get("kms_deployment"): cluster_data["spec"]["encryption"]["kms"] = { "enable": True, } if config.DEPLOYMENT.get("ceph_debug"): setup_ceph_debug() cluster_data["spec"]["managedResources"] = { "cephConfig": {"reconcileStrategy": "ignore"} } if config.ENV_DATA.get("is_multus_enabled"): cluster_data["spec"]["network"] = { "provider": "multus", "selectors": { "public": f"{defaults.ROOK_CLUSTER_NAMESPACE}/ocs-public" }, } cluster_data_yaml = tempfile.NamedTemporaryFile( mode="w+", prefix="cluster_storage", delete=False ) templating.dump_data_to_temp_yaml(cluster_data, cluster_data_yaml.name) run_cmd(f"oc create -f {cluster_data_yaml.name}", timeout=1200) if config.DEPLOYMENT["infra_nodes"]: _ocp = ocp.OCP(kind="node") _ocp.exec_oc_cmd( command=f"annotate namespace {defaults.ROOK_CLUSTER_NAMESPACE} " f"{constants.NODE_SELECTOR_ANNOTATION}" )