def gather_version_info_for_report(config):
"""
This function gather all version related info used for report.
Args:
config (pytest.config): Pytest config object
"""
gather_version_completed = False
try:
# add cluster version
clusterversion = get_cluster_version()
config._metadata["Cluster Version"] = clusterversion
# add ceph version
if not ocsci_config.ENV_DATA["mcg_only_deployment"]:
ceph_version = get_ceph_version()
config._metadata["Ceph Version"] = ceph_version
# add csi versions
csi_versions = get_csi_versions()
config._metadata["cephfsplugin"] = csi_versions.get(
"csi-cephfsplugin")
config._metadata["rbdplugin"] = csi_versions.get("csi-rbdplugin")
# add ocs operator version
config._metadata["OCS operator"] = get_ocs_build_number()
mods = {}
mods = get_version_info(
namespace=ocsci_config.ENV_DATA["cluster_namespace"])
skip_list = ["ocs-operator"]
for key, val in mods.items():
if key not in skip_list:
config._metadata[key] = val.rsplit("/")[-1]
gather_version_completed = True
except ResourceNotFoundError:
log.exception("Problem occurred when looking for some resource!")
except FileNotFoundError:
log.exception("File not found!")
except CommandFailed:
log.exception("Failed to execute command!")
except Exception:
log.exception("Failed to gather version info!")
finally:
if not gather_version_completed:
log.warning(
"Failed to gather version details! The report of version might"
"not be complete!")
def gather_version_info_for_report(config):
"""
This function gather all version related info used for report.
Args:
config (pytest.config): Pytest config object
"""
gather_version_completed = False
try:
# add cluster version
clusterversion = get_cluster_version()
config._metadata['Cluster Version'] = clusterversion
# add ceph version
ceph_version = get_ceph_version()
config._metadata['Ceph Version'] = ceph_version
# add csi versions
csi_versions = get_csi_versions()
config._metadata['cephfsplugin'] = csi_versions.get('csi-cephfsplugin')
config._metadata['rbdplugin'] = csi_versions.get('csi-rbdplugin')
# add ocs operator version
if ocsci_config.REPORTING['us_ds'] == 'DS':
config._metadata['OCS operator'] = (get_ocs_build_number())
mods = {}
mods = get_version_info(
namespace=ocsci_config.ENV_DATA['cluster_namespace'])
skip_list = ['ocs-operator']
for key, val in mods.items():
if key not in skip_list:
config._metadata[key] = val.rsplit('/')[-1]
gather_version_completed = True
except ResourceNotFoundError as ex:
log.error("Problem ocurred when looking for some resource! Error: %s",
ex)
except FileNotFoundError as ex:
log.error("File not found! Error: %s", ex)
except CommandFailed as ex:
log.error("Failed to execute command! Error: %s", ex)
except Exception as ex:
log.error("Failed to gather version info! Error: %s", ex)
finally:
if not gather_version_completed:
log.warning(
"Failed to gather version details! The report of version might"
"not be complete!")
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}"
)