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):
"""
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):
"""
Test Cases Covered :
CEPH-83573524 Ensure the subvolume attributes are retained post clone operations
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_2 --size 5368706371 --group_name subvolgroup_1
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_2 snap_1 --group_name subvolgroup_clone_attr_vol_1
7. Set file and size xattributes on dir
Test Case Flow:
1. Create Clone out of subvolume.
2. Mount the cloned volume.
3. Validate the contents of cloned volume with contents present of subvolume
4. Validate file and size xattributes on dir in cloned volume
Clean Up:
1. Delete Cloned volume
2. Delete subvolumegroup
"""
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_attr_vol_1"
},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_attr_vol",
"group_name": "subvolgroup_clone_attr_vol_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_attr_vol subvolgroup_clone_attr_vol_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 1 --top "
f"{kernel_mounting_dir_1}",
long_running=True,
)
fs_util.set_quota_attrs(clients[0], 9999, 999, kernel_mounting_dir_1)
quota_attrs = fs_util.get_quota_attrs(clients[0],
kernel_mounting_dir_1)
snapshot = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_attr_vol",
"snap_name": "snap_1",
"group_name": "subvolgroup_clone_attr_vol_1",
}
fs_util.create_snapshot(client1, **snapshot)
client1.exec_command(sudo=True, cmd=f"mkdir -p /tmp/{mounting_dir}")
log.info("Clone a subvolume from snapshot")
clone_attr_vol_1 = {
"vol_name": default_fs,
"subvol_name": "subvol_clone_attr_vol",
"snap_name": "snap_1",
"target_subvol_name": "clone_attr_vol_1",
"group_name": "subvolgroup_clone_attr_vol_1",
}
fs_util.create_clone(client1, **clone_attr_vol_1)
fs_util.validate_clone_state(client1, clone_attr_vol_1)
clonevol_path, rc = client1.exec_command(
sudo=True,
cmd=
f"ceph fs subvolume getpath {default_fs} {clone_attr_vol_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()}",
)
quota_attrs_clone = fs_util.get_quota_attrs(clients[0],
fuse_mounting_dir_2)
client1.exec_command(
sudo=True,
cmd=f"diff -qr {kernel_mounting_dir_1} {fuse_mounting_dir_2}")
if quota_attrs_clone != quota_attrs:
log.info(f"attributes of cloned volumes{quota_attrs_clone}")
log.info(f"attributes of volumes{quota_attrs}")
log.error(
"Quota attributes of the clone is not matching with quota attributes of subvolume"
)
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")
rmclone_list = [
{
"vol_name": default_fs,
"subvol_name": "clone_attr_vol_1"
},
]
for clone_vol in rmclone_list:
fs_util.remove_subvolume(client1, **clone_vol)
fs_util.remove_snapshot(client1,
**snapshot,
validate=False,
check_ec=False)
fs_util.remove_subvolume(client1,
**subvolume,
validate=False,
check_ec=False)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1,
**subvolumegroup,
force=True)
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):
"""
Test Cases Covered:
CEPH-83573408 Test to validate the quota remains intact even after rebooting the Node.
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 also set max files quota (say 20) and verify if
the set quota limit is working fine by filling max number of files and also by filling data to reach
the max limit. Reboot the node , once the node is up verify if the set quota remains or not.
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 and 50 files on both mount points
4. Reboot the client node
5. mount the subvolumes again
6. Validate the quota attributes after reboot
"""
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_increase_1"},
]
for subvolumegroup in subvolumegroup_list:
fs_util.create_subvolumegroup(client1, **subvolumegroup)
subvolume_list = [
{
"vol_name": default_fs,
"subvol_name": "subvol_byte_incr_fuse",
"group_name": "subvolgroup_quota_byte_increase_1",
"size": "5368706371",
},
{
"vol_name": default_fs,
"subvol_name": "subvol_byte_incr_kernel",
"group_name": "subvolgroup_quota_byte_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_byte_incr_kernel subvolgroup_quota_byte_increase_1",
)
kernel_subvol_path = subvol_path.read().decode().strip()
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_1,
",".join(mon_node_ips),
sub_dir=f"{kernel_subvol_path}",
)
subvol_path, rc = clients[0].exec_command(
sudo=True,
cmd=f"ceph fs subvolume getpath {default_fs} subvol_byte_incr_fuse subvolgroup_quota_byte_increase_1",
)
fuse_mounting_dir_1 = f"/mnt/cephfs_fuse{mounting_dir}_1/"
fuse_subvol_path = subvol_path.read().decode().strip()
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_1,
extra_params=f" -r {fuse_subvol_path}",
)
fs_util.set_quota_attrs(clients[0], 50, 1073741824, fuse_mounting_dir_1)
fuse_quota_attrs_before_reboot = fs_util.get_quota_attrs(
clients[0], fuse_mounting_dir_1
)
fs_util.set_quota_attrs(clients[0], 50, 1073741824, kernel_mounting_dir_1)
kernel_quota_attrs_before_reboot = fs_util.get_quota_attrs(
clients[0], kernel_mounting_dir_1
)
fs_util.reboot_node(client1)
fuse_mounting_dir_2 = f"/mnt/cephfs_fuse{mounting_dir}_2/"
kernel_mounting_dir_2 = f"/mnt/cephfs_kernel{mounting_dir}_2/"
fs_util.kernel_mount(
[clients[0]],
kernel_mounting_dir_2,
",".join(mon_node_ips),
sub_dir=f"{kernel_subvol_path}",
)
fs_util.fuse_mount(
[clients[0]],
fuse_mounting_dir_2,
extra_params=f" -r {fuse_subvol_path}",
)
fuse_quota_attrs_after_reboot = fs_util.get_quota_attrs(
clients[0], fuse_mounting_dir_2
)
kernel_quota_attrs_after_reboot = fs_util.get_quota_attrs(
clients[0], kernel_mounting_dir_2
)
log.info(
f"Quota Attributes befores reboot:{fuse_quota_attrs_before_reboot}\n"
f"After reboot: {fuse_quota_attrs_after_reboot}"
)
if fuse_quota_attrs_after_reboot != fuse_quota_attrs_before_reboot:
log.info("Fuse mount quota attributes are not matching after reboot")
log.error(
f"Quota Attributes befores reboot:{fuse_quota_attrs_before_reboot}\n"
f"After reboot: {fuse_quota_attrs_after_reboot}"
)
return 1
log.info(
f"Quota Attributes befores reboot:{kernel_quota_attrs_before_reboot}\n"
f"After reboot: {kernel_quota_attrs_after_reboot}"
)
if kernel_quota_attrs_before_reboot != kernel_quota_attrs_after_reboot:
log.info("Fuse mount quota attributes are not matching after reboot")
log.error(
f"Quota Attributes befores reboot:{kernel_quota_attrs_before_reboot}\n"
f"After reboot: {kernel_quota_attrs_after_reboot}"
)
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")
for subvolume in subvolume_list:
fs_util.remove_subvolume(client1, **subvolume)
for subvolumegroup in subvolumegroup_list:
fs_util.remove_subvolumegroup(client1, **subvolumegroup, force=True)
