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_mkdir_with_subvol_down(self):
'''
Test mkdir hashed to a down subvol
'''
# pylint: disable=too-many-locals
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
# pylint: disable=W0212
mount_obj = self.mounts[0]
mountpoint = mount_obj.mountpoint
# directory that needs to be created
parent_dir = mountpoint + '/parent'
child_dir = mountpoint + '/parent/child'
# get hashed subvol for name "parent"
subvols = (get_subvols(self.mnode, self.volname))['volume_subvols']
hashed, count = find_hashed_subvol(subvols, "/", "parent")
self.assertIsNotNone(hashed, "Could not find hashed subvol")
# bring target_brick offline
bring_bricks_offline(self.volname, subvols[count])
ret = are_bricks_offline(self.mnode, self.volname, subvols[count])
self.assertTrue(
ret, ('Error in bringing down subvolume %s', subvols[count]))
g.log.info('target subvol is offline')
# create parent dir
ret, _, err = g.run(self.clients[0], ("mkdir %s" % parent_dir))
self.assertNotEqual(
ret, 0, ('Expected mkdir of %s to fail with %s', parent_dir, err))
g.log.info('mkdir of dir %s failed as expected', parent_dir)
# check that parent_dir does not exist on any bricks and client
brickobject = create_brickobjectlist(subvols, "/")
for brickdir in brickobject:
adp = "%s/parent" % brickdir.path
bpath = adp.split(":")
self.assertTrue(
(file_exists(brickdir._host, bpath[1])) == 0,
('Expected dir %s not to exist on servers', parent_dir))
for client in self.clients:
self.assertTrue(
(file_exists(client, parent_dir)) == 0,
('Expected dir %s not to exist on clients', parent_dir))
g.log.info('dir %s does not exist on mount as expected', parent_dir)
# Bring up the subvols and create parent directory
bring_bricks_online(self.mnode,
self.volname,
subvols[count],
bring_bricks_online_methods=None)
ret = are_bricks_online(self.mnode, self.volname, subvols[count])
self.assertTrue(
ret, ("Error in bringing back subvol %s online", subvols[count]))
g.log.info('Subvol is back online')
ret, _, _ = g.run(self.clients[0], ("mkdir %s" % parent_dir))
self.assertEqual(ret, 0,
('Expected mkdir of %s to succeed', parent_dir))
g.log.info('mkdir of dir %s successful', parent_dir)
# get hash subvol for name "child"
hashed, count = find_hashed_subvol(subvols, "parent", "child")
self.assertIsNotNone(hashed, "Could not find hashed subvol")
# bring target_brick offline
bring_bricks_offline(self.volname, subvols[count])
ret = are_bricks_offline(self.mnode, self.volname, subvols[count])
self.assertTrue(
ret, ('Error in bringing down subvolume %s', subvols[count]))
g.log.info('target subvol is offline')
# create child dir
ret, _, err = g.run(self.clients[0], ("mkdir %s" % child_dir))
self.assertNotEqual(
ret, 0, ('Expected mkdir of %s to fail with %s', child_dir, err))
g.log.info('mkdir of dir %s failed', child_dir)
# check if child_dir exists on any bricks
for brickdir in brickobject:
adp = "%s/parent/child" % brickdir.path
bpath = adp.split(":")
self.assertTrue(
(file_exists(brickdir._host, bpath[1])) == 0,
('Expected dir %s not to exist on servers', child_dir))
for client in self.clients:
self.assertTrue((file_exists(client, child_dir)) == 0)
g.log.info('dir %s does not exist on mount as expected', child_dir)
def test_afr_dir_entry_creation_with_subvol_down(self):
"""
1. Create a distributed-replicated(3X3)/distributed-arbiter(3X(2+1))
and mount it on one client
2. Kill 3 bricks corresponding to the 1st subvol
3. Unmount and remount the volume on the same client
4. Create deep dir from mount point
mkdir -p dir1/subdir1/deepdir1
5. Create files under dir1/subdir1/deepdir1; touch <filename>
6. Now bring all sub-vols up by volume start force
7. Validate backend bricks for dir creation, the subvol which is
offline will have no dirs created, whereas other subvols will have
dirs created from step 4
8. Trigger heal from client by "#find . | xargs stat"
9. Verify that the directory entries are created on all back-end bricks
10. Create new dir (dir2) on location dir1/subdir1/deepdir1
11. Trigger rebalance and wait for the completion
12. Check backend bricks for all entries of dirs
13. Check if files are getting created on the subvol which was offline
"""
# Bring down first subvol of bricks offline
self.subvols = get_subvols(self.mnode, self.volname)['volume_subvols']
first_subvol = self.subvols[0]
ret = bring_bricks_offline(self.volname, first_subvol)
self.assertTrue(
ret, "Unable to bring {} bricks offline".format(first_subvol))
# Check bricks are offline or not
ret = are_bricks_offline(self.mnode, self.volname, first_subvol)
self.assertTrue(ret, "Bricks {} are still online".format(first_subvol))
# Unmount and remount the volume
ret, _, _ = umount_volume(self.mounts[0].client_system,
self.mounts[0].mountpoint)
self.assertFalse(ret, "Failed to unmount volume.")
ret, _, _ = mount_volume(self.volname, self.mount_type,
self.mounts[0].mountpoint, self.mnode,
self.mounts[0].client_system)
self.assertFalse(ret, "Failed to remount volume.")
g.log.info('Successfully umounted and remounted volume.')
# At this step, sleep is must otherwise file creation will fail
sleep(2)
# Create dir `dir1/subdir1/deepdir1` on mountpont
directory1 = "dir1/subdir1/deepdir1"
path = self.mounts[0].mountpoint + "/" + directory1
ret = mkdir(self.mounts[0].client_system, path, parents=True)
self.assertTrue(ret, "Directory {} creation failed".format(path))
# Create files on the 2nd and 3rd subvols which are online
brickobject = create_brickobjectlist(self.subvols, directory1)
self.assertIsNotNone(brickobject, "Failed to get brick object list")
self._create_number_of_files_on_the_subvol(brickobject[1],
directory1,
5,
mountpath=path)
self._create_number_of_files_on_the_subvol(brickobject[2],
directory1,
5,
mountpath=path)
# Bring bricks online using volume start force
ret, _, err = volume_start(self.mnode, self.volname, force=True)
self.assertEqual(ret, 0, err)
g.log.info("Volume: %s started successfully", self.volname)
# Check all bricks are online
ret = verify_all_process_of_volume_are_online(self.mnode, self.volname)
self.assertTrue(
ret, "Few process after volume start are offline for "
"volume: {}".format(self.volname))
# Validate Directory is not created on the bricks of the subvol which
# is offline
for subvol in self.subvols:
self._check_file_exists(subvol,
"/" + directory1,
exists=(subvol != first_subvol))
# Trigger heal from the client
cmd = "cd {}; find . | xargs stat".format(self.mounts[0].mountpoint)
ret, _, err = g.run(self.mounts[0].client_system, cmd)
self.assertEqual(ret, 0, err)
# Validate the directory1 is present on all the bricks
for subvol in self.subvols:
self._check_file_exists(subvol, "/" + directory1, exists=True)
# Create new dir (dir2) on location dir1/subdir1/deepdir1
directory2 = "/" + directory1 + '/dir2'
path = self.mounts[0].mountpoint + directory2
ret = mkdir(self.mounts[0].client_system, path, parents=True)
self.assertTrue(ret, "Directory {} creation failed".format(path))
# Trigger rebalance and validate the completion
ret, _, err = rebalance_start(self.mnode, self.volname)
self.assertEqual(ret, 0, err)
g.log.info("Rebalance on volume %s started successfully", self.volname)
ret = wait_for_rebalance_to_complete(self.mnode, self.volname)
self.assertTrue(
ret, "Rebalance didn't complete on the volume: "
"{}".format(self.volname))
# Validate all dirs are present on all bricks in each subvols
for subvol in self.subvols:
for each_dir in ("/" + directory1, directory2):
self._check_file_exists(subvol, each_dir, exists=True)
# Validate if files are getting created on the subvol which was
# offline
self._create_number_of_files_on_the_subvol(brickobject[0],
directory1,
5,
mountpath=path)
def test_rm_file_when_nonhash_vol_down(self):
"""
case -3:
- create parent
- mkdir parent/child
- touch parent/child/file
- bringdown a subvol where file is not present
- rm -rf parent
- Only file should be deleted
- rm -rf of parent should fail with ENOTCONN
"""
# pylint: disable=protected-access
# pylint: disable=too-many-statements
# pylint: disable=unsubscriptable-object
# Find a non hashed subvolume(or brick)
# Create parent dir
parent_dir = self.mountpoint + '/parent'
child_dir = parent_dir + '/child'
ret = mkdir(self.clients[0], parent_dir)
self.assertTrue(ret, ('mkdir failed for %s ' % parent_dir))
g.log.info("mkdir of parent directory %s successful", parent_dir)
# Create child dir
ret = mkdir(self.clients[0], child_dir)
self.assertTrue(ret, ('mkdir failed for %s ' % child_dir))
g.log.info("mkdir of child directory %s successful", child_dir)
# Create a file under child_dir
file_one = child_dir + '/file_one'
ret, _, err = g.run(self.clients[0], ("touch %s" % file_one))
self.assertFalse(ret, ('touch failed for %s err: %s' %
(file_one, err)))
# Find a non hashed subvolume(or brick)
nonhashed_subvol, count = find_nonhashed_subvol(self.subvols,
"parent/child",
"file_one")
self.assertIsNotNone(nonhashed_subvol,
"Error in finding nonhashed value")
g.log.info("nonhashed_subvol %s", nonhashed_subvol._host)
# Bring nonhashed_subbvol offline
ret = bring_bricks_offline(self.volname, self.subvols[count])
self.assertTrue(ret, ('Error in bringing down subvolume %s'
% self.subvols[count]))
g.log.info('target subvol %s is offline', self.subvols[count])
# 'rm -rf' on parent should fail with ENOTCONN
ret = rmdir(self.clients[0], parent_dir)
self.assertFalse(ret, ('Expected rmdir to fail for %s' % parent_dir))
g.log.info("rmdir of parent directory %s failed as expected"
" with err %s", parent_dir, err)
brickobject = create_brickobjectlist(self.subvols, "parent/child")
self.assertIsNotNone(brickobject,
"could not create brickobject list")
# Make sure file_one is deleted
for brickdir in brickobject:
dir_path = "%s/parent/child/file_one" % brickdir.path
brick_path = dir_path.split(":")
self.assertTrue((file_exists(brickdir._host, brick_path[1])) == 0,
('Expected file %s not to exist on servers'
% parent_dir))
g.log.info("file is deleted as expected")
# Cleanup
# Bring up the subvol - restart volume
ret = volume_start(self.mnode, self.volname, force=True)
self.assertTrue(ret, "Error in force start the volume")
g.log.info('Volume restart success.')
sleep(10)
# Delete parent_dir
ret = rmdir(self.clients[0], parent_dir, force=True)
self.assertTrue(ret, ('rmdir failed for %s ' % parent_dir))
g.log.info("rmdir of directory %s successful", parent_dir)
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")
