def tearDown(self):
# Validate USS running
g.log.info("Validating USS enabled or disabled")
ret = is_uss_enabled(self.mnode, self.volname)
if not ret:
# Disable USS
ret, _, _ = disable_uss(self.mnode, self.volname)
if not ret:
raise ExecutionError("Failed to disable USS on volume"
"%s" % self.volname)
g.log.info("Successfully disabled USS on volume %s",
self.volname)
# Unmount and cleanup original volume
g.log.info("Starting to Unmount Volume and Cleanup Volume")
ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to umount the vol & cleanup Volume")
g.log.info("Successful in umounting the volume and Cleanup")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def test_uss_snap_active_deactive(self):
# pylint: disable=too-many-statements
"""
Steps:
* Create volume
* Mount volume
* Perform I/O on mounts
* Create 2 snapshots snapy1 & snapy2
* Validate snap created
* Enable USS
* Validate USS is enabled
* Validate snapd is running
* Activate snapy1 & snapy2
* List snaps under .snap directory
-- snap1 and snap2 should be listed under .snaps
* Deactivate snapy2
* List snaps under .snap directory
-- snapy2 is not listed as it is deactivated
* Activate snapy2
* List snaps under .snap directory
-- snap1 and snap2 should be listed under .snaps
"""
# Perform I/O
g.log.info("Starting IO on all mounts...")
self.counter = 1
self.all_mounts_procs = []
for mount_obj in self.mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = (
"python %s create_deep_dirs_with_files "
"--dirname-start-num %d "
"--dir-depth 2 "
"--dir-length 2 "
"--max-num-of-dirs 2 "
"--num-of-files 2 %s" %
(self.script_upload_path, self.counter, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
self.all_mounts_procs.append(proc)
self.io_validation_complete = False
# Validate IO
g.log.info("Wait for IO to complete and validate IO ...")
ret = validate_io_procs(self.all_mounts_procs, self.mounts)
self.assertTrue(ret, "IO failed on some of the clients")
self.io_validation_complete = True
g.log.info("I/O successful on clients")
# Enable USS
g.log.info("Enable USS on volume")
ret, _, _ = enable_uss(self.mnode, self.volname)
self.assertEqual(ret, 0, "Failed to enable USS on volume")
g.log.info("Successfully enabled USS on volume")
# Validate USS is enabled
g.log.info("Validating USS is enabled")
ret = is_uss_enabled(self.mnode, self.volname)
self.assertTrue(ret, "USS is disabled on volume " "%s" % self.volname)
g.log.info("USS enabled on volume %s", self.volname)
# Validate snapd running
for server in self.servers:
g.log.info("Validating snapd daemon on:%s", server)
ret = is_snapd_running(server, self.volname)
self.assertTrue(ret, "Snapd is Not running on " "%s" % server)
g.log.info("Snapd Running on node: %s", server)
# Create 2 snapshot
g.log.info("Creating 2 snapshots for volume %s", self.volname)
for i in range(1, 3):
ret, _, _ = snap_create(self.mnode, self.volname, "snapy%s" % i)
self.assertEqual(
ret, 0, ("Failed to create snapshot for %s" % self.volname))
g.log.info("Snapshot %s created successfully for volume %s",
"snapy%s" % i, self.volname)
# Check for no of snaps using snap_list it should be 2 now
snap_list = get_snap_list(self.mnode)
self.assertEqual(
2, len(snap_list), "No of snaps not consistent "
"for volume %s" % self.volname)
g.log.info("Successfully validated number of snaps.")
# Activate snapshot snapy1 & snapy2
g.log.info("Activating snapshot snapy1 & snapy2")
for i in range(1, 3):
ret, _, _ = snap_activate(self.mnode, "snapy%s" % i)
self.assertEqual(ret, 0, "Failed to activate snapshot snapy%s" % i)
g.log.info("Both snapshots activated successfully")
# list activated snapshots directory under .snaps
g.log.info("Listing activated snapshots under .snaps")
for mount_obj in self.mounts:
ret, out, _ = uss_list_snaps(mount_obj.client_system,
mount_obj.mountpoint)
self.assertEqual(
ret, 0, "Directory Listing Failed for"
" Activated Snapshot")
validate_dir = out.split('\n')
self.assertIn(
"snapy1", validate_dir, "Failed to "
"validate snapy1 under .snaps directory")
g.log.info("Activated Snapshot snapy1 listed Successfully")
self.assertIn(
"snapy2", validate_dir, "Successfully listed"
" snapy2 under.snaps directory")
g.log.info("Expected: De-activated Snapshot not listed")
# Deactivate snapshot snapy2
g.log.info("Deactivating snapshot snapy2")
ret, _, _ = snap_deactivate(self.mnode, "snapy2")
self.assertEqual(ret, 0, "Failed to deactivate snapshot snapy2")
g.log.info("Successfully deactivated snapshot snapy2")
# validate snapy2 should not present in mountpoint
ret = view_snaps_from_mount(self.mounts, "snapy2")
self.assertFalse(
ret, " UnExpected : Still able to View snapy2"
" from mount ")
g.log.info("Successfully verified deactivated snapshot "
"snapy2 is not listed")
# Activate snapshot snapy2
ret, _, _ = snap_activate(self.mnode, "snapy2")
self.assertEqual(ret, 0, "Failed to activate Snapshot snapy2")
g.log.info("Snapshot snapy2 activated successfully")
# list activated snapshots directory under .snaps
g.log.info("Listing activated snapshots under .snaps")
for mount_obj in self.mounts:
ret, out, _ = uss_list_snaps(mount_obj.client_system,
mount_obj.mountpoint)
self.assertEqual(
ret, 0, "Directory Listing Failed for"
" Activated Snapshot")
validate_dir = out.split('\n')
self.assertIn(
"snapy1", validate_dir, "Failed to "
"validate snapy%s under .snaps directory")
g.log.info("Activated Snapshot listed Successfully")
self.assertIn(
"snapy2", validate_dir, "Successfully listed"
"snapy2 under .snaps directory")
g.log.info("Expected: De-activated Snapshot not listed")
def test_validate_snaps_dir_over_uss(self):
# pylint: disable=too-many-statements
"""
Run IOs on mount and take 2 snapshot.
Activate 1 snapshot and check directory listing.
Try to write to .snaps should not allow.
Try listing the other snapshot should fail.
"""
# run IOs
self.counter = 1
g.log.info("Starting IO on all mounts...")
self.all_mounts_procs = []
for mount_obj in self.mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = (
"/usr/bin/env python %s create_deep_dirs_with_files "
"--dirname-start-num %d "
"--dir-depth 2 "
"--dir-length 2 "
"--max-num-of-dirs 2 "
"--num-of-files 2 %s" %
(self.script_upload_path, self.counter, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
self.all_mounts_procs.append(proc)
self.io_validation_complete = False
# Validate IO
self.assertTrue(validate_io_procs(self.all_mounts_procs, self.mounts),
"IO failed on some of the clients")
self.io_validation_complete = True
# get the snapshot list.
snap_list = get_snap_list(self.mnode)
self.assertEqual(len(snap_list), 0, "Unexpected: %s snapshots"
"present" % len(snap_list))
g.log.info("Expected: No snapshots present")
# Create 2 snapshot
g.log.info("Starting to Create Snapshots")
for snap_num in range(0, 2):
ret, _, _ = snap_create(self.mnode, self.volname,
"snap-%s" % snap_num)
self.assertEqual(
ret, 0, "Snapshot Creation failed"
" for snap-%s" % snap_num)
g.log.info("Snapshot snap-%s of volume %s created"
" successfully", snap_num, self.volname)
# Activate snap-0
g.log.info("Activating snapshot snap-0")
ret, _, _ = snap_activate(self.mnode, "snap-0")
self.assertEqual(ret, 0, "Failed to activate " "Snapshot snap-0")
g.log.info("Snapshot snap-0 Activated Successfully")
# Enable USS for volume
g.log.info("Enable uss for volume")
ret, _, _ = enable_uss(self.mnode, self.volname)
self.assertEqual(
ret, 0, "Failed to enable USS for "
" volume %s" % self.volname)
g.log.info("Successfully enabled USS " "for volume %s", self.volname)
# Validate uss enabled
g.log.info("Validating uss enabled")
ret = is_uss_enabled(self.mnode, self.volname)
self.assertTrue(ret, "Failed to validate uss enable")
g.log.info("Successfully validated uss enable for volume"
"%s", self.volname)
# list activated snapshots directory under .snaps
g.log.info("Listing activated snapshots under .snaps")
for mount_obj in self.mounts:
ret, out, _ = uss_list_snaps(mount_obj.client_system,
mount_obj.mountpoint)
self.assertEqual(
ret, 0, "Directory Listing Failed for"
" Activated Snapshot")
validate_dir = out.split('\n')
self.assertIn(
'snap-0', validate_dir, "Failed to "
"validate snap-0 under .snaps directory")
g.log.info("Activated Snapshot Successfully listed")
self.assertNotIn(
'snap-1', validate_dir, "Unexpected: "
"Successfully listed snap-1 under "
".snaps directory")
g.log.info("Expected: De-activated Snapshot not listed")
# start I/0 ( write and read )
g.log.info("Starting IO on all mounts...")
all_mounts_procs = []
for mount_obj in self.mounts:
cmd = ("/usr/bin/env python %s create_files "
"-f 10 --base-file-name file %s/.snaps/abc/" %
(self.script_upload_path, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
# IO should fail
g.log.info("IO should Fail with ROFS error.....")
self.assertFalse(validate_io_procs(all_mounts_procs, self.mounts),
"Unexpected: IO successfully completed")
g.log.info("Expected: IO failed to complete")
# validate snap-0 present in mountpoint
ret = view_snaps_from_mount(self.mounts, "snap-0")
self.assertTrue(
ret, "UnExpected: Unable to list content "
"in activated snapshot"
" activated snapshot")
g.log.info("Expected: Successfully listed contents in"
" activated snapshot")
def test_snap_uss_while_io(self):
# pylint: disable=too-many-statements
"""
Steps:
1. Create volume
2. enable uss on created volume
3. validate uss running
4. validate snapd running on all nodes
5. perform io on mounts
6. create 10 snapshots with description
7. validate with snapshot list
8. validate io is completed
9. Activate snapshots to list all snaps
under .snaps
10. validate snapshots under .snaps directory
"""
# Enable USS
g.log.info("Enable USS for volume")
ret, _, _ = enable_uss(self.mnode, self.volname)
self.assertEqual(ret, 0, "Failed to enable USS on volume"
"%s" % self.volname)
g.log.info("Successfully enabled USS on volume %s", self.volname)
# Validate USS running
g.log.info("Validating USS enabled or disabled")
ret = is_uss_enabled(self.mnode, self.volname)
self.assertTrue(
ret, "Failed to validate USS for volume "
"%s" % self.volname)
g.log.info("Successfully validated USS for Volume" "%s", self.volname)
# Validate snapd running
for server in self.servers:
g.log.info("Validating snapd daemon on:%s", server)
ret = is_snapd_running(server, self.volname)
self.assertTrue(ret, "Snapd is Not running on " "%s" % server)
g.log.info("Snapd Running on node: %s", server)
# Perform I/O
g.log.info("Starting to Perform I/O")
all_mounts_procs = []
for mount_obj in self.mounts:
g.log.info("Generating data for %s:"
"%s", mount_obj.client_system, mount_obj.mountpoint)
# Create files
g.log.info('Creating files...')
command = (
"python %s create_files -f 100 --fixed-file-size 1M %s" %
(self.script_upload_path, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
command,
user=mount_obj.user)
all_mounts_procs.append(proc)
self.io_validation_complete = False
# Creating snapshot with description
g.log.info("Starting to Create snapshot")
for count in range(0, self.snap_count):
self.snap = "snap%s" % count
ret, _, _ = snap_create(self.mnode,
self.volname,
self.snap,
description='$p3C!@l C#@R@cT#R$')
self.assertEqual(
ret, 0,
("Failed to create snapshot for volume %s" % self.volname))
g.log.info("Snapshot %s created successfully"
" for volume %s", self.snap, self.volname)
# Validate snapshot list
g.log.info("Starting to list all snapshots")
ret, out, _ = snap_list(self.mnode)
self.assertEqual(
ret, 0, ("Failed to list snapshot of volume %s" % self.volname))
s_list = out.strip().split('\n')
self.assertEqual(len(s_list), self.snap_count, "Failed to validate "
"all snapshots")
g.log.info(
"Snapshot listed and Validated for volume %s"
" successfully", self.volname)
# Activating snapshot
g.log.info("Activating snapshot")
for count in range(0, self.snap_count):
self.snap = "snap%s" % count
ret, _, _ = snap_activate(self.mnode, self.snap)
self.assertEqual(ret, 0, "Failed to Activate snapshot "
"%s" % self.snap)
g.log.info("snapshot %s activated successfully", self.snap)
# Validate IO is completed
self.assertTrue(validate_io_procs(all_mounts_procs, self.mounts),
"IO failed on some of the clients")
self.io_validation_complete = True
# validate snapshots are listed under .snaps directory
g.log.info("Validating snaps under .snaps")
ret = view_snaps_from_mount(self.mounts, s_list)
self.assertTrue(ret, "Failed to list snaps under .snaps" "directory")
g.log.info("Snapshots Validated successfully")
def test_uss_brick_down(self):
# pylint: disable=too-many-statements
"""
Steps:
* Create volume
* Mount volume
* Perform I/O on mounts
* Bring down one brick
* Enable USS
* Validate USS is enabled
* Bring the brick online using gluster v start force
* Create 2 snapshots snapy1 & snapy2
* Validate snap created
* Activate snapy1 & snapy2
* List snaps under .snap directory
-- snap1 and snap2 should be listed under .snaps
"""
# Perform I/O
g.log.info("Starting IO on all mounts...")
self.counter = 1
self.all_mounts_procs = []
for mount_obj in self.mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = (
"/usr/bin/env python %s create_deep_dirs_with_files "
"--dirname-start-num %d "
"--dir-depth 2 "
"--dir-length 2 "
"--max-num-of-dirs 2 "
"--num-of-files 2 %s" %
(self.script_upload_path, self.counter, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
self.all_mounts_procs.append(proc)
self.io_validation_complete = False
# Validate IO
self.assertTrue(validate_io_procs(self.all_mounts_procs, self.mounts),
"IO failed on some of the clients")
self.io_validation_complete = True
# Bring down 1 brick from brick list
g.log.info("Getting all the bricks of the volume")
bricks_list = get_all_bricks(self.mnode, self.volname)
self.assertIsNotNone(bricks_list, "Failed to get the brick list")
g.log.info("Successfully got the list of bricks of volume")
ret = bring_bricks_offline(self.volname, bricks_list[0])
self.assertTrue(ret,
("Failed to bring down the brick %s ", bricks_list[0]))
g.log.info("Successfully brought the brick %s down", bricks_list[0])
# Enable USS
g.log.info("Enable USS on volume")
ret, _, _ = enable_uss(self.mnode, self.volname)
self.assertEqual(ret, 0, "Failed to enable USS on volume")
g.log.info("Successfully enabled USS on volume")
# Validate USS is enabled
g.log.info("Validating USS is enabled")
ret = is_uss_enabled(self.mnode, self.volname)
self.assertTrue(ret, "USS is disabled on volume " "%s" % self.volname)
g.log.info("USS enabled on volume %s", self.volname)
# Bring the brick online using gluster v start force
g.log.info("Bring the brick online using gluster v start force")
ret, _, _ = volume_start(self.mnode, self.volname, force=True)
self.assertEqual(ret, 0, "Volume start with force failed")
g.log.info("Volume start with force successful")
# Create 2 snapshot
g.log.info("Creating 2 snapshots for volume %s", self.volname)
for i in range(0, 2):
ret, _, _ = snap_create(self.mnode, self.volname, "snapy%s" % i)
self.assertEqual(
ret, 0, ("Failed to create snapshot for %s" % self.volname))
g.log.info("Snapshot %s created successfully for volume %s",
"snapy%s" % i, self.volname)
# Check for no of snaps using snap_list it should be 2 now
snap_list = get_snap_list(self.mnode)
self.assertEqual(
2, len(snap_list), "No of snaps not consistent "
"for volume %s" % self.volname)
g.log.info("Successfully validated number of snaps.")
# Activate snapshot snapy1 & snapy2
g.log.info("Activating snapshot snapy1 & snapy2")
for i in range(0, 2):
ret, _, _ = snap_activate(self.mnode, "snapy%s" % i)
self.assertEqual(ret, 0, "Failed to activate snapshot snapy%s" % i)
g.log.info("Both snapshots activated successfully")
# list activated snapshots directory under .snaps
g.log.info("Listing activated snapshots under .snaps")
for mount_obj in self.mounts:
ret, out, _ = uss_list_snaps(mount_obj.client_system,
mount_obj.mountpoint)
self.assertEqual(
ret, 0, "Directory Listing Failed for"
" Activated Snapshot")
validate_dir = out.split('\n')
for i in range(0, 2):
self.assertIn(
"snapy%s" % i, validate_dir, "Failed to "
"validate snapy%s under .snaps directory")
g.log.info("Activated Snapshot snapy%s listed Successfully", i)
def validate_uss(self):
""" Validate USS running """
ret = is_uss_enabled(self.mnode, self.clone_vol1)
self.assertTrue(ret, "USS is disabled in clone volume "
"%s" % self.clone_vol1)
g.log.info("USS enabled in cloned Volume %s", self.clone_vol1)
def test_uss_snap_restore(self):
"""
Description:
This test case will validate USS after Snapshot restore.
The restored snapshot should not be listed under the '.snaps'
directory.
* Perform I/O on mounts
* Enable USS on volume
* Validate USS is enabled
* Create a snapshot
* Activate the snapshot
* Perform some more I/O
* Create another snapshot
* Activate the second
* Restore volume to the second snapshot
* From mount point validate under .snaps
- first snapshot should be listed
- second snapshot should not be listed
"""
# pylint: disable=too-many-statements
# Perform I/O
cmd = ("/usr/bin/env python %s create_files "
"-f 10 --base-file-name firstfiles %s" %
(self.script_upload_path, self.mounts[0].mountpoint))
proc = g.run_async(self.mounts[0].client_system,
cmd,
user=self.mounts[0].user)
self.all_mounts_procs.append(proc)
# Wait for IO to complete and validate IO
self.assertTrue(
wait_for_io_to_complete(self.all_mounts_procs, self.mounts[0]),
"IO failed on %s" % self.mounts[0])
g.log.info("IO is successful on all mounts")
# Get stat of all the files/dirs created.
ret = get_mounts_stat(self.mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
# Enable USS
ret, _, _ = enable_uss(self.mnode, self.volname)
self.assertEqual(ret, 0, "Failed to enable USS on volume")
g.log.info("Successfully enabled USS on volume")
# Validate USS is enabled
ret = is_uss_enabled(self.mnode, self.volname)
self.assertTrue(ret, "USS is disabled on volume %s" % self.volname)
g.log.info("USS enabled on volume %s", self.volname)
# Create a snapshot
ret, _, _ = snap_create(self.mnode, self.volname, self.snapshots[0])
self.assertEqual(ret, 0,
("Failed to create snapshot for %s" % self.volname))
g.log.info("Snapshot %s created successfully for volume %s",
self.snapshots[0], self.volname)
# Check for number of snaps using snap_list it should be 1 now
snap_list = get_snap_list(self.mnode)
self.assertEqual(
1, len(snap_list), "No of snaps not consistent "
"for volume %s" % self.volname)
g.log.info("Successfully validated number of snapshots")
# Activate the snapshot
ret, _, _ = snap_activate(self.mnode, self.snapshots[0])
self.assertEqual(
ret, 0, ("Failed to activate snapshot %s" % self.snapshots[0]))
g.log.info("Snapshot %s activated successfully", self.snapshots[0])
# Perform I/O
self.all_mounts_procs = []
cmd = ("/usr/bin/env python %s create_files "
"-f 10 --base-file-name secondfiles %s" %
(self.script_upload_path, self.mounts[0].mountpoint))
proc = g.run_async(self.mounts[0].client_system,
cmd,
user=self.mounts[0].user)
self.all_mounts_procs.append(proc)
# Wait for IO to complete and validate IO
self.assertTrue(
wait_for_io_to_complete(self.all_mounts_procs, self.mounts[0]),
"IO failed on %s" % self.mounts[0])
g.log.info("IO is successful on all mounts")
# Get stat of all the files/dirs created.
ret = get_mounts_stat(self.mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
# Create another snapshot
ret, _, _ = snap_create(self.mnode, self.volname, self.snapshots[1])
self.assertEqual(
ret, 0, ("Failed to create snapshot for volume %s" % self.volname))
g.log.info("Snapshot %s created successfully for volume %s",
self.snapshots[1], self.volname)
# Check for number of snaps using snap_list it should be 2 now
snap_list = get_snap_list(self.mnode)
self.assertEqual(
2, len(snap_list), "No of snaps not consistent "
"for volume %s" % self.volname)
g.log.info("Successfully validated number of snapshots")
# Activate the second snapshot
ret, _, _ = snap_activate(self.mnode, self.snapshots[1])
self.assertEqual(
ret, 0, ("Failed to activate snapshot %s" % self.snapshots[1]))
g.log.info("Snapshot %s activated successfully", self.snapshots[1])
# Restore volume to the second snapshot
ret = snap_restore_complete(self.mnode, self.volname,
self.snapshots[1])
self.assertTrue(ret, ("Failed to restore snap %s on the "
"volume %s" % (self.snapshots[1], self.volname)))
g.log.info("Restore of volume is successful from %s on "
"volume %s", self.snapshots[1], self.volname)
# Verify all volume processes are online
ret = verify_all_process_of_volume_are_online(self.mnode, self.volname)
self.assertTrue(ret, "Failed: All volume processes are not online")
g.log.info("All volume processes are online")
ret = is_snapd_running(self.mnode, self.volname)
self.assertTrue(
ret, "Failed: snapd is not running for volume %s" % self.volname)
g.log.info("Successful: snapd is running")
# List activated snapshots under the .snaps directory
snap_dir_list = get_uss_list_snaps(self.mounts[0].client_system,
self.mounts[0].mountpoint)
self.assertIsNotNone(
snap_dir_list, "Failed to list snapshots under .snaps directory")
g.log.info("Successfully gathered list of snapshots under the .snaps"
" directory")
# Check for first snapshot as it should get listed here
self.assertIn(self.snapshots[0], snap_dir_list,
("Unexpected : %s not listed under .snaps "
"directory" % self.snapshots[0]))
g.log.info("Activated Snapshot %s listed Successfully",
self.snapshots[0])
# Check for second snapshot as it should not get listed here
self.assertNotIn(self.snapshots[1], snap_dir_list,
("Unexpected : %s listed in .snaps "
"directory" % self.snapshots[1]))
g.log.info("Restored Snapshot %s not listed ", self.snapshots[1])
def test_snap_uss(self):
# pylint: disable=too-many-statements
"""
Steps:
1. Create a volume and mount it.
2. Perform I/O on mounts
3. create a .snaps directory and create some files
4. Create Multiple snapshots of volume
5. Check info of volume
6. Enable USS for volume
7. Validate files created under .snaps
8. Disable USS
9. Again Validate the files created under .snaps directory
"""
# write files on all mounts
g.log.info("Starting IO on all mounts...")
g.log.info("mounts: %s", self.mounts)
all_mounts_procs = []
for mount_obj in self.mounts:
cmd = ("/usr/bin/env python %s create_files "
"-f 10 --base-file-name file %s" %
(self.script_upload_path, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
# Validate IO
self.assertTrue(validate_io_procs(all_mounts_procs, self.mounts),
"IO failed on some of the clients")
# starting I/O
g.log.info("Starting IO on all mounts...")
for mount_obj in self.mounts:
self.mpoint = "%s/.snaps" % mount_obj.mountpoint
ret = file_exists(mount_obj.client_system, self.mpoint)
if not ret:
ret = mkdir(mount_obj.client_system, self.mpoint)
self.assertTrue(ret, "Failed to create .snaps directory")
g.log.info("Successfully created .snaps directory")
break
else:
# Validate USS running
g.log.info("Validating USS enabled or disabled")
ret = is_uss_enabled(self.mnode, self.volname)
if not ret:
break
else:
g.log.info("USS is enabled in volume %s", self.volname)
ret, _, _ = disable_uss(self.mnode, self.volname)
self.assertEqual(
ret, 0, "Failed to disable USS on "
" volume %s" % self.volname)
g.log.info("USS disabled in Volume %s", self.volname)
ret = mkdir(mount_obj.client_system, self.mpoint)
self.assertTrue(ret, "Failed to create .snaps directory")
g.log.info("Successfully created .snaps directory")
cmd = ("/usr/bin/env python %s create_files "
"-f 10 --base-file-name foo %s" %
(self.script_upload_path, self.mpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
# List files under created .snaps directory
g.log.info("Starting to list files under .snaps directory")
for mount_obj in self.mounts:
ret, out, _ = uss_list_snaps(mount_obj.client_system,
mount_obj.mountpoint)
self.assertEqual(ret, 0, "Failed to list files under .snaps")
g.log.info("Successfully Created files under .snaps directory")
before_uss_enable = out.strip().split('\n')
# deleting the mount path from list
del before_uss_enable[0]
# Create Multiple snapshots for volume
g.log.info("Creating snapshots")
self.snaps_list = []
for snap_count in range(1, 5):
self.snap = "snap%s" % snap_count
ret, _, _ = snap_create(self.mnode, self.volname, self.snap)
self.assertEqual(
ret, 0, "Failed to create snapshot "
"%s for volume %s" % (self.snap, self.volname))
self.snaps_list.append(self.snap)
g.log.info("Snapshot %s created successfully for volume %s",
self.snap, self.volname)
g.log.info("Snapshot Creation Successful")
# Activate the snapshots
g.log.info("Activating snapshots")
for snap_count in range(1, 5):
self.snap = "snap%s" % snap_count
ret, _, _ = snap_activate(self.mnode, self.snap)
self.assertEqual(ret, 0,
("Failed to activate snapshot %s" % self.snap))
g.log.info("Snapshot snap%s activated successfully", self.snap)
# snapshot list
g.log.info("Starting to list snapshots")
ret, out, _ = snap_list(self.mnode)
self.assertEqual(ret, 0, "Failed to list snapshot")
snap_count = out.strip().split("\n")
self.assertEqual(len(snap_count), 4, "Failed to list all snaps")
g.log.info("Snapshot list Validated successfully")
# Enable USS
g.log.info("Enable USS on volume")
ret, _, _ = enable_uss(self.mnode, self.volname)
self.assertEqual(ret, 0, "Failed to enable USS on cloned volume")
g.log.info("Successfully enabled USS on Cloned volume")
# Validate USS running
g.log.info("Validating USS enabled or disabled")
ret = is_uss_enabled(self.mnode, self.volname)
self.assertTrue(ret, ("USS is disabled in volume %s" % self.volname))
g.log.info("USS enabled in Volume %s", self.volname)
# Validate snapshots under .snaps folder
self.validate_snaps()
# check snapshots are listed
g.log.info(".snaps Containing:")
for mount_obj in self.mounts:
ret, _, _ = uss_list_snaps(mount_obj.client_system,
mount_obj.mountpoint)
self.assertEqual(ret, 0, "Failed to list snapshot information")
g.log.info("Successfully Listed snapshots Created")
# Disable USS running
g.log.info("Disable USS on volume")
ret, _, _ = disable_uss(self.mnode, self.volname)
self.assertEqual(ret, 0, "Failed to disable USS on volume")
g.log.info("Successfully disabled USS on volume")
# check snapshots are listed
g.log.info(".snaps Containing:")
for mount_obj in self.mounts:
ret, out, _ = uss_list_snaps(mount_obj.client_system,
mount_obj.mountpoint)
self.assertEqual(ret, 0, "Failed to list snapshot information")
g.log.info("Successfully listed snapshots Created")
# Validate after disabling USS, all files should be same
g.log.info("Validate files after disabling uss")
after_uss_disable = out.strip().split('\n')
# deleting the mount path from list
del after_uss_disable[0]
for files in before_uss_enable:
self.assertIn(files, after_uss_disable,
"Files are Same under .snaps")
g.log.info("Validated files under .snaps directory")