def test_file_rename_when_source_and_dest_hash_same_subvol(self): """ Case 2: - Destination file does not exist - Source file is stored on hashed subvolume(s1) it self - Destination file should be hashed to same subvolume(s1) mv <source_file> <destination_file> - Source file should be renamed to destination file """ # pylint: disable=protected-access # pylint: disable=unsubscriptable-object # Create soruce file and Get hashed subvol (s1) source_hashed_subvol, count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Rename the file such that the new name hashes to a new subvol new_hashed = find_specific_hashed(self.subvols, "/", source_hashed_subvol) self.assertIsNotNone(new_hashed, "could not find new hashed for destination file") # Rename the source file to the destination file dest_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.clients[0], source_file, dest_file) self.assertTrue( ret, "Failed to move files {} and {}".format(source_file, dest_file)) _, rename_count = find_hashed_subvol(self.subvols, "/", str(new_hashed.newname)) self.assertEqual(count, rename_count, "The hashed subvols for src and dest are not same.")
def test_dht_file_rename_dest_exists_src_and_dest_hash_same(self): """ Case 7: - Destination file should exist - Source file is stored on hashed subvolume(s1) it self - Destination file should be hashed to same subvolume(s1) - Destination file is stored on hashed subvolume mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed to destination file """ # pylint: disable=protected-access # pylint: disable=unsubscriptable-object # Create soruce file and Get hashed subvol (s1) source_hashed_subvol, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Find a new file name for destination file that hashes # to same subvol (s1) new_hashed = find_specific_hashed(self.subvols, "/", source_hashed_subvol) self.assertIsNotNone( new_hashed, "Couldn't find a new hashed subvol " "for destination file") # Create destination_file and get its hashed subvol (should be s1) dest_hashed_subvol, dest_count, dest_file = ( self._create_file_and_get_hashed_subvol(str(new_hashed.newname))) # Verify the subvols are not same for source and destination files self.assertEqual(src_count, dest_count, "The subvols for src and dest are not same.") # Rename the source file to the destination file ret = move_file(self.mounts[0].client_system, source_file, dest_file) self.assertTrue( ret, ("Failed to move files {} and {}".format(source_file, dest_file))) # Verify the file move and the destination file is hashed to # same subvol or not _, rename_count = find_hashed_subvol(self.subvols, "/", str(new_hashed.newname)) self.assertEqual(dest_count, rename_count, ("The subvols for source : {} and dest : {} are " "not same.".format(source_hashed_subvol._fqpath, dest_hashed_subvol._fqpath))) # Verify destination file is removed ret = self._verify_file_exists(dest_hashed_subvol, str(new_hashed.newname)) self.assertTrue(ret, ("Destination file : {} is not removed in subvol" " : {}".format(str(new_hashed.newname), dest_hashed_subvol._fqpath))) g.log.info("The destination file is removed as expected")
def _create_number_of_files_on_the_subvol(self, subvol_object, directory, number_of_files, mountpath): """Creates number of files specified on the given subvol""" name = None for _ in range(number_of_files): hashed = find_specific_hashed(self.subvols, directory, subvol_object, existing_names=name) self.assertIsNotNone(hashed, "Couldn't find a subvol to " "create a file.") self._create_file(mountpath, hashed.newname) name = hashed.newname
def _create_dest_file_find_hash( self, src_cache_subvol_count, src_hash_subvol_count): """Find a name for dest file such that it hashed to a subvol different from the src file's hash and cache subvol""" # Get subvol list subvol_list = (get_subvols(self.mnode, self.volname))['volume_subvols'] self.assertIsNotNone(subvol_list, "Failed to get subvols") for item in (subvol_list[src_hash_subvol_count], subvol_list[src_cache_subvol_count]): subvol_list.remove(item) # Find name for dest file dest_subvol = BrickDir(subvol_list[0][0] + "/" + "/") dest_file = find_specific_hashed(self.subvols, "/", dest_subvol) self.assertIsNotNone(dest_file, "Could not find hashed for destfile") # Create dest file cmd = "touch {}/{}".format(self.m_point, dest_file.newname) ret, _, _ = g.run(self.client, cmd) self.assertEqual(ret, 0, "Failed to create destfile") g.log.info("Successfully created destfile") return dest_file.newname, dest_file.subvol_count
def test_file_rename_dest_exist_and_hash_to_srclink_subvol(self): """ Case 10: - Destination file should exist - Source file is hashed sub volume(s1) and cached on another subvolume(s2) - Destination file should be hashed to same subvolume(s1) where source file is hashed. mv <source_file> <destination_file> - Destination file is removed. - Source file(cached) should be renamed to destination file - Source file(hashed) should be removed. - Destination hahshed file should be created on its hashed subvolume(s1) """ # pylint: disable=protected-access # pylint: disable=unsubscriptable-object # Get hashed subvol s2) _, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Rename the file to create link in another subvol - (s1) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone(new_hashed, ("could not find new hashed subvol " "for {}".format(source_file))) self.assertNotEqual(src_count, new_hashed.subvol_count, "New file should hash to different sub-volume") # Rename the source file to the new file name dest_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, source_file, dest_file) self.assertTrue( ret, ("Failed to move file {} and {}".format(source_file, dest_file))) # Verify the Source link file is stored on hashed sub volume(s1) src_link_subvol = new_hashed.hashedbrickobject ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertTrue( ret, ("The New hashed volume {} doesn't have the " "expected linkto file {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) # Get a file name for dest to hash to the subvol s1 new_hashed2 = find_specific_hashed(self.subvols, "/", src_link_subvol, new_hashed.newname) self.assertIsNotNone(new_hashed2, ("Couldn't find a name hashed to the" " given subvol {}".format(src_link_subvol))) # Create destination file in the subvol (s2) dest_hashed_subvol, dest_count, dest_file = ( self._create_file_and_get_hashed_subvol(str(new_hashed2.newname))) # Verify the subvol is same as S1 self.assertEqual(new_hashed.subvol_count, dest_count, "The subvols for src and dest are not same.") # Move the source file to the new file name source_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) dest_file = "{}/{}".format(self.mount_point, str(new_hashed2.newname)) ret = move_file(self.mounts[0].client_system, source_file, dest_file) self.assertTrue(ret, "Failed to move file") # Verify destination file is removed ret = self._verify_file_exists(dest_hashed_subvol, str(new_hashed2.newname)) self.assertTrue(ret, ("Destination file : {} is not removed in subvol" " : {}".format(str(new_hashed.newname), dest_hashed_subvol._fqpath))) g.log.info("The destination file is removed as expected") # Check that the source link file is removed. ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertFalse( ret, ("The hashed volume {} still have the " "expected linkto file {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) g.log.info("The source link file is removed") # Check Destination link file is created on its hashed sub-volume(s1) ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed2.newname)) self.assertTrue( ret, ("The New hashed volume {} doesn't have the " "expected linkto file {}".format(src_link_subvol._fqpath, str(new_hashed2.newname)))) g.log.info("Destinaion link is created in desired subvol")
def test_file_rename_dest_exist_and_not_hash_src_srclink_subvol(self): """ Case 8: - Destination file should exist - Source file is hashed sub volume(s1) and cached on another subvolume(s2) - Destination file should be hashed to some other subvolume(s3) (should not be same subvolumes mentioned in above condition) mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Souce hashed file should be removed - Destination hashed file should be created on its hashed subvolume(s3) """ # pylint: disable=protected-access # pylint: disable=too-many-locals # pylint: disable=unsubscriptable-object # Find a non hashed subvolume(or brick) # Create soruce file and Get hashed subvol (s2) _, count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Rename the file to create link in hashed subvol -(s1) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone(new_hashed, "could not find new hashed for dstfile") count2 = new_hashed.subvol_count # Rename the source file to the new file name dest_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, source_file, dest_file) self.assertTrue( ret, ("Failed to move file {} and {}".format(source_file, dest_file))) # Verify the Source link file is stored on hashed sub volume(s1) src_link_subvol = new_hashed.hashedbrickobject ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertTrue( ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) # Find a subvol (s3) other than S1 and S2 brickobject = create_brickobjectlist(self.subvols, "/") self.assertIsNotNone(brickobject, "Failed to get brick object list") br_count = -1 subvol_new = None for brickdir in brickobject: br_count += 1 if br_count not in (count, count2): subvol_new = brickdir break new_hashed2 = find_specific_hashed(self.subvols, "/", subvol_new) self.assertIsNotNone(new_hashed2, "could not find new hashed for dstfile") # Create destination file in a new subvol (s3) dest_hashed_subvol, dest_count, dest_file = ( self._create_file_and_get_hashed_subvol(str(new_hashed2.newname))) # Verify the subvol is not same as S1 or S2 self.assertNotEqual( count2, dest_count, ("The subvols for src :{} and dest : {} are same.".format( count2, dest_count))) # Verify the subvol is not same as S1 or S2 self.assertNotEqual( count, dest_count, ("The subvols for src :{} and dest : {} are same.".format( count, dest_count))) # Rename the source file to the destination file source_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, source_file, dest_file) self.assertTrue( ret, ("Failed to move file {} and {}".format(source_file, dest_file))) # Verify destination file is removed ret = self._verify_file_exists(dest_hashed_subvol, str(new_hashed2.newname)) self.assertTrue(ret, ("Destination file : {} is not removed in subvol" " : {}".format(str(new_hashed.newname), dest_hashed_subvol._fqpath))) g.log.info("The destination file is removed as expected") # Check that the source link file is removed. ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertFalse( ret, ("The New hashed volume {} still have the " "expected linkto file {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) g.log.info("The source link file is removed") # Check Destination link file is created on its hashed sub-volume(s3) ret = self._verify_link_file_exists(dest_hashed_subvol, str(new_hashed2.newname)) self.assertTrue( ret, ("The New hashed volume {} doesn't have the " "expected linkto file {}".format(dest_hashed_subvol._fqpath, str(new_hashed2.newname)))) g.log.info("Destinaion link is created in desired subvol")
def test_file_rename_when_src_file_and_dest_file_hash_same_subvol(self): """ Case 4: - Destination file does not exist - Source link file is stored on hashed sub volume(s1) and Source file is stored on another subvolume(s2) - Destination file should be hashed to same subvolume(s2) mv <source_file> <destination_file> - Source file should be ranamed to destination file - source link file should be removed. """ # pylint: disable=protected-access # pylint: disable=unsubscriptable-object # Get hashed subvol (S2) source_hashed_subvol, count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Rename the file to create link in hashed subvol -(s1) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone( new_hashed, ("could not find new hashed for {}".format(source_file))) # Rename the source file to the new file name dest_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.clients[0], source_file, dest_file) self.assertTrue( ret, ("Failed to move file {} and {}".format(source_file, dest_file))) # Verify the Source link file is stored on hashed sub volume(s1) src_link_subvol = new_hashed.hashedbrickobject ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertTrue( ret, ("The New hashed volume {} doesn't have the " "expected linkto file {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) # Get a file name to hash to the subvol s2 new_hashed2 = find_specific_hashed(self.subvols, "/", source_hashed_subvol) self.assertIsNotNone( new_hashed2, "Could not find a name hashed" "to the given subvol") _, rename_count = (find_hashed_subvol(self.subvols, "/", str(new_hashed2.newname))) self.assertEqual(count, rename_count, "The subvols for src and dest are not same.") # Move the source file to the new file name source_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) dest_file = "{}/{}".format(self.mount_point, str(new_hashed2.newname)) ret = move_file(self.clients[0], source_file, dest_file) self.assertTrue( ret, ("Failed to move file {} and {}".format(source_file, dest_file))) # check that the source link file is removed. ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertFalse( ret, ("The New hashed volume {} still have the " "expected linkto file {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) g.log.info("The source link file is removed")
def test_file_rename_when_dest_hash_to_src_subvol(self): """ - Destination file should exist - Source file is stored on hashed subvolume it self - Destination file should be hased to same subvolume(s1) where source file is - Destination file hased subvolume(s1) but cached onsubvolume(s2) mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Destination link file should be removed """ # pylint: disable=protected-access # Create soruce file and Get hashed subvol (s1) source_hashed_subvol, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Find a file name that hashes to another subvol (s2) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone( new_hashed, ("could'nt find new hashed for {}".format(source_file))) # Create destination file in subvol S2 _, dest_count, dest_file = (self._create_file_and_get_hashed_subvol( str(new_hashed.newname))) # Rename dest file such that it hashes to S1 new_hashed2 = find_specific_hashed(self.subvols, "/", source_hashed_subvol) self.assertIsNotNone(new_hashed2, "could not find new hashed for dstfile") # Verify the subvol is S1 itself self.assertEqual( new_hashed2.subvol_count, src_count, "The destination file is not stored to desired " "subvol :{}".format(dest_count)) # Rename/Move the file dest_file2 = "{}/{}".format(self.mount_point, str(new_hashed2.newname)) ret = move_file(self.mounts[0].client_system, dest_file, dest_file2) self.assertTrue( ret, "Failed to move files {} and {}".format(source_file, dest_file)) # Verify the Dest link file is stored on hashed sub volume(s1) dest_link_subvol = new_hashed2.hashedbrickobject ret = self._verify_link_file_exists(dest_link_subvol, str(new_hashed2.newname)) self.assertTrue( ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}".format(dest_link_subvol._fqpath, str(new_hashed2.newname)))) # Rename Source to Dest src = "{}/{}".format(self.mount_point, "test_source_file") dest_file = "{}/{}".format(self.mount_point, str(new_hashed2.newname)) ret = move_file(self.mounts[0].client_system, src, dest_file) self.assertTrue( ret, "Failed to move files {} and {}".format(src, dest_file)) # Verify destination file is removed ret = self._verify_file_exists(new_hashed.hashedbrickobject, str(new_hashed.newname)) self.assertFalse( ret, ("Destination file : {} is not removed in subvol" " : {}".format(str(new_hashed.newname), new_hashed.hashedbrickobject._fqpath))) g.log.info("The destination file is removed as expected") # Verify the Destination link is removed ret = self._verify_link_file_exists(new_hashed2.hashedbrickobject, str(new_hashed2.newname)) self.assertFalse(ret, ("The hashed subvol {} still have the " "expected linkto file: {}".format( new_hashed2.hashedbrickobject._fqpath, str(new_hashed2.newname)))) g.log.info("The Destination link file is removed as expected")
def test_file_rename_when_dest_cache_to_src_subvol(self): """ - Destination file should exist - Source file is stored on hashed subvolume it self - Destination file should be hased to some other subvolume(s2) - Destination file hashed on subvolume(s2) but cached on the subvolume(s1) where souce file is present mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Destination link file should be there on hashed subvolume and should link to new destination file """ # pylint: disable=protected-access # Create soruce file and Get hashed subvol (s1) source_hashed_subvol, src_count, _ = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Find name for dest file to cache to S1 dest_subvol = find_specific_hashed(self.subvols, "/", source_hashed_subvol) dest_name = str(dest_subvol.newname) # Create destination file in subvol S1 _, dest_count, _ = self._create_file_and_get_hashed_subvol(dest_name) # Verify its subvol (s1) self.assertEqual(src_count, dest_count, ("The newly created file falls under subvol {} " "rather than {}".format(dest_count, src_count))) # Rename dest file such that it hashes to some other subvol S2 dest_hashed_subvol = find_new_hashed(self.subvols, "/", dest_name) self.assertIsNotNone(dest_hashed_subvol, "could not find new hashed for dstfile") # Rename/Move the file dest_file = "{}/{}".format(self.mount_point, dest_hashed_subvol.newname) src_file = "{}/{}".format(self.mount_point, dest_name) ret = move_file(self.mounts[0].client_system, src_file, dest_file) self.assertTrue( ret, "Failed to move files {} and {}".format(src_file, dest_file)) # Verify the Dest link file is stored on hashed sub volume(s2) dest_link_subvol = dest_hashed_subvol.hashedbrickobject ret = self._verify_link_file_exists(dest_link_subvol, str(dest_hashed_subvol.newname)) self.assertTrue( ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}".format( dest_link_subvol._fqpath, str(dest_hashed_subvol.newname)))) # Rename Source to Dest src = "{}/{}".format(self.mount_point, "test_source_file") dest_file = "{}/{}".format(self.mount_point, dest_hashed_subvol.newname) ret = move_file(self.mounts[0].client_system, src, dest_file) self.assertTrue( ret, "Failed to move files {} and {}".format(src, dest_file)) # Verify destination file is removed ret = self._verify_file_exists(dest_subvol.hashedbrickobject, dest_name) self.assertFalse(ret, ("Destination file : {} is not removed in subvol" " : {}".format(str(dest_hashed_subvol.newname), dest_link_subvol._fqpath))) g.log.info("The destination file is removed as expected") # Verify the Destination link is present ret = self._verify_link_file_exists(dest_link_subvol, str(dest_hashed_subvol.newname)) self.assertTrue( ret, ("The hashed subvol {} still have the " "expected linkto file: {}".format( dest_link_subvol._fqpath, str(dest_hashed_subvol.newname)))) g.log.info("The Destination link file is present as expected") # Verify the dest link file points to new destination file file_path = dest_link_subvol._fqpath + str(dest_hashed_subvol.newname) ret = (self._verify_file_links_to_specified_destination( dest_link_subvol._host, file_path, str(dest_hashed_subvol.newname))) self.assertTrue( ret, "The dest link file not pointing towards " "the desired file") g.log.info("The Destination link file is pointing to new file" " as expected")
def test_file_rename_when_source_and_dest_hash_same_subvol(self): """ - Destination file should exist - Source file is hashed sub volume(s1) and cached on another subvolume(s2) - Destination file should be hased to same subvolume(s1) where source file is hased - Destination hashed on subvolume(s1) but should be cached on subvolume(s2) where source file is stored mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Destination link file should be there on hashed subvolume and should link to new destination file - source link file should be removed """ # pylint: disable=protected-access # pylint: disable=too-many-locals # Create soruce file and Get hashed subvol (s2) source_hashed_subvol, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Rename the file such that the new name hashes to a new subvol (S1) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone( new_hashed, ("could'nt find new hashed for {}".format(source_file))) # Verify the subvols are not same for source and destination files self.assertNotEqual(src_count, new_hashed.subvol_count, "The subvols for src and dest are same.") # Rename/Move the file dest_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, source_file, dest_file) self.assertTrue( ret, "Failed to move files {} and {}".format(source_file, dest_file)) # Verify the Source link file is stored on hashed sub volume(s1) src_link_subvol = new_hashed.hashedbrickobject ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertTrue( ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) # Get a file name that stores to S2 for destination new_hashed2 = find_specific_hashed(self.subvols, "/", source_hashed_subvol) self.assertIsNotNone(new_hashed2, "could not find new hashed for dstfile") # Create destination file in subvol S2 dest_hashed_subvol, dest_count, dest_file = ( self._create_file_and_get_hashed_subvol(str(new_hashed2.newname))) # Verify the subvol is S2 itself self.assertEqual( dest_count, src_count, "The destination file is not stored to desired " "subvol :{}".format(dest_count)) # Create a linkfile to dest by renaming it to hash to S1 dest_hashed = find_specific_hashed(self.subvols, "/", src_link_subvol, new_hashed.newname) # Verify the subvol is S1 self.assertEqual( dest_hashed.subvol_count, new_hashed.subvol_count, "The destination file is not stored to desired " "subvol :{}, instead to subvol : {}".format( dest_hashed.subvol_count, new_hashed)) # Rename the dest file to the new file name dest_file_2 = "{}/{}".format(self.mount_point, str(dest_hashed.newname)) ret = move_file(self.mounts[0].client_system, dest_file, dest_file_2) self.assertTrue( ret, "Failed to move files {} and {}".format(source_file, dest_file_2)) # Rename source to destination src = "{}/{}".format(self.mount_point, str(new_hashed.newname)) dest_file = "{}/{}".format(self.mount_point, str(dest_hashed.newname)) ret = move_file(self.mounts[0].client_system, src, dest_file) self.assertTrue( ret, "Failed to move files {} and {}".format(src, dest_file)) # Verify destination file is removed ret = self._verify_file_exists(dest_hashed_subvol, str(new_hashed2.newname)) self.assertFalse(ret, ("Destination file : {} is not removed in subvol" " : {}".format(str(new_hashed2.newname), dest_hashed_subvol._fqpath))) g.log.info("The destination file is removed as expected") # Verify the source link is removed ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertFalse( ret, ("The hashed subvol {} still have the " "expected linkto file: {}".format(src_link_subvol._fqpath, str(new_hashed.newname)))) g.log.info("The source link file is removed as expected") # Verify the Destination link is on hashed subvolume ret = self._verify_link_file_exists(src_link_subvol, str(dest_hashed.newname)) self.assertTrue( ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}".format(dest_hashed_subvol._fqpath, str(dest_hashed.newname)))) # Verify the dest link file points to new destination file file_path = src_link_subvol._fqpath + str(dest_hashed.newname) ret = (self._verify_file_links_to_specified_destination( src_link_subvol._host, file_path, str(dest_hashed.newname))) self.assertTrue( ret, "The dest link file not pointing towards " "the desired file") g.log.info("The Destination link file is pointing to new file" " as expected")
def test_file_rename_when_dest_hash_src_hashed_but_cache_diff(self): """ - Destination file should exist - Source file is stored on hashed subvolume it self - Destination file should be hased to some other subvolume(s2) - Destination file hased on subvolume(s2) but cached on some other subvolume(s3)(neither s1 nor s2) mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Destination link file should be there on hashed subvolume and should link to new destination file """ # pylint: disable=protected-access # pylint: disable=too-many-locals # Create source file and Get hashed subvol (s1) _, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Find a new file name for destination to hash to some subvol S3 new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone(new_hashed, "couldn't find new hashed for destination file") # Create Dest file in S3 dest_cached, dest_count, dest_file = ( self._create_file_and_get_hashed_subvol(str(new_hashed.newname))) # Verify S1 and S3 are not same self.assertNotEqual(src_count, dest_count, ("The destination file is cached to the source " "cached subvol")) # Find new name for dest file, that it hashes to some other subvol S2 brickobject = create_brickobjectlist(self.subvols, "/") self.assertIsNotNone(brickobject, "Failed to get brick object list") br_count = -1 subvol_new = None for brickdir in brickobject: br_count += 1 if br_count not in (src_count, dest_count): subvol_new = brickdir break dest_hashed = find_specific_hashed(self.subvols, "/", subvol_new) # Move dest to new name dest = "{}/{}".format(self.mount_point, str(dest_hashed.newname)) ret = move_file(self.mounts[0].client_system, dest_file, dest) self.assertTrue(ret, ("Failed to move file {} and {}" .format(dest_file, dest))) # Move Source file to Dest ret = move_file(self.mounts[0].client_system, source_file, dest) self.assertTrue(ret, ("Failed to move file {} and {}" .format(source_file, dest))) # Verify Destination File is removed ret = self._verify_file_exists(dest_cached, str(new_hashed.newname)) self.assertFalse(ret, "The Source file is still present in {}" .format(dest_cached._fqpath)) # Verify Destination Link is present and points to new dest file ret = self._verify_link_file_exists(dest_hashed.hashedbrickobject, str(dest_hashed.newname)) self.assertTrue(ret, "The Dest link file is not present in {}" .format(dest_hashed.hashedbrickobject._fqpath)) file_path = dest_hashed.hashedbrickobject._fqpath + str( dest_hashed.newname) ret = (self._verify_file_links_to_specified_destination( dest_hashed.hashedbrickobject._host, file_path, str(dest_hashed.newname))) self.assertTrue(ret, "The dest link file not pointing towards " "the desired file") g.log.info("The Destination link file is pointing to new file" " as expected")
def test_file_rename_when_dest_neither_hash_cache_to_src_subvols(self): """ - Destination file should exist - Source file hashed on sub volume(s1) and cached on another subvolume(s2) - Destination file should be hased to some other subvolume(s3) (neither s1 nor s2) - Destination file hased on subvolume(s3) but cached on remaining subvolume(s4) mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Destination link file should be there on hashed subvolume and should link to new destination file - source link file should be removed """ # pylint: disable=protected-access # pylint: disable=too-many-locals # Create source file and Get hashed subvol (s2) _, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Find a new file name for destination file, which hashes # to another subvol (s2) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone(new_hashed, "couldn't find new hashed for destination file") # Rename the source file to the new file name src_hashed = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, source_file, src_hashed) self.assertTrue(ret, ("Failed to move file {} and {}" .format(source_file, src_hashed))) # Verify the Source link file is stored on hashed sub volume(s1) src_link_subvol = new_hashed.hashedbrickobject ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertTrue(ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}" .format(src_link_subvol._fqpath, str(new_hashed.newname)))) # Destination file cached on S4. # Find a subvol (s4) for dest file to linkto, other than S1 and S2 brickobject = create_brickobjectlist(self.subvols, "/") self.assertIsNotNone(brickobject, "Failed to get brick object list") br_count = -1 subvol_new = None for brickdir in brickobject: br_count += 1 if br_count not in (src_count, new_hashed.subvol_count): subvol_new = brickdir break dest_cached = find_specific_hashed(self.subvols, "/", subvol_new) self.assertIsNotNone(dest_cached, "could not find new hashed for dstfile") # Create a file in S3 _, _, dest_src = self._create_file_and_get_hashed_subvol( str(dest_cached.newname)) # Verify the subvol is not S2 and S1 self.assertNotEqual(dest_cached.subvol_count, new_hashed.subvol_count, ("The subvol found for destination is same as " "that of the source file hashed subvol")) self.assertNotEqual(dest_cached.subvol_count, src_count, ("The subvol found for destination is same as " "that of the source file cached subvol")) # Identify a name for dest that hashes to another subvol S3 # Find a subvol (s3) for dest file to linkto, other than S1 and S2 and # S4 brickobject = create_brickobjectlist(self.subvols, "/") self.assertIsNotNone(brickobject, "Failed to get brick object list") br_count = -1 subvol_new = None for brickdir in brickobject: br_count += 1 if br_count not in (src_count, new_hashed.subvol_count, dest_cached.subvol_count): subvol_new = brickdir break dest_hashed = find_specific_hashed(self.subvols, "/", subvol_new) # Move dest to new name dest = "{}/{}".format(self.mount_point, str(dest_hashed.newname)) ret = move_file(self.mounts[0].client_system, dest_src, dest) self.assertTrue(ret, ("Failed to move file {} and {}" .format(dest_src, dest))) # Move Source file to Dest src = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, src, dest) self.assertTrue(ret, ("Failed to move file {} and {}" .format(src, dest))) # Verify Destination File is removed ret = self._verify_file_exists(dest_cached.hashedbrickobject, str(dest_cached.newname)) self.assertFalse(ret, "The Source file is still present in {}" .format(dest_cached.hashedbrickobject._fqpath)) # Verify Source link is removed ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertFalse(ret, "The source link file is still present in {}" .format(src_link_subvol._fqpath)) # Verify Destination Link is present and points to new dest file ret = self._verify_link_file_exists(dest_hashed.hashedbrickobject, str(dest_hashed.newname)) self.assertTrue(ret, "The Dest link file is not present in {}" .format(dest_hashed.hashedbrickobject._fqpath)) file_path = dest_hashed.hashedbrickobject._fqpath + str( dest_hashed.newname) ret = (self._verify_file_links_to_specified_destination( dest_hashed.hashedbrickobject._host, file_path, str(dest_hashed.newname))) self.assertTrue(ret, "The dest link file not pointing towards " "the desired file") g.log.info("The Destination link file is pointing to new file" " as expected")
def test_file_rename_when_dest_hash_src_cached(self): """ - Destination file should exist - Source file hashed sub volume(s1) and cached on another subvolume(s2) - Destination file should be hased to subvolume where source file is stored(s2) - Destination file hased on subvolume(s2) but should be cached on some other subvolume(s3) than this two subvolume mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Destination link file should be removed - source link file should be removed """ # pylint: disable=protected-access # pylint: disable=too-many-locals # Create source file and Get hashed subvol (s2) src_subvol, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Find a new file name for destination file, which hashes # to another subvol (s2) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone(new_hashed, "couldn't find new hashed for destination file") # Rename the source file to the new file name src_hashed = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, source_file, src_hashed) self.assertTrue(ret, ("Failed to move file {} and {}" .format(source_file, src_hashed))) # Verify the Source link file is stored on hashed sub volume(s1) src_link_subvol = new_hashed.hashedbrickobject ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertTrue(ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}" .format(src_link_subvol._fqpath, str(new_hashed.newname)))) # Find a subvol (s3) for dest file to linkto, other than S1 and S2 brickobject = create_brickobjectlist(self.subvols, "/") self.assertIsNotNone(brickobject, "Failed to get brick object list") br_count = -1 subvol_new = None for brickdir in brickobject: br_count += 1 if br_count not in (src_count, new_hashed.subvol_count): subvol_new = brickdir break new_hashed2 = find_specific_hashed(self.subvols, "/", subvol_new) self.assertIsNotNone(new_hashed2, "could not find new hashed for dstfile") # Create a file in the subvol S3 dest_subvol, count, dest_file = ( self._create_file_and_get_hashed_subvol(str(new_hashed2.newname))) # Verify the subvol is not same as S1 and S2 self.assertNotEqual(count, src_count, ("The subvol found for destination is same as that" " of the source file cached subvol")) self.assertNotEqual(count, new_hashed.subvol_count, ("The subvol found for destination is same as that" " of the source file hashed subvol")) # Find a file name that hashes to S2 dest_hashed = find_specific_hashed(self.subvols, "/", src_subvol) self.assertIsNotNone(dest_hashed, "could not find new hashed for dstfile") # Rename destination to hash to S2 and verify dest = "{}/{}".format(self.mount_point, str(dest_hashed.newname)) ret = move_file(self.mounts[0].client_system, dest_file, dest) self.assertTrue(ret, ("Failed to move file {} and {}" .format(dest_file, dest))) # Rename Source File to Dest ret = move_file(self.mounts[0].client_system, src_hashed, dest) self.assertTrue(ret, ("Failed to move file {} and {}" .format(src_hashed, dest))) # Verify Destination File is removed ret = self._verify_file_exists(new_hashed2.hashedbrickobject, str(new_hashed2.newname)) self.assertFalse(ret, "The Destination file is still present in {}" .format(dest_subvol._fqpath)) # Verify Source link is removed ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertFalse(ret, "The source link file is still present in {}" .format(src_link_subvol._fqpath)) # Verify Destination Link is removed ret = self._verify_link_file_exists(dest_hashed.hashedbrickobject, str(dest_hashed.newname)) self.assertFalse(ret, "The Dest link file is still present in {}" .format(dest_hashed.hashedbrickobject._fqpath))
def test_file_rename_when_dest_doesnt_hash_src_cached_or_hashed(self): """ - Destination file should exist - Source file is hashed on sub volume(s1) and cached on another subvolume(s2) - Destination file should be hased to subvolume(s3) other than above two subvolumes - Destination file hased on subvolume(s3) but destination file should be cached on same subvolume(s2) where source file is stored mv <source_file> <destination_file> - Destination file is removed. - Source file should be renamed as destination file - Destination file hashed on subvolume and should link to new destination file - source link file should be removed """ # pylint: disable=protected-access # pylint: disable=too-many-locals # Create source file and Get hashed subvol (s2) src_subvol, src_count, source_file = ( self._create_file_and_get_hashed_subvol("test_source_file")) # Find a new file name for destination file, which hashes # to another subvol (s1) new_hashed = find_new_hashed(self.subvols, "/", "test_source_file") self.assertIsNotNone(new_hashed, "couldn't find new hashed for destination file") # Rename the source file to the new file name dest_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, source_file, dest_file) self.assertTrue(ret, ("Failed to move file {} and {}" .format(source_file, dest_file))) # Verify the Source link file is stored on hashed sub volume(s1) src_link_subvol = new_hashed.hashedbrickobject ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertTrue(ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}" .format(src_link_subvol._fqpath, str(new_hashed.newname)))) # Identify a file name for dest to get stored in S2 dest_cached_subvol = find_specific_hashed(self.subvols, "/", src_subvol) # Create the file with identified name _, _, dst_file = ( self._create_file_and_get_hashed_subvol( str(dest_cached_subvol.newname))) # Verify its in S2 itself self.assertEqual(dest_cached_subvol.subvol_count, src_count, ("The subvol found for destination is not same as " "that of the source file cached subvol")) # Find a subvol (s3) for dest file to linkto, other than S1 and S2 brickobject = create_brickobjectlist(self.subvols, "/") self.assertIsNotNone(brickobject, "Failed to get brick object list") br_count = -1 subvol_new = None for brickdir in brickobject: br_count += 1 if br_count not in (src_count, new_hashed.subvol_count): subvol_new = brickdir break new_hashed2 = find_specific_hashed(self.subvols, "/", subvol_new) self.assertIsNotNone(new_hashed2, "could not find new hashed for dstfile") # Verify the subvol is not same as S1(src_count) and S2(dest_count) self.assertNotEqual(new_hashed2.subvol_count, src_count, ("The subvol found for destination is same as that" " of the source file cached subvol")) self.assertNotEqual(new_hashed2.subvol_count, new_hashed.subvol_count, ("The subvol found for destination is same as that" " of the source file hashed subvol")) # Rename the dest file to the new file name dst_file_ln = "{}/{}".format(self.mount_point, str(new_hashed2.newname)) ret = move_file(self.mounts[0].client_system, dst_file, dst_file_ln) self.assertTrue(ret, ("Failed to move file {} and {}" .format(dst_file, dst_file_ln))) # Verify the Dest link file is stored on hashed sub volume(s3) dest_link_subvol = new_hashed2.hashedbrickobject ret = self._verify_link_file_exists(dest_link_subvol, str(new_hashed2.newname)) self.assertTrue(ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}" .format(dest_link_subvol._fqpath, str(new_hashed2.newname)))) # Move/Rename Source File to Dest src_file = "{}/{}".format(self.mount_point, str(new_hashed.newname)) ret = move_file(self.mounts[0].client_system, src_file, dst_file) self.assertTrue(ret, ("Failed to move file {} and {}" .format(src_file, dst_file))) # Verify Source file is removed ret = self._verify_file_exists(src_subvol, "test_source_file") self.assertFalse(ret, "The source file is still present in {}" .format(src_subvol._fqpath)) # Verify Source link is removed ret = self._verify_link_file_exists(src_link_subvol, str(new_hashed.newname)) self.assertFalse(ret, "The source link file is still present in {}" .format(src_link_subvol._fqpath)) # Verify the Destination link is on hashed subvolume ret = self._verify_link_file_exists(dest_link_subvol, str(new_hashed2.newname)) self.assertTrue(ret, ("The hashed subvol {} doesn't have the " "expected linkto file: {}" .format(dest_link_subvol._fqpath, str(new_hashed2.newname)))) # Verify the dest link file points to new destination file file_path = dest_link_subvol._fqpath + str(new_hashed2.newname) ret = (self._verify_file_links_to_specified_destination( dest_link_subvol._host, file_path, str(dest_cached_subvol.newname))) self.assertTrue(ret, "The dest link file not pointing towards " "the desired file") g.log.info("The Destination link file is pointing to new file" " as expected")