def pods(self, multi_pvc_factory, dc_pod_factory):
"""
Prepare multiple dc pods for the test
Returns:
list: Pod instances
"""
sc = default_storage_class(interface_type=constants.CEPHBLOCKPOOL)
pvc_objs = multi_pvc_factory(interface=constants.CEPHBLOCKPOOL,
storageclass=sc,
size=self.pvc_size,
num_of_pvc=self.num_of_pvcs)
pod_objs = []
for pvc_obj in pvc_objs:
pod_objs.append(dc_pod_factory(pvc=pvc_obj))
# Check for the created pvc metrics on prometheus pod
for pod_obj in pod_objs:
assert check_pvcdata_collected_on_prometheus(pod_obj.pvc.name), (
f"On prometheus pod for created pvc {pod_obj.pvc.name} related data is not collected"
)
return pod_objs
def test_install_and_run_amq_benchmark(
self,
interface,
test_fixture_amq,
):
"""
Create amq cluster and run open messages on it
"""
# Get sc
sc = default_storage_class(interface_type=interface)
# Deploy amq cluster
test_fixture_amq.setup_amq_cluster(sc.name)
# Run benchmark
amq_workload_dict = templating.load_yaml(constants.AMQ_WORKLOAD_YAML)
amq_workload_dict['producersPerTopic'] = 3
amq_workload_dict['consumerPerSubscription'] = 3
result = test_fixture_amq.run_amq_benchmark(
amq_workload_yaml=amq_workload_dict)
amq_output = test_fixture_amq.validate_amq_benchmark(
result, amq_workload_dict)
# Export pgdata to google google spreadsheet
test_fixture_amq.export_amq_output_to_gsheet(
amq_output=amq_output, sheet_name='E2E Workloads', sheet_index=1)
def amq_setup(self, amq_factory_fixture):
"""
Creates amq cluster and run benchmarks
"""
sc_name = default_storage_class(interface_type=constants.CEPHBLOCKPOOL)
self.amq, self.threads = amq_factory_fixture(
sc_name=sc_name.name
)
def amq_setup(self, amq_factory_fixture):
"""
Creates amq cluster and run benchmarks
"""
sc_name = default_storage_class(interface_type=constants.CEPHBLOCKPOOL)
self.amq_workload_dict = templating.load_yaml(
constants.AMQ_SIMPLE_WORKLOAD_YAML)
self.amq, self.thread = amq_factory_fixture(
sc_name=sc_name.name,
tiller_namespace="tiller",
amq_workload_yaml=self.amq_workload_dict,
run_in_bg=True)
def test_install_and_run_amq_benchmark(self, interface, test_fixture_amq):
"""
Create amq cluster and run open messages on it
"""
# Get sc
sc = default_storage_class(interface_type=interface)
# Deploy amq cluster
test_fixture_amq.setup_amq_cluster(sc.name)
# Run benchmark
amq_workload_dict = templating.load_yaml(constants.AMQ_WORKLOAD_YAML)
amq_workload_dict['producersPerTopic'] = 3
amq_workload_dict['consumerPerSubscription'] = 3
result = test_fixture_amq.run_amq_benchmark(
amq_workload_yaml=amq_workload_dict)
assert test_fixture_amq.validate_amq_benchmark(
result, amq_workload_dict) is not None, (
"Benchmark did not completely run or might failed in between")
def base_setup(self, interface, pvc_factory, pod_factory):
"""
A setup phase for the test:
get all the ceph pods information,
create maxsize pvc, pod and run IO
"""
osd_size = get_osd_size()
pvc_size_gb = osd_size * 1024
io_size_mb = f'{int((pvc_size_gb / 2) * 1000)}M'
pod_objs = get_all_pods(namespace=defaults.ROOK_CLUSTER_NAMESPACE,
selector=[
'noobaa', 'rook-ceph-osd-prepare',
'rook-ceph-drain-canary'
],
exclude_selector=True)
# Create maxsize pvc, app pod and run ios
self.sc = default_storage_class(interface_type=interface)
self.pvc_obj = pvc_factory(
interface=interface,
storageclass=self.sc,
size=pvc_size_gb,
)
self.pod_obj = pod_factory(interface=interface, pvc=self.pvc_obj)
log.info(f"Running FIO to fill PVC size: {io_size_mb}")
self.pod_obj.run_io('fs',
size=io_size_mb,
io_direction='write',
runtime=600)
log.info("Waiting for IO results")
self.pod_obj.get_fio_results()
return pod_objs
def test_install_amq_backed_by_ocs(self, interface, test_fixture_amq):
"""
Create amq cluster and run open messages on it
"""
# Get sc
sc = default_storage_class(interface_type=interface)
# Deploy amq cluster
test_fixture_amq.setup_amq_cluster(sc.name)
# Run open messages
test_fixture_amq.create_messaging_on_amq()
# Wait for some time to generate msg
waiting_time = 60
log.info(f"Waiting for {waiting_time}sec to generate msg")
time.sleep(waiting_time)
# Check messages are sent and received
threads = test_fixture_amq.run_in_bg()
for t in threads:
t.join()
def deploy_ocs(self):
"""
Handle OCS deployment, since OCS deployment steps are common to any
platform, implementing OCS deployment here in base class.
"""
ceph_cluster = ocp.OCP(kind='CephCluster', namespace=self.namespace)
try:
ceph_cluster.get().get('items')[0]
logger.warning("OCS cluster already exists")
return
except (IndexError, CommandFailed):
logger.info("Running OCS basic installation")
self.deploy_ocs_via_operator()
pod = ocp.OCP(kind=constants.POD, namespace=self.namespace)
cfs = ocp.OCP(kind=constants.CEPHFILESYSTEM, namespace=self.namespace)
# Check for Ceph pods
assert pod.wait_for_resource(condition='Running',
selector='app=rook-ceph-mon',
resource_count=3,
timeout=600)
assert pod.wait_for_resource(condition='Running',
selector='app=rook-ceph-mgr',
timeout=600)
assert pod.wait_for_resource(condition='Running',
selector='app=rook-ceph-osd',
resource_count=3,
timeout=600)
# validate ceph mon/osd volumes are backed by pvc
validate_cluster_on_pvc()
# validate PDB creation of MON, MDS, OSD pods
validate_pdb_creation()
# Creating toolbox pod
setup_ceph_toolbox()
assert pod.wait_for_resource(condition=constants.STATUS_RUNNING,
selector='app=rook-ceph-tools',
resource_count=1,
timeout=600)
# Check for CephFilesystem creation in ocp
cfs_data = cfs.get()
cfs_name = cfs_data['items'][0]['metadata']['name']
if helpers.validate_cephfilesystem(cfs_name):
logger.info("MDS deployment is successful!")
defaults.CEPHFILESYSTEM_NAME = cfs_name
else:
logger.error("MDS deployment Failed! Please check logs!")
# Change monitoring backend to OCS
if config.ENV_DATA.get('monitoring_enabled') and config.ENV_DATA.get(
'persistent-monitoring'):
sc = helpers.default_storage_class(
interface_type=constants.CEPHBLOCKPOOL)
# Get the list of monitoring pods
pods_list = get_all_pods(
namespace=defaults.OCS_MONITORING_NAMESPACE,
selector=['prometheus', 'alertmanager'])
# Create configmap cluster-monitoring-config and reconfigure
# storage class and telemeter server (if the url is specified in a
# config file)
create_configmap_cluster_monitoring_pod(
sc_name=sc.name,
telemeter_server_url=config.ENV_DATA.get(
"telemeter_server_url"))
# Take some time to respin the pod
waiting_time = 45
logger.info(f"Waiting {waiting_time} seconds...")
time.sleep(waiting_time)
# Validate the pods are respinned and in running state
retry((CommandFailed, ResourceWrongStatusException),
tries=3,
delay=15)(validate_pods_are_respinned_and_running_state)(
pods_list)
# Validate the pvc is created on monitoring pods
validate_pvc_created_and_bound_on_monitoring_pods()
# Validate the pvc are mounted on pods
retry((CommandFailed, AssertionError), tries=3, delay=15)(
validate_pvc_are_mounted_on_monitoring_pods)(pods_list)
elif config.ENV_DATA.get('monitoring_enabled') and config.ENV_DATA.get(
"telemeter_server_url"):
# Create configmap cluster-monitoring-config to reconfigure
# telemeter server url when 'persistent-monitoring' is False
create_configmap_cluster_monitoring_pod(
telemeter_server_url=config.ENV_DATA["telemeter_server_url"])
# Change registry backend to OCS CEPHFS RWX PVC
registry.change_registry_backend_to_ocs()
# Verify health of ceph cluster
# TODO: move destroy cluster logic to new CLI usage pattern?
logger.info("Done creating rook resources, waiting for HEALTH_OK")
try:
ceph_health_check(namespace=self.namespace, tries=30, delay=10)
except CephHealthException as ex:
err = str(ex)
logger.warning(f"Ceph health check failed with {err}")
if "clock skew detected" in err:
logger.info(f"Changing NTP on compute nodes to"
f" {constants.RH_NTP_CLOCK}")
update_ntp_compute_nodes()
assert ceph_health_check(namespace=self.namespace,
tries=60,
delay=10)
# patch gp2/thin storage class as 'non-default'
self.patch_default_sc_to_non_default()
if check_nodes_specs(min_cpu=constants.MIN_NODE_CPU,
min_memory=constants.MIN_NODE_MEMORY):
logger.info("The cluster specs meet the minimum requirements and "
"therefore, NooBaa auto scale will be enabled")
min_nb_eps = config.DEPLOYMENT.get('min_noobaa_endpoints')
max_nb_eps = config.DEPLOYMENT.get('max_noobaa_endpoints')
change_noobaa_endpoints_count(min_nb_eps=min_nb_eps,
max_nb_eps=max_nb_eps)
else:
logger.warning(
"The cluster specs do not meet the minimum requirements"
" and therefore, NooBaa auto scale will remain disabled")
change_noobaa_endpoints_count(min_nb_eps=1, max_nb_eps=1)
def create_multi_pvc_pod(
self, pods_per_iter=5, io_runtime=3600, start_io=False
):
"""
Function to create PVC of different type and attach them to PODs and start IO.
Args:
pods_per_iter (int): Number of PVC-POD to be created per PVC type
Example, If 2 then 8 PVC+POD will be created with 2 each of 4 PVC types
io_runtime (sec): Fio run time in seconds
start_io (bool): If True start IO else don't
Returns:
pod_objs (obj): Objs of all the PODs created
pvc_objs (obj): Objs of all the PVCs created
"""
rbd_sc = helpers.default_storage_class(constants.CEPHBLOCKPOOL)
cephfs_sc = helpers.default_storage_class(constants.CEPHFILESYSTEM)
pvc_size = f"{random.randrange(15, 105, 5)}Gi"
fio_size = get_size_based_on_cls_usage()
fio_rate = get_rate_based_on_cls_iops()
logging.info(f"Create {pods_per_iter * 4} PVCs and PODs")
# Create PVCs
cephfs_pvcs = helpers.create_multiple_pvc_parallel(
sc_obj=cephfs_sc, namespace=self.namespace, number_of_pvc=pods_per_iter,
size=pvc_size, access_modes=[constants.ACCESS_MODE_RWO, constants.ACCESS_MODE_RWX]
)
rbd_pvcs = helpers.create_multiple_pvc_parallel(
sc_obj=rbd_sc, namespace=self.namespace, number_of_pvc=pods_per_iter,
size=pvc_size, access_modes=[constants.ACCESS_MODE_RWO, constants.ACCESS_MODE_RWX]
)
# Appending all the pvc_obj and pod_obj to list
pvc_objs, pod_objs = ([] for i in range(2))
pvc_objs.extend(cephfs_pvcs + rbd_pvcs)
# Create pods with above pvc list
cephfs_pods = helpers.create_pods_parallel(
cephfs_pvcs, self.namespace, constants.CEPHFS_INTERFACE,
pod_dict_path=self.pod_dict_path, sa_name=self.sa_name,
dc_deployment=self.dc_deployment, node_selector=self.node_selector
)
rbd_rwo_pvc, rbd_rwx_pvc = ([] for i in range(2))
for pvc_obj in rbd_pvcs:
if pvc_obj.get_pvc_access_mode == constants.ACCESS_MODE_RWX:
rbd_rwx_pvc.append(pvc_obj)
else:
rbd_rwo_pvc.append(pvc_obj)
rbd_rwo_pods = helpers.create_pods_parallel(
rbd_rwo_pvc, self.namespace, constants.CEPHBLOCKPOOL,
pod_dict_path=self.pod_dict_path, sa_name=self.sa_name,
dc_deployment=self.dc_deployment, node_selector=self.node_selector
)
rbd_rwx_pods = helpers.create_pods_parallel(
rbd_rwx_pvc, self.namespace, constants.CEPHBLOCKPOOL,
pod_dict_path=self.pod_dict_path, sa_name=self.sa_name,
dc_deployment=self.dc_deployment, raw_block_pv=True,
node_selector=self.node_selector
)
temp_pod_objs = list()
temp_pod_objs.extend(cephfs_pods + rbd_rwo_pods)
# Appending all the pod_obj to list
pod_objs.extend(temp_pod_objs + rbd_rwx_pods)
# Start IO
import time
if start_io:
threads = list()
for pod_obj in temp_pod_objs:
process = threading.Thread(
target=pod_obj.run_io, kwargs={
'storage_type': 'fs', 'size': fio_size,
'runtime': io_runtime, 'rate': fio_rate
}
)
process.start()
threads.append(process)
time.sleep(30)
for pod_obj in rbd_rwx_pods:
process = threading.Thread(
target=pod_obj.run_io, kwargs={
'storage_type': 'block', 'size': fio_size,
'runtime': io_runtime, 'rate': fio_rate
}
)
process.start()
threads.append(process)
time.sleep(30)
for process in threads:
process.join()
return pod_objs, pvc_objs
def deploy_ocs(self):
"""
Handle OCS deployment, since OCS deployment steps are common to any
platform, implementing OCS deployment here in base class.
"""
ceph_cluster = ocp.OCP(kind='CephCluster', namespace=self.namespace)
try:
ceph_cluster.get().get('items')[0]
logger.warning("OCS cluster already exists")
return
except (IndexError, CommandFailed):
logger.info("Running OCS basic installation")
self.deploy_ocs_via_operator()
pod = ocp.OCP(kind=constants.POD, namespace=self.namespace)
cfs = ocp.OCP(kind=constants.CEPHFILESYSTEM, namespace=self.namespace)
# Check for Ceph pods
assert pod.wait_for_resource(condition='Running',
selector='app=rook-ceph-mon',
resource_count=3,
timeout=600)
assert pod.wait_for_resource(condition='Running',
selector='app=rook-ceph-mgr',
timeout=600)
assert pod.wait_for_resource(condition='Running',
selector='app=rook-ceph-osd',
resource_count=3,
timeout=600)
# validate ceph mon/osd volumes are backed by pvc
validate_cluster_on_pvc()
# validate PDB creation of MON, MDS, OSD pods
validate_pdb_creation()
# Creating toolbox pod
setup_ceph_toolbox()
assert pod.wait_for_resource(condition=constants.STATUS_RUNNING,
selector='app=rook-ceph-tools',
resource_count=1,
timeout=600)
# Workaround for https://bugzilla.redhat.com/show_bug.cgi?id=1847098
if config.DEPLOYMENT.get('local_storage'):
tools_pod = run_cmd(
f"oc -n {self.namespace} get pod -l 'app=rook-ceph-tools' "
f"-o jsonpath='{{.items[0].metadata.name}}'")
pgs_to_autoscale = [
'ocs-storagecluster-cephblockpool',
'ocs-storagecluster-cephfilesystem-data0'
]
for pg in pgs_to_autoscale:
run_cmd(f"oc -n {self.namespace} exec {tools_pod} -- "
f"ceph osd pool set {pg} pg_autoscale_mode on")
# Check for CephFilesystem creation in ocp
cfs_data = cfs.get()
cfs_name = cfs_data['items'][0]['metadata']['name']
if helpers.validate_cephfilesystem(cfs_name):
logger.info("MDS deployment is successful!")
defaults.CEPHFILESYSTEM_NAME = cfs_name
else:
logger.error("MDS deployment Failed! Please check logs!")
# Change monitoring backend to OCS
if config.ENV_DATA.get('monitoring_enabled') and config.ENV_DATA.get(
'persistent-monitoring'):
sc = helpers.default_storage_class(
interface_type=constants.CEPHBLOCKPOOL)
# Get the list of monitoring pods
pods_list = get_all_pods(
namespace=defaults.OCS_MONITORING_NAMESPACE,
selector=['prometheus', 'alertmanager'])
# Create configmap cluster-monitoring-config and reconfigure
# storage class and telemeter server (if the url is specified in a
# config file)
create_configmap_cluster_monitoring_pod(
sc_name=sc.name,
telemeter_server_url=config.ENV_DATA.get(
"telemeter_server_url"))
# Take some time to respin the pod
waiting_time = 45
logger.info(f"Waiting {waiting_time} seconds...")
time.sleep(waiting_time)
# Validate the pods are respinned and in running state
retry((CommandFailed, ResourceWrongStatusException),
tries=3,
delay=15)(validate_pods_are_respinned_and_running_state)(
pods_list)
# Validate the pvc is created on monitoring pods
validate_pvc_created_and_bound_on_monitoring_pods()
# Validate the pvc are mounted on pods
retry((CommandFailed, AssertionError), tries=3, delay=15)(
validate_pvc_are_mounted_on_monitoring_pods)(pods_list)
elif config.ENV_DATA.get('monitoring_enabled') and config.ENV_DATA.get(
"telemeter_server_url"):
# Create configmap cluster-monitoring-config to reconfigure
# telemeter server url when 'persistent-monitoring' is False
create_configmap_cluster_monitoring_pod(
telemeter_server_url=config.ENV_DATA["telemeter_server_url"])
# Change registry backend to OCS CEPHFS RWX PVC
registry.change_registry_backend_to_ocs()
# Verify health of ceph cluster
# TODO: move destroy cluster logic to new CLI usage pattern?
logger.info("Done creating rook resources, waiting for HEALTH_OK")
assert ceph_health_check(namespace=self.namespace)
# patch gp2/thin storage class as 'non-default'
self.patch_default_sc_to_non_default()
def factory(interface=constants.CEPHBLOCKPOOL,
project=None,
storageclass=None,
size=None,
access_mode=constants.ACCESS_MODE_RWO,
custom_data=None,
status=constants.STATUS_BOUND,
volume_mode=None):
"""
Args:
interface (str): CephBlockPool or CephFileSystem. This decides
whether a RBD based or CephFS resource is created.
RBD is default.
project (object): ocs_ci.ocs.resources.ocs.OCS instance
of 'Project' kind.
storageclass (object): ocs_ci.ocs.resources.ocs.OCS instance
of 'StorageClass' kind.
size (int): The requested size for the PVC
access_mode (str): ReadWriteOnce, ReadOnlyMany or ReadWriteMany.
This decides the access mode to be used for the PVC.
ReadWriteOnce is default.
custom_data (dict): If provided then PVC object is created
by using these data. Parameters `project` and `storageclass`
are not used but reference is set if provided.
status (str): If provided then factory waits for object to reach
desired state.
volume_mode (str): Volume mode for PVC.
eg: volume_mode='Block' to create rbd `block` type volume
Returns:
object: helpers.create_pvc instance.
"""
if custom_data:
pvc_obj = PVC(**custom_data)
pvc_obj.create(do_reload=False)
else:
nonlocal active_project
nonlocal active_rbd_storageclass
nonlocal active_cephfs_storageclass
project = project or active_project or project_factory()
active_project = project
if interface == constants.CEPHBLOCKPOOL:
storageclass = storageclass or helpers.default_storage_class(
interface_type=interface)
active_rbd_storageclass = storageclass
elif interface == constants.CEPHFILESYSTEM:
storageclass = storageclass or helpers.default_storage_class(
interface_type=interface)
active_cephfs_storageclass = storageclass
pvc_size = f"{size}Gi" if size else None
pvc_obj = helpers.create_pvc(sc_name=storageclass.name,
namespace=project.namespace,
size=pvc_size,
do_reload=False,
access_mode=access_mode,
volume_mode=volume_mode)
assert pvc_obj, "Failed to create PVC"
if status:
helpers.wait_for_resource_state(pvc_obj, status)
pvc_obj.storageclass = storageclass
pvc_obj.project = project
pvc_obj.access_mode = access_mode
instances.append(pvc_obj)
return pvc_obj
def factory(interface=constants.CEPHBLOCKPOOL,
project=None,
storageclass=None,
size=None,
access_modes=None,
access_modes_selection='distribute_sequential',
access_mode_dist_ratio=None,
status=constants.STATUS_BOUND,
num_of_pvc=1,
wait_each=False):
"""
Args:
interface (str): CephBlockPool or CephFileSystem. This decides
whether a RBD based or CephFS resource is created.
RBD is default.
project (object): ocs_ci.ocs.resources.ocs.OCS instance
of 'Project' kind.
storageclass (object): ocs_ci.ocs.resources.ocs.OCS instance
of 'StorageClass' kind.
size (int): The requested size for the PVC
access_modes (list): List of access modes. One of the access modes
will be chosen for creating each PVC. If not specified,
ReadWriteOnce will be selected for all PVCs. To specify
volume mode, append volume mode in the access mode name
separated by '-'.
eg: ['ReadWriteOnce', 'ReadOnlyMany', 'ReadWriteMany',
'ReadWriteMany-Block']
access_modes_selection (str): Decides how to select accessMode for
each PVC from the options given in 'access_modes' list.
Values are 'select_random', 'distribute_random'
'select_random' : While creating each PVC, one access mode will
be selected from the 'access_modes' list.
'distribute_random' : The access modes in the list
'access_modes' will be distributed based on the values in
'distribute_ratio' and the order in which PVCs are created
will not be based on the access modes. For example, 1st and
6th PVC might have same access mode.
'distribute_sequential' :The access modes in the list
'access_modes' will be distributed based on the values in
'distribute_ratio' and the order in which PVCs are created
will be as sets of PVCs of same assess mode. For example,
first set of 10 will be having same access mode followed by
next set of 13 with a different access mode.
access_mode_dist_ratio (list): Contains the number of PVCs to be
created for each access mode. If not specified, the given list
of access modes will be equally distributed among the PVCs.
eg: [10,12] for num_of_pvc=22 and
access_modes=['ReadWriteOnce', 'ReadWriteMany']
status (str): If provided then factory waits for object to reach
desired state.
num_of_pvc(int): Number of PVCs to be created
wait_each(bool): True to wait for each PVC to be in status 'status'
before creating next PVC, False otherwise
Returns:
list: objects of PVC class.
"""
pvc_list = []
if wait_each:
status_tmp = status
else:
status_tmp = ""
project = project or project_factory()
storageclass = storageclass or helpers.default_storage_class(
interface_type=interface)
access_modes = access_modes or [constants.ACCESS_MODE_RWO]
access_modes_list = []
if access_modes_selection == 'select_random':
for _ in range(num_of_pvc):
mode = random.choice(access_modes)
access_modes_list.append(mode)
else:
if not access_mode_dist_ratio:
num_of_modes = len(access_modes)
dist_val = floor(num_of_pvc / num_of_modes)
access_mode_dist_ratio = [dist_val] * num_of_modes
access_mode_dist_ratio[-1] = (dist_val +
(num_of_pvc % num_of_modes))
zipped_share = list(zip(access_modes, access_mode_dist_ratio))
for mode, share in zipped_share:
access_modes_list.extend([mode] * share)
if access_modes_selection == 'distribute_random':
random.shuffle(access_modes_list)
for access_mode in access_modes_list:
if '-' in access_mode:
access_mode, volume_mode = access_mode.split('-')
else:
volume_mode = ''
pvc_obj = pvc_factory(interface=interface,
project=project,
storageclass=storageclass,
size=size,
access_mode=access_mode,
status=status_tmp,
volume_mode=volume_mode)
pvc_list.append(pvc_obj)
pvc_obj.project = project
if status and not wait_each:
for pvc_obj in pvc_list:
helpers.wait_for_resource_state(pvc_obj, status)
return pvc_list
def deploy_ocs(self):
"""
Handle OCS deployment, since OCS deployment steps are common to any
platform, implementing OCS deployment here in base class.
"""
ceph_cluster = ocp.OCP(
kind='CephCluster', namespace=self.namespace
)
try:
ceph_cluster.get().get('items')[0]
logger.warning("OCS cluster already exists")
return
except (IndexError, CommandFailed):
logger.info("Running OCS basic installation")
self.deploy_ocs_via_operator()
pod = ocp.OCP(
kind=constants.POD, namespace=self.namespace
)
cfs = ocp.OCP(
kind=constants.CEPHFILESYSTEM,
namespace=self.namespace
)
# Check for Ceph pods
assert pod.wait_for_resource(
condition='Running', selector='app=rook-ceph-mon',
resource_count=3, timeout=600
)
assert pod.wait_for_resource(
condition='Running', selector='app=rook-ceph-mgr',
timeout=600
)
assert pod.wait_for_resource(
condition='Running', selector='app=rook-ceph-osd',
resource_count=3, timeout=600
)
# validate ceph mon/osd volumes are backed by pvc
validate_cluster_on_pvc()
# Creating toolbox pod
setup_ceph_toolbox()
assert pod.wait_for_resource(
condition=constants.STATUS_RUNNING,
selector='app=rook-ceph-tools', resource_count=1, timeout=600
)
# Check for CephFilesystem creation in ocp
cfs_data = cfs.get()
cfs_name = cfs_data['items'][0]['metadata']['name']
if helpers.validate_cephfilesystem(cfs_name):
logger.info(f"MDS deployment is successful!")
defaults.CEPHFILESYSTEM_NAME = cfs_name
else:
logger.error(
f"MDS deployment Failed! Please check logs!"
)
# Change monitoring backend to OCS
if config.ENV_DATA.get('monitoring_enabled') and config.ENV_DATA.get('persistent-monitoring'):
sc = helpers.default_storage_class(interface_type=constants.CEPHBLOCKPOOL)
# Get the list of monitoring pods
pods_list = get_all_pods(
namespace=defaults.OCS_MONITORING_NAMESPACE,
selector=['prometheus', 'alertmanager']
)
# Create configmap cluster-monitoring-config and reconfigure
# storage class and telemeter server (if the url is specified in a
# config file)
create_configmap_cluster_monitoring_pod(
sc_name=sc.name,
telemeter_server_url=config.ENV_DATA.get("telemeter_server_url"))
# Take some time to respin the pod
waiting_time = 45
logger.info(f"Waiting {waiting_time} seconds...")
time.sleep(waiting_time)
# Validate the pods are respinned and in running state
validate_pods_are_respinned_and_running_state(
pods_list
)
# Validate the pvc is created on monitoring pods
validate_pvc_created_and_bound_on_monitoring_pods()
# Validate the pvc are mounted on pods
validate_pvc_are_mounted_on_monitoring_pods(pods_list)
elif config.ENV_DATA.get('monitoring_enabled') and config.ENV_DATA.get("telemeter_server_url"):
# Create configmap cluster-monitoring-config to reconfigure
# telemeter server url when 'persistent-monitoring' is False
create_configmap_cluster_monitoring_pod(
telemeter_server_url=config.ENV_DATA["telemeter_server_url"])
# Change registry backend to OCS CEPHFS RWX PVC
registry.change_registry_backend_to_ocs()
# Verify health of ceph cluster
# TODO: move destroy cluster logic to new CLI usage pattern?
logger.info("Done creating rook resources, waiting for HEALTH_OK")
assert ceph_health_check(
namespace=self.namespace
)
# patch gp2/thin storage class as 'non-default'
self.patch_default_sc_to_non_default()
