def _verify_link_file_exists(brickdir, file_name): """ Verifies whether a file link is present in given subvol Args: brickdir(Class Object): BrickDir object containing data about bricks under a specific subvol Returns: True/False(bool): Based on existance of file link """ # pylint: disable=protected-access # pylint: disable=unsubscriptable-object file_path = brickdir._fqpath + file_name file_stat = get_file_stat(brickdir._host, file_path) if file_stat is None: g.log.error("Failed to get File stat for %s", file_path) return False if not file_stat['access'] == "1000": g.log.error("Access value not 1000 for %s", file_path) return False # Check for file type to be'sticky empty', have size of 0 and # have the glusterfs.dht.linkto xattr set. ret = is_linkto_file(brickdir._host, file_path) if not ret: g.log.error("%s is not a linkto file", file_path) return False return True
def test_access_file_with_stale_linkto_xattr(self): """ Description: Checks if the files are accessible as non-root user if the files have stale linkto xattr. Steps: 1) Create a volume and start it. 2) Mount the volume on client node using FUSE. 3) Create a file. 4) Enable performance.parallel-readdir and performance.readdir-ahead on the volume. 5) Rename the file in order to create a linkto file. 6) Force the linkto xattr values to become stale by changing the dht subvols in the graph 7) Login as an non-root user and access the file. """ # pylint: disable=protected-access # Set permissions on the mount-point m_point = self.mounts[0].mountpoint ret = set_file_permissions(self.clients[0], m_point, "-R 777") self.assertTrue(ret, "Failed to set file permissions") g.log.info("Successfully set file permissions on mount-point") # Creating a file on the mount-point cmd = 'dd if=/dev/urandom of={}/FILE-1 count=1 bs=16k'.format(m_point) ret, _, _ = g.run(self.clients[0], cmd) self.assertEqual(ret, 0, "File to create file") # Enable performance.parallel-readdir and # performance.readdir-ahead on the volume options = { "performance.parallel-readdir": "enable", "performance.readdir-ahead": "enable" } ret = set_volume_options(self.mnode, self.volname, options) self.assertTrue(ret, "Failed to set volume options") g.log.info("Successfully set volume options") # Finding a file name such that renaming source file to it will form a # linkto file subvols = (get_subvols(self.mnode, self.volname))['volume_subvols'] newhash = find_new_hashed(subvols, "/", "FILE-1") new_name = str(newhash.newname) new_host = str(newhash.hashedbrickobject._host) new_name_path = str(newhash.hashedbrickobject._fqpath)[:-1] # Move file such that it hashes to some other subvol and forms linkto # file ret = move_file(self.clients[0], "{}/FILE-1".format(m_point), "{}/{}".format(m_point, new_name)) self.assertTrue(ret, "Rename failed") g.log.info('Renamed file %s to %s', "{}/FILE-1".format(m_point), "{}/{}".format(m_point, new_name)) # Check if "dst_file" is linkto file ret = is_linkto_file(new_host, '{}{}'.format(new_name_path, new_name)) self.assertTrue(ret, "File is not a linkto file") g.log.info("File is linkto file") # Force the linkto xattr values to become stale by changing the dht # subvols in the graph; for that: # disable performance.parallel-readdir and # performance.readdir-ahead on the volume options = { "performance.parallel-readdir": "disable", "performance.readdir-ahead": "disable" } ret = set_volume_options(self.mnode, self.volname, options) self.assertTrue(ret, "Failed to disable volume options") g.log.info("Successfully disabled volume options") # Access the file as non-root user cmd = "ls -lR {}".format(m_point) ret, _, _ = g.run(self.mounts[0].client_system, cmd, user="******") self.assertEqual(ret, 0, "Lookup failed ") g.log.info("Lookup successful")
def test_delete_file_in_migration(self): """ Verify that if a file is picked for migration and then deleted, the file should be removed successfully. * First create a big data file of 10GB. * Rename that file, such that after rename a linkto file is created (we are doing this to make sure that file is picked for migration.) * Add bricks to the volume and trigger rebalance using force option. * When the file has been picked for migration, delete that file from the mount point. * Check whether the file has been deleted or not on the mount-point as well as the back-end bricks. """ # pylint: disable=too-many-statements # pylint: disable=too-many-locals # pylint: disable=protected-access mountpoint = self.mounts[0].mountpoint # Location of source file src_file = mountpoint + '/file1' # Finding a file name such that renaming source file to it will form a # linkto file subvols = (get_subvols(self.mnode, self.volname))['volume_subvols'] newhash = find_new_hashed(subvols, "/", "file1") new_name = str(newhash.newname) new_host = str(newhash.hashedbrickobject._host) new_name_path = str(newhash.hashedbrickobject._fqpath)[:-2] # Location of destination file to which source file will be renamed dst_file = '{}/{}'.format(mountpoint, new_name) # Create a 10GB file source file cmd = ( "dd if=/dev/urandom of={} bs=1024K count=10000".format(src_file)) ret, _, _ = g.run(self.clients[0], cmd) self.assertEqual(ret, 0, ("File {} creation failed".format(src_file))) # Move file such that it hashes to some other subvol and forms linkto # file ret = move_file(self.clients[0], src_file, dst_file) self.assertTrue(ret, "Rename failed") g.log.info('Renamed file %s to %s', src_file, dst_file) # Check if "file_two" is linkto file ret = is_linkto_file(new_host, '{}/{}'.format(new_name_path, new_name)) self.assertTrue(ret, "File is not a linkto file") g.log.info("File is linkto file") # Expanding volume by adding bricks to the volume ret, _, _ = add_brick(self.mnode, self.volname, self.add_brick_list, force=True) self.assertEqual(ret, 0, ("Volume {}: Add-brick failed".format(self.volname))) g.log.info("Volume %s: add-brick successful", self.volname) # Log Volume Info and Status after expanding the volume log_volume_info_and_status(self.mnode, self.volname) # Start Rebalance ret, _, _ = rebalance_start(self.mnode, self.volname, force=True) self.assertEqual( ret, 0, ("Volume {}: Failed to start rebalance".format(self.volname))) g.log.info("Volume %s : Rebalance started ", self.volname) # Check if rebalance is running and delete the file status_info = get_rebalance_status(self.mnode, self.volname) status = status_info['aggregate']['statusStr'] self.assertEqual(status, 'in progress', "Rebalance is not running") ret, _, _ = g.run(self.clients[0], (" rm -rf {}".format(dst_file))) self.assertEqual(ret, 0, ("Cannot delete file {}".format(dst_file))) g.log.info("File is deleted") # Check if the file is present on the mount point ret, _, _ = g.run(self.clients[0], ("ls -l {}".format(dst_file))) self.assertEqual(ret, 2, ("Failed to delete file {}".format(dst_file))) # Check if the file is present on the backend bricks bricks = get_all_bricks(self.mnode, self.volname) for brick in bricks: node, brick_path = brick.split(':') ret, _, _ = g.run(node, "ls -l {}/{}".format(brick_path, new_name)) self.assertEqual( ret, 2, "File is still present on" " back-end brick: {}".format(brick_path)) g.log.info("File is deleted from back-end brick: %s", brick_path) # Check if rebalance process is still running for server in self.servers: ret, _, _ = g.run(server, "pgrep rebalance") self.assertEqual(ret, 1, ("Rebalance process is still" " running on server {}".format(server))) g.log.info("Rebalance process is not running")