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()