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}"
)
