def tearDown(self):
"""
tearDown for every test
"""
ret, _, _ = snap_delete_all(self.mnode)
if ret != 0:
raise ExecutionError("Snapshot Delete Failed")
ret, _, _ = set_snap_config(self.mnode, self.option_disable)
if ret != 0:
raise ExecutionError("Failed to execute set_snap_config")
ret = get_snap_config(self.mnode, self.volname)
if ret is None:
raise ExecutionError("Failed to execute get_snap_config")
if 'disable' not in ret['systemConfig']['activateOnCreate']:
raise ExecutionError("Failed to disable activate-on-create")
g.log.info("set_snap_config Success to disable "
"activate-on-create")
# Cleanup-volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed to Cleanup Volume")
g.log.info("Successful in Cleanup Volume")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""
tearDown for every test
"""
ret, _, _ = snap_delete_all(self.mnode)
self.assertEqual(ret, 0, "Snapshot Delete Failed")
ret, _, _ = set_snap_config(self.mnode, self.option_disable)
self.assertEqual(ret, 0, "Failed to execute set_snap_config")
ret = get_snap_config(self.mnode, self.volname)
if ret is None:
raise ExecutionError("Failed to execute get_snap_config")
if 'disable' not in ret['systemConfig']['activateOnCreate']:
raise ExecutionError("Failed to disable activate-on-create")
g.log.info("set_snap_config Success to disable " "activate-on-create")
# Calling GlusterBaseClass tearDown
GlusterBaseClass.tearDown.im_func(self)
def setUp(self):
"""
Initialize necessary variables.
"""
# Calling GlusterBaseClass setUp
self.get_super_method(self, 'setUp')()
# Gather the default snapshot config option values
self.snap_conf = get_snap_config(self.mnode)
self.assertIsNotNone(self.snap_conf,
"Failed to get the snapshot config options")
softlim = self.snap_conf['systemConfig']['softLimit']
self.def_conf_softlim = {'snap-max-soft-limit': softlim[:-1]}
autodel = self.snap_conf['systemConfig']['autoDelete']
self.def_conf_autodel = {'auto-delete': autodel}
g.log.info("Successfully gathered the default snapshot config options")
self.snapshots = [
('snap-test-snap-auto-delete-%s-%s' % (self.volname, i))
for i in range(0, 20)
]
def test_validate_snaps_restore(self):
# pylint: disable=too-many-statements
# Start IO on all mounts.
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 = ("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" %
(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 = count + 10
# Validate IO
g.log.info("Validating IO's")
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")
# Get stat of all the files/dirs created.
g.log.info("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")
# Setting some volume option related to snapshot
option_before_restore = {
'volumeConfig': [{
'softLimit': '100',
'effectiveHardLimit': '200',
'hardLimit': '256'
}],
'systemConfig': {
'softLimit': '90%',
'activateOnCreate': 'disable',
'hardLimit': '256',
'autoDelete': 'disable'
}
}
ret = set_snap_config(self.mnode, option_before_restore)
self.assertTrue(ret,
("Failed to set vol option on %s" % self.volname))
g.log.info("Volume options for%s is set successfully", self.volname)
# Get brick list before taking snap_restore
bricks_before_snap_restore = get_all_bricks(self.mnode, self.volname)
g.log.info("Brick List before snap restore "
"volume: %s", bricks_before_snap_restore)
# Creating snapshot
ret = snap_create(self.mnode, self.volname, "snap1")
self.assertTrue(ret,
("Failed to create snapshot for %s" % self.volname))
g.log.info("Snapshot snap1 created successfully for volume %s",
self.volname)
# Again start IO on all mounts.
all_mounts_procs = []
count = 1000
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 10 "
"--max-num-of-dirs 5 "
"--num-of-files 5 %s" %
(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 = count + 10
# Validate IO
g.log.info("Validating IO's")
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")
# Get stat of all the files/dirs created.
g.log.info("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")
# Reset volume to make sure volume options will reset
ret = volume_reset(self.mnode, self.volname, force=False)
self.assertTrue(ret, ("Failed to reset %s" % self.volname))
g.log.info("Reset Volume %s is Successful", self.volname)
# Removing one brick
g.log.info("Starting volume shrink")
ret = shrink_volume(self.mnode, self.volname, force=True)
self.assertTrue(ret, ("Failed to shrink the volume on "
"volume %s", self.volname))
g.log.info("Shrinking volume is successful on "
"volume %s", self.volname)
# Restore snapshot
ret = snap_restore_complete(self.mnode, self.volname, "snap1")
self.assertTrue(ret, ("Failed to restore snap snap1 on the "
"volume %s", self.volname))
g.log.info(
"Restore of volume is successful from snap1 on "
"volume %s", self.volname)
# Validate volume is up and running
g.log.info("Verifying volume is up and process are online")
ret = verify_all_process_of_volume_are_online(self.mnode, self.volname)
self.assertTrue(
ret, ("Volume %s : All process are not online", self.volname))
g.log.info("Volume %s : All process are online", self.volname)
# Get volume options post restore
option_after_restore = get_snap_config(self.mnode)
# Compare volume options
self.assertNotEqual(option_before_restore, option_after_restore,
"Volume Options are not same after snap restore")
# Get brick list post restore
bricks_after_snap_restore = get_all_bricks(self.mnode, self.volname)
g.log.info("Brick List after snap restore "
"volume: %s", bricks_after_snap_restore)
# Compare brick_list
self.assertNotEqual(bricks_before_snap_restore,
bricks_after_snap_restore,
"Bricks are not same after snap restore")
# Creating snapshot
ret = snap_create(self.mnode, self.volname, "snap2")
self.assertTrue(ret,
("Failed to create snapshot for %s" % self.volname))
g.log.info("Snapshot snap2 created successfully for volume %s",
self.volname)
# Again start IO on all mounts after restore
all_mounts_procs = []
count = 1000
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 10 "
"--max-num-of-dirs 5 "
"--num-of-files 5 %s" %
(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 = count + 10
# Validate IO
g.log.info("Validating IO's")
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")
# Get stat of all the files/dirs created.
g.log.info("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")
def test_snap_auto_delete(self):
"""
Verifying snapshot auto-delete config option
* Enable auto-delete snapshot
* Set snap-max-hard limit and snap-max-soft-limit
* Validate snap-max-hard-limit and snap-max-soft-limit
* Verify the limits by creating another 20 snapshots
* Oldest of newly created snapshots will be deleted
* Retaining the latest 8 (softlimit) snapshots
* Cleanup snapshots and volumes
"""
# pylint: disable=too-many-statements
# Enable auto-delete snapshot config option
ret, _, _ = set_snap_config(self.mnode, self.autodel_enable)
self.assertEqual(ret, 0, ("Failed to enable auto-delete snapshot "
"config option on volume %s", self.volname))
g.log.info("Successfully enabled snapshot auto-delete")
# Set snap-max-hard-limit snapshot config option for volume
max_hard_limit = {'snap-max-hard-limit': '10'}
ret, _, _ = set_snap_config(self.mnode, max_hard_limit, self.volname)
self.assertEqual(ret, 0, ("Failed to set snap-max-hard-limit"
"config option for volume %s", self.volname))
g.log.info(
"Successfully set snap-max-hard-limit config option for"
"volume %s", self.volname)
# Validate snap-max-hard-limit snapshot config option
hard_limit_val = get_snap_config(self.mnode)
self.assertEqual(hard_limit_val['volumeConfig'][0]['hardLimit'], '10',
("Failed to Validate snap-max-hard-limit"))
g.log.info("Successfully validated snap-max-hard-limit")
# Set snap-max-soft-limit snapshot config option
max_soft_limit = {'snap-max-soft-limit': '80'}
ret, _, _ = set_snap_config(self.mnode, max_soft_limit)
self.assertEqual(ret, 0, ("Failed to set snap-max-soft-limit"
"config option"))
g.log.info("Successfully set snap-max-soft-limit config option")
# Validate snap-max-soft-limit snapshot config option
soft_limit_val = get_snap_config(self.mnode)
self.assertEqual(soft_limit_val['volumeConfig'][0]['softLimit'], '8',
("Failed to Validate max-soft-limit"))
g.log.info("Successfully validated snap-max-soft-limit")
# Create 20 snapshots. As the count of snapshots crosses the
# soft-limit the oldest of newly created snapshot should
# be deleted and only the latest 8 snapshots must remain.
for snapname in self.snapshots:
ret, _, _ = snap_create(self.mnode,
self.volname,
snapname,
description="This is the Description wit#"
" ($p3c1al) ch@r@cters!")
self.assertEqual(ret, 0, ("Failed to create snapshot %s for "
"volume %s", snapname, self.volname))
g.log.info("Snapshot snap%s of volume %s created successfully",
snapname, self.volname)
# Perform snapshot list to get total number of snaps after auto-delete
# Validate the existence of the snapshots using the snapname
snaplist = get_snap_list(self.mnode)
self.assertEqual(len(snaplist), 8,
("Failed: The snapshot count is not as expected"))
for snapname in self.snapshots[-8:]:
self.assertIn(
snapname, snaplist, "Failed to validate snapshot "
"existence for the snapshot %s" % snapname)
g.log.info("Successful in validating the Snapshot count and existence "
"by snapname")
def test_auto_delete_snap(self):
"""
* enabling auto-delete snapshot
* Setting max-hard limit and max-soft-limit
* Validating max-hard-limit and max-soft-limit
* Verify the limits by creating another 20 snapshots
* Oldest of newly created snapshots will be deleted
* Retaining the latest 8(softlimit) snapshots
* cleanup snapshots and volumes
"""
# Setup volume
ret = self.setup_volume()
if not ret:
raise ExecutionError("Failed to setup volume %s" % self.volname)
g.log.info("Volume %s has been setup successfully" % self.volname)
# enabling auto-delete
cmd = "gluster snapshot config auto-delete enable"
ret = g.run(self.mnode, cmd)
self.assertTrue(ret, ("Failed to enable auto-delete snapshot config"
"option on volume % s" % self.volname))
g.log.info("Snapshot auto-delete Successfully enabled")
# setting max-hard-limit
option = {'snap-max-hard-limit': '10'}
ret = set_snap_config(self.mnode, option, self.volname)
self.assertTrue(ret, ("Failed to set snap-max-hardlimit"
"config option for volume %s" % self.volname))
g.log.info("snap-max-hardlimit config option Successfully set for"
"volume %s" % self.volname)
# Validating max-hard-limit
hardlimit = get_snap_config(self.mnode)
get_hardlimit = hardlimit['volumeConfig'][0]['hardLimit']
if get_hardlimit != '10':
self.assertTrue(ret, ("Failed to Validate max-hard-limit"))
g.log.info("Successfully validated max-hard-limit")
# setting max-soft-limit
option = {'snap-max-soft-limit': '80'}
ret = set_snap_config(self.mnode, option)
self.assertTrue(ret, ("Failed to set snap-max-soft-limit"
"config option"))
g.log.info("snap-max-soft-limit config option Successfully set")
# Validating max-soft-limit
softlimit = get_snap_config(self.mnode)
get_softlimit = softlimit['volumeConfig'][0]['softLimit']
if get_softlimit != '8':
self.assertTrue(ret, ("Failed to Validate max-soft-limit"))
g.log.info("Successfully validated max-soft-limit")
# creating 20 snapshots. As the count
# of snapshots crosses the
# soft-limit the oldest of newly created snapshot should
# be deleted only latest 8 snapshots
# should remain.
# creating 20 more snapshots
for snap_count in range(10, 30):
ret = snap_create(
self.mnode, self.volname, "snap%s" % snap_count, False,
"This is the Description with $p3c1al"
"characters!")
self.assertTrue(ret, ("Failed to create snapshot snap%s for volume"
"%s" % (snap_count, self.volname)))
g.log.info("Snapshot snap%s of volume %s created successfully")
# snapshot list to list total number of snaps after auto-delete
cmd = "gluster snapshot list | wc -l"
ret, out, _ = g.run(self.mnode, cmd)
self.assertEqual(
ret, 0, ("Failed to list snapshot of volume %s" % self.volname))
g.log.info("Total number of snapshots created after auto-delete"
"enabled is %s" % out)
if out != 8:
g.log.info("Failed to validate snapshots with expected"
"number of snapshots")
g.log.info("Snapshot Validation Successful")
g.log.info("Snapshot list command for volume %s was successful" %
self.volname)
def test_snap_delete(self):
# pylint: disable=too-many-statements
"""
Delete a snapshot of a volume
* Creating and deleting 10 snapshots
* deleting previously created 10 snapshots
* enabling auto-delete snapshot
* Setting max-hard limit and max-soft-limit
* Verify the limits by creating another 20 snapshots
* Oldest of newly created snapshots will be deleted
* Retaining the latest 8(softlimit) snapshots
* cleanup snapshots and volumes
"""
# creating 10 snapshots
g.log.info("Creating 10 snapshots")
for snap_count in range(0, 10):
ret, _, _ = snap_create(self.mnode, self.volname,
"snap%s" % snap_count, False,
"Description with $p3c1al characters!")
self.assertEqual(ret, 0, ("Failed to create snapshot"
"snap%s" % snap_count))
g.log.info("Snapshot snap%s of volume %s created"
"successfully.", snap_count, self.volname)
# snapshot list
g.log.info("Starting to list all snapshots")
ret, _, _ = snap_list(self.mnode)
self.assertEqual(ret, 0, ("Failed to list snapshot"
"of volume %s" % self.volname))
g.log.info("Snapshot list command for volume %s"
"was successful", self.volname)
# deleting all 10 snapshots from the volume
g.log.info("Starting to Delete 10 created snapshots")
ret, _, _ = snap_delete_by_volumename(self.mnode, self.volname)
self.assertEqual(ret, 0, ("Failed to delete"
"snapshot of volume %s" % self.volname))
g.log.info("Snapshots of volume %s deleted Successfully", self.volname)
# enabling auto-delete
g.log.info("Enabling auto-delete")
cmd = "gluster snapshot config auto-delete enable"
ret, _, _ = g.run(self.mnode, cmd)
self.assertEqual(ret, 0, ("Failed to enable auto-delete"
"snapshot config"
"option on volume % s" % self.volname))
g.log.info("Snapshot auto-delete Successfully enabled")
# setting max-hard-limit
g.log.info("Setting max-hard-limit")
option = {'snap-max-hard-limit': '10'}
ret, _, _ = set_snap_config(self.mnode, option, self.volname)
self.assertEqual(ret, 0, ("Failed to set snap-max-hardlimit"
"config option for"
"volume %s" % self.volname))
g.log.info(
"snap-max-hardlimit config option Successfully set for"
"volume %s", self.volname)
# Validating max-hard-limit
g.log.info("Validating max-hard-limit")
hardlimit = get_snap_config(self.mnode)
self.assertIsNotNone(hardlimit, "Failed to get snap config")
get_hardlimit = hardlimit['volumeConfig'][0]['hardLimit']
self.assertEqual(get_hardlimit, '10', ("Failed to Validate"
"max-hard-limit"))
g.log.info("Successfully validated max-hard-limit")
# setting max-soft-limit
g.log.info("Setting max-soft-limit")
option = {'snap-max-soft-limit': '80'}
ret, _, _ = set_snap_config(self.mnode, option)
self.assertEqual(ret, 0, ("Failed to set snap-max-soft-limit"
"config option"))
g.log.info("snap-max-soft-limit config option Successfully set")
# Validating max-soft-limit
g.log.info("Validating max-soft-limit")
softlimit = get_snap_config(self.mnode)
self.assertIsNotNone(softlimit, "Failed to get snap config")
get_softlimit = softlimit['volumeConfig'][0]['softLimit']
self.assertEqual(get_softlimit, '8', ("Failed to Validate"
"max-soft-limit"))
g.log.info("Successfully validated max-soft-limit")
# creating 20 more snapshots. As the count
# of snapshots crosses the
# soft-limit the oldest of newly created snapshot should
# be deleted only latest 8(softlimit) snapshots
# should remain
g.log.info("Starting to create 20 more snapshots")
for snap_count in range(10, 30):
ret, _, _ = snap_create(
self.mnode, self.volname, "snap%s" % snap_count, False,
"This is the Description with $p3c1al"
"characters!")
self.assertEqual(ret, 0, ("Failed to create snapshot snap%s"
"for volume"
"%s" % (snap_count, self.volname)))
g.log.info("Snapshot snap%s of volume"
"%s created successfully.", snap_count, self.volname)
# snapshot list to list total number of snaps after auto-delete
g.log.info("validate total no.of snapshots after auto-delete enable")
cmd = "gluster snapshot list | wc -l"
ret, out, _ = g.run(self.mnode, cmd)
tot = out.strip().split('\n')
self.assertEqual(
ret, 0, ("Failed to list snapshot of volume %s" % self.volname))
g.log.info(
"Total number of snapshots created after auto-delete"
"enabled is %s", tot[0])
self.assertEqual(tot[0], '8', ("Failed to validate snapshots with"
"expected number of snapshots "))
g.log.info("Successfully validated snapshots with expected"
"number of snapshots")
def test_activate_on_create(self):
# pylint: disable=too-many-branches, too-many-statements
"""
Verifying Snapshot activate on create
* Create a default snapshot
* Enable activate-on-create snapshot config option
* Create more snapshots
* Validate snapshot info after snapshot create. It should be in
started state.
* Validate snapshot status after snapshot create. It should be in
started state.
* Validate the default snapshot info and status. It should be in
stopped state
"""
# Create Default Snapshot
g.log.info("Starting to Create Snapshot one")
snap_default = "snap_%s" % self.volname
ret, _, _ = snap_create(self.mnode, self.volname, snap_default)
self.assertEqual(ret, 0, ("Snapshot Creation failed for %s",
snap_default))
g.log.info("Successfully created Snapshot %s of volume %s",
snap_default, self.volname)
# Enable activate_on_create snapshot
g.log.info("Enabling snapshot activate-on-create config option")
ret, _, _ = set_snap_config(self.mnode, self.option_enable)
self.assertEqual(ret, 0, "Failed to execute set_snap_config")
g.log.info("Validating the value of activate-on-create")
ret = get_snap_config(self.mnode, self.volname)
self.assertIsNotNone(ret, ("Failed to execute get_snap_config"))
self.assertIn('enable', (ret['systemConfig']['activateOnCreate']),
("Failed to validate activate-on-create value as "
"'enabled'"))
g.log.info("Successfully enabled activate-on-create")
# Create Snapshots after enabling activate-on-create
g.log.info("Starting to Create Snapshots")
for snap_count in range(1, 5):
snap_name = "snap_%s" % snap_count
ret, _, _ = snap_create(self.mnode, self.volname, snap_name)
self.assertEqual(ret, 0, ("Snapshot Creation failed for %s",
snap_name))
g.log.info("Successfully created Snapshot %s of volume %s",
snap_name, self.volname)
# Validate Snapshot Info After Snapshot Create
g.log.info("Validating 'snapshot info' after enabling "
"activate-on-create")
ret = get_snap_info_by_snapname(self.mnode, snap_name)
self.assertIsNotNone(ret, ("Failed to Fetch Snapshot info after "
"activation for %s", snap_name))
g.log.info("Snapshot info Success for %s",
ret['snapVolume']['status'])
self.assertEqual(ret['snapVolume']['status'], 'Started',
("Activated Snapshot is in Stopped State %s",
(ret['snapVolume']['status'])))
g.log.info("Snapshot %s is Activated By Default - %s state",
snap_name, (ret['snapVolume']['status']))
# Validate Snaphot Status After Snapshot Create
g.log.info("Validating 'snapshot status' after enabling "
"activate-on-create")
ret = get_snap_status_by_snapname(self.mnode, snap_name)
self.assertIsNotNone("Failed to Fetch Snapshot status for %s",
snap_name)
g.log.info("Snapshot Status Success for %s", snap_name)
for brick in ret['volume']['brick']:
self.assertNotEqual(brick['pid'], 'N/A',
("Brick Path %s Not Available for "
"Activated Snapshot %s",
(brick['path'], snap_name)))
g.log.info("Success: Snapshot Brick Path Available")
# Validate Snapshot Info for the 'default' snapshot
# Expected to be Stopped
g.log.info("Validating 'snapshot info' of the 'default' snapshot")
ret = get_snap_info_by_snapname(self.mnode, snap_default)
self.assertIsNotNone(ret, ("Failed to Fetch Snapshot info for %s",
snap_default))
g.log.info("Snapshot info Success for %s", ret['snapVolume']['status'])
self.assertEqual(ret['snapVolume']['status'], 'Stopped',
("Snapshot Status is not in Stopped State"))
g.log.info("Snapshot %s is in Stopped state as it "
"is not Activated", snap_default)
# Validate Snapshot Status for the 'default' snapshot
# Expected to be N/A
g.log.info("Validating 'snapshot status' of the 'default' snapshot")
ret = get_snap_status_by_snapname(self.mnode, snap_default)
self.assertIsNotNone(ret, ("Failed to Fetch Snapshot status for %s",
snap_default))
g.log.info("Snapshot Status Success for %s", snap_default)
for brick in ret['volume']['brick']:
self.assertEqual(brick['pid'], 'N/A',
("Brick Pid available for %s", brick['path']))
g.log.info("Success: Snapshot %s Brick PID is 'N/A'", snap_default)
def test_activate_on_create(self):
# pylint: disable=too-many-branches
"""
Verifying Snapshot activate on create
"""
# Create Default Snapshot
g.log.info("Starting to Create Snapshot one")
snap_default = "snap_%s" % self.volname
ret, _, _ = snap_create(self.mnode, self.volname, snap_default)
self.assertEqual(ret, 0, "Snapshot Creation failed"
" for %s" % snap_default)
g.log.info("Snapshot %s of volume %s created"
" successfully", snap_default, self.volname)
# Enable activate_on_create snapshot
ret, _, _ = set_snap_config(self.mnode, self.option_enable)
self.assertEqual(ret, 0, "Failed to execute set_snap_config")
ret = get_snap_config(self.mnode, self.volname)
if ret is None:
raise ExecutionError("Failed to execute get_snap_config")
if 'enable' not in ret['systemConfig']['activateOnCreate']:
raise ExecutionError("Failed to enable activate-on-create")
g.log.info("set_snap_config Success to enable " "activate-on-create")
# Create Snapshot Snapshots
g.log.info("Starting to Create Snapshot two")
for snap_count in range(1, 5):
snap_name = "snap_%s" % snap_count
ret, _, _ = snap_create(self.mnode, self.volname, snap_name)
self.assertEqual(ret, 0, "Snapshot Creation failed"
" for %s" % snap_name)
g.log.info("Snapshot %s of volume %s created"
" successfully", snap_name, self.volname)
# Validate Snapshot Info After Snapshot Create
ret = get_snap_info_by_snapname(self.mnode, snap_name)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"info after activate "
"for %s" % snap_name)
g.log.info("Snapshot info Success "
"for %s", ret['snapVolume']['status'])
if ret['snapVolume']['status'] != 'Started':
raise ExecutionError("Activated Snapshot is in Stopped "
"State %s" %
(ret['snapVolume']['status']))
g.log.info("%s Activated By "
"Default- %s state", snap_name,
(ret['snapVolume']['status']))
# Validate Snaphot Status After Snapshot Create
ret = get_snap_status_by_snapname(self.mnode, snap_name)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"status for %s" % snap_name)
g.log.error("Snapshot Status Success for %s", snap_name)
for brick in ret['volume']['brick']:
if brick['pid'] == 'N/A':
raise ExecutionError("Brick Path %s Not Available "
"for Activated Snapshot %s" %
(brick['path'], snap_name))
g.log.info("snap_2 Snapshot Brick Path Available as Expected")
# Validate Deactivated Snapshot Info
# Expected to be Stopped
ret = get_snap_info_by_snapname(self.mnode, snap_default)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
" info for %s" % snap_default)
g.log.info("Snapshot info Success for %s", ret['snapVolume']['status'])
if ret['snapVolume']['status'] != 'Stopped':
raise ExecutionError("Snapshot Status is not in Stopped State")
g.log.info("Snapshot %s is in Stopped state as it "
"is not Activated", snap_default)
# Validate Deactivated Snapshot status
# Expected tobe NA
ret = get_snap_status_by_snapname(self.mnode, snap_default)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"status for %s" % snap_default)
g.log.info("Snapshot Status Success for %s", snap_default)
for brick in ret['volume']['brick']:
if brick['pid'] != 'N/A':
raise ExecutionError("Brick Pid available for %s" %
brick['path'])
g.log.info("Deactivated Snapshot Brick PID N/A as Expected")
