def setUp(self):
# SettingUp volume and Mounting the volume
GlusterBaseClass.setUp.im_func(self)
g.log.info("Starting to SetUp and Mount Volume")
ret = self.setup_volume_and_mount_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to setup volume %s" % self.volname)
g.log.info("Volume %s has been setup successfully", self.volname)
# Enable Shared storage
g.log.info("Starting to enable shared storage")
ret = enable_shared_storage(self.mnode)
if not ret:
raise ExecutionError("Unexpected: Failed to enable shared storage")
g.log.info("Successfully enabled shared storage as expected")
# Validate shared storage mounted
g.log.info("Starting to validate shared storage mounted")
ret = is_shared_volume_mounted(self.mnode)
if not ret:
raise ExecutionError("Failed to mount shared volume")
g.log.info("Successfully mounted shared volume")
# Validate shared storage is enabled
g.log.info("Starting to validate shared storage volume")
volinfo = get_volume_info(self.mnode, "gluster_shared_storage")
if ((volinfo['gluster_shared_storage']['options']
['cluster.enable-shared-storage']) != 'enable'):
raise ExecutionError("Unexpected: shared storage is disabled")
g.log.info("Shared storage enabled successfully as expected")
def tearDown(self):
# Disable snap scheduler
g.log.info("Starting to disable snapshot scheduler on all nodes")
ret, _, _ = scheduler_disable(self.mnode)
if ret != 0:
raise ExecutionError("Failed to disable snap scheduler "
"on all nodes")
g.log.info("Successfully disabled snapshot scheduler on all nodes")
# Check if shared storage is enabled
# Disable if true
g.log.info("Checking if shared storage is mounted")
ret = is_shared_volume_mounted(self.mnode)
if ret:
g.log.info("Disabling shared storage")
ret = disable_shared_storage(self.mnode)
if not ret:
raise ExecutionError("Failed to disable shared storage")
g.log.info("Successfully disabled shared storage")
# Unmount and cleanup-volume
g.log.info("Starting to Unmount and cleanup-volume")
ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to Unmount and Cleanup Volume")
g.log.info("Successful in Unmount Volume and Cleanup Volume")
def _is_shared_storage_mounted_on_the_nodes(self, brick_details, mounted):
"""
Checks if the shared storage is mounted on the nodes where it is
created.
"""
for node in brick_details:
ret = is_shared_volume_mounted(node.split(":")[0])
if mounted:
self.assertTrue(ret, ("Shared volume not mounted even after"
" enabling it"))
g.log.info("Shared volume mounted successfully")
else:
self.assertFalse(ret, ("Shared volume not unmounted even"
" after disabling it"))
g.log.info("Shared volume unmounted successfully")
def tearDown(self):
"""
tearDown for every test
"""
# disable snap scheduler
g.log.info("disabling snap scheduler")
ret, _, _ = scheduler_disable(self.mnode)
self.assertEqual(ret, 0, "Unexpected: Failed to disable "
"snapshot scheduler")
g.log.info("Successfully disabled snapshot scheduler")
# Check snapshot scheduler status
g.log.info("checking status of snapshot scheduler")
for server in self.servers:
count = 0
while count < 40:
ret, status, _ = scheduler_status(server)
status = status.strip().split(":")[2]
if not ret and status == ' Disabled':
break
sleep(2)
count += 1
self.assertEqual(ret, 0, "Failed to check status of scheduler"
" on node %s" % server)
g.log.info("Successfully checked scheduler status on %s nodes",
server)
# Check if shared storage is enabled
# Disable if true
g.log.info("Checking if shared storage is mounted")
ret = is_shared_volume_mounted(self.mnode)
if ret:
g.log.info("Disabling shared storage")
ret = disable_shared_storage(self.mnode)
if not ret:
raise ExecutionError("Failed to disable shared storage")
g.log.info("Successfully disabled shared storage")
# Unmount and cleanup-volume
g.log.info("Starting to cleanup-volume")
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed to Cleanup Volume %s" % self.volname)
g.log.info("Successful in Cleanup Volume")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def test_snap_scheduler_behaviour(self):
"""
Steps:
1. Create volumes
2. Enable shared storage
3. Validate shared storage mounted
4. Validate shared storage is enabled
5. Initialise snapshot scheduler on all node
6. Enable snapshot scheduler
7. Validate snapshot scheduler status
8. Disable snapshot scheduler
9. Validate snapshot scheduler status
"""
# Enable shared storage
g.log.info("Enable shared storage")
ret = enable_shared_storage(self.mnode)
self.assertTrue(ret, "Failed to enable shared storage")
g.log.info("Successfully enabled shared storage")
# Validate shared storage mounted
g.log.info("Starting to validate shared storage mounted")
for server in self.servers:
ret = is_shared_volume_mounted(server)
self.assertTrue(ret, "Failed to mount shared volume")
g.log.info("Successfully mounted shared volume")
# Validate shared storage is enabled
g.log.info("Starting to validate shared storage volume")
self.shared = "gluster_shared_storage"
volinfo = get_volume_info(self.mnode, self.shared)
self.assertEqual(
volinfo['gluster_shared_storage']['options']
['cluster.enable-shared-storage'], 'enable',
"shared storage is disabled")
g.log.info("Shared storage enabled successfully")
# Initialise snap scheduler
g.log.info("Initialising snapshot scheduler on all nodes")
ret = scheduler_init(self.servers)
self.assertTrue(ret, "Failed to initialize scheduler on all nodes")
g.log.info("Successfully initialized scheduler on all nodes")
# Enable snap scheduler
g.log.info("Starting to enable snapshot scheduler on all nodes")
ret, _, _ = scheduler_enable(self.mnode)
self.assertEqual(ret, 0, "Failed to enable scheduler on all servers")
g.log.info("Successfully enabled scheduler on all nodes")
# Check snapshot scheduler status
g.log.info("checking status of snapshot scheduler")
for server in self.servers:
count = 0
while count < 40:
ret, status, _ = scheduler_status(server)
if status.strip().split(":")[2] == ' Enabled':
break
time.sleep(2)
count += 2
self.assertEqual(status.strip().split(":")[2], ' Enabled',
"Failed to check status of scheduler")
g.log.info("Successfully checked scheduler status")
# Disable snap scheduler
g.log.info("Starting to disable snapshot scheduler on all nodes")
ret, _, _ = scheduler_disable(self.mnode)
self.assertEqual(
ret, 0, "Failed to disable scheduler on node"
" %s" % self.mnode)
g.log.info("Successfully disabled scheduler on all nodes")
# Check snapshot scheduler status
g.log.info("checking status of snapshot scheduler")
for server in self.servers:
count = 0
while count < 40:
ret, status, _ = scheduler_status(server)
if status.strip().split(":")[2] == ' Disabled':
break
time.sleep(2)
count += 2
self.assertEqual(status.strip().split(":")[2], ' Disabled',
"Failed to check status of scheduler")
g.log.info("Successfully checked scheduler status")
def test_snap_scheduler_status(self):
# pylint: disable=too-many-statements
"""
Steps:
1. create volumes
2. initialise snap scheduler without
enabling shared storage should fail
3. enable shared storage
4. initialise snap scheduler
5. check snapshot scheduler status
"""
# Validate shared storage is enabled
g.log.info("Starting to validate shared storage volume")
volinfo = get_volume_options(self.mnode,
self.volname,
option=("cluster.enable"
"-shared-storage"))
if volinfo["cluster.enable-shared-storage"] == "disable":
# Initialise snapshot scheduler
g.log.info("Initialising snapshot scheduler on all nodes")
ret = scheduler_init(self.servers)
self.assertFalse(
ret, "Unexpected: Successfully initialized "
"scheduler on all nodes")
g.log.info("As Expected, Failed to initialize scheduler on "
"all nodes")
self.assertEqual(volinfo["cluster.enable-shared-storage"], "disable",
"Unexpected: Shared storage "
"is enabled on cluster")
# Enable Shared storage
g.log.info("enabling shared storage")
ret = enable_shared_storage(self.mnode)
self.assertTrue(ret, "Failed to enable shared storage")
g.log.info("Successfully enabled shared storage")
# Validate shared storage mounted
g.log.info("validate shared storage mounted")
ret = is_shared_volume_mounted(self.mnode)
self.assertTrue(ret, "Failed to mount shared volume")
g.log.info("Successfully mounted shared volume")
# Validate shared storage volume is enabled
g.log.info("validate shared storage volume")
volinfo = get_volume_options(self.mnode,
self.volname,
option=("cluster.enable"
"-shared-storage"))
self.assertIsNotNone(volinfo, "Failed to validate volume option")
self.assertEqual(volinfo["cluster.enable-shared-storage"], "enable",
"Failed to enable shared storage volume")
g.log.info("Shared storage enabled successfully")
# Initialise snap scheduler
g.log.info("Initialising snapshot scheduler on all nodes")
count = 0
while count < 40:
ret = scheduler_init(self.servers)
if ret:
break
time.sleep(2)
count += 1
self.assertTrue(ret, "Failed to initialize scheduler on all nodes")
g.log.info("Successfully initialized scheduler on all nodes")
# Enable snap scheduler
g.log.info("Enabling snap scheduler")
ret, _, _ = scheduler_enable(self.mnode)
self.assertEqual(ret, 0,
"Failed to enable scheduler on %s node" % self.mnode)
g.log.info("Successfully enabled scheduler on %s node", self.mnode)
# Check snapshot scheduler status
g.log.info("checking status of snapshot scheduler")
for server in self.servers:
count = 0
while count < 40:
ret, status, _ = scheduler_status(server)
if ret == 0:
self.assertEqual(status.strip().split(":")[2], ' Enabled',
"Failed to check status of scheduler")
break
time.sleep(2)
count += 1
self.assertEqual(
ret, 0, "Failed to check status of scheduler"
" on nodes %s" % server)
g.log.info("Successfully checked scheduler status on %s nodes",
server)
# disable snap scheduler
g.log.info("disabling snap scheduler")
ret, _, _ = scheduler_disable(self.mnode)
self.assertEqual(ret, 0, "Unexpected: Failed to disable "
"snapshot scheduler")
g.log.info("Successfully disabled snapshot scheduler")
# disable shared storage
g.log.info("starting to disable shared storage")
ret = disable_shared_storage(self.mnode)
self.assertTrue(ret, "Failed to disable shared storage")
g.log.info("Successfully disabled shared storage")
# Validate shared volume unmounted
g.log.info("Validate shared volume unmounted")
ret = is_shared_volume_unmounted(self.mnode)
self.assertTrue(ret, "Failed to unmount shared storage")
g.log.info("Successfully unmounted shared storage")
def test_snap_scheduler_status(self):
# pylint: disable=too-many-statements
"""
Validating the snapshot scheduler behavior when shared storage
volume is mounted/not mounted.
* Initialise snap_scheduler without enabling shared storage
* Enable shared storage
* Initialise snap_scheduler on all nodes
* Check snap_scheduler status
"""
# Validate shared storage is disabled
g.log.info("Validating shared storage is disabled")
volinfo = get_volume_options(self.mnode, self.volname,
option=("cluster.enable-shared-storage"))
if volinfo["cluster.enable-shared-storage"] == "disable":
# Initialise snapshot scheduler
g.log.info("Initialising snapshot scheduler on all nodes")
ret = scheduler_init(self.servers)
self.assertFalse(ret, "Unexpected: Successfully initialized "
"scheduler on all nodes")
g.log.info("Expected: Failed to initialize snap_scheduler on "
"all nodes")
self.assertEqual(volinfo["cluster.enable-shared-storage"],
"disable", "Unexpected: Shared storage "
"is enabled on cluster")
# Enable shared storage
g.log.info("enabling shared storage")
ret = enable_shared_storage(self.mnode)
self.assertTrue(ret, "Failed to enable shared storage")
g.log.info("Successfully enabled shared storage")
# Validate shared storage volume is mounted
g.log.info("Validating if shared storage volume is mounted")
count = 0
while count < 5:
ret = is_shared_volume_mounted(self.mnode)
if ret:
break
sleep(2)
count += 1
self.assertTrue(ret, "Failed to validate if shared volume is mounted")
g.log.info("Successfully validated shared volume is mounted")
# Validate shared storage volume is enabled
g.log.info("Validate shared storage is enabled")
volinfo = get_volume_options(self.mnode, self.volname,
option=("cluster.enable-shared-storage"))
self.assertIsNotNone(volinfo, "Failed to validate volume option")
self.assertEqual(volinfo["cluster.enable-shared-storage"], "enable",
"Failed to validate if shared storage is enabled")
g.log.info("Successfully validated shared storage is enabled")
# Initialise snap_scheduler on all nodes
g.log.info("Initialising snapshot scheduler on all nodes")
count = 0
sleep(2)
while count < 40:
ret = scheduler_init(self.servers)
if ret:
break
sleep(2)
count += 1
self.assertTrue(ret, "Failed to initialize scheduler on all nodes")
g.log.info("Successfully initialized scheduler on all nodes")
# Enable snap_scheduler
g.log.info("Enabling snap_scheduler")
ret, _, _ = scheduler_enable(self.mnode)
self.assertEqual(ret, 0, "Failed to enable scheduler on %s node" %
self.mnode)
g.log.info("Successfully enabled scheduler on %s node", self.mnode)
# Check snapshot scheduler status
g.log.info("checking status of snapshot scheduler")
for server in self.servers:
count = 0
while count < 40:
ret, status, _ = scheduler_status(server)
status = status.strip().split(":")[2]
if ret == 0 and status == ' Enabled':
break
sleep(2)
count += 1
self.assertEqual(ret, 0, "Failed to check status of scheduler"
" on node %s" % server)
g.log.info("Successfully checked scheduler status on %s nodes",
server)
def test_shared_storage(self):
"""This test case includes:
-> Enable a shared storage
-> Disable a shared storage
-> Create volume of any type with
name gluster_shared_storage
-> Disable the shared storage
-> Check, volume created in step-3 is
not deleted
-> Delete the volume
-> Enable the shared storage
-> Check volume with name gluster_shared_storage
is created
-> Disable the shared storage
"""
# pylint: disable=too-many-statements, too-many-branches
# Enable a shared storage without specifying the domain
ret = enable_shared_storage(self.mnode)
self.assertTrue(ret, ("Failed to enable a shared storage"))
g.log.info("Successfully enabled: enable-shared-storage option")
# Check volume list to confirm gluster_shared_storage is created
ret = check_gluster_shared_volume(self.mnode)
self.assertTrue(ret, ("gluster_shared_storage volume not"
" created even after enabling it"))
g.log.info("gluster_shared_storage volume created" " successfully")
# Check the shared volume got mounted
ret = is_shared_volume_mounted(self.mnode)
self.assertTrue(ret, ("Shared volume not mounted even"
" after enabling it"))
g.log.info("Shared volume mounted successfully")
# Disable a shared storage without specifying the domain
ret = disable_shared_storage(self.mnode)
self.assertTrue(ret, ("Failed to disable a shared storage"))
g.log.info("Successfully disabled: disable-shared-storage")
# Check volume list to confirm gluster_shared_storage is deleted
ret = check_gluster_shared_volume(self.mnode, present=False)
self.assertTrue(ret, ("gluster_shared_storage volume not"
" deleted even after disabling it"))
g.log.info("gluster_shared_storage volume deleted" " successfully")
# Check the shared volume unmounted
ret = is_shared_volume_mounted(self.mnode)
self.assertFalse(ret, ("Shared volume not unmounted even"
" after disabling it"))
g.log.info("Shared volume unmounted successfully")
# Create a volume with name gluster_shared_storage
g.log.info("creation of volume should succeed")
volume = "gluster_shared_storage"
bricks_list = form_bricks_list(self.mnode, volume, 2, self.servers,
self.all_servers_info)
count = 0
while count < 20:
ret, _, _ = volume_create(self.mnode, volume, bricks_list, True)
if not ret:
break
sleep(2)
count += 1
self.assertEqual(ret, 0, "Failed to create volume")
g.log.info("Volume create is success")
# Disable the shared storage should fail
ret = disable_shared_storage(self.mnode)
self.assertFalse(ret, ("Unexpected: Successfully disabled"
" shared-storage"))
g.log.info("Volume set: failed as expected")
# Check volume list to confirm gluster_shared_storage
# is not deleted which was created before
vol_list = get_volume_list(self.mnode)
_rc = False
for vol in vol_list:
if vol == "gluster_shared_storage":
_rc = True
break
self.assertTrue(_rc, ("gluster_shared_storage volume got"
" deleted after disabling it"))
g.log.info("gluster_shared_storage volume not deleted as "
" expected after disabling enable-shared-storage")
# Delete the volume created
ret = volume_delete(self.mnode, volume)
self.assertTrue(ret, ("Failed to cleanup the Volume " "%s", volume))
g.log.info("Volume deleted successfully : %s", volume)
# Enable the shared storage
ret = enable_shared_storage(self.mnode)
self.assertTrue(ret, ("Failed to enable a shared storage"))
g.log.info("Successfully enabled: enable-shared-storage option")
# Check volume list to confirm gluster_shared_storage is created
ret = check_gluster_shared_volume(self.mnode)
self.assertTrue(ret, ("gluster_shared_storage volume not"
" created even after enabling it"))
g.log.info("gluster_shared_storage volume created" " successfully")
# Check the shared volume got mounted
ret = is_shared_volume_mounted(self.mnode)
self.assertTrue(ret, ("Shared volume not mounted even"
" after enabling it"))
g.log.info("Shared volume mounted successfully")
# Disable a shared storage
ret = disable_shared_storage(self.mnode)
self.assertTrue(ret, ("Failed to disable a shared storage"))
g.log.info("Successfully disabled: disable-shared-storage")
# Check volume list to confirm gluster_shared_storage is deleted
ret = check_gluster_shared_volume(self.mnode, present=False)
self.assertTrue(ret, ("gluster_shared_storage volume not"
" deleted even after disabling it"))
g.log.info("gluster_shared_storage volume deleted" " successfully")
# Check the shared volume unmounted
ret = is_shared_volume_mounted(self.mnode)
self.assertFalse(ret, ("Shared volume not unmounted even"
" after disabling it"))
g.log.info("Shared volume unmounted successfully")
