def _insert_bp(self, host, logpath): """ Generates and inserts a breakpoint in the given logpath on the host """ append_string = self.bp_text + str(self.bp_count) ret = append_string_to_file(host, logpath, append_string) self.assertTrue( ret, 'Not able to append string to the file {} ' 'on {}'.format(logpath, host)) self.bp_count += 1
def _filecreate_and_hashcheck(self, timeoutval): """Create a file and check on which subvol it is hashed to""" # Create and write to a file to test the eagerlock timeout behavior objectname = 'EagerLockTimeoutCheck-file-' + timeoutval objectpath = ("{}/{}".format(self.mounts[0].mountpoint, objectname)) ret = append_string_to_file(self.mounts[0].client_system, objectpath, 'EagerLockTest') self.assertTrue(ret, 'create and append of %s failed' % objectname) ret = get_subvols(self.mnode, self.volname) # Find the hashed subvol of the file created if len(ret['volume_subvols']) > 1: _, hashed_subvol = find_hashed_subvol(ret['volume_subvols'], '', objectname) if hashed_subvol is None: g.log.error("Error in finding hash value of %s", objectname) return None return (objectname, ret['volume_subvols'], hashed_subvol) # Set subvol to 0 for plain(non-distributed) disperse volume hashed_subvol = 0 return (objectname, ret['volume_subvols'], hashed_subvol)
def test_gfind_modify(self): """ Verifying the glusterfind functionality with deletion of files. * Create a volume * Create a session on the volume * Create various files from mount point * Perform glusterfind pre * Perform glusterfind post * Check the contents of outfile * Modify the contents of the files from mount point * Perform glusterfind pre * Perform glusterfind post * Check the contents of outfile Files modified must be listed """ # pylint: disable=too-many-statements # Create a session for the volume ret, _, _ = gfind_create(self.mnode, self.volname, self.session) self.assertEqual(ret, 0, ("Unexpected: Creation of a session for the " "volume %s failed" % self.volname)) g.log.info("Successfully created a session for the volume %s", self.volname) # Perform glusterfind list to check if session exists _, out, _ = gfind_list(self.mnode, volname=self.volname, sessname=self.session) self.assertNotEqual(out, "No sessions found.", "Failed to list the glusterfind session") g.log.info("Successfully listed the glusterfind session") # Starting IO on the mounts cmd = "cd %s ; touch file{1..10}" % self.mounts[0].mountpoint ret, _, _ = g.run(self.mounts[0].client_system, cmd) self.assertEqual(ret, 0, "Failed to create files on mountpoint") g.log.info("Files created successfully on mountpoint") # Gather the list of files from the mount point files = list_files(self.mounts[0].client_system, self.mounts[0].mountpoint) self.assertIsNotNone(files, "Failed to get the list of files") g.log.info("Successfully gathered the list of files from mount point") # Check if the files exist for filename in files: ret = file_exists(self.mounts[0].client_system, filename) self.assertTrue(ret, ("Unexpected: File '%s' does not exist" % filename)) g.log.info("Successfully validated existence of '%s'", filename) # Wait for changelog to get updated sleep(2) # Perform glusterfind pre for the session ret, _, _ = gfind_pre(self.mnode, self.volname, self.session, self.outfiles[0], full=True, noencode=True, debug=True) self.assertEqual(ret, 0, ("Failed to perform glusterfind pre")) g.log.info("Successfully performed glusterfind pre") # Check if the outfile exists ret = file_exists(self.mnode, self.outfiles[0]) self.assertTrue(ret, ("Unexpected: File '%s' does not exist" % self.outfiles[0])) g.log.info("Successfully validated existence of '%s'", self.outfiles[0]) # Check if all the files are listed in the outfile for i in range(1, 11): ret = check_if_pattern_in_file(self.mnode, "file%s" % i, self.outfiles[0]) self.assertEqual(ret, 0, ("File 'file%s' not listed in %s" % (i, self.outfiles[0]))) g.log.info("File 'file%s' listed in %s", i, self.outfiles[0]) # Perform glusterfind post for the session ret, _, _ = gfind_post(self.mnode, self.volname, self.session) self.assertEqual(ret, 0, ("Failed to perform glusterfind post")) g.log.info("Successfully performed glusterfind post") # Modify the files created from mount point mod_string = "this is a test string\n" for filenum in files: ret = append_string_to_file(self.mounts[0].client_system, filenum, mod_string) self.assertTrue(ret, "Failed to append to file '%s'" % filenum) g.log.info("Successfully modified all the files") # Check if the files modified exist from mount point for filenum in files: ret = check_if_pattern_in_file(self.mounts[0].client_system, mod_string, filenum) self.assertEqual(ret, 0, ("Unexpected: File '%s' does not contain" " the string '%s' after being modified" % (filenum, mod_string))) g.log.info("Successfully validated '%s' is modified", filenum) # Wait for changelog to get updated sleep(2) # Perform glusterfind pre for the session ret, _, _ = gfind_pre(self.mnode, self.volname, self.session, self.outfiles[1], debug=True) self.assertEqual(ret, 0, ("Failed to perform glusterfind pre")) g.log.info("Successfully performed glusterfind pre") # Check if the outfile exists ret = file_exists(self.mnode, self.outfiles[1]) self.assertTrue(ret, ("Unexpected: File '%s' does not exist" % self.outfiles[1])) g.log.info("Successfully validated existence of outfile '%s'", self.outfiles[1]) # Check if all the files are listed in the outfile for num in range(1, 11): pattern = "MODIFY file%s" % num ret = check_if_pattern_in_file(self.mnode, pattern, self.outfiles[1]) self.assertEqual(ret, 0, ("File 'file%s' not listed in '%s'" % (num, self.outfiles[1]))) g.log.info("File 'file%s' listed in '%s'", num, self.outfiles[1])
def test_dht_custom_xattr(self): """ Test case: 1.Create a gluster volume and start it. 2.Create file and link files. 3.Create a custom xattr for file. 4.Verify that xattr for file is displayed on mount point and bricks 5.Modify custom xattr value and verify that xattr for file is displayed on mount point and bricks 6.Verify that custom xattr is not displayed once you remove it 7.Create a custom xattr for symbolic link. 8.Verify that xattr for symbolic link is displayed on mount point and sub-volume 9.Modify custom xattr value and verify that xattr for symbolic link is displayed on mount point and bricks 10.Verify that custom xattr is not displayed once you remove it. """ # Initializing variables mount_point = self.mounts[0].mountpoint self.client_node = self.mounts[0].client_system self.list_of_files, list_of_softlinks = [], [] list_of_hardlinks = [] for number in range(1, 3): # Create regular files fname = '{0}/regular_file_{1}'.format(mount_point, str(number)) ret = append_string_to_file(self.client_node, fname, 'Sample content for file.') self.assertTrue( ret, "Unable to create regular file " "{}".format(fname)) self.list_of_files.append(fname) # Create hard link for file hardlink = '{0}/link_file_{1}'.format(mount_point, str(number)) ret = create_link_file(self.client_node, fname, hardlink) self.assertTrue( ret, "Unable to create hard link file " "{}".format(hardlink)) list_of_hardlinks.append(hardlink) # Create soft link for file softlink = '{0}/symlink_file_{1}'.format(mount_point, str(number)) ret = create_link_file(self.client_node, fname, softlink, soft=True) self.assertTrue( ret, "Unable to create symlink file " "{}".format(softlink)) list_of_softlinks.append(softlink) self.files_and_soft_links = self.list_of_files + list_of_softlinks # Check if files are created on the right subvol ret = validate_files_in_dir( self.client_node, mount_point, file_type=k.FILETYPE_FILES, test_type=k.TEST_FILE_EXISTS_ON_HASHED_BRICKS) self.assertTrue(ret, "Files not created on correct sub-vols") g.log.info("Files are on correct sub-vols according to " "the hash value") # Set custom xattr on all the regular files self.set_xattr_user_foo(self.list_of_files, 'bar2') # Check if custom xattr is set to all the regular files self.check_custom_xattr_visible('bar2') # Change the custom xattr on all the regular files self.set_xattr_user_foo(self.list_of_files, 'ABC') # Check if xattr is set to all the regular files self.check_custom_xattr_visible('ABC') # Delete Custom xattr from all regular files self.delete_xattr_user_foo(self.list_of_files) # Check mount point and brick for the xattr list_of_all_files = list_of_hardlinks + self.files_and_soft_links self.check_mount_point_and_bricks_for_xattr(list_of_all_files) # Check if pathinfo xattr is visible self.check_for_trusted_glusterfs_pathinfo(self.list_of_files) # Set custom xattr on all the regular files self.set_xattr_user_foo(list_of_softlinks, 'bar2') # Check if custom xattr is set to all the regular files self.check_custom_xattr_visible('bar2') # Change the custom xattr on all the regular files self.set_xattr_user_foo(list_of_softlinks, 'ABC') # Check if xattr is set to all the regular files self.check_custom_xattr_visible('ABC') # Delete Custom xattr from all regular files self.delete_xattr_user_foo(list_of_softlinks) # Check mount point and brick for the xattr self.check_mount_point_and_bricks_for_xattr(list_of_all_files) # Check if pathinfo xattr is visible self.check_for_trusted_glusterfs_pathinfo(list_of_softlinks)
def test_alert_time_out(self): """ Verifying directory quota functionality with respect to alert-time, soft-timeout and hard-timeout. * Enable quota * Set limit on '/' * Set default-soft-limit to 50% * Set alert time to 1 sec * Set soft-timeout to 0 sec * Set hard timeout to 0 sec * Check quota list * Perform some IO such that soft limit is not exceeded * Check for alert message in brick logfile (NO alert present) * Perform IO and exceed the soft limit * Check for alert message in brick logfile (Alert present) * Remove some files so that usage falls below soft limit * Create some files such that hard limit is exceeded * Check for alert message in brick logfile * Remove some files so that usage falls below soft limit * Check for alert message in brick logfile (NO alert present) """ # pylint: disable=too-many-statements # Enable Quota g.log.info("Enabling quota on the volume %s", self.volname) ret, _, _ = quota_enable(self.mnode, self.volname) self.assertFalse( ret, "Failed to enable quota on the volume %s" % self.volname) g.log.info("Successfully enabled quota on the volume %s", self.volname) # Path to set quota limit path = "/" # Create a directory from mount point mount_obj = self.mounts[0] mount_dir = mount_obj.mountpoint client = mount_obj.client_system g.log.info("Creating dir named 'foo' from client %s", client) ret = mkdir(client, "%s/foo" % mount_dir) self.assertTrue( ret, "Failed to create dir under %s-%s" % (client, mount_dir)) g.log.info("Directory 'foo' created successfully") # Set Quota limit on the root of the volume g.log.info("Set Quota Limit on the path %s of the volume %s", path, self.volname) ret, _, _ = quota_limit_usage(self.mnode, self.volname, path=path, limit="100MB") self.assertEqual(ret, 0, ("Failed to set quota limit on path %s of " " the volume %s", path, self.volname)) g.log.info("Successfully set the Quota limit on %s of the volume %s", path, self.volname) # Set default soft limit to 50% g.log.info("Set default soft limit:") ret, _, _ = quota_set_default_soft_limit(self.mnode, self.volname, '50%') self.assertEqual(ret, 0, ("Failed to set quota default soft limit")) g.log.info("Quota default soft limit set successfully") # Check quota list to validate limits g.log.info("List all files and directories:") ret = quota_validate(self.mnode, self.volname, path=path, soft_limit_percent=50, hard_limit=104857600) self.assertTrue(ret, "Failed to validate Quota list") g.log.info("Quota List successful") # Set alert time to 1 second g.log.info("Set quota alert timeout:") ret, _, _ = quota_set_alert_time(self.mnode, self.volname, '1sec') self.assertEqual(ret, 0, ("Failed to set alert timeout")) g.log.info("Quota alert time set successful") # Set soft timeout to 0 second g.log.info("Set quota soft timeout:") ret, _, _ = quota_set_soft_timeout(self.mnode, self.volname, '0sec') self.assertEqual(ret, 0, ("Failed to set soft timeout")) g.log.info("Quota soft timeout set successful") # Set hard timeout to 0 second g.log.info("Set quota hard timeout:") ret, _, _ = quota_set_hard_timeout(self.mnode, self.volname, '0sec') self.assertEqual(ret, 0, ("Failed to set hard timeout")) g.log.info("Quota hard timeout set successful") # Get the brick log file path for a random node bricks = get_all_bricks(self.mnode, self.volname) selected_node, brick_path = random.choice(bricks[0:6]).split(':') brickpath = str.replace(brick_path, '/', '-') brickpathfinal = brickpath[1:] brick_log = "/var/log/glusterfs/bricks/%s.log" % brickpathfinal # Append unique string to the brick log g.log.info("Appending string 'appended_string_1' to the log:") append_string_to_file(selected_node, brick_log, "appended_string_1") # Starting IO on the mounts without crossing the soft limit # file creation should be normal g.log.info("Creating Files on %s:%s", client, mount_dir) cmd = ("cd %s/foo ; " "for i in `seq 1 9` ; " "do dd if=/dev/urandom of=file$i " "bs=5M " "count=1 ; " "done" % mount_dir) ret, _, _ = g.run(client, cmd) self.assertEqual(ret, 0, ("Failed to create files on mountpoint")) g.log.info("Files created succesfully on mountpoint") # Append unique string to the brick log g.log.info("Appending string 'appended_string_2' to the log:") append_string_to_file(selected_node, brick_log, "appended_string_2") # Soft limit not crossed # Check if alert message is logged in the brick (shouldn't be logged) g.log.info("Check for alert message in logfile:") ret = search_pattern_in_file(selected_node, "120004", brick_log, "appended_string_1", "appended_string_2") self.assertFalse(ret, "Found unnecessary alert in logfile") g.log.info("Alert message not seen before crossing soft limit") # Continue IO on the mounts to exceed soft limit g.log.info("Creating Files on %s:%s", client, mount_dir) cmd = ("cd %s/foo ; " "for i in `seq 1 200` ; " "do dd if=/dev/urandom of=foo$i " "bs=100K " "count=1 ; " "done" % mount_dir) ret, _, _ = g.run(client, cmd) self.assertEqual(ret, 0, ("Failed to create files on mountpoint")) g.log.info("Files created succesfully on mountpoint and " "exceed soft limit") # Check if quota soft limit exceeded g.log.info("Check soft limit:") ret = quota_validate(self.mnode, self.volname, path=path, sl_exceeded=True) self.assertTrue(ret, "Failed: soft limit not exceeded") g.log.info('Quota soft limit exceeded') # Inserting sleep of 2 seconds so the alert message gets enough time # to be logged time.sleep(2) # Append unique string to the brick log g.log.info("Appending string 'appended_string_3' to the log:") append_string_to_file(selected_node, brick_log, "appended_string_3") # Check if alert message logged in the brick g.log.info("Check for message:") ret = search_pattern_in_file(selected_node, "120004", brick_log, "appended_string_2", "appended_string_3") self.assertTrue(ret, "Alert message not found") g.log.info("Pattern Found: got alert message") # Append unique string to the brick log g.log.info("Appending string 'appended_string_4' to the log:") append_string_to_file(selected_node, brick_log, "appended_string_4") # Continue IO on the mounts by removing data g.log.info("Removing Files on %s:%s", client, mount_dir) cmd = ("rm -rfv %s/foo/foo* " % mount_dir) ret, _, _ = g.run(client, cmd) self.assertEqual(ret, 0, ("Failed to delete files on mountpoint")) g.log.info("Files removed succesfully from mountpoint and reached " "below soft limit") # Check if quota soft limit exceeded g.log.info("Check soft limit:") ret = quota_validate(self.mnode, self.volname, path=path, sl_exceeded=False) self.assertTrue(ret, "Failed: soft limit exceeded") g.log.info('Quota soft limit not exceeded') # Inserting sleep of 2 seconds so the alert message gets enough time # to be logged time.sleep(2) # Append unique string to the brick log g.log.info("Appending string 'appended_string_5' to the log:") append_string_to_file(selected_node, brick_log, "appended_string_5") # Check if alert message is logged in the brick g.log.info("Check for message:") ret = search_pattern_in_file(selected_node, "120004", brick_log, "appended_string_4", "appended_string_5") self.assertFalse(ret, "Found unnecessary alert message in logfile") g.log.info("Alert message not seen before crossing soft limit") # Continue IO on the mounts to exceed hard limit g.log.info("Creating Files on %s:%s", client, mount_dir) cmd = ("cd %s/foo ; " "for i in `seq 11 20` ; " "do dd if=/dev/urandom of=file$i " "bs=10M " "count=1 ; " "done" % mount_dir) ret, _, _ = g.run(client, cmd) self.assertEqual(ret, 1, ("Failed: Files created successfully inspite " "of crossing hard-limit")) g.log.info("Files creation stopped on mountpoint once exceeded " "hard limit") # Inserting sleep of 6 seconds so the alert message gets enough time # to be logged time.sleep(6) # Append unique string to the brick log g.log.info("Appending string 'appended_string_6' to the log:") append_string_to_file(selected_node, brick_log, "appended_string_6") # Check if alert message is logged in the brick g.log.info("Check for message:") ret = search_pattern_in_file(selected_node, "120004", brick_log, "appended_string_5", "appended_string_6") self.assertTrue(ret, "Alert message not seen in logfile") g.log.info("Pattern Found: got alert message") # Append unique string to the brick log g.log.info("Appending string 'Done_with_alert_check_7' to the log:") append_string_to_file(selected_node, brick_log, "Done_with_alert_check_7") # Continue IO on the mounts by removing data to come below hard limit g.log.info("Removing Files on %s:%s", client, mount_dir) cmd = ("rm -rfv %s/foo/file{11..20}" % mount_dir) ret, _, _ = g.run(client, cmd) self.assertEqual(ret, 0, ("Failed to delete files on mountpoint")) g.log.info("Files removed succesfully on mountpoint and " "reached below soft limit") # Inserting sleep of 2 seconds so the alert message gets enough time # to be logged time.sleep(2) # Append unique string to the brick log g.log.info("Appending string 'Done_with_alert_check_8' to the log:") append_string_to_file(selected_node, brick_log, "Done_with_alert_check_8") # Check if alert message is logged in the brick g.log.info("Check for message:") ret = search_pattern_in_file(selected_node, "120004", brick_log, "Done_with_alert_check_7", "Done_with_alert_check_8") self.assertFalse(ret, "Found unnecessary alert in logfile") g.log.info("EXPECTED: Alert message not seen before crossing " "soft limit") # have got below the soft and hard limit # check quota list g.log.info("List all files and directories:") ret = quota_validate(self.mnode, self.volname, path=path, sl_exceeded=False, hl_exceeded=False) self.assertTrue( ret, "Failed to validate Quota list with " "soft and hard limits") g.log.info("Quota List validated successfully")
def test_special_file_creation(self): """ Description : check creation of different types of files. Steps: 1) From mount point, Create a regular file eg: touch f1 - From mount point, create character, block device and pipe files mknod c mknod b mkfifo 2) Stat on the files created in Step-2 from mount point 3) Verify that file is stored on only one bricks which is mentioned in trusted.glusterfs.pathinfo xattr On mount point - " getfattr -n trusted.glusterfs.pathinfo On all bricks " ls / " 4) Verify that file permissions are same on mount point and sub-volumes " stat " 5) Append some data to the file. 6) List content of file to verify that data has been appended. " cat " 7) Verify that file change time and size has been updated accordingly(from mount point and sub-volume) " stat / " """ # pylint: disable=too-many-statements # pylint: disable=too-many-locals # Create a regular file self._create_file_using_touch("regfile") # Create a character and block file for (file_name, parameter) in [("blockfile", "b"), ("charfile", "c")]: cmd = "mknod {}/{} {} 1 5".format(self.m_point, file_name, parameter) ret, _, _ = g.run(self.client, cmd) self.assertEqual(ret, 0, "Failed to create {} file".format(file_name)) g.log.info("%s file created successfully", file_name) # Create a pipe file cmd = "mkfifo {}/pipefile".format(self.m_point) ret, _, _ = g.run(self.client, cmd) self.assertEqual(ret, 0, "Failed to create pipe file") g.log.info("Pipe file is created successfully") # Stat all the files created on mount-point for (file_name, check_string) in [("regfile", "regular empty file"), ("charfile", "character special file"), ("blockfile", "block special file"), ("pipefile", "fifo")]: self._check_file_stat_on_mountpoint(file_name, check_string) # Verify files are stored on backend bricks as per # the trusted.glusterfs.pathinfo file_types = ["regfile", "charfile", "blockfile", "pipefile"] for file_name in file_types: self._is_file_present_on_brick(file_name) # Verify that the file permissions are same on # mount-point and bricks for file_name in file_types: self._compare_file_permissions(file_name) # Note the modification time on mount and bricks # for all files. Also it should be same on mnt and bricks reg_mnt_ctime_1 = self._check_change_time_mnt("regfile") char_mnt_ctime_1 = self._check_change_time_mnt("charfile") block_mnt_ctime_1 = self._check_change_time_mnt("blockfile") fifo_mnt_ctime_1 = self._check_change_time_mnt("pipefile") reg_brick_ctime_1 = self._check_change_time_brick("regfile") char_brick_ctime_1 = self._check_change_time_brick("charfile") block_brick_ctime_1 = self._check_change_time_brick("blockfile") fifo_brick_ctime_1 = self._check_change_time_brick("pipefile") for (file_name, mnt_ctime, brick_ctime) in [ ("regfile", reg_mnt_ctime_1, reg_brick_ctime_1), ("charfile", char_mnt_ctime_1, char_brick_ctime_1), ("blockfile", block_mnt_ctime_1, block_brick_ctime_1), ("pipefile", fifo_mnt_ctime_1, fifo_brick_ctime_1) ]: self._compare_file_permissions(file_name, mnt_ctime, brick_ctime) # Append some data to the files for (file_name, data_str) in [("regfile", "regular"), ("charfile", "character special"), ("blockfile", "block special")]: ret = append_string_to_file( self.client, "{}/{}".format(self.m_point, file_name), "Welcome! This is a {} file".format(data_str)) self.assertTrue(ret, "Failed to append data to {}".format(file_name)) g.log.info("Successfully appended data to %s", file_name) # Check if the data has been appended check = "Welcome! This is a regular file" cmd = "cat {}/{}".format(self.m_point, "regfile") ret, out, _ = g.run(self.client, cmd) self.assertEqual(out.strip(), check, "No data present at regfile") # Append data to pipefile and check if it has been appended g.run_async(self.client, "echo 'Hello' > {}/{} ".format(self.m_point, "pipefile")) ret, out, _ = g.run(self.client, "cat < {}/{}".format(self.m_point, "pipefile")) self.assertEqual(ret, 0, "Unable to fetch datat on other terimnal") self.assertEqual("Hello", out.split('\n')[0], "Hello not recieved on the second terimnal") # Lookup on mount-point cmd = "ls -lR {}".format(self.m_point) ret, _, _ = g.run(self.client, cmd) self.assertEqual(ret, 0, "Lookup on mountpoint failed") # Collect ctime on mount point after appending data reg_mnt_ctime_2 = self._check_change_time_mnt("regfile") # After appending data the ctime for file should change self.assertNotEqual(reg_mnt_ctime_1, reg_mnt_ctime_2, "Unexpected:" "The ctime has not been changed") g.log.info("The modification time for regfile has been" " changed as expected") # Collect the ctime on bricks reg_brick_ctime_2 = self._check_change_time_brick("regfile") # Check if the ctime has changed on bricks as per mount self._compare_file_permissions("regfile", reg_mnt_ctime_2, reg_brick_ctime_2)
def test_root_squash_enable(self): """ Tests to verify Nfs Ganesha rootsquash functionality when glusterd service 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 glusterd on all the nodes 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("Successfull in getting stats of files/dirs " "from mount point") # Restart glusterd on all servers ret = restart_glusterd(self.servers) self.assertTrue(ret, ("Failed to restart glusterd on all servers %s", self.servers)) g.log.info("Successfully restarted glusterd on all servers %s", self.servers) # Check if glusterd is running on all servers ret = is_glusterd_running(self.servers) self.assertEqual(ret, 0, ("Failed:Glusterd is not running on all " "servers %s", self.servers)) g.log.info("Glusterd is running on all the servers %s", self.servers) # Checking if peer is connected. ret = wait_for_peers_to_connect(self.mnode, self.servers) self.assertTrue(ret, "Failed:Peer is not in connected state.") g.log.info("Peers are in connected state.") # 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_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_root_squash_enable(self): """ Tests to verify Nfs Ganesha rootsquash functionality with multi client Steps: 1. Create some directories on mount point. 2. Create some files inside those directories 3. Set permission as 777 for mount point 4. Enable root-squash on volume 5. Edit file created by root user from client 2 It should not allow to edit the file 6. Create some directories on mount point. 7. Create some files inside the directories Files and directories will be created by nfsnobody user 8. Edit the file created in step 7 It should allow to edit the file 9. Disable root squash 10. Edit the file created at step 7 It should allow to edit the file """ # Create Directories on Mount point cmd = ("for i in {1..10}; do mkdir %s/dir$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) # Create files inside directories on mount point. cmd = ("for i in {1..10}; do touch %s/dir$i/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") # Edit file created by root user from client 2 ret = append_string_to_file( self.mounts[1].client_system, "%s/dir5/file5" % self.mounts[1].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") # Create Directories on Mount point cmd = ("for i in {1..10}; do mkdir %s/SquashDir$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) # Create files inside directories on mount point cmd = ("for i in {1..10}; do touch %s/SquashDir$i/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") # Edit the file created by nfsnobody user from client 2 ret = append_string_to_file( self.mounts[1].client_system, "%s/SquashDir5/Squashfile5" % self.mounts[1].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") # Disable root-squash ret = set_root_squash(self.servers[0], self.volname, squash=False, do_refresh_config=True) self.assertTrue(ret, "Failed to disable root-squash on volume") g.log.info("root-squash is disabled on the volume") # Edit the file created by nfsnobody user from root user ret = append_string_to_file( self.mounts[1].client_system, "%s/SquashDir10/Squashfile10" % self.mounts[1].mountpoint, 'hello') self.assertTrue( ret, "Unexpected:root user failed to edit " "the file created by nfsnobody user") g.log.info("Successful:root user successfully edited the " "file created by nfsnobody user")
def test_root_squash_mount_unmount(self): """ Tests to verify Nfs Ganesha rootsquash functionality when volume is remounted Steps: 1. Set permission as 777 for mount point 2. Create some files and dirs inside mount point 3. Enable root-squash on volume 4. Create some more files and dirs inside mount point 5. Unmount the volume 6. Remount the volume 7. Try to edit file created in step 2 It should not allow to edit the file 8. Try to edit the file created in step 4 It should allow to edit the file 9. Create some more files and directory inside mount point It should be created as nobody user 10. Disable root-squash on volume 11. Edit any of the file created in step 2. It should allow to edit the file """ # 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") # Create Directories on Mount point cmd = ("for i in {1..20}; do mkdir %s/dir$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) # Create multiple files inside directories on mount point. for i in range(1, 21): cmd = ("for j in {1..20}; do touch %s/dir%s/file$j; done" % (self.mounts[0].mountpoint, i)) 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") # 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") # Create some more Directories after enabling root-squash cmd = ("for i in {1..20}; do mkdir %s/squashed_dir$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) # Create some more files inside directories for i in range(1, 21): cmd = ("for j in {1..20}; do touch " "%s/squashed_dir%s/squashed_file$j; done" % (self.mounts[0].mountpoint, i)) 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") # Unmount volume ret = unmount_mounts(self.mounts) self.assertTrue(ret, "Volume unmount failed for %s" % self.volname) # Remount volume ret = self.mount_volume(self.mounts) self.assertTrue(ret, "Volume mount failed for %s" % self.volname) # Edit file created by root user for mount_obj in self.mounts: ret = append_string_to_file( mount_obj.client_system, "%s/dir10/file10" % mount_obj.mountpoint, 'hello') self.assertFalse( ret, "Unexpected:nobody user editing file " "created by root user should FAIL") g.log.info("Successful:nobody user failed to edit file " "created by root user") # Edit the file created by nobody user for mount_obj in self.mounts: ret = append_string_to_file( mount_obj.client_system, "%s/squashed_dir10/squashed_file10" % mount_obj.mountpoint, 'hello') self.assertTrue( ret, "Unexpected:nobody user failed to edit " "the file created by nobody user") g.log.info("Successful:nobody user successfully edited the " "file created by nobody user") # Create some more files on mount point post remount. cmd = ("for i in {1..20}; do touch %s/remount_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") # Check for owner and group of all the files for mount_obj in self.mounts: for i in range(1, 21): cmd = ( "ls -l %s/remount_file%i | awk '{ print $3, $4 }' |sort" % (mount_obj.mountpoint, i)) ret, out, err = g.run(mount_obj.client_system, cmd) self.assertFalse(ret, err) if is_rhel7: self.assertIn("nobody nobody", out, "Owner and group is not nobody") else: self.assertIn("nfsnobody nfsnobody", out, "Owner and group is not nobody") g.log.info("Owner and group of file is nobody") # Disable root-squash ret = set_root_squash(self.mnode, self.volname, squash=False, do_refresh_config=True) self.assertTrue(ret, "Failed to disable root-squash on volume") g.log.info("root-squash is disable on the volume") # Edit file created by root user for mount_obj in self.mounts: ret = append_string_to_file( mount_obj.client_system, "%s/dir15/file15" % mount_obj.mountpoint, 'hello') self.assertTrue( ret, "Unexpected:root user should be allowed to " "edit the file created by root user") g.log.info("Successful:root user successful in editing file " "created by root user")