def measure_create_snapshot_time(self, pvc_name, snap_name, namespace, interface, start_time=None): """ Creation volume snapshot, and measure the creation time Args: pvc_name (str): the PVC name to create a snapshot of snap_name (str): the name of the snapshot to be created interface (str): the interface (rbd / cephfs) to used Returns: int : the snapshot creation time in seconds """ # Find the snapshot yaml according to the interface snap_yaml = constants.CSI_RBD_SNAPSHOT_YAML if interface == constants.CEPHFILESYSTEM: snap_yaml = constants.CSI_CEPHFS_SNAPSHOT_YAML # Create the Snapshot of the PVC self.snap_obj = pvc.create_pvc_snapshot( pvc_name=pvc_name, snap_yaml=snap_yaml, snap_name=snap_name, namespace=namespace, sc_name=helpers.default_volumesnapshotclass(interface).name, ) # Wait until the snapshot is bound and ready to use self.snap_obj.ocp.wait_for_resource( condition="true", resource_name=self.snap_obj.name, column=constants.STATUS_READYTOUSE, timeout=600, ) # Getting the snapshot content name self.snap_content = helpers.get_snapshot_content_obj(self.snap_obj) self.snap_uid = (self.snap_content.data.get("spec").get( "volumeSnapshotRef").get("uid")) log.info(f"The snapshot UID is :{self.snap_uid}") # Measure the snapshot creation time c_time = performance_lib.measure_total_snapshot_creation_time( snap_name, start_time) return c_time
def test_pvc_snapshot(self, interface_iterate, teardown_factory): """ 1. Create PVC, POD's 2. Create own volumesnapshotclass 3. Take a snapshot of PVC from created snapshotclass 4. Delete the volumesnapshotclass used to create the above volume snapshot 5. Check the status of volume snapshot """ # Create own snapshotclass snapclass_obj = self.create_snapshotclass(interface=self.interface) teardown_factory(snapclass_obj) # Take a snapshot from created snapshotclass snap_yaml = ( constants.CSI_CEPHFS_SNAPSHOT_YAML if self.interface == constants.CEPHFILESYSTEM else constants.CSI_RBD_SNAPSHOT_YAML ) snap_name = helpers.create_unique_resource_name("test", "snapshot") snap_obj = pvc.create_pvc_snapshot( self.pvc_obj.name, snap_yaml, snap_name, self.pvc_obj.namespace, snapclass_obj.name, ) snap_obj.ocp.wait_for_resource( condition="true", resource_name=snap_obj.name, column=constants.STATUS_READYTOUSE, timeout=60, ) teardown_factory(snap_obj) snap_obj_get = snap_obj.get() # Delete the volumesnapshotclass used to create the above volume snapshot log.info( "Delete the volumesnapshotclass used to create the above volume snapshot" ) snapclass_obj.delete() # Verify volumesnapshotclass deleted try: snapclass_obj.get() except CommandFailed as ex: if ( f'volumesnapshotclasses.snapshot.storage.k8s.io "{snapclass_obj.name}" not found' not in str(ex) ): log.error("Volumesnapshotclass not deleted") raise ex log.info("Volumesnapshotclass deleted succesfully") # Check the status of snapshots are in Ready state snap_obj.ocp.wait_for_resource( condition="true", resource_name=snap_obj.name, column=constants.STATUS_READYTOUSE, timeout=60, ) # Check the status of snapshot contents are in Ready state snapshotcontent_name = snap_obj_get["status"]["boundVolumeSnapshotContentName"] snapshotcontent_obj = OCP( kind=constants.VOLUMESNAPSHOTCONTENT, namespace=snap_obj.namespace ) snapshotcontent_obj.wait_for_resource( condition="true", resource_name=snapshotcontent_name, column=constants.STATUS_READYTOUSE, timeout=60, )
def test_pvc_snapshot(self, interface, teardown_factory): """ 1. Run I/O on a pod file. 2. Calculate md5sum of the file. 3. Take a snapshot of the PVC. 4. Create a new PVC out of that snapshot. 5. Attach a new pod to it. 6. Verify that the file is present on the new pod also. 7. Verify that the md5sum of the file on the new pod matches with the md5sum of the file on the original pod. Args: interface(str): The type of the interface (e.g. CephBlockPool, CephFileSystem) pvc_factory: A fixture to create new pvc teardown_factory: A fixture to destroy objects """ log.info(f"Running IO on pod {self.pod_obj.name}") file_name = self.pod_obj.name log.info(f"File created during IO {file_name}") self.pod_obj.run_io(storage_type="fs", size="1G", fio_filename=file_name) # Wait for fio to finish fio_result = self.pod_obj.get_fio_results() err_count = fio_result.get("jobs")[0].get("error") assert err_count == 0, (f"IO error on pod {self.pod_obj.name}. " f"FIO result: {fio_result}") log.info(f"Verified IO on pod {self.pod_obj.name}.") # Verify presence of the file file_path = pod.get_file_path(self.pod_obj, file_name) log.info(f"Actual file path on the pod {file_path}") assert pod.check_file_existence( self.pod_obj, file_path), f"File {file_name} doesn't exist" log.info(f"File {file_name} exists in {self.pod_obj.name}") # Calculate md5sum orig_md5_sum = pod.cal_md5sum(self.pod_obj, file_name) # Take a snapshot snap_yaml = constants.CSI_RBD_SNAPSHOT_YAML if interface == constants.CEPHFILESYSTEM: snap_yaml = constants.CSI_CEPHFS_SNAPSHOT_YAML snap_name = helpers.create_unique_resource_name("test", "snapshot") snap_obj = pvc.create_pvc_snapshot( self.pvc_obj.name, snap_yaml, snap_name, self.pvc_obj.namespace, helpers.default_volumesnapshotclass(interface).name, ) snap_obj.ocp.wait_for_resource( condition="true", resource_name=snap_obj.name, column=constants.STATUS_READYTOUSE, timeout=60, ) teardown_factory(snap_obj) # Same Storage class of the original PVC sc_name = self.pvc_obj.backed_sc # Size should be same as of the original PVC pvc_size = str(self.pvc_obj.size) + "Gi" # Create pvc out of the snapshot # Both, the snapshot and the restore PVC should be in same namespace restore_pvc_name = helpers.create_unique_resource_name( "test", "restore-pvc") restore_pvc_yaml = constants.CSI_RBD_PVC_RESTORE_YAML if interface == constants.CEPHFILESYSTEM: restore_pvc_yaml = constants.CSI_CEPHFS_PVC_RESTORE_YAML restore_pvc_obj = pvc.create_restore_pvc( sc_name=sc_name, snap_name=snap_obj.name, namespace=snap_obj.namespace, size=pvc_size, pvc_name=restore_pvc_name, restore_pvc_yaml=restore_pvc_yaml, ) helpers.wait_for_resource_state(restore_pvc_obj, constants.STATUS_BOUND) restore_pvc_obj.reload() teardown_factory(restore_pvc_obj) # Create and attach pod to the pvc restore_pod_obj = helpers.create_pod( interface_type=interface, pvc_name=restore_pvc_obj.name, namespace=snap_obj.namespace, pod_dict_path=constants.NGINX_POD_YAML, ) # Confirm that the pod is running helpers.wait_for_resource_state(resource=restore_pod_obj, state=constants.STATUS_RUNNING) restore_pod_obj.reload() teardown_factory(restore_pod_obj) # Verify that the file is present on the new pod log.info(f"Checking the existence of {file_name} " f"on restore pod {restore_pod_obj.name}") assert pod.check_file_existence( restore_pod_obj, file_path), f"File {file_name} doesn't exist" log.info(f"File {file_name} exists in {restore_pod_obj.name}") # Verify that the md5sum matches log.info(f"Verifying that md5sum of {file_name} " f"on pod {self.pod_obj.name} matches with md5sum " f"of the same file on restore pod {restore_pod_obj.name}") assert pod.verify_data_integrity( restore_pod_obj, file_name, orig_md5_sum), "Data integrity check failed" log.info("Data integrity check passed, md5sum are same") log.info("Running IO on new pod") # Run IO on new pod restore_pod_obj.run_io(storage_type="fs", size="1G", runtime=20) # Wait for fio to finish restore_pod_obj.get_fio_results() log.info("IO finished o new pod")