def create_storageclass_cephfs(): """ Function for creating CephFs storageclass """ helpers.create_storage_class(constants.CEPHFILESYSTEM, helpers.get_cephfs_data_pool_name(), CEPHFS_SECRET_OBJ.name) return True
def setup_fs(): log.info("Creating CEPHFS Secret") global CEPHFS_SECRET_OBJ CEPHFS_SECRET_OBJ = helpers.create_secret(constants.CEPHFILESYSTEM) global CEPHFS_SC_OBJ log.info("Creating CephFS Storage class ") CEPHFS_SC_OBJ = helpers.create_storage_class( constants.CEPHFILESYSTEM, helpers.get_cephfs_data_pool_name(), CEPHFS_SECRET_OBJ.name)
def test_create_multiple_sc_with_same_pool_name(self, interface_type, resources): """ This test function does below, *. Creates multiple Storage Classes with same pool name *. Creates PVCs using each Storage Class *. Mount each PVC to an app pod *. Run IO on each app pod """ # Unpack resources pods, pvcs, storageclasses = resources # Create 3 Storage Classes with same pool name if interface_type == constants.CEPHBLOCKPOOL: secret = self.rbd_secret_obj.name interface_name = self.cbp_obj.name else: interface_type = constants.CEPHFILESYSTEM secret = self.cephfs_secret_obj.name interface_name = helpers.get_cephfs_data_pool_name() for i in range(3): log.info(f"Creating a {interface_type} storage class") storageclasses.append( helpers.create_storage_class(interface_type=interface_type, interface_name=interface_name, secret_name=secret)) log.info(f"{interface_type}StorageClass: {storageclasses[i].name} " f"created successfully") # Create PVCs using each SC for i in range(3): log.info(f"Creating a PVC using {storageclasses[i].name}") pvcs.append(helpers.create_pvc(storageclasses[i].name)) log.info(f"PVC: {pvcs[i].name} created successfully using " f"{storageclasses[i].name}") # Create app pod and mount each PVC for i in range(3): log.info(f"Creating an app pod and mount {pvcs[i].name}") pods.append( helpers.create_pod(interface_type=interface_type, pvc_name=pvcs[i].name, desired_status=constants.STATUS_RUNNING, wait=True, namespace=defaults.ROOK_CLUSTER_NAMESPACE)) log.info(f"{pods[i].name} created successfully and " f"mounted {pvcs[i].name}") # Run IO on each app pod for sometime for pod in pods: log.info(f"Running FIO on {pod.name}") pod.run_io('fs', size='2G') for pod in pods: get_fio_rw_iops(pod)
def test_create_storage_class_with_wrong_provisioner(self, interface): """ Test function which creates Storage Class with wrong provisioner and verifies PVC status """ log.info(f"Creating a {interface} storage class") if interface == "RBD": interface_type = constants.CEPHBLOCKPOOL secret = self.rbd_secret_obj.name interface_name = self.cbp_obj.name else: interface_type = constants.CEPHFILESYSTEM secret = self.cephfs_secret_obj.name interface_name = helpers.get_cephfs_data_pool_name() sc_obj = helpers.create_storage_class( interface_type=interface_type, interface_name=interface_name, secret_name=secret, provisioner=constants.AWS_EFS_PROVISIONER) log.info( f"{interface}Storage class: {sc_obj.name} created successfully") # Create PVC pvc_obj = helpers.create_pvc(sc_name=sc_obj.name, do_reload=False) # Check PVC status pvc_output = pvc_obj.get() pvc_status = pvc_output['status']['phase'] log.info(f"Status of PVC {pvc_obj.name} after creation: {pvc_status}") log.info(f"Waiting for status '{constants.STATUS_PENDING}' " f"for 20 seconds (it shouldn't change)") pvc_obj.ocp.wait_for_resource(resource_name=pvc_obj.name, condition=constants.STATUS_PENDING, timeout=20, sleep=5) # Check PVC status again after 20 seconds pvc_output = pvc_obj.get() pvc_status = pvc_output['status']['phase'] assert_msg = ( f"PVC {pvc_obj.name} is not in {constants.STATUS_PENDING} " f"status") assert pvc_status == constants.STATUS_PENDING, assert_msg log.info(f"Status of {pvc_obj.name} after 20 seconds: {pvc_status}") # Delete PVC log.info(f"Deleting PVC: {pvc_obj.name}") assert pvc_obj.delete() log.info(f"PVC {pvc_obj.name} delete successfully") # Delete Storage Class log.info(f"Deleting Storageclass: {sc_obj.name}") assert sc_obj.delete() log.info(f"Storage Class: {sc_obj.name} deleted successfully")
def dynamic_pvc_base(self, interface_type, reclaim_policy): """ Base function for Dynamic PVC creation tests Fetches the worker nodes name list, creates StorageClass and PVC """ self.interface_type = interface_type self.reclaim_policy = reclaim_policy self.worker_nodes_list = helpers.get_worker_nodes() if self.interface_type == constants.CEPHBLOCKPOOL: self.interface_name = self.cbp_obj.name self.secret_name = self.rbd_secret_obj.name elif self.interface_type == constants.CEPHFILESYSTEM: self.interface_name = helpers.get_cephfs_data_pool_name() self.secret_name = self.cephfs_secret_obj.name logger.info( f"Creating Storage Class with reclaimPolicy: {self.reclaim_policy}" ) self.sc_obj = helpers.create_storage_class( interface_type=self.interface_type, interface_name=self.interface_name, secret_name=self.secret_name, reclaim_policy=self.reclaim_policy ) logger.info(f"Creating PVC with accessModes: {self.access_mode}") self.pvc_obj = helpers.create_pvc( sc_name=self.sc_obj.name, namespace=self.namespace, size=self.pvc_size, access_mode=self.access_mode ) helpers.wait_for_resource_state(self.pvc_obj, constants.STATUS_BOUND) self.pvc_obj.reload() logger.info( f"Creating first pod on node: {self.worker_nodes_list[0]}" f" with pvc {self.pvc_obj.name}" ) self.pod_obj1 = helpers.create_pod( interface_type=self.interface_type, pvc_name=self.pvc_obj.name, namespace=self.namespace, node_name=self.worker_nodes_list[0], pod_dict_path=constants.NGINX_POD_YAML ) helpers.wait_for_resource_state(self.pod_obj1, constants.STATUS_RUNNING) self.pod_obj1.reload()
def factory( interface=constants.CEPHBLOCKPOOL, secret=None, custom_data=None, sc_name=None, reclaim_policy=constants.RECLAIM_POLICY_DELETE ): """ Args: interface (str): CephBlockPool or CephFileSystem. This decides whether a RBD based or CephFS resource is created. RBD is default. secret (object): An OCS instance for the secret. custom_data (dict): If provided then storageclass object is created by using these data. Parameters `block_pool` and `secret` are not useds but references are set if provided. sc_name (str): Name of the storage class Returns: object: helpers.create_storage_class instance with links to block_pool and secret. """ if custom_data: sc_obj = helpers.create_resource(**custom_data) else: secret = secret or secret_factory(interface=interface) ceph_pool = ceph_pool_factory(interface) if interface == constants.CEPHBLOCKPOOL: interface_name = ceph_pool.name elif interface == constants.CEPHFILESYSTEM: interface_name = helpers.get_cephfs_data_pool_name() sc_obj = helpers.create_storage_class( interface_type=interface, interface_name=interface_name, secret_name=secret.name, sc_name=sc_name, reclaim_policy=reclaim_policy ) assert sc_obj, f"Failed to create {interface} storage class" sc_obj.ceph_pool = ceph_pool sc_obj.secret = secret instances.append(sc_obj) return sc_obj
def create_cephfs_storageclass(request): """ Create a CephFS storage class """ class_instance = request.node.cls def finalizer(): """ Delete the CephFS storage class """ if class_instance.sc_obj.get(): class_instance.sc_obj.delete() class_instance.sc_obj.ocp.wait_for_delete( class_instance.sc_obj.name) request.addfinalizer(finalizer) class_instance.sc_obj = helpers.create_storage_class( interface_type=constants.CEPHFILESYSTEM, interface_name=helpers.get_cephfs_data_pool_name(), secret_name=class_instance.cephfs_secret_obj.name) assert class_instance.sc_obj, f"Failed to create storage class"
def validate_cluster(self, resources, instances): """ Perform cluster validation - nodes readiness, Ceph cluster health check and functional resources tests """ instances_names = list(instances.values()) assert ocp.wait_for_nodes_ready(instances_names), ( "Not all nodes reached status Ready" ) ceph_cluster = CephCluster() assert ceph_health_check( namespace=config.ENV_DATA['cluster_namespace'] ) ceph_cluster.cluster_health_check(timeout=60) # Create resources and run IO for both FS and RBD # Unpack resources projects, secrets, pools, storageclasses, pvcs, pods = resources[:6] # Project projects.append(helpers.create_project()) # Secrets secrets.append(helpers.create_secret(constants.CEPHBLOCKPOOL)) secrets.append(helpers.create_secret(constants.CEPHFILESYSTEM)) # Pools pools.append(helpers.create_ceph_block_pool()) pools.append(helpers.get_cephfs_data_pool_name()) # Storageclasses storageclasses.append( helpers.create_storage_class( interface_type=constants.CEPHBLOCKPOOL, interface_name=pools[0].name, secret_name=secrets[0].name ) ) storageclasses.append( helpers.create_storage_class( interface_type=constants.CEPHFILESYSTEM, interface_name=pools[1], secret_name=secrets[1].name ) ) # PVCs pvcs.append(helpers.create_pvc( sc_name=storageclasses[0].name, namespace=projects[0].namespace) ) pvcs.append(helpers.create_pvc( sc_name=storageclasses[1].name, namespace=projects[0].namespace) ) # Pods pods.append( helpers.create_pod( interface_type=constants.CEPHBLOCKPOOL, pvc_name=pvcs[0].name, namespace=projects[0].namespace ) ) pods.append( helpers.create_pod( interface_type=constants.CEPHFILESYSTEM, pvc_name=pvcs[1].name, namespace=projects[0].namespace ) ) # Run IO for pod in pods: pod.run_io('fs', '1G') for pod in pods: fio_result = pod.get_fio_results() logger.info(f"IOPs after FIO for pod {pod.name}:") logger.info( f"Read: {fio_result.get('jobs')[0].get('read').get('iops')}" ) logger.info( f"Write: {fio_result.get('jobs')[0].get('write').get('iops')}" )
def create_resources(resources, run_io=True): """ Sanity validation - Create resources (FS and RBD) and run IO Args: resources (tuple): Lists of projects, secrets, pools, storageclasses, pvcs and pods run_io (bool): True for run IO, False otherwise """ # Create resources and run IO for both FS and RBD # Unpack resources projects, secrets, pools, storageclasses, pvcs, pods = resources[:6] # Project projects.append(helpers.create_project()) # Secrets secrets.append(helpers.create_secret(constants.CEPHBLOCKPOOL)) secrets.append(helpers.create_secret(constants.CEPHFILESYSTEM)) # Pools pools.append(helpers.create_ceph_block_pool()) pools.append(helpers.get_cephfs_data_pool_name()) # Storageclasses storageclasses.append( helpers.create_storage_class(interface_type=constants.CEPHBLOCKPOOL, interface_name=pools[0].name, secret_name=secrets[0].name)) storageclasses.append( helpers.create_storage_class(interface_type=constants.CEPHFILESYSTEM, interface_name=pools[1], secret_name=secrets[1].name)) # PVCs pvcs.append( helpers.create_pvc(sc_name=storageclasses[0].name, namespace=projects[0].namespace)) pvcs.append( helpers.create_pvc(sc_name=storageclasses[1].name, namespace=projects[0].namespace)) for pvc in pvcs: helpers.wait_for_resource_state(pvc, constants.STATUS_BOUND) pvc.reload() # Pods pods.append( helpers.create_pod(interface_type=constants.CEPHBLOCKPOOL, pvc_name=pvcs[0].name, namespace=projects[0].namespace)) pods.append( helpers.create_pod(interface_type=constants.CEPHFILESYSTEM, pvc_name=pvcs[1].name, namespace=projects[0].namespace)) for pod in pods: helpers.wait_for_resource_state(pod, constants.STATUS_RUNNING) pod.reload() if run_io: # Run IO for pod in pods: pod.run_io('fs', '1G') for pod in pods: fio_result = pod.get_fio_results() logger.info(f"IOPs after FIO for pod {pod.name}:") logger.info( f"Read: {fio_result.get('jobs')[0].get('read').get('iops')}") logger.info( f"Write: {fio_result.get('jobs')[0].get('write').get('iops')}")