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