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_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_ec_uss_snapshot(self):
"""
- Start resource consumption tool
- Create directory dir1
- Create 5 directory and 5 files in dir of mountpoint
- Rename all files inside dir1 at mountpoint
- Create softlink and hardlink of files in dir1 of mountpoint
- Delete op for deleting all file in one of the dirs inside dir1
- Create tiny, small, medium and large file
- Create IO's
- Enable USS
- Create a Snapshot
- Activate Snapshot
- List snapshot and the contents inside snapshot
- Delete Snapshot
- Create Snapshot with same name
- Activate Snapshot
- List snapshot and the contents inside snapshot
- Validating IO's and waiting for it to complete
- Close connection and check file exist for memory log
"""
# pylint: disable=too-many-branches,too-many-statements,too-many-locals
# Starting resource consumption using top
log_file_mem_monitor = '/var/log/glusterfs/mem_usage.log'
cmd = ("for i in {1..20};do top -n 1 -b|egrep "
"'RES|gluster' & free -h 2>&1 >> %s ;"
"sleep 10;done" % (log_file_mem_monitor))
g.log.info(cmd)
cmd_list_procs = []
for server in self.servers:
proc = g.run_async(server, cmd)
cmd_list_procs.append(proc)
# Creating dir1
ret = mkdir(self.mounts[0].client_system,
"%s/dir1" % self.mounts[0].mountpoint)
self.assertTrue(ret, "Failed to create dir1")
g.log.info("Directory dir1 on %s created successfully", self.mounts[0])
# Create 5 dir and 5 files in each dir at mountpoint on dir1
start, end = 1, 5
for mount_obj in self.mounts:
# Number of dir and files to be created.
dir_range = ("%s..%s" % (str(start), str(end)))
file_range = ("%s..%s" % (str(start), str(end)))
# Create dir 1-5 at mountpoint.
ret = mkdir(mount_obj.client_system,
"%s/dir1/dir{%s}" % (mount_obj.mountpoint, dir_range))
self.assertTrue(ret, "Failed to create directory")
g.log.info("Directory created successfully")
# Create files inside each dir.
cmd = ('touch %s/dir1/dir{%s}/file{%s};' %
(mount_obj.mountpoint, dir_range, file_range))
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "File creation failed")
g.log.info("File created successfull")
# Increment counter so that at next client dir and files are made
# with diff offset. Like at next client dir will be named
# dir6, dir7...dir10. Same with files.
start += 5
end += 5
# Rename all files inside dir1 at mountpoint on dir1
cmd = ('cd %s/dir1/dir1/; '
'for FILENAME in *;'
'do mv $FILENAME Unix_$FILENAME;'
'done;' % self.mounts[0].mountpoint)
ret, _, _ = g.run(self.mounts[0].client_system, cmd)
self.assertEqual(ret, 0, "Failed to rename file on " "client")
g.log.info("Successfully renamed file on client")
# Truncate at any dir in mountpoint inside dir1
# start is an offset to be added to dirname to act on
# diff files at diff clients.
start = 1
for mount_obj in self.mounts:
cmd = ('cd %s/dir1/dir%s/; '
'for FILENAME in *;'
'do echo > $FILENAME;'
'done;' % (mount_obj.mountpoint, str(start)))
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "Truncate failed")
g.log.info("Truncate of files successfull")
# Create softlink and hardlink of files in mountpoint. Start is an
# offset to be added to dirname to act on diff files at diff clients.
start = 1
for mount_obj in self.mounts:
cmd = ('cd %s/dir1/dir%s; '
'for FILENAME in *; '
'do ln -s $FILENAME softlink_$FILENAME;'
'done;' % (mount_obj.mountpoint, str(start)))
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "Creating Softlinks have failed")
g.log.info("Softlink of files have been changed successfully")
cmd = ('cd %s/dir1/dir%s; '
'for FILENAME in *; '
'do ln $FILENAME hardlink_$FILENAME;'
'done;' % (mount_obj.mountpoint, str(start + 1)))
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "Creating Hardlinks have failed")
g.log.info("Hardlink of files have been changed successfully")
start += 5
# Create tiny, small, medium and large file
# at mountpoint. Offset to differ filenames
# at diff clients.
offset = 1
for mount_obj in self.mounts:
cmd = 'fallocate -l 100 tiny_file%s.txt' % str(offset)
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "Fallocate for tiny files failed")
g.log.info("Fallocate for tiny files successfully")
cmd = 'fallocate -l 20M small_file%s.txt' % str(offset)
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "Fallocate for small files failed")
g.log.info("Fallocate for small files successfully")
cmd = 'fallocate -l 200M medium_file%s.txt' % str(offset)
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "Fallocate for medium files failed")
g.log.info("Fallocate for medium files successfully")
cmd = 'fallocate -l 1G large_file%s.txt' % str(offset)
ret, _, _ = g.run(mount_obj.client_system, cmd)
self.assertFalse(ret, "Fallocate for large files failed")
g.log.info("Fallocate for large files successfully")
offset += 1
# Creating files on client side for dir1
# Write IO
all_mounts_procs, count = [], 1
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 10 "
"--max-num-of-dirs 5 "
"--num-of-files 5 %s/dir1" %
(self.script_upload_path, count, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
count += 10
# 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")
# Create Snapshot
ret, _, _ = snap_create(self.mnode,
self.volname,
"ec_snap",
timestamp=False)
self.assertEqual(ret, 0, "Failed to create snapshot ec_snap")
g.log.info("Snapshot ec_snap of volume %s created"
"successfully.", self.volname)
# Activate snapshot
ret, _, _ = snap_activate(self.mnode, "ec_snap")
self.assertEqual(ret, 0, "Failed to activate snapshot ec_snap")
g.log.info("Snapshot activated successfully")
# List contents inside snaphot and wait before listing
sleep(5)
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")
self.assertIn(
"ec_snap", out.split("\n"), "Failed to "
"validate ec_snap under .snaps directory")
g.log.info("Activated Snapshot listed Successfully")
# Delete Snapshot ec_snap
ret, _, _ = snap_delete(self.mnode, "ec_snap")
self.assertEqual(ret, 0, "Failed to delete snapshot")
g.log.info("Snapshot deleted Successfully")
# Creating snapshot with the same name
ret, _, _ = snap_create(self.mnode,
self.volname,
"ec_snap",
timestamp=False)
self.assertEqual(ret, 0, "Failed to create snapshot ec_snap")
g.log.info("Snapshot ec_snap of volume %s created"
"successfully.", self.volname)
# Activate snapshot ec_snap
ret, _, _ = snap_activate(self.mnode, "ec_snap")
self.assertEqual(ret, 0, "Failed to activate snapshot ec_snap")
g.log.info("Snapshot activated successfully")
# List contents inside ec_snap and wait before listing
sleep(5)
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")
self.assertIn(
"ec_snap", out.split('\n'), "Failed to "
"validate ec_snap under .snaps directory")
g.log.info("Activated Snapshot listed Successfully")
# Validating IO's and waiting to complete
ret = validate_io_procs(all_mounts_procs, self.mounts)
self.assertTrue(ret, "IO failed on some of the clients")
g.log.info("Successfully validated all io's")
# Close connection and check file exist for memory log
ret = file_exists(self.mnode, '/var/log/glusterfs/mem_usage.log')
self.assertTrue(ret, "Unexpected:Memory log file does " "not exist")
g.log.info("Memory log file exists")
for proc in cmd_list_procs:
ret, _, _ = proc.async_communicate()
self.assertEqual(ret, 0, "Memory logging failed")
g.log.info("Memory logging is successful")
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 check_snaps(self):
""" Check snapshots under .snaps folder """
ret, _, _ = uss_list_snaps(self.clients[0], self.mpoint)
self.assertEqual(ret, 0, "Unexpected: .snaps directory not found")
g.log.info("Expected: .snaps directory is present")
def test_snap_clone_snapd(self):
"""
Steps:
1. create a volume
2. Create a snapshots and activate
3. Clone the snapshot and mount it
4. Check for snapd daemon
5. enable uss and validate snapd
5. stop cloned volume
6. Validate snapd
7. start cloned volume
8. validate snapd
9. Create 5 more snapshot
10. Validate total number of
snapshots created.
11. Activate 5 snapshots
12. Enable USS
13. Validate snapd
14. kill snapd on all nodes
15. validate snapd running
16. force start clone volume
17. validate snaps inside .snaps directory
"""
# pylint: disable=too-many-statements, too-many-locals
# Starting I/O
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 I/O
ret = validate_io_procs(all_mounts_procs, self.mounts)
self.assertTrue(ret, "IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# Creating snapshot
ret, _, _ = snap_create(self.mnode, self.volname, self.snap)
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)
# Activating created snapshots
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
self.assertIsNotNone(
get_snap_list(self.mnode), "Failed to list snapshot")
g.log.info("Snapshot list command Successful")
# Creating and starting a Clone of snapshot:
ret, _, _ = snap_clone(self.mnode, self.snap, self.clone_vol1)
self.assertEqual(ret, 0, "Failed to clone %s" % self.clone_vol1)
g.log.info("Clone volume %s created successfully", self.clone_vol1)
# Start the clone volumes
ret, _, _ = volume_start(self.mnode, self.clone_vol1)
self.assertEqual(ret, 0, "Failed to start %s" % self.clone_vol1)
g.log.info("%s started successfully", self.clone_vol1)
# Form server list
brick_list = get_all_bricks(self.mnode, self.clone_vol1)
for bricks in brick_list:
self.server_lists.append(bricks.split(":")[0])
self.server_list = list(set(self.server_lists))
# Get volume info
vol_info = get_volume_info(self.mnode, self.clone_vol1)
self.assertIsNotNone(vol_info, "Failed to get vol info")
g.log.info("Successfully in getting vol info")
# Redefining mounts for cloned volume
self.mount_points, self.mounts_dict_list = [], []
for client in self.all_clients_info:
mount = {
'protocol': self.mount_type,
'server': self.mnode,
'volname': self.volname,
'client': self.all_clients_info[client],
'mountpoint': (path.join(
"%s" % self.mpoint)),
'options': ''
}
self.mounts_dict_list.append(mount)
self.mount1 = create_mount_objs(self.mounts_dict_list)
self.mount_points.append(self.mpoint)
g.log.info("Successfully made entry in self.mount1")
# FUSE mount clone1 volume
for mount_obj in self.mounts:
ret, _, _ = mount_volume(self.clone_vol1, self.mount_type,
self.mpoint,
self.mnode, mount_obj.client_system)
self.assertEqual(ret, 0, "Volume mount failed for clone1")
g.log.info("%s mounted Successfully", self.clone_vol1)
# Validate clone volume is mounted or not
ret = is_mounted(self.clone_vol1, self.mpoint, self.mnode,
mount_obj.client_system, self.mount_type)
self.assertTrue(ret, "Volume not mounted on mount point: "
"%s" % self.mpoint)
g.log.info("Volume %s mounted on %s", self.clone_vol1, self.mpoint)
# Log Cloned Volume information
ret = log_volume_info_and_status(self.mnode, self.clone_vol1)
self.assertTrue("Failed to Log Info and Status of Volume "
"%s" % self.clone_vol1)
g.log.info("Successfully Logged Info and Status")
# Validate snapd running on all nodes
self.validate_snapd(check_condition=False)
# Enable USS
ret, _, _ = enable_uss(self.mnode, self.clone_vol1)
self.assertEqual(ret, 0, "Failed to enable USS on cloned volume")
g.log.info("Successfully enabled USS on Cloned volume")
# Validate USS running
self.validate_uss()
# Validate snapd running on all nodes
self.validate_snapd()
# Stop cloned volume
ret, _, _ = volume_stop(self.mnode, self.clone_vol1)
self.assertEqual(ret, 0, "Failed to stop cloned volume "
"%s" % self.clone_vol1)
g.log.info("Successfully Stopped Cloned volume %s", self.clone_vol1)
# Validate snapd running on all nodes
self.validate_snapd(check_condition=False)
# Start cloned volume
ret, _, _ = volume_start(self.mnode, self.clone_vol1)
self.assertEqual(ret, 0, "Failed to start cloned volume"
" %s" % self.clone_vol1)
g.log.info("Successfully started cloned volume"
" %s", self.clone_vol1)
# Validate snapd running on all nodes
self.validate_snapd()
# Create 5 snapshots
self.snaps_list = [('test_snap_clone_snapd-snap%s'
% i)for i in range(0, 5)]
for snapname in self.snaps_list:
ret, _, _ = snap_create(self.mnode, self.clone_vol1,
snapname)
self.assertEqual(ret, 0, ("Failed to create snapshot for volume"
" %s" % self.clone_vol1))
g.log.info("Snapshot %s created successfully for volume "
"%s", snapname, self.clone_vol1)
# Validate USS running
self.validate_uss()
# Check snapshot under .snaps directory
self.check_snaps()
# Activate Snapshots
for snapname in self.snaps_list:
ret, _, _ = snap_activate(self.mnode, snapname)
self.assertEqual(ret, 0, ("Failed to activate snapshot %s"
% snapname))
g.log.info("Snapshot %s activated "
"successfully", snapname)
# Validate USS running
self.validate_uss()
# Validate snapshots under .snaps folder
self.validate_snaps()
# Kill snapd on node and validate snapd except management node
for server in self.servers[1:]:
ret, _, _ = terminate_snapd_on_node(server)
self.assertEqual(ret, 0, "Failed to Kill snapd on node %s"
% server)
g.log.info("snapd Killed Successfully on node %s", server)
# Check snapd running
ret = is_snapd_running(server, self.clone_vol1)
self.assertTrue(ret, "Unexpected: Snapd running on node: "
"%s" % server)
g.log.info("Expected: Snapd is not running on node:%s", server)
# Check snapshots under .snaps folder
g.log.info("Validating snapshots under .snaps")
ret, _, _ = uss_list_snaps(self.clients[0], self.mpoint)
self.assertEqual(ret, 0, "Target endpoint not connected")
g.log.info("Successfully listed snapshots under .snaps")
# Kill snapd in management node
ret, _, _ = terminate_snapd_on_node(self.servers[0])
self.assertEqual(ret, 0, "Failed to Kill snapd on node %s"
% self.servers[0])
g.log.info("snapd Killed Successfully on node %s", self.servers[0])
# Validate snapd running on all nodes
self.validate_snapd(check_condition=False)
# Validating snapshots under .snaps
ret, _, _ = uss_list_snaps(self.clients[0], self.mpoint)
self.assertNotEqual(ret, 0, "Unexpected: Successfully listed "
"snapshots under .snaps")
g.log.info("Expected: Target endpoint not connected")
# Start the Cloned volume(force start)
ret, _, _ = volume_start(self.mnode, self.clone_vol1, force=True)
self.assertEqual(ret, 0, "Failed to start cloned volume "
"%s" % self.clone_vol1)
g.log.info("Successfully Started Cloned volume %s", self.clone_vol1)
# Validate snapd running on all nodes
self.validate_snapd()
# Validate snapshots under .snaps folder
self.validate_snaps()
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")
