def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573878 Verify the option to enable/disable multiFS support
Pre-requisites :
1. We need atleast one client node to execute this test case
Test Case Flow:
1. check the enable_multiple flag value
2. Get total number of filesystems present
3. Disable enable_multiple if enabled and try creating filesystem
4. Enable enable_multiple and try creating filesystem
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if not clients:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
client1 = clients[0]
total_fs = fs_util.get_fs_details(client1)
if len(total_fs) == 1:
client1.exec_command(sudo=True,
cmd="ceph fs flag set enable_multiple false")
out, rc = client1.exec_command(sudo=True,
cmd="ceph fs volume create cephfs_new",
check_ec=False)
if rc == 0:
raise CommandFailed(
"We are able to create multipe filesystems even after setting enable_multiple to false"
)
log.info(
"We are not able to create multipe filesystems after setting enable_multiple to false as expected"
)
client1.exec_command(sudo=True,
cmd="ceph fs flag set enable_multiple true")
client1.exec_command(sudo=True, cmd="ceph fs volume create cephfs_new")
log.info(
"We are able to create multipe filesystems after setting enable_multiple to True as expected"
)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
commands = [
"ceph config set mon mon_allow_pool_delete true",
"ceph fs volume rm cephfs_new --yes-i-really-mean-it",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
def run(ceph_cluster, **kw):
"""
pre-requisites:
1. Create a volume with a name
2. Create a subvolume with a name
3. Create a subvolume group with a name
Test operation:
1. Try to create a volume with the same name
2. Try to create a subvolume with the same name
3. Try to create a subvolume group with the same name
"""
try:
tc = "CEPH-83573428"
log.info(f"Running CephFS tests for BZ-{tc}")
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
fs_util.auth_list([client1])
fs_util.prepare_clients(clients, build)
random_name = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(5)))
volume_name = "vol_01" + random_name
subvolume_name = "subvol_01" + random_name
subvolume_group_name = "subvol_group_name_01" + random_name
log.info("Ceph Build number is " + build[0])
fs_util.create_fs(client1, volume_name)
fs_util.create_subvolume(client1, volume_name, subvolume_name)
fs_util.create_subvolumegroup(client1, "cephfs", subvolume_group_name)
output1, err1 = fs_util.create_fs(client1, volume_name, check_ec=False)
output2, err2 = fs_util.create_subvolume(client1,
volume_name,
subvolume_name,
check_ec=False)
output3, err3 = fs_util.create_subvolumegroup(client1,
volume_name,
subvolume_name,
check_ec=False)
if output1 == 0 or output2 == 0 or output3 == 0:
return 1
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
try:
log.info(f"MetaData Information {log.metadata} in {__name__}")
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10))
)
fuse_mounting_dir = f"/mnt/cephfs_fuse{mounting_dir}/"
fs_util.fuse_mount(clients, fuse_mounting_dir)
mount_test_case(clients, fuse_mounting_dir)
kernel_mounting_dir = f"/mnt/cephfs_kernel{mounting_dir}/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(clients, kernel_mounting_dir, ",".join(mon_node_ips))
mount_test_case(clients, kernel_mounting_dir)
log.info("Cleaning up!-----")
rc = fs_util.client_clean_up(
[],
clients,
kernel_mounting_dir,
"umount",
)
if rc != 0:
raise CommandFailed("fuse clients cleanup failed")
log.info("Fuse clients cleaned up successfully")
rc = fs_util.client_clean_up(
clients,
[],
fuse_mounting_dir,
"umount",
)
if rc != 0:
raise CommandFailed("kernel clients cleanup failed")
log.info("kernel clients cleaned up successfully")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573873 Try creating 2 Filesystem using same Pool(negative)
Pre-requisites :
1. We need atleast one client node to execute this test case
Test Case Flow:
1. Check if cephfs filesystem is present, if not create cephfs
2. collect data pool and meta datapool info of cephfs
3. try creating cephfs1 with data pool and meta datapool of cephfs
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if not clients:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
fs_details = fs_util.get_fs_info(client1)
out, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs new cephfs1 {fs_details['metadata_pool_name']} {fs_details['data_pool_name']}",
check_ec=False,
)
if rc == 0:
raise CommandFailed(
"We are able to create filesystems with same pool used by other filesystem"
)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. We need atleast one client node to execute this test case
1. creats fs volume create cephfs if the volume is not there
2. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvolgroup_1
3. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_
4. Create Data on the subvolume
Ex: python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 --files
100 --files-per-dir 10 --dirs-per-dir 2 --top /mnt/cephfs_fuse1baxgbpaia_1/
5. Create snapshot of the subvolume
Ex: ceph fs subvolume snapshot create cephfs subvol_2 snap_1 --group_name subvolgroup_1
Concurrent Clone Operations:
1. Validate default value foe the clones i.e., 4
2. Create 5 clones of the snap_1
Ex: ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_1 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_2 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_3 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_4 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_5 --group_name subvolgroup_1
3. Get the status of each clone using below command
Ex: ceph fs clone status cephfs clone_1
ceph fs clone status cephfs clone_2
ceph fs clone status cephfs clone_3
ceph fs clone status cephfs clone_4
ceph fs clone status cephfs clone_5
4. We are validating the total clones in_progress should not be greater than 4
5. Once all the clones moved to complete state we are deleting all the clones
6. Set the concurrent threads to 2
Ex: ceph config set mgr mgr/volumes/max_concurrent_clones 2
7. Create 5 clones of the snap_1
Ex: ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_1 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_2 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_3 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_4 --group_name subvolgroup_1
ceph fs subvolume snapshot clone cephfs subvol_2 snap_1 clone_5 --group_name subvolgroup_1
8. Get the status of each clone using below command
Ex: ceph fs clone status cephfs clone_1
ceph fs clone status cephfs clone_2
ceph fs clone status cephfs clone_3
ceph fs clone status cephfs clone_4
ceph fs clone status cephfs clone_5
9. We are validating the total clones in_progress should not be greater than 2
10.Once all the clones moved to complete state we are deleting all the clones
Clean-up:
1. ceph fs snapshot rm <vol_name> <subvol_name> snap_name [--group_name <subvol_group_name>]
2. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
3. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup = {
"vol_name": default_fs,
"group_name": "subvolgroup_1"
}
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_2",
"group_name": "subvolgroup_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_2 subvolgroup_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[client1],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.read().decode().strip()}",
)
out, rc = client1.exec_command(
sudo=True,
cmd=
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4000 "
f"--files 100 --files-per-dir 10 --dirs-per-dir 2 --top "
f"{fuse_mounting_dir_1}",
long_running=True,
)
snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_2",
"snap_name": "snap_1",
"group_name": "subvolgroup_1",
}
fs_util.create_snapshot(client1, **snapshot)
clone_list = [{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"snap_name": "snap_1",
"target_subvol_name": f"clone_{x}",
"group_name": "subvolgroup_1",
} for x in range(1, 6)]
with parallel() as p:
for clone in clone_list:
p.spawn(fs_util.create_clone, client1, **clone, validate=False)
status_list = []
iteration = 0
while status_list.count("complete") < len(clone_list):
status_list.clear()
iteration += 1
for clone in clone_list:
cmd_out, cmd_rc = fs_util.get_clone_status(
client1, clone["vol_name"], clone["target_subvol_name"])
status = json.loads(cmd_out.read().decode())
status_list.append(status["status"]["state"])
log.info(
f"{clone['target_subvol_name']} status is {status['status']['state']}"
)
if status_list.count("in-progress") > 4:
return 1
else:
log.info(
f"cloneing is in progress for {status_list.count('in-progress')} out of {len(clone_list)}"
)
log.info(f"Iteration {iteration} has been completed")
rmclone_list = [{
"vol_name": default_fs,
"subvol_name": f"clone_{x}"
} for x in range(1, 6)]
for clonevolume in rmclone_list:
fs_util.remove_subvolume(client1, **clonevolume)
log.info(
"Set clone threads to 2 and verify only 2 clones are in progress")
client1.exec_command(
sudo=True,
cmd="ceph config set mgr mgr/volumes/max_concurrent_clones 2")
for clone in clone_list:
fs_util.create_clone(client1, **clone)
status_list = []
iteration = 0
while status_list.count("complete") < len(clone_list):
iteration += 1
status_list.clear()
for clone in clone_list:
cmd_out, cmd_rc = fs_util.get_clone_status(
client1, clone["vol_name"], clone["target_subvol_name"])
status = json.loads(cmd_out.read().decode())
status_list.append(status["status"]["state"])
log.info(
f"{clone['target_subvol_name']} status is {status['status']['state']}"
)
if status_list.count("in-progress") > 2:
return 1
else:
log.info(
f"cloneing is in progress for {status_list.count('in-progress')} out of {len(clone_list)}"
)
log.info(f"Iteration {iteration} has been completed")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Setting back the clones to default value 4")
client1.exec_command(
sudo=True,
cmd="ceph config set mgr mgr/volumes/max_concurrent_clones 4")
for clonevolume in rmclone_list:
fs_util.remove_subvolume(client1,
**clonevolume,
force=True,
validate=False)
log.info("Clean Up in progess")
fs_util.remove_snapshot(client1, **snapshot)
fs_util.remove_subvolume(client1, **subvolume)
def run(ceph_cluster, **kw):
"""
Test Cases Covered :
CEPH-83573402 Test to validate the quota.max_bytes Create a FS and create 10 directories and m...
Test to validate the quota.max_bytes Create a FS and create 10 directories and
mount them on kernel client and fuse client(5 mounts each)
Set max bytes quota to a number(say 1Gb) and fill data until it reaches the limit and
verify if the set quota limit is working fine. Similarly set different limit on
different directories and verify quota.
Pre-requisites :
1. We need atleast one client node to execute this test case
2. create fs volume create cephfs if the volume is not there
3. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvolgroup_clone_attr_vol_1
4. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_1 --size 5368706371 --group_name subvolgroup_1
5. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_1
Test Case Flow:
1. Mount the subvolume_1 on the client using fuse
2. Mount the subvolume_2 on the client using kernel
3. set quota attribute 1gb on both mount points
4. Create 3gb files and check it fails
5. Perform same on kernel mount
6. Create a directory inside fuse mount and set quota attribute and verify
7. Create a directory inside kernel mount and set quota attribute and verify
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if not clients:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10))
)
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
log.info("Cheking the file quota on root directory")
root_folder_fuse_mount = f"/mnt/cephfs_fuse{mounting_dir}_2/"
fs_util.fuse_mount([clients[0]], root_folder_fuse_mount)
clients[0].exec_command(
sudo=True,
cmd=f"rm -rf {root_folder_fuse_mount}*;mkdir {root_folder_fuse_mount}test_fuse;",
)
fs_util.set_quota_attrs(
clients[0], 20, 1073741824, f"{root_folder_fuse_mount}test_fuse"
)
quota_attrs = fs_util.get_quota_attrs(
clients[0], f"{root_folder_fuse_mount}test_fuse"
)
fs_util.byte_quota_test(
clients[0], f"{root_folder_fuse_mount}test_fuse", quota_attrs
)
log.info("Setting Back the file quota to 0 on root directory ")
fs_util.set_quota_attrs(
clients[0], "0", "0", f"{root_folder_fuse_mount}test_fuse"
)
root_folder_kernel_mount = f"/mnt/cephfs_kernel{mounting_dir}_2/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]], root_folder_kernel_mount, ",".join(mon_node_ips)
)
clients[0].exec_command(
sudo=True,
cmd=f"rm -rf {root_folder_kernel_mount}*;mkdir {root_folder_kernel_mount}test_kernel",
)
fs_util.set_quota_attrs(
clients[0], 20, 1073741824, f"{root_folder_kernel_mount}test_kernel"
)
quota_attrs = fs_util.get_quota_attrs(
clients[0], f"{root_folder_kernel_mount}test_kernel"
)
fs_util.byte_quota_test(
clients[0], f"{root_folder_kernel_mount}test_kernel", quota_attrs
)
log.info("Setting Back the file quota to 0 on root directory ")
fs_util.set_quota_attrs(
clients[0], "0", "0", f"{root_folder_kernel_mount}test_kernel"
)
subvolumegroup_list = [
{"vol_name": default_fs, "group_name": "subvolgroup_quota_byte_limit_1"},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_byte_fuse",
"group_name": "subvolgroup_quota_byte_limit_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_bytes_kernel",
"group_name": "subvolgroup_quota_byte_limit_1",
"size": "5368706371",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_bytes_kernel subvolgroup_quota_byte_limit_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_byte_fuse subvolgroup_quota_byte_limit_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.strip()}",
)
fs_util.set_quota_attrs(clients[0], 200, 1073741824, kernel_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0], kernel_mounting_dir_1)
fs_util.byte_quota_test(clients[0], kernel_mounting_dir_1, quota_attrs)
fs_util.set_quota_attrs(clients[0], 100, 1073741824, fuse_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0], fuse_mounting_dir_1)
fs_util.byte_quota_test(clients[0], fuse_mounting_dir_1, quota_attrs)
clients[0].exec_command(
sudo=True, cmd=f"cd {fuse_mounting_dir_1};rm -rf *;mkdir test;"
)
fs_util.set_quota_attrs(
clients[0], 30, 1073741824, f"{fuse_mounting_dir_1}/test"
)
quota_attrs = fs_util.get_quota_attrs(clients[0], f"{fuse_mounting_dir_1}/test")
fs_util.byte_quota_test(clients[0], f"{fuse_mounting_dir_1}/test", quota_attrs)
clients[0].exec_command(
sudo=True, cmd=f"cd {kernel_mounting_dir_1};rm -rf *;mkdir test;"
)
fs_util.set_quota_attrs(
clients[0], 30, 1073741824, f"{kernel_mounting_dir_1}/test"
)
quota_attrs = fs_util.get_quota_attrs(
clients[0], f"{kernel_mounting_dir_1}/test"
)
fs_util.byte_quota_test(
clients[0], f"{kernel_mounting_dir_1}/test", quota_attrs
)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
if "5" in build:
fs_util.set_quota_attrs(clients[0], "0", "0", root_folder_fuse_mount)
for subvolume in subvolume_list:
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1, **subvolumegroup, force=True)
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. create fs volume create cephfs and cephfs-ec
Operations :
1. ceph fs subvolumegroup create <vol_name> <group_name> --mode <octal_value>
2. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
3. Mount subvolume on both fuse and kernel clients and run IO's
4. Add additional Data Pool to the existing FS
5. Run IO's again.
Clean-up:
1. Remove files from mountpoint, Unmount subvolumes.
2. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
3. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
log.info("checking Pre-requisites")
if len(clients) < 2:
log.info(
f"This test requires minimum 2 client nodes.This has only {len(clients)} clients"
)
return 1
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
default_fs = "cephfs"
if build.startswith("4"):
# create EC pool
list_cmds = [
"ceph fs flag set enable_multiple true",
"ceph osd pool create cephfs-data-ec 64 erasure",
"ceph osd pool create cephfs-metadata 64",
"ceph osd pool set cephfs-data-ec allow_ec_overwrites true",
"ceph fs new cephfs-ec cephfs-metadata cephfs-data-ec --force",
]
if fs_util.get_fs_info(clients[0], "cephfs_new"):
default_fs = "cephfs_new"
list_cmds.append("ceph fs volume create cephfs")
for cmd in list_cmds:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Create SubVolumeGroups on each filesystem")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_1"
},
{
"vol_name": "cephfs-ec",
"group_name": "subvolgroup_ec1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(clients[0], **subvolumegroup)
log.info(
"Create a Sub volumes on each of the subgroup on different pool with Size 5GB"
)
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"group_name": "subvolgroup_1",
"size": "5368709120",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_2",
"group_name": "subvolgroup_ec1",
"size": "5368709120",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
log.info(
"Mount 1 subvolume on kernel and 1 subvloume on Fuse → Client1")
if build.startswith("5"):
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of subvolume on default filesystem")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
extra_params=f",fs={default_fs}",
)
log.info("Get the path of subvolume on EC filesystem")
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_EC_1/"
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
"ceph fs subvolume getpath cephfs-ec subvol_2 subvolgroup_ec1",
)
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.strip()} --client_fs cephfs-ec",
)
else:
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of subvolume on default filesystem")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
)
log.info("Get the path of subvolume on EC filesystem")
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_EC_1/"
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
"ceph fs subvolume getpath cephfs-ec subvol_2 subvolgroup_ec1",
)
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.strip()}",
)
log.info("Run IO's")
with parallel() as p:
for i in [
kernel_mounting_dir_1,
fuse_mounting_dir_1,
]:
p.spawn(fs_util.run_ios, clients[0], i)
log.info("Create 2 Data Pools, 1 - Replicated , 1 - EC Data Pool")
create_pools = [
"ceph osd pool create cephfs-new-data-pool",
"ceph osd pool create cephfs-new-data-pool-ec erasure",
"ceph osd pool set cephfs-new-data-pool-ec allow_ec_overwrites true",
]
for cmd in create_pools:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Add created data pools to each of the filesystem")
add_pool_to_FS = [
"ceph fs add_data_pool cephfs cephfs-new-data-pool",
"ceph fs add_data_pool cephfs-ec cephfs-new-data-pool-ec",
]
for cmd in add_pool_to_FS:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Run IO's")
with parallel() as p:
for i in [
kernel_mounting_dir_1,
fuse_mounting_dir_1,
]:
p.spawn(fs_util.run_ios, clients[0], i)
log.info("Clean up the system")
for subvolume in subvolume_list:
fs_util.remove_subvolume(clients[0], **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(clients[0], **subvolumegroup)
clients[0].exec_command(
sudo=True, cmd="ceph config set mon mon_allow_pool_delete true")
return 0
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. create fs volume create cephfs and cephfs-ec
Subvolume Group Operations :
1. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
2. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
3. Mount subvolume on both fuse and kernel clients and run IO's
Clean-up:
1. Remove files from mountpoint, Unmount subvolumes.
2. Remove the pools added as part of pool_layout
3. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
4. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
log.info("checking Pre-requisites")
if len(clients) < 2:
log.info(
f"This test requires minimum 2 client nodes.This has only {len(clients)} clients"
)
return 1
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
default_fs = "cephfs"
if build.startswith("4"):
# create EC pool
list_cmds = [
"ceph fs flag set enable_multiple true",
"ceph osd pool create cephfs-data-ec 64 erasure",
"ceph osd pool create cephfs-metadata 64",
"ceph osd pool set cephfs-data-ec allow_ec_overwrites true",
"ceph fs new cephfs-ec cephfs-metadata cephfs-data-ec --force",
]
if fs_util.get_fs_info(clients[0], "cephfs_new"):
default_fs = "cephfs_new"
list_cmds.append("ceph fs volume create cephfs")
for cmd in list_cmds:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Create 2 pools, 1 - Replicated , 1 - EC Data Pool")
create_pools = [
"ceph osd pool create cephfs-data-pool-layout",
"ceph osd pool create cephfs-data-pool-layout-ec 64 erasure",
"ceph osd pool set cephfs-data-pool-layout-ec allow_ec_overwrites true",
]
for cmd in create_pools:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Add created data pools to each of the filesystem")
add_pool_to_FS = [
"ceph fs add_data_pool cephfs cephfs-data-pool-layout",
"ceph fs add_data_pool cephfs-ec cephfs-data-pool-layout-ec",
]
for cmd in add_pool_to_FS:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Create cephfs subvolumegroup with desired data pool_layout")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_1",
"pool_layout": "cephfs-data-pool-layout",
},
{
"vol_name": "cephfs-ec",
"group_name": "subvolgroup_ec1",
"pool_layout": "cephfs-data-pool-layout-ec",
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(clients[0], **subvolumegroup)
log.info(
"Create 2 Sub volumes on each of the subvolume group Size 5 GB")
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_3",
"group_name": "subvolgroup_ec1",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_4",
"group_name": "subvolgroup_ec1",
"size": "5368706371",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
log.info(
"Mount 1 subvolumegroup/subvolume on kernel and 1 subvloume on Fuse → Client1"
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_2 subvolgroup_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.strip()}",
)
log.info(
"On EC,Mount 1 subvolumegroup/subvolume on kernal and 1 subvloume on Fuse → Client2"
)
if build.startswith("5"):
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_EC_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd=
"ceph fs subvolume getpath cephfs-ec subvol_3 subvolgroup_ec1",
)
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
extra_params=",fs=cephfs-ec",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
"ceph fs subvolume getpath cephfs-ec subvol_4 subvolgroup_ec1",
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_EC_1/"
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_2,
extra_params=f" -r {subvol_path.strip()} --client_fs cephfs-ec",
)
log.info(
"Check the Pool status before the IO's to confirm if no IO's are going on on the pool attached"
)
get_pool_status_before = fs_util.get_pool_df(
client=clients[0],
pool_name="cephfs-data-pool-layout",
vol_name=default_fs)
get_pool_status_before_EC = fs_util.get_pool_df(
client=clients[1],
pool_name="cephfs-data-pool-layout-ec",
vol_name="cephfs-ec",
)
run_ios(clients[0], kernel_mounting_dir_1)
run_ios(clients[0], fuse_mounting_dir_1)
run_ios(clients[1], kernel_mounting_dir_2)
run_ios(clients[1], fuse_mounting_dir_2)
log.info(
"Check the Pool status and verify the IO's are going only to the Pool attached"
)
get_pool_status_after = fs_util.get_pool_df(
client=clients[0],
pool_name="cephfs-data-pool-layout",
vol_name=default_fs)
get_pool_status_after_EC = fs_util.get_pool_df(
client=clients[1],
pool_name="cephfs-data-pool-layout-ec",
vol_name="cephfs-ec",
)
if get_pool_status_after["used"] < get_pool_status_before["used"]:
log.error("Pool attached is unused")
return 1
if get_pool_status_after_EC["used"] < get_pool_status_before_EC["used"]:
log.info("EC Pool attached is unused")
return 1
log.info("Clean up the system")
fs_util.client_clean_up("umount",
kernel_clients=[clients[0]],
mounting_dir=kernel_mounting_dir_1)
fs_util.client_clean_up("umount",
kernel_clients=[clients[1]],
mounting_dir=kernel_mounting_dir_2)
fs_util.client_clean_up("umount",
fuse_clients=[clients[0]],
mounting_dir=fuse_mounting_dir_1)
fs_util.client_clean_up("umount",
fuse_clients=[clients[1]],
mounting_dir=fuse_mounting_dir_2)
clients[1].exec_command(
sudo=True, cmd="ceph config set mon mon_allow_pool_delete true")
for subvolume in subvolume_list:
fs_util.remove_subvolume(clients[0], **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(clients[0], **subvolumegroup)
log.info(
"Remove the data pools from the filesystem and delete the created pools."
)
rm_pool_from_FS = [
"ceph fs rm_data_pool cephfs cephfs-data-pool-layout",
"ceph fs rm_data_pool cephfs-ec cephfs-data-pool-layout-ec",
"ceph osd pool delete cephfs-data-pool-layout "
"cephfs-data-pool-layout --yes-i-really-really-mean-it-not-faking",
"ceph osd pool delete cephfs-data-pool-layout-ec "
"cephfs-data-pool-layout-ec --yes-i-really-really-mean-it-not-faking",
]
for cmd in rm_pool_from_FS:
clients[0].exec_command(sudo=True, cmd=cmd)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. create fs volume create cephfs and cephfs-ec
Subvolume Group Operations :
1. ceph fs subvolumegroup create <vol_name> <group_name> --gid <num> --uid <num>
2. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
3. Mount subvolume on both fuse and kernel clients and run IO's
Clean-up:
1. Remove files from mountpoint, Unmount subvolumes.
2. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
3. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
log.info("checking Pre-requisites")
if len(clients) < 2:
log.info(
f"This test requires minimum 2 client nodes.This has only {len(clients)} clients"
)
return 1
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
default_fs = "cephfs"
if build.startswith("4"):
# create EC pool
list_cmds = [
"ceph fs flag set enable_multiple true",
"ceph osd pool create cephfs-data-ec 64 erasure",
"ceph osd pool create cephfs-metadata 64",
"ceph osd pool set cephfs-data-ec allow_ec_overwrites true",
"ceph fs new cephfs-ec cephfs-metadata cephfs-data-ec --force",
]
if fs_util.get_fs_info(clients[0], "cephfs_new"):
default_fs = "cephfs_new"
list_cmds.append("ceph fs volume create cephfs")
for cmd in list_cmds:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Create cephfs subvolumegroup with customized uid and gid ")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_1",
"uid": "20",
"gid": "30",
},
{
"vol_name": "cephfs-ec",
"group_name": "subvolgroup_ec1",
"uid": "40",
"gid": "50",
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(clients[0], **subvolumegroup)
log.info("Create 2 Sub volumes on each of the subvolume group Size 5 GB")
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_3",
"group_name": "subvolgroup_ec1",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_4",
"group_name": "subvolgroup_ec1",
"size": "5368706371",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10))
)
log.info(
"Mount 1 subvolumegroup/subvolume on kernel and 1 subvloume on Fuse → Client1"
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_2 subvolgroup_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
)
log.info(
"On EC,Mount 1 subvolumegroup/subvolume on kernal and 1 subvloume on Fuse → Client2"
)
if build.startswith("5"):
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_EC_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_3 subvolgroup_ec1",
)
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
extra_params=",fs=cephfs-ec",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_4 subvolgroup_ec1",
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_EC_1/"
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_2,
extra_params=" --client_fs cephfs-ec",
)
log.info("Get the path of subvolume group")
subvolgroup_default, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolumegroup getpath {default_fs} subvolgroup_1",
)
subvolgroup_default_path = subvolgroup_default.read().decode().strip()
subvolgroup_ec, rc = clients[0].exec_command(
sudo=True,
cmd="ceph fs subvolumegroup getpath cephfs-ec subvolgroup_ec1",
)
subvolgroup_ec_path = subvolgroup_ec.read().decode().strip()
def get_defined_uid(group_name, subvolumegroup_list):
for subvolumegroup in subvolumegroup_list:
if group_name == subvolumegroup["group_name"]:
return subvolumegroup.get("uid")
log.info("Validate the uid of the subgroup")
subgroup_1_uid = get_defined_uid(
"subvolgroup_1", subvolumegroup_list=subvolumegroup_list
)
subgroup_2_uid = get_defined_uid(
"subvolgroup_ec1", subvolumegroup_list=subvolumegroup_list
)
stat_of_uid_on_kernel_default_fs = fs_util.get_stats(
client=clients[0],
file_path=kernel_mounting_dir_1.rstrip("/") + subvolgroup_default_path,
format="%u",
)
stat_of_uid_on_kernel_default_ec = fs_util.get_stats(
client=clients[1],
file_path=kernel_mounting_dir_2.rstrip("/") + subvolgroup_ec_path,
format="%u",
)
stat_of_uid_on_fuse_default_fs = fs_util.get_stats(
client=clients[0],
file_path=fuse_mounting_dir_1.rstrip("/") + subvolgroup_default_path,
format="%u",
)
stat_of_uid_on_fuse_default_ec = fs_util.get_stats(
client=clients[1],
file_path=fuse_mounting_dir_2.rstrip("/") + subvolgroup_ec_path,
format="%u",
)
if int(subgroup_1_uid) != int(stat_of_uid_on_kernel_default_fs) and int(
subgroup_1_uid
) != int(stat_of_uid_on_fuse_default_fs):
log.error("UID is mismatching on sunvolgroup_1")
return 1
if int(subgroup_2_uid) != int(stat_of_uid_on_fuse_default_ec) and int(
subgroup_2_uid
) != int(stat_of_uid_on_kernel_default_ec):
log.error("UID is mismatching on subvolgroup_ec1")
return 1
def get_defined_gid(group_name, subvolumegroup_list):
for subvolumegroup in subvolumegroup_list:
if group_name == subvolumegroup["group_name"]:
return subvolumegroup.get("gid")
log.info("Validate the gid of the subgroup")
subgroup_1_gid = get_defined_gid(
"subvolgroup_1", subvolumegroup_list=subvolumegroup_list
)
subgroup_2_gid = get_defined_gid(
"subvolgroup_ec1", subvolumegroup_list=subvolumegroup_list
)
stat_of_gid_on_kernel_default_fs = fs_util.get_stats(
client=clients[0],
file_path=kernel_mounting_dir_1.rstrip("/") + subvolgroup_default_path,
format="%g",
)
stat_of_gid_on_kernel_default_ec = fs_util.get_stats(
client=clients[1],
file_path=kernel_mounting_dir_2.rstrip("/") + subvolgroup_ec_path,
format="%g",
)
stat_of_gid_on_fuse_default_fs = fs_util.get_stats(
client=clients[0],
file_path=fuse_mounting_dir_1.rstrip("/") + subvolgroup_default_path,
format="%g",
)
stat_of_gid_on_fuse_default_ec = fs_util.get_stats(
client=clients[1],
file_path=fuse_mounting_dir_2.rstrip("/") + subvolgroup_ec_path,
format="%g",
)
if int(subgroup_1_gid) != int(stat_of_gid_on_kernel_default_fs) and int(
subgroup_1_gid
) != int(stat_of_gid_on_fuse_default_fs):
log.error("GID is mismatching on sunvolgroup_1")
return 1
if int(subgroup_2_gid) != int(stat_of_gid_on_kernel_default_ec) and int(
subgroup_2_gid
) != int(stat_of_gid_on_fuse_default_ec):
log.error("GID is mismatching on subvolgroup_ec1")
return 1
run_ios(clients[0], kernel_mounting_dir_1)
run_ios(clients[0], fuse_mounting_dir_1)
run_ios(clients[1], kernel_mounting_dir_2)
run_ios(clients[1], fuse_mounting_dir_2)
log.info("Clean up the system")
for subvolume in subvolume_list:
fs_util.remove_subvolume(clients[0], **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(clients[0], **subvolumegroup)
fs_util.client_clean_up(
"umount", kernel_clients=[clients[0]], mounting_dir=kernel_mounting_dir_1
)
fs_util.client_clean_up(
"umount", kernel_clients=[clients[1]], mounting_dir=kernel_mounting_dir_2
)
fs_util.client_clean_up(
"umount", fuse_clients=[clients[0]], mounting_dir=fuse_mounting_dir_1
)
fs_util.client_clean_up(
"umount", fuse_clients=[clients[1]], mounting_dir=fuse_mounting_dir_2
)
clients[1].exec_command(
sudo=True, cmd="ceph config set mon mon_allow_pool_delete true"
)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Test Cases Covered :
CEPH-83573409 Test to validate the removal of quota_max_bytes
Create a FS and create 10 directories and mount them on kernel and fuse client(5 mounts each)
Set max bytes quota to a number(say 1Gb) and fill data until it reaches the limit and
verify if the set quota limit is working fine.
Remove the quota once it reaches the max bytes and try adding more
data, verify if set quota is removed. Repeat the procedure for few more times.
Pre-requisites :
1. We need atleast one client node to execute this test case
2. create fs volume create cephfs if the volume is not there
3. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvolgroup_clone_attr_vol_1
4. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_1 --size 5368706371 --group_name subvolgroup_1
5. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_1
Test Case Flow:
1. Mount the subvolume_1 on the client using fuse
2. Mount the subvolume_2 on the client using kernel
3. set byte attribute 1gb on both mount points
4. Create 3gb bytes and check it fails
5. Perform same on kernel mount
6. Remove the quota of bytes and try creating the files on the same directory used in step 3 ie., set bytes to 0
7. Perform same on Kernel mount
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if not clients:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_quota_byte_remove_1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_byte_remove_fuse",
"group_name": "subvolgroup_quota_byte_remove_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_byte_remove_kernel",
"group_name": "subvolgroup_quota_byte_remove_1",
"size": "5368706371",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_byte_remove_kernel subvolgroup_quota_byte_remove_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_byte_remove_fuse subvolgroup_quota_byte_remove_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.read().decode().strip()}",
)
fs_util.set_quota_attrs(clients[0], 100, 1073741824,
fuse_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0], fuse_mounting_dir_1)
fs_util.byte_quota_test(clients[0], fuse_mounting_dir_1, quota_attrs)
log.info("Removing the quota to 0 and validating file quota attr")
fs_util.set_quota_attrs(clients[0], 100, "0", fuse_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0], fuse_mounting_dir_1)
fs_util.byte_quota_test(clients[0], fuse_mounting_dir_1, quota_attrs)
fs_util.set_quota_attrs(clients[0], 100, 1073741824,
kernel_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0],
kernel_mounting_dir_1)
fs_util.byte_quota_test(clients[0], kernel_mounting_dir_1, quota_attrs)
log.info("Increasing the quota to 0 and validating file quota attr")
fs_util.set_quota_attrs(clients[0], 100, "0", kernel_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0],
kernel_mounting_dir_1)
fs_util.byte_quota_test(clients[0], kernel_mounting_dir_1, quota_attrs)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
for subvolume in subvolume_list:
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1,
**subvolumegroup,
force=True)
def run(ceph_cluster, **kw):
"""
Pre-requisites:
1. Create 2 cephfs volume
creats fs volume create <vol_name>
Test operation:
1. Mount both cephfs with same client
2. Remove all data from both cephfs
3. Run IO's on first cephfs
4. Verify second cephfs has not data
5. Copy first cephfs data to local directory
6. Run IO's on second cephfs
7. Verify data consistency of first cephfs using local directory
8. Copy second cephfs data to another local directory
9. Run IO's on first cephfs
10. Verify data consistency of second cephfs using local directory
Clean-up:
1. Remove all the data in Cephfs file system
2. Remove all the cephfs mounts
"""
try:
tc = "CEPH-83573876"
log.info(f"Running cephfs {tc} test case")
config = kw["config"]
build = config.get("build", config.get("rhbuild"))
fs_util = FsUtils(ceph_cluster)
clients = ceph_cluster.get_ceph_objects("client")
client1 = clients[0]
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
mon_node_ip = fs_util.get_mon_node_ips()
mon_node_ip = ",".join(mon_node_ip)
mount_points = []
fs1 = "cephfs"
log.info(f"mounting {fs1}")
fs1_kernel_mount_dir = "/mnt/kernel_" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
fs_util.kernel_mount(
clients,
fs1_kernel_mount_dir,
mon_node_ip,
new_client_hostname="admin",
extra_params=f",fs={fs1}",
)
fs1_fuse_mount_dir = "/mnt/fuse_" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
mount_points.extend([fs1_kernel_mount_dir, fs1_fuse_mount_dir])
fs_util.fuse_mount(
clients,
fs1_fuse_mount_dir,
new_client_hostname="admin",
extra_params=f" --client_fs {fs1}",
)
fs2 = "cephfs-ec"
log.info(f"mounting {fs2}")
fs2_kernel_mount_dir = "/mnt/kernel_" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
fs_util.kernel_mount(
clients,
fs2_kernel_mount_dir,
mon_node_ip,
new_client_hostname="admin",
extra_params=f",fs={fs2}",
)
fs2_fuse_mount_dir = "/mnt/fuse_" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
mount_points.extend([fs2_kernel_mount_dir, fs2_fuse_mount_dir])
fs_util.fuse_mount(
clients,
fs2_fuse_mount_dir,
new_client_hostname="admin",
extra_params=f" --client_fs {fs2}",
)
log.info(f"Remove all data in both {fs1} & {fs2}")
commands = [
f"rm -rf {fs1_kernel_mount_dir}/*",
f"rm -rf {fs2_kernel_mount_dir}/*",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command, long_running=True)
log.info(f"Run IO's on {fs1}")
commands = [
f"mkdir {fs1_kernel_mount_dir}/dir1",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {fs1_kernel_mount_dir}/dir1",
f"dd if=/dev/urandom of={fs1_kernel_mount_dir}/file1 bs=4M count=1000; done",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command, long_running=True)
log.info(f"Copy {fs1} data to local directory")
commands = [
"mkdir /home/cephuser/cephfs_backup",
f"cp {fs1_kernel_mount_dir}/* -R /home/cephuser/cephfs_backup/",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command, long_running=True)
log.info(f"Verifying {fs2} has no data after IO's on {fs1}")
output, rc = client1.exec_command(sudo=True,
cmd=f"ls {fs2_kernel_mount_dir}")
if "" == output:
log.info(f"{fs2} has no data")
else:
if "file1" in output or "dir1" in output:
log.error("Data is being shared accross file systems")
return 1
else:
log.error("Directory is not empty")
return 1
log.info(f"Run IO's on {fs2}")
commands = [
f"mkdir {fs2_kernel_mount_dir}/dir2",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {fs2_kernel_mount_dir}/dir2",
f"dd if=/dev/urandom of={fs2_kernel_mount_dir}/file2 bs=1M count=1000; done",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command, long_running=True)
log.info(f"Copy {fs2} data to another local directory")
commands = [
"mkdir /home/cephuser/cephfs_ec_backup",
f"cp {fs2_kernel_mount_dir}/* -R /home/cephuser/cephfs_ec_backup/",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command, long_running=True)
log.info(f"Verifying data consistency in {fs1} after IO's on {fs2}")
command = f"diff -qr {fs1_kernel_mount_dir} /home/cephuser/cephfs_backup/"
rc = client1.exec_command(sudo=True, cmd=command, long_running=True)
if rc == 0:
log.info(f"Data is consistent in {fs1}")
else:
log.error(f"Data is inconsistent in {fs1}")
return 1
log.info(f"Run IO's on {fs1}")
commands = [
f"mkdir {fs1_kernel_mount_dir}/dir3",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {fs1_kernel_mount_dir}/dir3",
f"dd if=/dev/urandom of={fs1_kernel_mount_dir}/file3 bs=8M count=1000; done",
]
log.info(f"Verifying data consistency in {fs2} after IO's on {fs1}")
for command in commands:
client1.exec_command(sudo=True, cmd=command, long_running=True)
command = f"diff -qr {fs2_kernel_mount_dir} /home/cephuser/cephfs_ec_backup/"
rc = client1.exec_command(sudo=True, cmd=command, long_running=True)
if rc == 0:
log.info(f"Data is consistent in {fs2}")
else:
log.error(f"Data is inconsistent in {fs2}")
return 1
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Cleaning up the system")
client1.exec_command(sudo=True, cmd=f"rm -rf {mount_points[0]}/*")
client1.exec_command(sudo=True, cmd=f"rm -rf {mount_points[2]}/*")
client1.exec_command(sudo=True,
cmd="rm -rf /home/cephuser/*backup/",
check_ec=False)
for client in clients:
for mount_point in mount_points:
client.exec_command(sudo=True,
cmd=f"umount {mount_point}",
check_ec=False)
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-11319 Create first snap add more data to original then create a second snap.
Rollback 1st snap do data validation.
Rollback 2nd snap and do data validation.Perform cross platform rollback
i.e. take snap on kernel mount and perform rollback using fuse mount
Pre-requisites :
1. We need atleast one client node to execute this test case
1. creats fs volume create cephfs if the volume is not there
2. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvol_cross_platform_snapshot_1
3. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_
4. Create Data on the subvolume. We will add known data as we are going to verify the files
Ex: create_file_data()
5. Create snapshot of the subvolume
Ex: ceph fs subvolume snapshot create cephfs subvol_2 snap_1 --group_name subvol_cross_platform_snapshot_1
Script Flow:
1. Mount the subvolume on the client using Kernel and fuse mount
2. Write data into the fuse mount point i.e., data_from_fuse_mount
3. Collect the checksum of the files
4. Take snapshot at this point i.e., snap_1
5. Write data into the kernel mount point i.e., data_from_kernel_mount
6. Collect the checksum of the files
7. Take snapshot at this point i.e., snap_2
8. On Kernel mount revert the snapshot to snap_1 and compare the checksum of the files collected in step 3
9. On Fuse mount revert the snapshot to snap_2 and compare the checksum of the files colleced in step 6
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10))
)
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{"vol_name": default_fs, "group_name": "subvol_cross_platform_snapshot_1"},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_cross_platform_snapshot",
"group_name": "subvol_cross_platform_snapshot_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_cross_platform_snapshot"
f" subvol_cross_platform_snapshot_1",
)
subvol_path = subvol_path.strip()
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[client1],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path}",
)
fs_util.create_file_data(
client1, fuse_mounting_dir_1, 3, "snap1", "data_from_fuse_mount "
)
fuse_files_checksum = fs_util.get_files_and_checksum(
client1, fuse_mounting_dir_1
)
fuse_snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_cross_platform_snapshot",
"snap_name": "snap_1",
"group_name": "subvol_cross_platform_snapshot_1",
}
fs_util.create_snapshot(client1, **fuse_snapshot)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path}",
)
fs_util.create_file_data(
client1, kernel_mounting_dir_1, 3, "snap1", "data_from_kernel_mount "
)
kernel_snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_cross_platform_snapshot",
"snap_name": "snap_2",
"group_name": "subvol_cross_platform_snapshot_1",
}
fs_util.create_snapshot(client1, **kernel_snapshot)
kernel_files_checksum = fs_util.get_files_and_checksum(
client1, kernel_mounting_dir_1
)
client1.exec_command(
sudo=True, cmd=f"cd {kernel_mounting_dir_1};cp .snap/_snap_1_*/* ."
)
kernel_mount_revert_snap_fuse = fs_util.get_files_and_checksum(
client1, kernel_mounting_dir_1
)
if fuse_files_checksum != kernel_mount_revert_snap_fuse:
log.error(
"checksum is not when reverted to snap1 i.e., from fuse mount snapshot revert"
)
return 1
client1.exec_command(
sudo=True, cmd=f"cd {fuse_mounting_dir_1};cp .snap/_snap_2_*/* ."
)
fuse_mount_revert_snap_kernel = fs_util.get_files_and_checksum(
client1, kernel_mounting_dir_1
)
if kernel_files_checksum != fuse_mount_revert_snap_kernel:
log.error(
"checksum is not when reverted to snap2 i.e., from kernel mount snapshot revert"
)
return 1
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
fs_util.remove_snapshot(client1, **kernel_snapshot)
fs_util.remove_snapshot(client1, **fuse_snapshot)
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1, **subvolumegroup, force=True)
def run(ceph_cluster, **kw):
"""
CEPH-83574024 - Ensure Snapshot and cloning works on nfs exports
Pre-requisites:
1. Create cephfs volume
creats fs volume create <vol_name>
2. Create nfs cluster
ceph nfs cluster create <nfs_name> <nfs_server>
Test operation:
1. Create cephfs nfs export
ceph nfs export create cephfs <fs_name> <nfs_name> <nfs_export_name> path=<export_path>
2. Crete cephfs subvolume group
3. Create cephfs subvolume in cephfs subvolume group
4. Create cephfs subvolume in deafault cephfs subvolume group
5. Mount nfs mount with cephfs export
"mount -t nfs -o port=2049 <nfs_server>:<nfs_export> <nfs_mounting_dir>
6. Run IOs on both cephfs subvolumes
7. Create snapshots of both cephfs subvolumes
8. Create clone of both cephfs subvolumes from snapshots
9. Verify data is consistent across subvolumes, snapshots & clones
Clean-up:
1. Remove all the data in Cephfs file system
2. Remove all the cephfs mounts
3. Delete cephfs nfs export
"""
try:
tc = "CEPH-83574024"
log.info(f"Running cephfs {tc} test case")
config = kw["config"]
build = config.get("build", config.get("rhbuild"))
fs_util = FsUtils(ceph_cluster)
clients = ceph_cluster.get_ceph_objects("client")
client1 = clients[0]
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
mon_node_ip = fs_util.get_mon_node_ips()
mon_node_ip = ",".join(mon_node_ip)
rhbuild = config.get("rhbuild")
nfs_servers = ceph_cluster.get_ceph_objects("nfs")
nfs_server = nfs_servers[0].node.hostname
nfs_name = "cephfs-nfs"
nfs_export_name = "/export_" + "".join(
secrets.choice(string.digits) for i in range(3))
export_path = "/"
fs_name = "cephfs"
nfs_mounting_dir = "/mnt/nfs_" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
if "5.0" in rhbuild:
client1.exec_command(
sudo=True,
cmd=f"ceph nfs export create cephfs {fs_name} {nfs_name} "
f"{nfs_export_name} path={export_path}",
)
else:
client1.exec_command(
sudo=True,
cmd=f"ceph nfs export create cephfs {nfs_name} "
f"{nfs_export_name} {fs_name} path={export_path}",
)
subvolumegroup = {
"vol_name": fs_name,
"group_name": "subvolume_group1",
}
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume_list = [
{
"vol_name": fs_name,
"subvol_name": "subvolume1",
"group_name": "subvolume_group1",
},
{
"vol_name": fs_name,
"subvol_name": "subvolume2",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(client1, **subvolume)
commands = [
f"mkdir -p {nfs_mounting_dir}",
f"mount -t nfs -o port=2049 {nfs_server}:{nfs_export_name} {nfs_mounting_dir}",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
out, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {fs_name} subvolume1 --group_name subvolume_group1",
)
subvolume1_path = out.read().decode().rstrip()
out, rc = client1.exec_command(
sudo=True, cmd=f"ceph fs subvolume getpath {fs_name} subvolume2")
subvolume2_path = out.read().decode().rstrip()
commands = [
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --file-size 4 "
f"--files 1000 --top {nfs_mounting_dir}{subvolume1_path}",
f"for n in {{1..20}}; do dd if=/dev/urandom of={nfs_mounting_dir}{subvolume2_path}"
f"/file$(printf %03d "
"$n"
") bs=500k count=1000; done",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command, long_running=True)
commands = [
f"ceph fs subvolume snapshot create {fs_name} subvolume1 snap1 --group_name subvolume_group1",
f"ceph fs subvolume snapshot create {fs_name} subvolume2 snap2",
]
for command in commands:
out, err = client1.exec_command(sudo=True, cmd=command)
clone_status_1 = {
"vol_name": fs_name,
"subvol_name": "subvolume1",
"snap_name": "snap1",
"target_subvol_name": "clone1",
"group_name": "subvolume_group1",
"target_group_name": "subvolume_group1",
}
fs_util.create_clone(client1, **clone_status_1)
fs_util.validate_clone_state(client1, clone_status_1, timeout=6000)
clone_status_2 = {
"vol_name": fs_name,
"subvol_name": "subvolume2",
"snap_name": "snap2",
"target_subvol_name": "clone2",
}
fs_util.create_clone(client1, **clone_status_2)
fs_util.validate_clone_state(client1, clone_status_2, timeout=6000)
out, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {fs_name} clone1 --group_name subvolume_group1",
)
clone1_path = out.read().decode().rstrip()
out, rc = client1.exec_command(
sudo=True, cmd=f"ceph fs subvolume getpath {fs_name} clone2")
clone2_path = out.read().decode().rstrip()
commands = [
f"diff -r {nfs_mounting_dir}{subvolume1_path} {nfs_mounting_dir}{subvolume1_path}/.snap/_snap1*",
f"diff -r {nfs_mounting_dir}{subvolume2_path} {nfs_mounting_dir}{subvolume2_path}/.snap/_snap2*",
f"diff -r {nfs_mounting_dir}{subvolume1_path} {nfs_mounting_dir}{clone1_path}",
f"diff -r {nfs_mounting_dir}{subvolume2_path} {nfs_mounting_dir}{clone2_path}",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
log.info("Test completed successfully")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Cleaning up")
client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume snapshot rm {fs_name} subvolume1 snap1 --group_name subvolume_group1",
check_ec=False,
)
client1.exec_command(
sudo=True,
cmd=f"ceph fs subvolume snapshot rm {fs_name} subvolume2 snap2",
check_ec=False,
)
client1.exec_command(sudo=True, cmd=f"rm -rf {nfs_mounting_dir}/*")
client1.exec_command(sudo=True, cmd=f"umount {nfs_mounting_dir}")
client1.exec_command(sudo=True,
cmd=f"rm -rf {nfs_mounting_dir}/",
check_ec=False)
client1.exec_command(
sudo=True,
cmd=f"ceph nfs export delete {nfs_name} {nfs_export_name}",
check_ec=False,
)
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573501 Create a Cloned Volume using a snapshot
Pre-requisites :
1. We need atleast one client node to execute this test case
2. creats fs volume create cephfs if the volume is not there
3. Create 2 sub volume groups
Ex : ceph fs subvolumegroup create cephfs subvolgroup_1
ceph fs subvolumegroup create cephfs subvolgroup_2
4. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_clone_status --size 5368706371 --group_name subvolgroup_
5. Create Data on the subvolume
Ex: python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 --files
100 --files-per-dir 10 --dirs-per-dir 2 --top /mnt/cephfs_fuse1baxgbpaia_1/
6. Create snapshot of the subvolume
Ex: ceph fs subvolume snapshot create cephfs subvol_clone_status snap_1 --group_name subvolgroup_1
Clone Operations and Clone States:
1. Create a clone in default locaction.
ceph fs subvolume snapshot clone cephfs subvol_clone_status snap_1 clone_status_1 --group_name subvolgroup_1
2. Validate all the states of clone creation progress
pending : Clone operation has not started
in-progress : Clone operation is in progress
complete : Clone operation has successfully finished
3. Mount the cloned volume and check the contents
4. Create a clone in different subvolumegroup ie., subvolumegroup 2
ceph fs subvolume snapshot clone cephfs subvol_clone_status snap_1 clone_status_1 --group_name subvolgroup_1
--target_group_name subvolgroup_2
5. Validate all the states of clone creation progress
pending : Clone operation has not started
in-progress : Clone operation is in progress
complete : Clone operation has successfully finished
6.Once all the clones moved to complete state we are deleting all the clones
Clean-up:
1. ceph fs snapshot rm <vol_name> <subvol_name> snap_name [--group_name <subvol_group_name>]
2. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
3. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_clone_status_1"
},
{
"vol_name": default_fs,
"group_name": "subvolgroup_clone_status_2"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_status",
"group_name": "subvolgroup_clone_status_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_clone_status subvolgroup_clone_status_1",
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
client1.exec_command(
sudo=True,
cmd=
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 "
f"--files 100 --files-per-dir 10 --dirs-per-dir 2 --top "
f"{kernel_mounting_dir_1}",
long_running=True,
)
snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_status",
"snap_name": "snap_1",
"group_name": "subvolgroup_clone_status_1",
}
fs_util.create_snapshot(client1, **snapshot)
clone_status_1 = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_status",
"snap_name": "snap_1",
"target_subvol_name": "clone_status_1",
"group_name": "subvolgroup_clone_status_1",
}
fs_util.create_clone(client1, **clone_status_1)
transitation_states = fs_util.validate_clone_state(
client1, clone_status_1)
valid_state_flow = [
["pending", "in-progress", "complete"],
["in-progress", "complete"],
]
if transitation_states in valid_state_flow:
return 1
clonevol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} {clone_status_1['target_subvol_name']}",
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_2/"
fs_util.fuse_mount(
[client1],
fuse_mounting_dir_2,
extra_params=f" -r {clonevol_path.read().decode().strip()}",
)
client1.exec_command(
sudo=True,
cmd=f"diff -qr {kernel_mounting_dir_1} {fuse_mounting_dir_2}")
clone_status_2 = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_status",
"snap_name": "snap_1",
"target_subvol_name": "clone_status_2",
"group_name": "subvolgroup_clone_status_1",
"target_group_name": "subvolgroup_clone_status_2",
}
fs_util.create_clone(client1, **clone_status_2)
transitation_states = fs_util.validate_clone_state(
client1, clone_status_2)
if transitation_states in valid_state_flow:
return 1
clonevol_path, rc = client1.exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} "
f"{clone_status_2['target_subvol_name']} {clone_status_2['target_group_name']}",
)
fuse_mounting_dir_3 = f"/mnt/cephfs_fuse{mounting_dir}_3/"
fs_util.fuse_mount(
[client1],
fuse_mounting_dir_3,
extra_params=f" -r {clonevol_path.read().decode().strip()}",
)
client1.exec_command(
sudo=True,
cmd=f"diff -qr {kernel_mounting_dir_1} {fuse_mounting_dir_3}")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
rmclone_list = [
{
"vol_name": default_fs,
"subvol_name": "clone_status_1"
},
{
"vol_name": default_fs,
"subvol_name": "clone_status_2",
"group_name": "subvolgroup_clone_status_2",
},
]
for clone_vol in rmclone_list:
fs_util.remove_subvolume(client1, **clone_vol)
fs_util.remove_snapshot(client1, **snapshot)
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1,
**subvolumegroup,
force=True)
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. create fs volume create cephfs and cephfs-ec
Subvolume Group Operations :
1. ceph fs subvolumegroup create <vol_name> <group_name>
2. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
3. Mount subvolume on both fuse and kernel clients and run IO's
4. ceph fs subvolume resize <vol_name> <subvolume_name> <new_size> [--group_name <subvol_group>]
5. Mount subvolume on both fuse and kernel clients and run IO's
6. Validate the resize.
Clean-up:
1. Remove files from mountpoint, Unmount subvolumes.
2. Remove the pools added as part of pool_layout
3. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
4. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
log.info("checking Pre-requisites")
if len(clients) < 2:
log.info(
f"This test requires minimum 2 client nodes.This has only {len(clients)} clients"
)
return 1
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
default_fs = "cephfs"
if build.startswith("4"):
# create EC pool
list_cmds = [
"ceph fs flag set enable_multiple true",
"ceph osd pool create cephfs-data-ec 64 erasure",
"ceph osd pool create cephfs-metadata 64",
"ceph osd pool set cephfs-data-ec allow_ec_overwrites true",
"ceph fs new cephfs-ec cephfs-metadata cephfs-data-ec --force",
]
if fs_util.get_fs_info(clients[0], "cephfs_new"):
default_fs = "cephfs_new"
list_cmds.append("ceph fs volume create cephfs")
for cmd in list_cmds:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Create SubVolumeGroups on each filesystem")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_1"
},
{
"vol_name": "cephfs-ec",
"group_name": "subvolgroup_ec1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(clients[0], **subvolumegroup)
log.info(
"Create 2 Sub volumes on each of the subvolume group with Size 2GB"
)
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"group_name": "subvolgroup_1",
"size": "2147483648",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"group_name": "subvolgroup_1",
"size": "2147483648",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_3",
"group_name": "subvolgroup_ec1",
"size": "2147483648",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_4",
"group_name": "subvolgroup_ec1",
"size": "2147483648",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
log.info("Validate the Subvolume Size")
for subvolume in subvolume_list:
subvolume_size_subvol = fs_util.get_subvolume_info(
client=clients[0], **subvolume)
if int(subvolume.get("size", "infinite")) != int(
subvolume_size_subvol["bytes_quota"]):
log.error(
f"Size mismatchiing for {subvolume.get('subvol_name')} "
f"Expected size is : {subvolume.get('size', 'infinite')}"
f"Actual Size: {subvolume_size_subvol['bytes_quota']}")
return 1
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
log.info(
"Mount 1 subvolumegroup/subvolume on kernel and 1 subvloume on Fuse → Client1"
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_2 subvolgroup_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.strip()}",
)
log.info(
"On EC,Mount 1 subvolumegroup/subvolume on kernal and 1 subvloume on Fuse → Client2"
)
if build.startswith("5"):
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_EC_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd=
"ceph fs subvolume getpath cephfs-ec subvol_3 subvolgroup_ec1",
)
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
extra_params=",fs=cephfs-ec",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
"ceph fs subvolume getpath cephfs-ec subvol_4 subvolgroup_ec1",
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_EC_1/"
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_2,
extra_params=f" -r {subvol_path.strip()} --client_fs cephfs-ec",
)
run_ios(
clients[0],
kernel_mounting_dir_1,
file_name="dd_before",
bs="100M",
count=20,
)
run_ios(clients[0],
fuse_mounting_dir_1,
file_name="dd_before",
bs="100M",
count=20)
run_ios(
clients[1],
kernel_mounting_dir_2,
file_name="dd_before",
bs="100M",
count=20,
)
run_ios(clients[1],
fuse_mounting_dir_2,
file_name="dd_before",
bs="100M",
count=20)
log.info("Resize the subvolumes to 5GB and add data more than 2GB")
resize_subvolumes = [
f"ceph fs subvolume resize {default_fs} subvol_1 5368709120 --group_name subvolgroup_1",
f"ceph fs subvolume resize {default_fs} subvol_2 5368709120 --group_name subvolgroup_1",
"ceph fs subvolume resize cephfs-ec subvol_3 5368709120 --group_name subvolgroup_ec1",
"ceph fs subvolume resize cephfs-ec subvol_4 5368709120 --group_name subvolgroup_ec1",
]
for cmd in resize_subvolumes:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Validate the Subvolume after Resize")
for subvolume in subvolume_list:
subvolume_size_subvol = fs_util.get_subvolume_info(
client=clients[0], **subvolume)
if 5368709120 != int(subvolume_size_subvol["bytes_quota"]):
log.error(
f"Size mismatchiing for {subvolume.get('subvol_name')} Expected size is : 5368709120"
f"Actual Size: {subvolume_size_subvol['bytes_quota']}")
return 1
run_ios(clients[0],
kernel_mounting_dir_1,
file_name="dd_after",
bs="100M",
count=30)
run_ios(clients[0],
fuse_mounting_dir_1,
file_name="dd_after",
bs="100M",
count=30)
run_ios(clients[1],
kernel_mounting_dir_2,
file_name="dd_after",
bs="100M",
count=30)
run_ios(clients[1],
fuse_mounting_dir_2,
file_name="dd_after",
bs="100M",
count=30)
log.info("Clean up the system")
fs_util.client_clean_up("umount",
kernel_clients=[clients[0]],
mounting_dir=kernel_mounting_dir_1)
fs_util.client_clean_up("umount",
kernel_clients=[clients[1]],
mounting_dir=kernel_mounting_dir_2)
fs_util.client_clean_up("umount",
fuse_clients=[clients[0]],
mounting_dir=fuse_mounting_dir_1)
fs_util.client_clean_up("umount",
fuse_clients=[clients[1]],
mounting_dir=fuse_mounting_dir_2)
clients[1].exec_command(
sudo=True, cmd="ceph config set mon mon_allow_pool_delete true")
for subvolume in subvolume_list:
fs_util.remove_subvolume(clients[0], **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(clients[0], **subvolumegroup)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. Requires 2 client nodes in the setup
Operations performed :
1. Enable Multiple File systems 1. In Replicated 2. In EC
2. Create 2 SubVolumeGroups on each file system
3. Create 2 Sub volumes on each of the subvolume group Size 20 GB
4. Create 2 sub volumes on default subvolume group
5. Mount 1 subvolumegroup/subvolume on kernal and 1 subvloume on Fuse → Client1
6. Mount 1 subvolumeon kernal and 1 subvloumegroup/subvolume on Fuse → Client2
7. On EC,Mount 1 subvolumegroup/subvolume on kernal and 1 subvloume on Fuse → Client2
8. On EC,Mount 1 subvolumeon kernal and 1 subvloumegroup/subvolume on Fuse → Client1
9. Run IOs on subvolumegroup/subvolume on kernel client and subvolume in Fuse clientusing below commands
git clone https://github.com/distributed-system-analysis/smallfile.git
cd smallfile
for i in create read append read delete create overwrite rename delete-renamed mkdir rmdir create symlink
stat chmod ls-l delete cleanup ;
do python3 smallfile_cli.py --operation $i --threads 8 --file-size 10240 --files 100 --top /mnt/kcephfs/vol5/
; done
IO Tool 2 :
wget -O linux.tar.gz http://download.ceph.com/qa/linux-5.4.tar.gz
tar -xzf linux.tar.gz tardir/ ; sleep 10 ; rm -rf tardir/ ; sleep 10 ; done
DD on Each volume:
Wget :
http://download.eng.bos.redhat.com/fedora/linux/releases/34/Server/x86_64/iso/Fedora-Server-dvd-x86_64-34-1.2.iso
http://download.eng.bos.redhat.com/fedora/linux/releases/33/Server/x86_64/iso/Fedora-Server-dvd-x86_64-33-1.2.iso
http://download.eng.bos.redhat.com/fedora/linux/releases/32/Server/x86_64/iso/Fedora-Server-dvd-x86_64-32-1.6.iso
Note : Run 2 IO tools mentioned above on each volume mounted
10. Create Snapshots.Verify the snap ls | grep to see snap ot created
11. Create Clones on all 8 volumes. Verify the clones got created using clone ls(subvolume ls)
12. Set File Level Quota on 2 directories under subvolume and Size Level Quota on under 2 directories
under subvolume.
13. Verify quota based on your configuration
14. Clear Quotas
15. Remove Clones
16. Remove Snapshots
17. Unmount
18. Remove Volumes.
Args:
ceph_cluster:
**kw:
Returns:
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
log.info("checking Pre-requisites")
if len(clients) < 2:
log.info(
f"This test requires minimum 2 client nodes.This has only {len(clients)} clients"
)
return 1
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
default_fs = "cephfs"
if build.startswith("4"):
# create EC pool
list_cmds = [
"ceph fs flag set enable_multiple true",
"ceph osd pool create cephfs-data-ec 64 erasure",
"ceph osd pool create cephfs-metadata 64",
"ceph osd pool set cephfs-data-ec allow_ec_overwrites true",
"ceph fs new cephfs-ec cephfs-metadata cephfs-data-ec --force",
]
if fs_util.get_fs_info(clients[0], "cephfs_new"):
default_fs = "cephfs_new"
list_cmds.append("ceph fs volume create cephfs")
for cmd in list_cmds:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Create 2 SubVolumeGroups on each file system")
subvolumegroup_list = [
{"vol_name": default_fs, "group_name": "subvolgroup_1"},
{"vol_name": default_fs, "group_name": "subvolgroup_2"},
{"vol_name": "cephfs-ec", "group_name": "subvolgroup_1"},
{"vol_name": "cephfs-ec", "group_name": "subvolgroup_2"},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(clients[0], **subvolumegroup)
log.info("Create 2 Sub volumes on each of the subvolume group Size 20 GB")
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"group_name": "subvolgroup_2",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_3",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_4",
"group_name": "subvolgroup_2",
"size": "5368706371",
},
{"vol_name": default_fs, "subvol_name": "subvol_5", "size": "5368706371"},
{"vol_name": default_fs, "subvol_name": "subvol_6", "size": "5368706371"},
{"vol_name": "cephfs-ec", "subvol_name": "subvol_7", "size": "5368706371"},
{"vol_name": "cephfs-ec", "subvol_name": "subvol_8", "size": "5368706371"},
{"vol_name": default_fs, "subvol_name": "subvol_9", "size": "5368706371"},
{"vol_name": "cephfs-ec", "subvol_name": "subvol_10", "size": "5368706371"},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10))
)
log.info(
"Mount 1 subvolumegroup/subvolume on kernal and 1 subvloume on Fuse → Client1"
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
subvol_path, rc = clients[0].exec_command(
sudo=True, cmd=f"ceph fs subvolume getpath {default_fs} subvol_5"
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.read().decode().strip()}",
)
log.info(
"Mount 1 subvolumeon kernal and 1 subvloumegroup/subvolume on Fuse → Client2"
)
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_2/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[1].exec_command(
sudo=True, cmd=f"ceph fs subvolume getpath {default_fs} subvol_6"
)
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_2 subvolgroup_2",
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_2/"
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_2,
extra_params=f" -r {subvol_path.read().decode().strip()}",
)
log.info(
"On EC,Mount 1 subvolumegroup/subvolume on kernal and 1 subvloume on Fuse → Client2"
)
if build.startswith("5"):
kernel_mounting_dir_3 = f"/mnt/cephfs_kernel{mounting_dir}_EC_3/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_3 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_3,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
extra_params=",fs=cephfs-ec",
)
subvol_path, rc = clients[0].exec_command(
sudo=True, cmd="ceph fs subvolume getpath cephfs-ec subvol_7"
)
fuse_mounting_dir_3 = f"/mnt/cephfs_fuse{mounting_dir}_EC_3/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_3,
extra_params=f" -r {subvol_path.read().decode().strip()} --client_fs cephfs-ec",
)
log.info(
"On EC,Mount 1 subvolumeon kernal and 1 subvloumegroup/subvolume on Fuse → Client1"
)
if build.startswith("5"):
kernel_mounting_dir_4 = f"/mnt/cephfs_kernel{mounting_dir}_EC_4/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[1].exec_command(
sudo=True, cmd="ceph fs subvolume getpath cephfs-ec subvol_8"
)
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_4,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
extra_params=",fs=cephfs-ec",
)
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_4 subvolgroup_2",
)
fuse_mounting_dir_4 = f"/mnt/cephfs_fuse{mounting_dir}_EC_4/"
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_4,
extra_params=f" -r {subvol_path.read().decode().strip()} --client_fs cephfs-ec",
)
run_ios(clients[0], kernel_mounting_dir_1)
run_ios(clients[0], fuse_mounting_dir_1)
run_ios(clients[1], kernel_mounting_dir_2)
run_ios(clients[1], fuse_mounting_dir_2)
if build.startswith("5"):
run_ios(clients[0], kernel_mounting_dir_3)
run_ios(clients[1], kernel_mounting_dir_4)
run_ios(clients[0], fuse_mounting_dir_3)
run_ios(clients[1], fuse_mounting_dir_4)
log.info("Create Snapshots.Verify the snap ls")
snapshot_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"snap_name": "snap_1",
"group_name": "subvolgroup_1",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"snap_name": "snap_2",
"group_name": "subvolgroup_2",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_3",
"snap_name": "snap_3",
"group_name": "subvolgroup_1",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_4",
"snap_name": "snap_4",
"group_name": "subvolgroup_2",
},
{"vol_name": default_fs, "subvol_name": "subvol_5", "snap_name": "snap_5"},
{"vol_name": default_fs, "subvol_name": "subvol_6", "snap_name": "snap_6"},
{"vol_name": "cephfs-ec", "subvol_name": "subvol_7", "snap_name": "snap_7"},
{"vol_name": "cephfs-ec", "subvol_name": "subvol_8", "snap_name": "snap_8"},
]
for snapshot in snapshot_list:
fs_util.create_snapshot(clients[0], **snapshot)
clone_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"snap_name": "snap_1",
"target_subvol_name": "clone_1",
"group_name": "subvolgroup_1",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"snap_name": "snap_2",
"target_subvol_name": "clone_2",
"group_name": "subvolgroup_2",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_3",
"snap_name": "snap_3",
"target_subvol_name": "clone_3",
"group_name": "subvolgroup_1",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_4",
"snap_name": "snap_4",
"target_subvol_name": "clone_4",
"group_name": "subvolgroup_2",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_5",
"snap_name": "snap_5",
"target_subvol_name": "clone_5",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_6",
"snap_name": "snap_6",
"target_subvol_name": "clone_6",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_7",
"snap_name": "snap_7",
"target_subvol_name": "clone_7",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_8",
"snap_name": "snap_8",
"target_subvol_name": "clone_8",
},
]
for clone in clone_list:
fs_util.create_clone(clients[0], **clone)
log.info(
"Set File Level Quota on 2 directories under subvolume and Size Level Quota on "
"under 2 directories under subvolume"
)
subvol_path, rc = clients[0].exec_command(
sudo=True, cmd=f"ceph fs subvolume getpath {default_fs} subvol_9"
)
fuse_mounting_dir_5 = f"/mnt/cephfs_fuse{mounting_dir}_5/"
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_5,
extra_params=f" -r {subvol_path.read().decode().strip()}",
)
clients[1].exec_command(
sudo=True,
cmd=f"setfattr -n ceph.quota.max_files -v 10 {fuse_mounting_dir_5}",
)
clients[1].exec_command(
sudo=True, cmd=f"getfattr -n ceph.quota.max_files {fuse_mounting_dir_5}"
)
out, rc = clients[1].exec_command(
sudo=True,
cmd=f"cd {fuse_mounting_dir_5};touch quota{{1..15}}.txt",
)
log.info(out)
if clients[1].node.exit_status == 0:
log.warning(
"Quota set has been failed,Able to create more files."
"This is known limitation"
)
if build.startswith("5"):
subvol_path, rc = clients[0].exec_command(
sudo=True, cmd="ceph fs subvolume getpath cephfs-ec subvol_10"
)
kernel_mounting_dir_5 = f"/mnt/cephfs_kernel{mounting_dir}_5/"
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_5,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
extra_params=",fs=cephfs-ec",
)
clients[1].exec_command(
sudo=True,
cmd=f"setfattr -n ceph.quota.max_files -v 10 {kernel_mounting_dir_5}",
)
clients[1].exec_command(
sudo=True,
cmd=f"getfattr -n ceph.quota.max_files {kernel_mounting_dir_5}",
)
out, rc = clients[1].exec_command(
sudo=True,
cmd=f"cd {kernel_mounting_dir_5};touch quota{{1..15}}.txt",
)
log.info(out)
if clients[1].node.exit_status == 0:
log.warning(
"Quota set has been failed,Able to create more files."
"This is known limitation"
)
# return 1
log.info("Clean up the system")
fs_util.client_clean_up(
"umount", kernel_clients=[clients[0]], mounting_dir=kernel_mounting_dir_1
)
fs_util.client_clean_up(
"umount", kernel_clients=[clients[1]], mounting_dir=kernel_mounting_dir_2
)
if build.startswith("5"):
fs_util.client_clean_up(
"umount",
kernel_clients=[clients[0]],
mounting_dir=kernel_mounting_dir_3,
)
fs_util.client_clean_up(
"umount",
kernel_clients=[clients[1]],
mounting_dir=kernel_mounting_dir_4,
)
fs_util.client_clean_up(
"umount",
kernel_clients=[clients[1]],
mounting_dir=kernel_mounting_dir_5,
)
fs_util.client_clean_up(
"umount", fuse_clients=[clients[0]], mounting_dir=fuse_mounting_dir_1
)
fs_util.client_clean_up(
"umount", fuse_clients=[clients[1]], mounting_dir=fuse_mounting_dir_2
)
if build.startswith("5"):
fs_util.client_clean_up(
"umount", fuse_clients=[clients[0]], mounting_dir=fuse_mounting_dir_3
)
fs_util.client_clean_up(
"umount", fuse_clients=[clients[1]], mounting_dir=fuse_mounting_dir_4
)
fs_util.client_clean_up(
"umount", fuse_clients=[clients[1]], mounting_dir=fuse_mounting_dir_5
)
clients[1].exec_command(
sudo=True, cmd="ceph config set mon mon_allow_pool_delete true"
)
rmsnapshot_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"snap_name": "snap_1",
"group_name": "subvolgroup_1",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"snap_name": "snap_2",
"group_name": "subvolgroup_2",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_3",
"snap_name": "snap_3",
"group_name": "subvolgroup_1",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_4",
"snap_name": "snap_4",
"group_name": "subvolgroup_2",
},
{"vol_name": default_fs, "subvol_name": "subvol_5", "snap_name": "snap_5"},
{"vol_name": default_fs, "subvol_name": "subvol_6", "snap_name": "snap_6"},
{"vol_name": "cephfs-ec", "subvol_name": "subvol_7", "snap_name": "snap_7"},
{"vol_name": "cephfs-ec", "subvol_name": "subvol_8", "snap_name": "snap_8"},
]
for snapshot in rmsnapshot_list:
fs_util.remove_snapshot(clients[0], **snapshot)
rmclone_list = [
{"vol_name": default_fs, "subvol_name": "clone_1"},
{"vol_name": default_fs, "subvol_name": "clone_2"},
{"vol_name": "cephfs-ec", "subvol_name": "clone_3"},
{"vol_name": "cephfs-ec", "subvol_name": "clone_4"},
{"vol_name": default_fs, "subvol_name": "clone_5"},
{"vol_name": default_fs, "subvol_name": "clone_6"},
{"vol_name": "cephfs-ec", "subvol_name": "clone_7"},
{"vol_name": "cephfs-ec", "subvol_name": "clone_8"},
]
rmsubvolume_list = rmclone_list + subvolume_list
for subvolume in rmsubvolume_list:
fs_util.remove_subvolume(clients[0], **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(clients[0], **subvolumegroup)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573418 Create a Snapshot, reboot the node and rollback the snapshot
Pre-requisites :
1. We need atleast one client node to execute this test case
2. creats fs volume create cephfs if the volume is not there
3. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvolgroup_reboot_snapshot_1
4. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_
5. Create Data on the subvolume. We will add known data as we are going to verify the files
Ex: create_file_data()
6. Create snapshot of the subvolume
Ex: ceph fs subvolume snapshot create cephfs subvol_2 snap_1 --group_name subvolgroup_reboot_snapshot_1
Script Flow:
1. Mount the subvolume on the client using Kernel
2. Write data into the mount point
3. Get the checksum of the files inside the mount point
4. Reboot the node
5. Mount again the subvolume and revert the snapshot
6. get the checksum of the files
7. Validate the checksums
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_reboot_snapshot_1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_reboot_snapshot",
"group_name": "subvolgroup_reboot_snapshot_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_reboot_snapshot subvolgroup_reboot_snapshot_1",
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
fs_util.create_file_data(client1, kernel_mounting_dir_1, 3, "snap1",
"snap_1_data ")
snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_reboot_snapshot",
"snap_name": "snap_1",
"group_name": "subvolgroup_reboot_snapshot_1",
}
fs_util.create_snapshot(client1, **snapshot)
files_checksum_before_reboot = fs_util.get_files_and_checksum(
client1, f"/mnt/cephfs_kernel{mounting_dir}_1")
fs_util.reboot_node(client1)
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_2/"
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_reboot_snapshot subvolgroup_reboot_snapshot_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
client1.exec_command(
sudo=True,
cmd=f"cd {kernel_mounting_dir_2};cp .snap/_snap_1_*/* .")
files_checksum_after_reboot = fs_util.get_files_and_checksum(
client1, kernel_mounting_dir_2)
if files_checksum_before_reboot != files_checksum_after_reboot:
log.error("checksum is not matching after snapshot1 revert")
return 1
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
fs_util.remove_snapshot(client1, **snapshot)
fs_util.remove_subvolume(client1, **subvolume)
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573255 Try renaming the snapshot directory and rollbackCreate a FS and
create 10 directories and mount them on kernel client and fuse client(5 mounts each)
Add data (~ 100 GB). Create a Snapshot and verify the content in snap directory.
Try modifying the snapshot name.
Pre-requisites :
1. We need atleast one client node to execute this test case
2. creats fs volume create cephfs if the volume is not there
3. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvol_rename_sanp_1
4. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_
5. Create snapshot of the subvolume
Ex: ceph fs subvolume snapshot create cephfs subvol_2 snap_1 --group_name subvol_rename_sanp_1
Script Flow:
1. Mount the subvolume on the client using fuse mount.
2. Rename the snapshot snap/_snap_1 to snap/_snap_rename.
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvol_rename_sanp_1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_rename_sanp",
"group_name": "subvol_rename_sanp_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_rename_sanp subvol_rename_sanp_1",
)
subvol_path = subvol_path.strip()
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[client1],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path}",
)
fs_util.create_file_data(client1, fuse_mounting_dir_1, 3, "snap1",
"data_from_fuse_mount ")
fuse_snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_rename_sanp",
"snap_name": "snap_1",
"group_name": "subvol_rename_sanp_1",
}
fs_util.create_snapshot(client1, **fuse_snapshot)
out, rc = client1.exec_command(
sudo=True,
cmd=
f"cd {fuse_mounting_dir_1};mv .snap/_snap_1_* .snap/_snap_rename_",
check_ec=False,
)
if rc == 0:
raise CommandFailed(
"we are able to rename the snap directory.. which is not correct"
)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
fs_util.remove_snapshot(client1, **fuse_snapshot)
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1,
**subvolumegroup,
force=True)
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. create fs volume create cephfs and cephfs-ec
Subvolume Group Operations :
1. ceph fs subvolumegroup create <vol_name> <group_name> --mode <octal_value>
2. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
3. Mount subvolume on both fuse and kernel clients and run IO's
Clean-up:
1. Remove files from mountpoint, Unmount subvolumes.
2. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
3. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
build = config.get("build", config.get("rhbuild"))
clients = ceph_cluster.get_ceph_objects("client")
log.info("checking Pre-requisites")
if len(clients) < 2:
log.info(
f"This test requires minimum 2 client nodes.This has only {len(clients)} clients"
)
return 1
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
default_fs = "cephfs"
if build.startswith("4"):
# create EC pool
list_cmds = [
"ceph fs flag set enable_multiple true",
"ceph osd pool create cephfs-data-ec 64 erasure",
"ceph osd pool create cephfs-metadata 64",
"ceph osd pool set cephfs-data-ec allow_ec_overwrites true",
"ceph fs new cephfs-ec cephfs-metadata cephfs-data-ec --force",
]
if fs_util.get_fs_info(clients[0], "cephfs_new"):
default_fs = "cephfs_new"
list_cmds.append("ceph fs volume create cephfs")
for cmd in list_cmds:
clients[0].exec_command(sudo=True, cmd=cmd)
log.info("Create cephfs subvolumegroup with different octal modes")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_1",
"mode": "777",
},
{
"vol_name": default_fs,
"group_name": "subvolgroup_2",
"mode": "700",
},
{
"vol_name": "cephfs-ec",
"group_name": "subvolgroup_ec1",
"mode": "755",
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(clients[0], **subvolumegroup)
log.info("Create 2 Sub volumes on each of the subvolume group of Size 5GB")
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_1",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_2",
"group_name": "subvolgroup_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_3",
"group_name": "subvolgroup_2",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_4",
"group_name": "subvolgroup_2",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_5",
"group_name": "subvolgroup_ec1",
"size": "5368706371",
},
{
"vol_name": "cephfs-ec",
"subvol_name": "subvol_6",
"group_name": "subvolgroup_ec1",
"size": "5368706371",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10))
)
log.info(
"Mount 1 subvolumegroup/subvolume on kernel and 1 subvolume on Fuse → Client1"
)
if build.startswith("5"):
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
extra_params=f",fs={default_fs}",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_2 subvolgroup_1",
)
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" --client_fs {default_fs}",
)
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_2/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_3 subvolgroup_2",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
extra_params=f",fs={default_fs}",
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_2/"
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_4 subvolgroup_2",
)
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_2,
extra_params=f" --client_fs {default_fs}",
)
kernel_mounting_dir_3 = f"/mnt/cephfs_kernel{mounting_dir}_EC_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_5 subvolgroup_ec1",
)
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_3,
",".join(mon_node_ips),
extra_params=",fs=cephfs-ec",
)
fuse_mounting_dir_3 = f"/mnt/cephfs_fuse{mounting_dir}_EC_1/"
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_6 subvolgroup_ec1",
)
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_3,
extra_params=" --client_fs cephfs-ec",
)
else:
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_1 subvolgroup_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_2 subvolgroup_1",
)
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
)
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_2/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_3 subvolgroup_2",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_2/"
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_4 subvolgroup_2",
)
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_2,
)
kernel_mounting_dir_3 = f"/mnt/cephfs_kernel{mounting_dir}_EC_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[1].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_5 subvolgroup_ec1",
)
fs_util.kernel_mount(
[clients[1]],
kernel_mounting_dir_3,
",".join(mon_node_ips),
extra_params=",fs=cephfs-ec",
)
fuse_mounting_dir_3 = f"/mnt/cephfs_fuse{mounting_dir}_EC_1/"
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd="ceph fs subvolume getpath cephfs-ec subvol_6 subvolgroup_ec1",
)
fs_util.fuse_mount(
[clients[1]],
fuse_mounting_dir_3,
extra_params=" --client_fs cephfs-ec",
)
log.info("Get the path of subvolume groups")
subvolgroup1_getpath, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolumegroup getpath {default_fs} subvolgroup_1",
)
subvolgroup1_getpath = subvolgroup1_getpath.strip()
subvolgroup2_getpath, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolumegroup getpath {default_fs} subvolgroup_2",
)
subvolgroup2_getpath = subvolgroup2_getpath.strip()
subvolgroup_ec_getpath, rc = clients[0].exec_command(
sudo=True,
cmd="ceph fs subvolumegroup getpath cephfs-ec subvolgroup_ec1",
)
subvolgroup_ec_getpath = subvolgroup_ec_getpath.strip()
def get_defined_mode(group_name, subvolumegroup_list):
for subvolumegroup in subvolumegroup_list:
if group_name == subvolumegroup["group_name"]:
return subvolumegroup.get("mode")
log.info("Validate the octal mode set on the subgroup")
subgroup_1_mode = get_defined_mode(
"subvolgroup_1", subvolumegroup_list=subvolumegroup_list
)
subgroup_2_mode = get_defined_mode(
"subvolgroup_2", subvolumegroup_list=subvolumegroup_list
)
subgroup_ec_mode = get_defined_mode(
"subvolgroup_ec1", subvolumegroup_list=subvolumegroup_list
)
stat_of_octal_mode_on_kernel_dir1 = fs_util.get_stats(
client=clients[0],
file_path=kernel_mounting_dir_1.rstrip("/") + subvolgroup1_getpath,
format="%a",
)
stat_of_octal_mode_on_kernel_dir2 = fs_util.get_stats(
client=clients[0],
file_path=kernel_mounting_dir_2.rstrip("/") + subvolgroup2_getpath,
format="%a",
)
stat_of_octal_mode_on_kernel_dir3 = fs_util.get_stats(
client=clients[1],
file_path=kernel_mounting_dir_3.rstrip("/") + subvolgroup_ec_getpath,
format="%a",
)
stat_of_octal_mode_on_fuse_dir1 = fs_util.get_stats(
client=clients[0],
file_path=fuse_mounting_dir_1.rstrip("/") + subvolgroup1_getpath,
format="%a",
)
stat_of_octal_mode_on_fuse_dir2 = fs_util.get_stats(
client=clients[0],
file_path=fuse_mounting_dir_2.rstrip("/") + subvolgroup2_getpath,
format="%a",
)
stat_of_octal_mode_on_fuse_dir3 = fs_util.get_stats(
client=clients[1],
file_path=fuse_mounting_dir_3.rstrip("/") + subvolgroup_ec_getpath,
format="%a",
)
if int(subgroup_1_mode) != int(stat_of_octal_mode_on_kernel_dir1) and int(
subgroup_1_mode
) != int(stat_of_octal_mode_on_fuse_dir1):
log.error("Octal values are mismatching on subvolgroup_1")
return 1
if int(subgroup_2_mode) != int(stat_of_octal_mode_on_kernel_dir2) and int(
subgroup_2_mode
) != int(stat_of_octal_mode_on_fuse_dir2):
log.error("Octal values are mismatching on subvolgroup_2")
return 1
if int(subgroup_ec_mode) != int(stat_of_octal_mode_on_kernel_dir3) and int(
subgroup_ec_mode
) != int(stat_of_octal_mode_on_fuse_dir3):
log.error("Octal values are mismatching on subvolgroup_ec1")
return 1
log.info("Run IO's")
with parallel() as p:
for i in [
kernel_mounting_dir_1,
fuse_mounting_dir_1,
kernel_mounting_dir_2,
fuse_mounting_dir_2,
]:
p.spawn(fs_util.run_ios, clients[0], i)
for i in [kernel_mounting_dir_3, fuse_mounting_dir_3]:
p.spawn(fs_util.run_ios, clients[1], i)
log.info("Clean up the system")
for subvolume in subvolume_list:
fs_util.remove_subvolume(clients[0], **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(clients[0], **subvolumegroup)
for i in [kernel_mounting_dir_1, kernel_mounting_dir_2]:
fs_util.client_clean_up(
"umount", kernel_clients=[clients[0]], mounting_dir=i
)
for i in [fuse_mounting_dir_1, fuse_mounting_dir_2]:
fs_util.client_clean_up("umount", fuse_clients=[clients[0]], mounting_dir=i)
fs_util.client_clean_up(
"umount", kernel_clients=[clients[1]], mounting_dir=kernel_mounting_dir_3
)
fs_util.client_clean_up(
"umount", kernel_clients=[clients[1]], mounting_dir=fuse_mounting_dir_3
)
clients[1].exec_command(
sudo=True, cmd="ceph config set mon mon_allow_pool_delete true"
)
return 0
except Exception as e:
log.error(e)
log.error(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
try:
"""
Pre-requisites :
1. creats fs volume create cephfs if the volume is not there
Custom fscid cephfs operation:
1. Create data & metadata pools for cephfs
Ex. ceph osd pool create cephfs_data 64 64
ceph osd pool create cephfs_metadata 8 8
2. Create Cephfs with data & metadata pool with specific fscid
ceph fs new <cephfs_name> <metada_pool> <data_pool> --fscid <fscid> --force
Ex. ceph fs new cephfs cephfs_metadata cephfs_data --fscid {fscid} --force
3. Verify cephfs is created with specified fscid
ceph fs ls
ceph fs dump
4. Verify that another Cephfs is getting not created with same fscid
"""
tc = "CEPH-83574632"
log.info("Running cephfs %s test case" % (tc))
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
rhbuild = config.get("rhbuild")
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
client1 = clients[0]
fscid = "300"
fs_name = "fs2"
if "4." in rhbuild:
client1.exec_command(sudo=True,
cmd="ceph fs flag set enable_multiple true")
commands = [
"ceph osd pool create fs_data 64 64",
"ceph osd pool create fs_metadata 8 8",
f"ceph fs new {fs_name} fs_metadata fs_data --fscid {fscid} --force",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
if "5." in rhbuild:
mdss = ceph_cluster.get_ceph_objects("mds")
mds1 = mdss[0].node.hostname
mds2 = mdss[1].node.hostname
cmd = f"ceph orch apply mds {fs_name} --placement='2 {mds1} {mds2}'"
client1.exec_command(sudo=True, cmd=cmd)
out, err = client1.exec_command(sudo=True,
cmd="ceph fs ls | grep cephfs")
if "cephfs" in out:
log.info("CephFs is successfully created")
else:
log.error("CephFs creation failed")
return 1
cmd = f"ceph fs dump | grep Filesystem | grep {fs_name}"
out, err = client1.exec_command(sudo=True, cmd=cmd)
if fscid in out:
log.info("CephFs is successfully created with specific fscid")
else:
log.error("custom fscid setting failed")
return 1
fs_name = "fs3"
commands = [
"ceph osd pool create cfs_data 64 64",
"ceph osd pool create cfs_metadata 8 8",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
try:
cmd = f"ceph fs new {fs_name} cfs_metadata cfs_data --fscid {fscid} --force"
client1.exec_command(sudo=True, cmd=cmd)
except CommandFailed as e:
log.info(e)
log.info("Cephfs creation failed with same fscid as expected")
else:
log.error("Cephfs did not failed with same fscid as expected")
return 1
log.info("Cleaning up")
fs_name = "fs2"
commands = [
"ceph config set mon mon_allow_pool_delete true",
f"ceph fs volume rm {fs_name} --yes-i-really-mean-it",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
return 0
except CommandFailed as e:
log.info(e)
log.info(traceback.format_exc())
return 1
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573520 Validate the max snapshot that can be created under a root FS sub volume level.
Increase by 50 at a time until it reaches the max limit.
Pre-requisites :
1. We need atleast one client node to execute this test case
2. creats fs volume create cephfs if the volume is not there
3. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_max_snap --size 5368706371 --group_name subvolgroup_1
4. Create Data on the subvolume
Ex: python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 --files
100 --files-per-dir 10 --dirs-per-dir 2 --top /mnt/cephfs_fuse1baxgbpaia_1/
Test Script Flow :
1. We will create snapshots in batch of 50 till 1000.
2. We will breakout when ever it reaches the maximum allowed snapshots.
Clean up:
1. Deletes all the snapshots created
2. Deletes snapshot and subvolume created.
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_max_snap",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_max_snap",
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
)
client1.exec_command(
sudo=True,
cmd=
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 "
f"--files 100 --files-per-dir 10 --dirs-per-dir 2 --top "
f"{kernel_mounting_dir_1}",
long_running=True,
)
snapshot_list = [{
"vol_name": default_fs,
"subvol_name": "subvol_max_snap",
"snap_name": f"snap_limit_{x}",
} for x in range(1, 1000)]
for i in range(0, 1000, 50):
for snapshot in snapshot_list[i:i + 50]:
try:
fs_util.create_snapshot(clients[0],
**snapshot,
validate=False)
except CommandFailed:
log.info(
f"Max Snapshots allowed under a root FS sub volume level is {i}"
)
max_sanpshots_allowed = i
break
else:
continue
break
log.info(f"Snapshot creation is successful from {i} to {i+50}")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
for snapshot in snapshot_list[0:max_sanpshots_allowed]:
fs_util.remove_snapshot(client1, **snapshot)
fs_util.remove_subvolume(client1, **subvolume)
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573420 Try writing the data to snap directory
Pre-requisites :
1. We need atleast one client node to execute this test case
1. creats fs volume create cephfs if the volume is not there
2. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvolgroup_write_snapshot_1
3. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_
Script Flow:
1. Mount the subvolume on the client using Kernel
2. Write data into the mount point
3. Try creating directory and file inside the mount_point/.snap directory(CEPH-83573420)
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_write_snapshot_1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_write_snapshot",
"group_name": "subvolgroup_write_snapshot_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_write_snapshot subvolgroup_write_snapshot_1",
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
fs_util.create_file_data(client1, kernel_mounting_dir_1, 3, "snap1",
"snap_1_data ")
snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_write_snapshot",
"snap_name": "snap_1",
"group_name": "subvolgroup_write_snapshot_1",
}
fs_util.create_snapshot(client1, **snapshot)
out, rc = client1.exec_command(
sudo=True,
cmd=f"mkdir /mnt/cephfs_kernel{mounting_dir}_1/.snap/test",
check_ec=False,
)
if rc == 0:
raise CommandFailed("Mkdir is working in .snap directory")
out, rc = client1.exec_command(
sudo=True,
cmd=f"touch /mnt/cephfs_kernel{mounting_dir}_1/.snap/test",
check_ec=False,
)
if rc == 0:
raise CommandFailed("touch is working in .snap directory")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
fs_util.remove_snapshot(client1, **snapshot)
fs_util.remove_subvolume(client1, **subvolume)
def run(ceph_cluster, **kw):
"""
Test Cases Covered :
CEPH-83573521 Remove a subvolume group by retaining the snapshot : ceph fs subvolume rm <vol_n...
Pre-requisites :
1. We need atleast one client node to execute this test case
1. creats fs volume create cephfs if the volume is not there
2. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvolgroup_retain_snapshot_1
3. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_
4. Create Data on the subvolume
Ex: python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 --files
100 --files-per-dir 10 --dirs-per-dir 2 --top /mnt/cephfs_fuse1baxgbpaia_1/
5. Create snapshot of the subvolume
Ex: ceph fs subvolume snapshot create cephfs subvol_2 snap_1 --group_name subvolgroup_retain_snapshot_1
6. Collect the data from mount volume to local disk for verififaction
Retain the snapshots nad verify the data after cloning:
1. ceph fs snapshot rm <vol_name> <subvol_name> snap_name [--group_name <subvol_group_name>
--force --retain-snapshots]
2. Remove the sub volume.
3. Clone the new volume from the retained snapshots
4. Check the contents of the cloned volume with the copy present locally
Clean Up:
1. Del all the snapshots created
2. Del Subvolumes
3. Del SubvolumeGroups
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_retain_snapshot_1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_retain_snapshot",
"group_name": "subvolgroup_retain_snapshot_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_retain_snapshot subvolgroup_retain_snapshot_1",
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
client1.exec_command(
sudo=True,
cmd=
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 "
f"--files 100 --files-per-dir 10 --dirs-per-dir 2 --top "
f"{kernel_mounting_dir_1}",
long_running=True,
)
snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_retain_snapshot",
"snap_name": "snap_1",
"group_name": "subvolgroup_retain_snapshot_1",
}
fs_util.create_snapshot(client1, **snapshot)
client1.exec_command(sudo=True, cmd=f"mkdir -p /tmp/{mounting_dir}")
client1.exec_command(
sudo=True,
cmd=f"cp -r {kernel_mounting_dir_1}/* /tmp/{mounting_dir}")
fs_util.remove_subvolume(client1,
**subvolume,
retain_snapshots=True,
force=True,
validate=False)
log.info(
"Verifying Get the path of sub volume as subvolume will still be listed in filesystem"
)
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_retain_snapshot subvolgroup_retain_snapshot_1",
check_ec=False,
)
if rc == 0:
raise CommandFailed(
"Remove subvolume with --retainSnapshots has not succeeded."
"We are still able to fetch path of subvolume after deletion")
return 1
log.info("Clone a subvolume from snapshot")
retain_snapshot_1 = {
"vol_name": default_fs,
"subvol_name": "subvol_retain_snapshot",
"snap_name": "snap_1",
"target_subvol_name": "retain_snapshot_1",
"group_name": "subvolgroup_retain_snapshot_1",
}
fs_util.create_clone(client1, **retain_snapshot_1)
fs_util.validate_clone_state(client1, retain_snapshot_1)
clonevol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} {retain_snapshot_1['target_subvol_name']}",
)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_2/"
fs_util.fuse_mount(
[client1],
fuse_mounting_dir_2,
extra_params=f" -r {clonevol_path.read().decode().strip()}",
)
client1.exec_command(
sudo=True,
cmd=f"diff -qr /tmp/{mounting_dir} {fuse_mounting_dir_2}")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
rmclone_list = [
{
"vol_name": default_fs,
"subvol_name": "retain_snapshot_1"
},
]
for clone_vol in rmclone_list:
fs_util.remove_subvolume(client1, **clone_vol)
fs_util.remove_snapshot(client1,
**snapshot,
validate=False,
force=True)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1,
**subvolumegroup,
force=True)
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. Create cephfs volume
creats fs volume create <vol_name>
2. Create cephfs subvolume
creats fs subvolume create <vol_name> <subvolume_name>
Operations:
1. Mount Cephfs on kernel client with recover_session=no
2. Block the client node on which cephfs is mounted
3. Verify mount is inaccessible
Clean-up:
1. Remove all the data in Cephfs file system
2. Unblock the client node
3. Remove all cephfs mounts
"""
try:
tc = "CEPH-83573676"
log.info(f"Running cephfs {tc} test case")
fs_util = FsUtils(ceph_cluster)
config = kw["config"]
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
rhbuild = config.get("rhbuild")
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
client1 = clients[0]
client2 = clients[1]
mon_node_ip = fs_util.get_mon_node_ips()
mon_node_ip = ",".join(mon_node_ip)
mount_dir = "/mnt/" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
if "4." in rhbuild:
fs_name = "cephfs_new"
else:
fs_name = "cephfs"
commands = [
f"ceph fs subvolume create {fs_name} sub1",
f"mkdir {mount_dir}",
f"mount -t ceph {mon_node_ip}:/ {mount_dir} -o name=admin,recover_session=no",
f"ls {mount_dir}",
]
output = None
for command in commands:
output, rc = client1.exec_command(sudo=True, cmd=command)
if "volumes" in output:
log.info("Cephfs mount is accessible")
else:
log.error("Cephfs mount is not accessible")
return 1
log.info("Creating Directories")
commands = [
f"mkdir {mount_dir}/volumes/dir",
f"for n in {{1..5}}; do dd if=/dev/urandom of={mount_dir}/volumes/dir/file$( printf %03d "
"$n"
" )"
" bs=1M count=1000; done",
"ceph tell mds.0 client ls --format json",
]
for command in commands:
out, rc = client1.exec_command(sudo=True, cmd=command)
output = json.loads(out)
for item in output:
client_metadata = item["client_metadata"]
kernel_client = 0
if "kernel_version" in client_metadata.keys():
kernel_client = 1
if (client1.node.shortname == item["client_metadata"]["hostname"]
and kernel_client == 1):
client_id = item["id"]
log.info("Blocking the Cephfs client")
command = f"ceph tell mds.0 client evict id={client_id}"
out, rc = client1.exec_command(sudo=True, cmd=command)
time.sleep(5)
try:
log.info("Verifying mount is inaccessible")
out, rc = client1.exec_command(sudo=True, cmd=f"ls {mount_dir}")
except CommandFailed as e:
log.info(e)
log.info("Mount point is inaccessible as expected")
return 0
else:
output = out
if "volumes" in output:
log.error("Mount point is accessible")
return 1
except CommandFailed as e:
log.info(e)
log.info(traceback.format_exc())
return 1
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Cleaning up")
mount_dir_2 = "/mnt/" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
client2.exec_command(sudo=True, cmd=f"mkdir {mount_dir_2}")
command = f"mount -t ceph {mon_node_ip}:/ {mount_dir_2} -o name=admin"
client2.exec_command(sudo=True, cmd=command)
client2.exec_command(sudo=True, cmd=f"rm -rf {mount_dir_2}/*")
client2.exec_command(sudo=True, cmd=f"umount {mount_dir_2}")
ip, rc = client1.exec_command(
sudo=True, cmd="ifconfig eth0 | grep 'inet ' | awk '{{print $2}}'")
log.info("Unblocking the Cephfs client")
if "4." in rhbuild:
out, rc = client1.exec_command(
sudo=True, cmd=f"ceph osd blacklist ls | grep {ip}")
out = out.split()
blocked_client = out[0]
client1.exec_command(sudo=True,
cmd=f"ceph osd blacklist rm {blocked_client}")
else:
out, rc = client1.exec_command(
sudo=True, cmd=f"ceph osd blocklist ls | grep {ip}")
blocked_client = out.split()
client = blocked_client[0]
log.info(f"client_list - {client}")
client1.exec_command(sudo=True,
cmd=f"ceph osd blocklist rm {client}")
client1.exec_command(sudo=True, cmd=f"umount {mount_dir}")
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573870 - Create 2 Filesystem with default values on different MDS daemons
Pre-requisites :
1. We need atleast one client node to execute this test case
Test Case Flow:
1. Create 2 file systems with placement arguments
2. validate the mds came on the specified placements
3. mount both the file systems and using fuse mount
4. Run IOs on the FS
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if not clients:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
client1 = clients[0]
out, rc = client1.exec_command(
sudo=True, cmd="ceph orch ps --daemon_type mds -f json")
daemon_ls_before = json.loads(out.read().decode())
daemon_count_before = len(daemon_ls_before)
host_list = [
client1.node.hostname.replace("node7", "node2"),
client1.node.hostname.replace("node7", "node3"),
]
hosts = " ".join(host_list)
client1.exec_command(
sudo=True,
cmd=f"ceph fs volume create cephfs_new --placement='2 {hosts}'",
check_ec=False,
)
fs_util.wait_for_mds_process(client1, "cephfs_new")
out, rc = client1.exec_command(
sudo=True, cmd="ceph orch ps --daemon_type mds -f json")
daemon_ls_after = json.loads(out.read().decode())
daemon_count_after = len(daemon_ls_after)
assert daemon_count_after > daemon_count_before, (
"daemon count is reduced after creating FS. "
"Expectation is MDS daemons whould be more")
total_fs = fs_util.get_fs_details(client1)
if len(total_fs) < 2:
log.error(
"We can't proceed with the test case as we are not able to create 2 filesystems"
)
fs_names = [fs["name"] for fs in total_fs]
validate_mds_placements("cephfs_new", daemon_ls_after, hosts, 2)
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_2/"
fs_util.fuse_mount([clients[0]],
fuse_mounting_dir_1,
extra_params=f"--client_fs {fs_names[0]}")
fs_util.fuse_mount([clients[0]],
fuse_mounting_dir_2,
extra_params=f"--client_fs {fs_names[1]}")
client1.exec_command(
sudo=True,
cmd=
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 "
f"--files 100 --files-per-dir 10 --dirs-per-dir 1 --top "
f"{fuse_mounting_dir_1}",
long_running=True,
)
client1.exec_command(
sudo=True,
cmd=
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 "
f"--files 100 --files-per-dir 10 --dirs-per-dir 1 --top "
f"{fuse_mounting_dir_2}",
long_running=True,
)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
fs_util.client_clean_up("umount",
fuse_clients=[clients[0]],
mounting_dir=fuse_mounting_dir_1)
fs_util.client_clean_up("umount",
fuse_clients=[clients[0]],
mounting_dir=fuse_mounting_dir_2)
commands = [
"ceph config set mon mon_allow_pool_delete true",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
fs_util.remove_fs(client1, "cephfs_new")
def run(ceph_cluster, **kw):
"""
Test Cases Covered:
CEPH-83573502 Interrupt the cloning operation in-between and observe the behavior..
Pre-requisites :
1. We need atleast one client node to execute this test case
1. creats fs volume create cephfs if the volume is not there
2. Create 1 sub volume groups
Ex : ceph fs subvolumegroup create cephfs subvolgroup_1
3. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_clone_cancel --size 5368706371 --group_name subvolgroup_
4. Create Data on the subvolume
Ex: python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 --files
100 --files-per-dir 10 --dirs-per-dir 2 --top /mnt/cephfs_fuse1baxgbpaia_1/
5. Create snapshot of the subvolume
Ex: ceph fs subvolume snapshot create cephfs subvol_clone_cancel snap_1 --group_name subvolgroup_1
Clone Operations and Clone States:
1. Create a clone in default locaction.
ceph fs subvolume snapshot clone cephfs subvol_clone_cancel snap_1 clone_status_1 --group_name subvolgroup_1
2. Create a clone and Cancel the Operation and check the state is in "canceled".
3. Clone state should move to canceled state
Clean-up:
1. ceph fs snapshot rm <vol_name> <subvol_name> snap_name [--group_name <subvol_group_name>]
2. ceph fs subvolume rm <vol_name> <subvol_name> [--group_name <subvol_group_name>]
3. ceph fs subvolumegroup rm <vol_name> <group_name>
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if len(clients) < 1:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10))
)
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{"vol_name": default_fs, "group_name": "subvolgroup_clone_cancel_1"}
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_cancel",
"group_name": "subvolgroup_clone_cancel_1",
"size": "5368706371",
}
fs_util.create_subvolume(client1, **subvolume)
log.info("Get the path of sub volume")
subvol_path, rc = client1.exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_clone_cancel subvolgroup_clone_cancel_1",
)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.read().decode().strip()}",
)
client1.exec_command(
sudo=True,
cmd=f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 400 "
f"--files 100 --files-per-dir 10 --dirs-per-dir 2 --top "
f"{kernel_mounting_dir_1}",
long_running=True,
)
snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_cancel",
"snap_name": "snap_1",
"group_name": "subvolgroup_clone_cancel_1",
}
fs_util.create_snapshot(client1, **snapshot)
clone_status_3 = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_cancel",
"snap_name": "snap_1",
"target_subvol_name": "clone_status_3",
"group_name": "subvolgroup_clone_cancel_1",
}
fs_util.create_clone(client1, **clone_status_3)
fs_util.clone_cancel(
client1,
clone_status_3["vol_name"],
clone_status_3["target_subvol_name"],
group_name=clone_status_3.get("target_group_name", ""),
)
fs_util.validate_clone_state(client1, clone_status_3, "canceled")
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
rmclone_list = [
{"vol_name": default_fs, "subvol_name": "clone_status_3", "force": True},
]
for clone_vol in rmclone_list:
fs_util.remove_subvolume(client1, **clone_vol)
fs_util.remove_snapshot(client1, **snapshot)
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1, **subvolumegroup, force=True)
def run(ceph_cluster, **kw):
"""
Test Cases Covered :
CEPH-83573400 Test to validate the increase in quota limit once it reaches the max limit. (files)
Create a FS and create 10 directories and mount them on kernel client and fuse client(5 mounts
each). Set max file quota to a number(say 50) and add up to that number of files to that directory
and verify if the set quota limit is working fine.
Increase the set quota limit to more that what was set
earlier and add more files and verify.
Similarly set different limit on different directories, increase
the limit and verify it’s functionality and verify quota
Pre-requisites :
1. We need atleast one client node to execute this test case
2. create fs volume create cephfs if the volume is not there
3. ceph fs subvolumegroup create <vol_name> <group_name> --pool_layout <data_pool_name>
Ex : ceph fs subvolumegroup create cephfs subvolgroup_clone_attr_vol_1
4. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_1 --size 5368706371 --group_name subvolgroup_1
5. ceph fs subvolume create <vol_name> <subvol_name> [--size <size_in_bytes>] [--group_name <subvol_group_name>]
[--pool_layout <data_pool_name>] [--uid <uid>] [--gid <gid>] [--mode <octal_mode>] [--namespace-isolated]
Ex: ceph fs subvolume create cephfs subvol_2 --size 5368706371 --group_name subvolgroup_1
Test Case Flow:
1. Mount the subvolume_1 on the client using fuse
2. Mount the subvolume_2 on the client using kernel
3. set file attribute 10 on both mount points
4. Create 11 files and check it fails at 11 iteration
5. Perform same on kernel mount
6. Create a directory inside fuse mount and set file attribute and verify
7. Create a directory inside kernel mount and set file attribute and verify
8. Increase the quota of files to 20 and try creating the files on the same directory used in step 3
9. Perorm same on Kernel mount
"""
try:
fs_util = FsUtils(ceph_cluster)
config = kw.get("config")
clients = ceph_cluster.get_ceph_objects("client")
build = config.get("build", config.get("rhbuild"))
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
log.info("checking Pre-requisites")
if not clients:
log.info(
f"This test requires minimum 1 client nodes.This has only {len(clients)} clients"
)
return 1
default_fs = "cephfs"
mounting_dir = "".join(
random.choice(string.ascii_lowercase + string.digits)
for _ in list(range(10)))
client1 = clients[0]
fs_details = fs_util.get_fs_info(client1)
if not fs_details:
fs_util.create_fs(client1, "cephfs")
subvolumegroup_list = [
{
"vol_name": default_fs,
"group_name": "subvolgroup_quota_file_increase_1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_file_incr_fuse",
"group_name": "subvolgroup_quota_file_increase_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_file_incr_kernel",
"group_name": "subvolgroup_quota_file_increase_1",
"size": "5368706371",
},
]
for subvolume in subvolume_list:
fs_util.create_subvolume(clients[0], **subvolume)
kernel_mounting_dir_1 = f"/mnt/cephfs_kernel{mounting_dir}_1/"
mon_node_ips = fs_util.get_mon_node_ips()
log.info("Get the path of sub volume")
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_file_incr_kernel subvolgroup_quota_file_increase_1",
)
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{subvol_path.strip()}",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} subvol_file_incr_fuse subvolgroup_quota_file_increase_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {subvol_path.strip()}",
)
fs_util.set_quota_attrs(clients[0], 50, 10000000, fuse_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0], fuse_mounting_dir_1)
fs_util.file_quota_test(clients[0], fuse_mounting_dir_1, quota_attrs)
log.info("Increasing the quota to 100 and validating file quota attr")
fs_util.set_quota_attrs(clients[0], 100, 10000000, fuse_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0], fuse_mounting_dir_1)
fs_util.file_quota_test(clients[0], fuse_mounting_dir_1, quota_attrs)
fs_util.set_quota_attrs(clients[0], 50, 10000000,
kernel_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0],
kernel_mounting_dir_1)
fs_util.file_quota_test(clients[0], kernel_mounting_dir_1, quota_attrs)
log.info("Increasing the quota to 100 and validating file quota attr")
fs_util.set_quota_attrs(clients[0], 100, 10000000,
kernel_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0],
kernel_mounting_dir_1)
fs_util.file_quota_test(clients[0], kernel_mounting_dir_1, quota_attrs)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Clean Up in progess")
for subvolume in subvolume_list:
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1,
**subvolumegroup,
force=True)
def run(ceph_cluster, **kw):
"""
Pre-requisites:
1. Create 3 cephfs volume
creats fs volume create <vol_name>
ceph orch apply mds <fs_name> --placement='<no. of mds> <mds_nodes...>'
Test operation:
1. Create client1 restricted to first cephfs
ceph fs authorize <fs_name> client.<client_id> <path-in-cephfs> rw
2. Create client2 restricted to second cephfs
3. Create client3 restricted to third cephfs
4. Get filesystem information using client1
5. Ensure only first cephfs info is shown
6. Get filesystem information using client2
7. Ensure only second cephfs info is shown
8. Get filesystem information using client3
9. Ensure only third cephfs info is shown
Clean-up:
1. Remove third cephfs
2. Remove all the cephfs mounts
3. Remove all the clients
"""
try:
tc = "CEPH-83573875"
log.info(f"Running cephfs {tc} test case")
config = kw["config"]
build = config.get("build", config.get("rhbuild"))
mdss = ceph_cluster.get_ceph_objects("mds")
fs_util = FsUtils(ceph_cluster)
clients = ceph_cluster.get_ceph_objects("client")
client1 = clients[0]
mds1 = mdss[0].node.hostname
mds2 = mdss[1].node.hostname
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
mon_node_ip = fs_util.get_mon_node_ips()
mon_node_ip = ",".join(mon_node_ip)
fs1 = "cephfs"
fs2 = "cephfs-ec"
fs3 = "Ceph_fs_new"
commands = [
f"ceph fs volume create {fs3}",
f"ceph orch apply mds {fs3} --placement='2 {mds1} {mds2}'",
]
for command in commands:
_, err = clients[0].exec_command(sudo=True,
cmd=command,
long_running=True)
if err:
return 1
wait_for_process(client=clients[0],
process_name=fs3,
ispresent=True)
log.info(f"Creating client authorized to {fs1}")
fs_util.fs_client_authorize(client1, fs1, "client1", "/", "rw")
log.info(f"Creating client authorized to {fs2}")
fs_util.fs_client_authorize(client1, fs2, "client2", "/", "rw")
log.info(f"Creating client authorized to {fs3}")
fs_util.fs_client_authorize(client1, fs3, "client3", "/", "rw")
log.info("Verifying file system information for client1")
command = (
"ceph auth get client.client1 -o /etc/ceph/ceph.client.client1.keyring"
)
client1.exec_command(sudo=True, cmd=command)
command = "ceph fs ls -n client.client1 -k /etc/ceph/ceph.client.client1.keyring --format json"
out, rc = client1.exec_command(sudo=True, cmd=command)
output = json.loads(out.read().decode())
validate_fs_info(fs1, output)
log.info("Verifying file system information for client2")
command = (
"ceph auth get client.client2 -o /etc/ceph/ceph.client.client2.keyring"
)
client1.exec_command(sudo=True, cmd=command)
command = "ceph fs ls -n client.client2 -k /etc/ceph/ceph.client.client2.keyring --format json"
out, rc = client1.exec_command(sudo=True, cmd=command)
output = json.loads(out.read().decode())
validate_fs_info(fs2, output)
log.info("Verifying file system information for client3")
command = (
"ceph auth get client.client3 -o /etc/ceph/ceph.client.client3.keyring"
)
client1.exec_command(sudo=True, cmd=command)
command = "ceph fs ls -n client.client3 -k /etc/ceph/ceph.client.client3.keyring --format json"
out, rc = client1.exec_command(sudo=True, cmd=command)
output = json.loads(out.read().decode())
validate_fs_info(fs3, output)
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Cleaning up the system")
commands = [
"ceph config set mon mon_allow_pool_delete true",
f"ceph fs volume rm {fs3} --yes-i-really-mean-it",
]
for command in commands:
client1.exec_command(sudo=True, cmd=command)
for num in range(1, 4):
client1.exec_command(sudo=True,
cmd=f"ceph auth rm client.client{num}")
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. Create 2 cephfs volume
creats fs volume create <vol_name>
Test operation:
1. Mount both cephfs with same auth_key(client)
2. Run IO's on both cephfs mounts
Clean-up:
1. Remove all the data in Cephfs file system
2. Remove all the cephfs mounts
"""
try:
tc = "CEPH-83573877"
log.info(f"Running cephfs {tc} test case")
config = kw["config"]
build = config.get("build", config.get("rhbuild"))
fs_util = FsUtils(ceph_cluster)
clients = ceph_cluster.get_ceph_objects("client")
client1 = clients[0]
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
mon_node_ip = fs_util.get_mon_node_ips()
mon_node_ip = ",".join(mon_node_ip)
mount_points = []
multiple_cephfs = ["cephfs", "cephfs-ec"]
for fs_name in multiple_cephfs:
log.info(f"Mounting {fs_name} on fuse & kernel client with same auth_key")
kernel_mount_dir = "/mnt/kernel_" + "".join(
secrets.choice(string.ascii_uppercase + string.digits) for i in range(5)
)
fs_util.kernel_mount(
clients,
kernel_mount_dir,
mon_node_ip,
new_client_hostname="admin",
extra_params=f",fs={fs_name}",
)
fuse_mount_dir = "/mnt/fuse_" + "".join(
secrets.choice(string.ascii_uppercase + string.digits) for i in range(5)
)
mount_points.extend([kernel_mount_dir, fuse_mount_dir])
fs_util.fuse_mount(
clients,
fuse_mount_dir,
new_client_hostname="admin",
extra_params=f" --client_fs {fs_name}",
)
log.info(f"Running IO's on {fs_name}")
commands = [
f"mkdir {kernel_mount_dir}/dir1 {fuse_mount_dir}/dir2",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {kernel_mount_dir}/dir1",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation read --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {kernel_mount_dir}/dir1",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {fuse_mount_dir}/dir2",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation read --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {fuse_mount_dir}/dir2",
]
for command in commands:
_, err = client1.exec_command(sudo=True, cmd=command, long_running=True)
if err:
return 1
return 0
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Cleaning up the system")
client1.exec_command(sudo=True, cmd=f"rm -rf {mount_points[0]}/*")
client1.exec_command(sudo=True, cmd=f"rm -rf {mount_points[2]}/*")
for client in clients:
for mount_point in mount_points:
client.exec_command(sudo=True, cmd=f"umount {mount_point}")
def run(ceph_cluster, **kw):
"""
Pre-requisites :
1. Create cephfs volume
creats fs volume create <vol_name>
2. Disable pg_autoscale_mode for cephfs pools if set
ceph osd pool set cephfs_data pg_autoscale_mode off
ceph osd pool set cephfs_metadata pg_autoscale_mode off
3. Configure 2 clients with Fuse client and another 1 client with kernel client
Test operation:
1. Run IO's on both clients
2. Verify there are no "heartbeat_map" timeout issue in logs
3. Fill up cluster upto 20%
4. Change cephfs data and metadata pool pg_num and pgp_num to existing size "-1" with client IO running
5. Wait for cluster to come to active + clean state , while running IO's
6. Write some more data to the cluster
7. Change cephfs data and metadata pool pg_num and pgp_num to existing size "+1" with client IO running
8. Wait for cluster to come to active + clean state , while running IO's
Clean-up:
1. Remove all the data in Cephfs file system
2. Remove all the cephfs mounts
3. Reset pg_autoscale_mode for cephfs pools to on
"""
try:
tc = "CEPH-83574596"
log.info(f"Running cephfs {tc} test case")
config = kw["config"]
rhbuild = config.get("rhbuild")
build = config.get("build", config.get("rhbuild"))
mdss = ceph_cluster.get_ceph_objects("mds")
fs_util = FsUtils(ceph_cluster)
clients = ceph_cluster.get_ceph_objects("client")
fs_util.prepare_clients(clients, build)
fs_util.auth_list(clients)
mon_node_ip = fs_util.get_mon_node_ips()
mon_node_ip = ",".join(mon_node_ip)
mount_points = []
kernel_mount_dir = "/mnt/" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
fs_util.kernel_mount(clients,
kernel_mount_dir,
mon_node_ip,
new_client_hostname="admin")
fuse_mount_dir = "/mnt/" + "".join(
secrets.choice(string.ascii_uppercase + string.digits)
for i in range(5))
fs_util.fuse_mount(clients,
fuse_mount_dir,
new_client_hostname="admin")
mount_points.extend([kernel_mount_dir, fuse_mount_dir])
if "4." in rhbuild:
data_pool = "cephfs_data"
metadata_pool = "cephfs_metadata"
else:
data_pool = "cephfs.cephfs.data"
metadata_pool = "cephfs.cephfs.meta"
commands = [
f"ceph osd pool set {data_pool} pg_autoscale_mode off",
f"ceph osd pool set {metadata_pool} pg_autoscale_mode off",
]
for command in commands:
clients[0].exec_command(sudo=True, cmd=command, long_running=True)
data_pool_pg_num, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph osd pool get {data_pool} pg_num | awk '{{print $2}}'")
metadata_pool_pg_num, rc = clients[0].exec_command(
sudo=True,
cmd=
f"ceph osd pool get {metadata_pool} pg_num | awk '{{print $2}}'",
)
for num in range(1, 7):
log.info("Creating Directories")
out, rc = clients[0].exec_command(sudo=True,
cmd="mkdir %s/%s%d" %
(kernel_mount_dir, "dir", num))
log.info("Running IO's to get cluster upto 20% capacity")
no_of_files = "{1..10}"
commands = [
f'for n in {no_of_files}; do dd if=/dev/urandom of={kernel_mount_dir}/dir1/file$( printf %03d "$n" )'
f" bs=1M count=1000; done",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {kernel_mount_dir}/dir2",
]
for command in commands:
clients[0].exec_command(sudo=True, cmd=command, long_running=True)
log.info("Checking for heartbeat map timeout issue")
rc = fs_util.heartbeat_map(mdss[0])
if rc == 1:
log.error("heartbeat map timeout issue found")
return 1
log.info(
"Changing cephfs data and metadata pool pg_num and pgp_num to existing size '-1' with client IO running"
)
no_of_files = "{1..1000}"
data_pool_pg_num = str(int(data_pool_pg_num) - 1)
metadata_pool_pg_num = str(int(metadata_pool_pg_num) - 1)
commands = [
f'for n in {no_of_files}; do dd if=/dev/urandom of={kernel_mount_dir}/dir3/file$( printf %03d "$n" )'
f" bs=1M count=10; done",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {kernel_mount_dir}/dir4",
f"ceph osd pool set {data_pool} pg_num {data_pool_pg_num}",
f"ceph osd pool set {data_pool} pgp_num {data_pool_pg_num}",
f"ceph osd pool set {metadata_pool} pg_num {metadata_pool_pg_num}",
f"ceph osd pool set {metadata_pool} pgp_num {metadata_pool_pg_num}",
]
with parallel() as p:
for num in range(0, 6):
p.spawn(clients[0].exec_command, sudo=True, cmd=commands[num])
time.sleep(1)
log.info("Verifying pgs are in active+clean state")
rc = check_clean_pgs(clients)
if rc == 1:
return 1
log.info(
"Change cephfs data and metadata pool pg_num and pgp_num to existing size '+1' with client IO running"
)
data_pool_pg_num = str(int(data_pool_pg_num) + 1)
metadata_pool_pg_num = str(int(metadata_pool_pg_num) + 1)
commands = [
f'for n in {no_of_files}; do dd if=/dev/urandom of={kernel_mount_dir}/dir5/file$( printf %03d "$n" )'
f" bs=1M count=10; done",
f"python3 /home/cephuser/smallfile/smallfile_cli.py --operation create --threads 10 --file-size 4 "
f"--files 1000 --files-per-dir 10 --top {kernel_mount_dir}/dir6",
f"ceph osd pool set {data_pool} pg_num {data_pool_pg_num}",
f"ceph osd pool set {data_pool} pgp_num {data_pool_pg_num}",
f"ceph osd pool set {metadata_pool} pg_num {metadata_pool_pg_num}",
f"ceph osd pool set {metadata_pool} pgp_num {metadata_pool_pg_num}",
]
with parallel() as p:
for num in range(0, 6):
p.spawn(clients[0].exec_command, sudo=True, cmd=commands[num])
time.sleep(1)
log.info("Verifying pgs are in active+clean state")
rc = check_clean_pgs(clients)
if rc == 1:
return 1
return 0
except CommandFailed as e:
log.info(e)
log.info(traceback.format_exc())
return 1
except Exception as e:
log.info(e)
log.info(traceback.format_exc())
return 1
finally:
log.info("Cleaning up the system")
out, rc = clients[0].exec_command(sudo=True,
cmd=f"rm -rf {mount_points[1]}/*")
for mount_point in mount_points:
clients[0].exec_command(sudo=True, cmd=f"umount {mount_point}")
if "4." in rhbuild:
commands = [
f"ceph osd pool set {data_pool} pg_autoscale_mode warn",
f"ceph osd pool set {metadata_pool} pg_autoscale_mode warn",
]
for command in commands:
clients[0].exec_command(sudo=True,
cmd=command,
long_running=True)
else:
commands = [
f"ceph osd pool set {data_pool} pg_autoscale_mode on",
f"ceph osd pool set {metadata_pool} pg_autoscale_mode on",
]
for command in commands:
clients[0].exec_command(sudo=True,
cmd=command,
long_running=True)
for mount_point in mount_points:
clients[0].exec_command(sudo=True, cmd=f"rm -rf {mount_point}")
