def test_nfs_ganesha_export_after_vol_restart(self):
"""
Tests script to check nfs-ganesha volume gets exported after
multiple volume restarts.
"""
for i in range(1, 6):
g.log.info(
"Testing nfs ganesha export after volume stop/start."
"Count : %s", str(i))
# Stopping volume
ret = volume_stop(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to stop volume %s" % self.volname))
# Waiting for few seconds for volume unexport. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_unexported(
self.mnode, self.volname)
self.assertTrue(ret, ("Failed to unexport volume %s after "
"stopping volume" % self.volname))
# Starting volume
ret = volume_start(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to start volume %s" % self.volname))
# Waiting for few seconds for volume export. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_exported(
self.mnode, self.volname)
self.assertTrue(ret, ("Failed to export volume %s after "
"starting volume" % self.volname))
def test_nfs_ganesha_exportID_after_vol_restart(self):
"""
Tests script to check nfs-ganesha volume gets exported with same
Export ID after multiple volume restarts.
Steps:
1. Create and Export the Volume
2. Stop and Start the volume multiple times
3. Check for export ID
Export ID should not change
"""
for i in range(1, 4):
g.log.info(
"Testing nfs ganesha exportID after volume stop and "
"start.\n Count : %s", str(i))
# Stopping volume
ret = volume_stop(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to stop volume %s" % self.volname))
g.log.info("Volume is stopped")
# Waiting for few seconds for volume unexport. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_unexported(
self.mnode, self.volname)
self.assertTrue(ret, ("Failed to unexport volume %s after "
"stopping volume" % self.volname))
g.log.info("Volume is unexported via ganesha")
# Starting volume
ret = volume_start(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to start volume %s" % self.volname))
g.log.info("Volume is started")
# Waiting for few seconds for volume export. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_exported(
self.mnode, self.volname)
self.assertTrue(ret, ("Failed to export volume %s after "
"starting volume" % self.volname))
g.log.info("Volume is exported via ganesha")
# Check for Export ID
cmd = ("cat /run/gluster/shared_storage/nfs-ganesha/exports/"
"export.*.conf | grep Export_Id | grep -Eo '[0-9]'")
ret, out, _ = g.run(self.mnode, cmd)
self.assertEqual(
ret, 0,
"Unable to get export ID of the volume %s" % self.volname)
g.log.info("Successful in getting volume export ID: %s " % out)
self.assertEqual(
out.strip("\n"), "2",
"Export ID changed after export and unexport "
"of volume: %s" % out)
g.log.info("Export ID of volume is same after export "
"and export: %s" % out)
def test_nfs_ganesha_enable_disable_cluster(self):
"""
Tests script to check nfs-ganehsa volume gets exported after
multiple enable/disable of cluster.
"""
for i in range(1, 6):
g.log.info(
"Executing multiple enable/disable of nfs ganesha "
"cluster. Count : %s ", str(i))
ret, _, _ = disable_nfs_ganesha(self.mnode)
self.assertEqual(ret, 0, "Failed to disable nfs-ganesha cluster")
sleep(2)
vol_option = get_volume_options(self.mnode,
self.volname,
option='ganesha.enable')
if vol_option is None:
self.assertEqual(ret, 0, ("Failed to get ganesha.enable volume"
" option for %s " % self.volume))
self.assertEqual(
vol_option.get('ganesha.enable'), 'off', "Failed "
"to unexport volume by default after disabling "
"cluster")
ret, _, _ = enable_nfs_ganesha(self.mnode)
self.assertEqual(ret, 0, "Failed to enable nfs-ganesha cluster")
# Check nfs-ganesha status
for itr in range(5):
ret = is_nfs_ganesha_cluster_in_healthy_state(self.mnode)
if ret:
g.log.info("nfs-ganesha cluster is healthy")
break
g.log.warning(
"nfs-ganesha cluster is not healthy. "
"Iteration: %s", str(itr))
self.assertEqual(
itr, 4, "Wait timeout: nfs-ganesha cluster "
"is not healthy")
sleep(3)
vol_option = get_volume_options(self.mnode,
self.volname,
option='ganesha.enable')
if vol_option is None:
self.assertEqual(ret, 0, ("Failed to get ganesha.enable volume"
" option for %s " % self.volume))
self.assertEqual(
vol_option.get('ganesha.enable'), 'off', "Volume "
"%s is exported by default after disable and "
"enable of cluster which is unexpected." % self.volname)
# Export volume after disable and enable of cluster
ret, _, _ = export_nfs_ganesha_volume(mnode=self.mnode,
volname=self.volname)
self.assertEqual(
ret, 0, ("Failed to export volume %s "
"after disable and enable of cluster" % self.volname))
# Wait for volume to get exported
ret = wait_for_nfs_ganesha_volume_to_get_exported(
self.mnode, self.volname)
self.assertTrue(
ret, "Volume %s is not exported after setting "
"ganesha.enable 'on'" % self.volname)
g.log.info("Exported volume after enabling nfs-ganesha cluster")
def test_nfs_ganesha_subdirectory_mount_from_server_side(self):
"""
Tests script to verify nfs ganesha subdirectory mount from server
side succeeds and able to write IOs.
"""
subdir_to_mount = self.subdir_path.replace(self.mounts[0].mountpoint,
'')
if not subdir_to_mount.startswith(os.path.sep):
subdir_to_mount = os.path.sep + subdir_to_mount
subdir = self.volname + subdir_to_mount
for mount_obj in self.sub_dir_mounts:
mount_obj.volname = subdir
export_file = ("/var/run/gluster/shared_storage/nfs-ganesha/exports/"
"export.%s.conf" % self.volname)
cmd = (r"sed -i s/'Path = .*'/'Path = \"\/%s\";'/g %s" %
(re.escape(subdir), export_file))
ret, _, _ = g.run(self.mnode, cmd)
self.assertEqual(ret, 0, ("Unable to change Path info to %s in %s" %
("/" + subdir, export_file)))
cmd = ("sed -i 's/volume=.*/& \\n volpath=\"%s\";/g' %s" %
(re.escape(subdir_to_mount), export_file))
ret, _, _ = g.run(self.mnode, cmd)
self.assertEqual(ret, 0, ("Unable to add volpath info to %s in %s" %
("/" + subdir, export_file)))
cmd = (r"sed -i s/'Pseudo=.*'/'Pseudo=\"\/%s\";'/g %s" %
(re.escape(subdir), export_file))
ret, _, _ = g.run(self.mnode, cmd)
self.assertEqual(ret, 0, ("Unable to change pseudo Path info to "
"%s in %s" % ("/" + subdir, export_file)))
# Stop and start volume to take the modified export file to effect.
# Stopping volume
ret = volume_stop(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to stop volume %s" % self.volname))
# Waiting for few seconds for volume unexport. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_unexported(
self.mnode, self.volname)
self.assertTrue(ret, ("Failed to unexport volume %s after "
"stopping volume" % self.volname))
# Starting volume
ret = volume_start(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to start volume %s" % self.volname))
# Waiting for few seconds for volume export. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_exported(self.mnode, subdir)
self.assertTrue(ret, ("Failed to export sub directory %s after "
"starting volume" % subdir))
for mount_obj in self.sub_dir_mounts:
if not mount_obj.is_mounted():
ret = mount_obj.mount()
self.assertTrue(
ret, ("Unable to mount volume '%s:%s' "
"on '%s:%s'" %
(mount_obj.server_system, mount_obj.volname,
mount_obj.client_system, mount_obj.mountpoint)))
ret = self.start_and_wait_for_io_to_complete(self.sub_dir_mounts)
self.assertTrue(ret, ("Failed to write IOs when sub directory is"
" mounted from server side"))
g.log.info("IO successful on clients")
def test_nfs_ganesha_export_with_multiple_volumes(self):
"""
Test case to verify multiple volumes gets exported when IO is in
progress.
"""
# Starting IO on the mounts
all_mounts_procs = []
count = 1
for mount_obj in self.mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = ("/usr/bin/env python %s create_deep_dirs_with_files "
"--dirname-start-num %d "
"--dir-depth 2 "
"--dir-length 10 "
"--max-num-of-dirs 5 "
"--num-of-files 5 %s" %
(self.script_upload_path, count, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
count = count + 10
# Create and export five new volumes
for i in range(5):
# Check availability of bricks to create new volume
num_of_unused_bricks = 0
servers_unused_bricks_dict = get_servers_unused_bricks_dict(
self.mnode, self.all_servers, self.all_servers_info)
for each_server_unused_bricks_list in list(
servers_unused_bricks_dict.values()):
num_of_unused_bricks = (num_of_unused_bricks +
len(each_server_unused_bricks_list))
if num_of_unused_bricks < 2:
self.assertNotEqual(
i, 0, "New volume cannot be created due "
"to unavailability of bricks.")
g.log.warning(
"Tried to create five new volumes. But could "
"create only %s volume due to unavailability "
"of bricks.", str(i))
break
self.volume['name'] = "nfsvol" + str(i)
self.volume['voltype']['type'] = 'distributed'
self.volume['voltype']['replica_count'] = 1
self.volume['voltype']['dist_count'] = 2
new_vol = self.volume['name']
# Create volume
ret = setup_volume(mnode=self.mnode,
all_servers_info=self.all_servers_info,
volume_config=self.volume,
force=True)
if not ret:
self.assertTrue(ret, "Setup volume [%s] failed" % self.volume)
g.log.info("Wait for volume processes to be online")
ret = wait_for_volume_process_to_be_online(self.mnode, new_vol)
self.assertTrue(
ret, "Volume %s process not online despite "
"waiting for 300 seconds" % new_vol)
# Export volume with nfs ganesha
ret, _, _ = export_nfs_ganesha_volume(mnode=self.mnode,
volname=new_vol)
self.assertEqual(ret, 0, ("Failed to export volume %s "
"using nfs-ganesha" % new_vol))
# Wait for volume to get exported
ret = wait_for_nfs_ganesha_volume_to_get_exported(
self.mnode, new_vol)
self.assertTrue(
ret, "Volume %s is not exported after setting "
"ganesha.enable 'on'" % new_vol)
g.log.info("Exported nfs-ganesha volume %s", new_vol)
# Log Volume Info and Status
ret = log_volume_info_and_status(self.mnode, new_vol)
self.assertTrue(
ret, "Logging volume %s info and status failed" % new_vol)
# Validate IO
g.log.info("Validating IO")
ret = validate_io_procs(all_mounts_procs, self.mounts)
self.assertTrue(ret, "IO failed on some of the clients")
g.log.info("Successfully validated all IO")
def test_new_volume_while_io_in_progress(self):
"""
Create, export and mount new volume while IO running on mount of
another volume
Steps:
1. Start IO on mount points
2. Create another volume 'volume_new'
3. Export volume_new through nfs-ganesha
4. Mount the volume on clients
"""
# pylint: disable=too-many-statements, too-many-locals
# Start IO on all mount points
all_mounts_procs = []
count = 1
for mount_obj in self.mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = ("/usr/bin/env python %s create_deep_dirs_with_files "
"--dirname-start-num %d "
"--dir-depth 2 "
"--dir-length 10 "
"--max-num-of-dirs 5 "
"--num-of-files 5 %s" %
(self.script_upload_path, count, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
count = count + 10
self.volname_new = '%s_new' % self.volname
kwargs = {}
dict_index = 0
# Creating mounts list for mounting new volume
self.mounts_new = []
for mount_obj in self.mounts:
self.mounts_new.append(deepcopy(mount_obj))
for mount_obj in self.mounts_new:
mount_obj.volname = self.volname_new
mount_obj.mountpoint = '%s_new' % mount_obj.mountpoint
# Fetch details for creating a replicate volume.
replica_count = (
self.default_volume_type_config['replicated']['replica_count'])
servers_bricks_dict = get_servers_bricks_dict(self.all_servers,
self.all_servers_info)
bricks_list = []
kwargs['replica_count'] = replica_count
kwargs['transport_type'] = (
self.default_volume_type_config['replicated']['transport'])
for num in range(0, replica_count):
# Current_server is the server on which brick path will be created
current_server = list(servers_bricks_dict.keys())[dict_index]
current_server_unused_bricks_list = (list(
servers_bricks_dict.values())[dict_index])
if current_server_unused_bricks_list:
brick_path = (
"%s:%s/%s_brick%s" %
(current_server, current_server_unused_bricks_list[0],
self.volname_new, num))
bricks_list.append(brick_path)
# Remove the added brick from the list
list(servers_bricks_dict.values())[dict_index].pop(0)
if dict_index < len(servers_bricks_dict) - 1:
dict_index = dict_index + 1
else:
dict_index = 0
# Create volume 'volume_new'
ret, _, _ = volume_create(mnode=self.mnode,
volname=self.volname_new,
bricks_list=bricks_list,
force=False,
**kwargs)
self.assertEqual(ret, 0,
"Unable to create volume %s" % self.volname_new)
g.log.info("Successfully created volume %s", self.volname_new)
ret, _, _ = volume_start(self.mnode, self.volname_new)
self.assertEqual(ret, 0,
"Unable to start volume %s" % self.volname_new)
# Wait for volume processes to be online
g.log.info("Wait for volume %s processes to be online",
self.volname_new)
ret = wait_for_volume_process_to_be_online(self.mnode,
self.volname_new)
self.assertTrue(
ret, "Wait timeout: Processes of volume %s are "
"not online." % self.volname_new)
g.log.info("Volume processes of volume %s are now online",
self.volname_new)
# Export volume as nfs-ganesha export
ret, _, _ = export_nfs_ganesha_volume(self.mnode, self.volname_new)
self.assertEqual(
ret, 0, "Failed to set ganesha.enable 'on' on "
"volume %s" % self.volname_new)
g.log.info(
"Successful in setting ganesha.enable to 'on' on "
"volume %s", self.volname_new)
# Verify volume export
ret = wait_for_nfs_ganesha_volume_to_get_exported(
self.mnode, self.volname_new)
self.assertTrue(
ret, "Failed to export volume %s as nfs-ganesha "
"export" % self.volname_new)
g.log.info("Successfully exported volume %s", self.volname_new)
# Mount the new volume
for mount_obj in self.mounts_new:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted %s on client %s",
mount_obj.volname, mount_obj.client_system)
# Verify mounts
for mount_obj in self.mounts_new:
ret = mount_obj.is_mounted()
self.assertTrue(
ret, ("Volume %s is not mounted on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Verified: Volume %s is mounted on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Export and mount of new volume %s is success.",
self.volname_new)
# Validate IO
g.log.info("Validating IO's")
ret = validate_io_procs(all_mounts_procs, self.mounts)
self.assertTrue(ret, "IO failed on some of the clients")
g.log.info("Successfully validated all IO")
# Get stat of all the files/dirs created.
g.log.info("Get stat of all the files/dirs created.")
ret = get_mounts_stat(self.mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
def test_root_squash_enable(self):
"""
Tests to verify Nfs Ganesha rootsquash functionality when volume
is restarted
Steps:
1. Create some files and dirs inside mount point
2. Set permission as 777 for mount point
3. Enable root-squash on volume
4. Create some more files and dirs
5. Restart volume
6. Try to edit file created in step 1
It should not allow to edit the file
7. Try to edit the file created in step 5
It should allow to edit the file
"""
# Start IO on mount point.
cmd = ("for i in {1..10}; do touch %s/file$i; done" %
self.mounts[0].mountpoint)
ret, _, err = g.run(self.mounts[0].client_system,
cmd,
user=self.mounts[0].user)
self.assertEqual(ret, 0, err)
# Get stat of all the files/dirs created.
ret = get_mounts_stat(self.mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successful in getting stats of files/dirs "
"from mount point")
# Set mount point permission to 777
ret = set_file_permissions(self.mounts[0].client_system,
self.mounts[0].mountpoint, 777)
self.assertTrue(ret, "Failed to set permission for directory")
g.log.info("Successfully set permissions for directory")
# Enable root-squash on volume
ret = set_root_squash(self.servers[0], self.volname)
self.assertTrue(ret, "Failed to enable root-squash on volume")
g.log.info("root-squash is enable on the volume")
# Start IO on mount point.
cmd = ("for i in {1..10}; do touch %s/Squashfile$i; done" %
self.mounts[0].mountpoint)
ret, _, err = g.run(self.mounts[0].client_system,
cmd,
user=self.mounts[0].user)
self.assertEqual(ret, 0, err)
# Get stat of all the files/dirs created.
ret = get_mounts_stat(self.mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successful in getting stats of files/dirs "
"from mount point")
# Stopping volume
ret = volume_stop(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to stop volume %s" % self.volname))
g.log.info("Successful in stopping volume %s" % self.volname)
# Waiting for few seconds for volume unexport. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_unexported(
self.mnode, self.volname)
self.assertTrue(ret, ("Failed to unexport volume %s after "
"stopping volume" % self.volname))
g.log.info("Volume is unexported successfully")
# Starting volume
ret = volume_start(self.mnode, self.volname)
self.assertTrue(ret, ("Failed to start volume %s" % self.volname))
g.log.info("Successful in starting volume %s" % self.volname)
# Waiting for few seconds for volume export. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_exported(
self.mnode, self.volname)
self.assertTrue(ret, ("Failed to export volume %s after "
"starting volume" % self.volname))
g.log.info("Volume is exported successfully")
# Edit file created by root user
for mount_obj in self.mounts:
ret = append_string_to_file(mount_obj.client_system,
"%s/file10" % mount_obj.mountpoint,
'hello')
self.assertFalse(
ret, "Unexpected:nfsnobody user editing file "
"created by root user should FAIL")
g.log.info("Successful:nfsnobody user failed to edit file "
"created by root user")
# Edit the file created by nfsnobody user
for mount_obj in self.mounts:
ret = append_string_to_file(
mount_obj.client_system,
"%s/Squashfile5" % mount_obj.mountpoint, 'hello')
self.assertTrue(
ret, "Unexpected:nfsnobody user failed to edit "
"the file created by nfsnobody user")
g.log.info("Successful:nfsnobody user successfully edited the "
"file created by nfsnobody user")
def test_nfs_ganesha_export_with_multiple_volumes(self):
"""
Testcase to verfiy multiple volumes gets exported when IO is in
progress.
"""
for i in range(5):
self.volume['name'] = "nfsvol" + str(i)
self.volume['voltype']['type'] = 'distributed'
self.volume['voltype']['replica_count'] = 1
self.volume['voltype']['dist_count'] = 2
# Create volume
ret = setup_volume(mnode=self.mnode,
all_servers_info=self.all_servers_info,
volume_config=self.volume,
force=True)
if not ret:
self.assertTrue(ret, ("Setup volume %s failed" % self.volume))
time.sleep(5)
# Export volume with nfs ganesha, if it is not exported already
vol_option = get_volume_options(self.mnode,
self.volume['name'],
option='ganesha.enable')
self.assertIsNotNone(
vol_option, "Failed to get ganesha.enable "
"volume option for %s" % self.volume['name'])
if vol_option['ganesha.enable'] != 'on':
ret, _, _ = export_nfs_ganesha_volume(
mnode=self.mnode, volname=self.volume['name'])
self.assertEqual(
ret, 0, "Failed to export volume %s as NFS "
"export" % self.volume['name'])
time.sleep(5)
else:
g.log.info("Volume %s is exported already",
self.volume['name'])
# Waiting for few seconds for volume export. Max wait time is
# 120 seconds.
ret = wait_for_nfs_ganesha_volume_to_get_exported(
self.mnode, (self.volume['name']))
self.assertTrue(ret, ("Failed to export volume %s after "
"starting volume when IO is running on "
"another volume" % self.volume['name']))
# Log Volume Info and Status
ret = log_volume_info_and_status(self.mnode, self.volume['name'])
self.assertTrue(
ret, "Logging volume %s info and status failed" %
self.volume['name'])
# Validate IO
ret = validate_io_procs(self.all_mounts_procs, self.mounts)
self.io_validation_complete = True
self.assertTrue(ret, "IO failed on some of the clients")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
self.assertTrue(ret, "Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")