def add_extra_servers_to_cluster(mnode, extra_servers):
"""Adds the given extra servers to cluster
Args:
mnode (str): Node on which cmd has to be executed.
extra_servers (str|list) : A server|list of extra servers to be
attached to cluster
Returns:
bool: True, if extra servers are attached to cluster
False, otherwise
Example:
add_extra_servers_to_cluster("abc.com", ['peer_node1','peer_node2'])
"""
if not isinstance(extra_servers, list):
extra_servers = [extra_servers]
ret = start_glusterd(servers=extra_servers)
if not ret:
g.log.error("glusterd did not start in peer nodes")
return False
ret = peer_probe_servers(mnode, servers=extra_servers)
if not ret:
g.log.error("Unable to do peer probe on extra server machines")
return False
return True
def tearDown(self):
# start the volume, it should succeed
ret, _, _ = volume_start(self.mnode, self.volname)
self.assertEqual(ret, 0, "Volume stop failed")
# start glusterd on all servers
ret = start_glusterd(self.servers)
if not ret:
raise ExecutionError("Failed to start glusterd on all servers")
for server in self.servers:
ret = wait_for_peers_to_connect(server, self.servers)
if not ret:
ret = peer_probe_servers(server, self.servers)
if not ret:
raise ExecutionError("Failed to peer probe all "
"the servers")
# clean up all volumes
vol_list = get_volume_list(self.mnode)
if vol_list is None:
raise ExecutionError("Failed to get the volume list")
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Unable to delete volume % s" % volume)
g.log.info("Volume deleted successfully : %s", volume)
self.get_super_method(self, 'tearDown')()
def setUpClass(cls):
GlusterBaseClass.setUpClass.im_func(cls)
g.log.info("Starting %s " % cls.__name__)
'''
checking for peer status from every node, if peers are in not
connected state, performing peer probe.
'''
ret = cls.validate_peers_are_connected()
if not ret:
ret = peer_probe_servers(cls.mnode, cls.servers)
if ret:
g.log.info("peers are connected successfully from %s to other \
servers in severlist %s:" % (cls.mnode, cls.servers))
else:
g.log.error("Peer probe failed from %s to other \
servers in severlist %s:" % (cls.mnode, cls.servers))
raise ExecutionError("Peer probe failed ")
else:
g.log.info("All server peers are already in connected state\
%s:" % cls.servers)
# Creating Volume
g.log.info("Started creating volume")
ret = cls.setup_volume()
if ret:
g.log.info("Volme created successfully : %s" % cls.volname)
else:
raise ExecutionError("Volume creation failed: %s" % cls.volname)
def tearDown(self):
# start glusterd on all servers
ret = start_glusterd(self.servers)
if not ret:
raise ExecutionError("Failed to start glusterd on all servers")
for server in self.servers:
ret = is_peer_connected(server, self.servers)
if not ret:
ret = peer_probe_servers(server, self.servers)
if not ret:
raise ExecutionError("Failed to peer probe all "
"the servers")
# clean up all volumes
vol_list = get_volume_list(self.mnode)
if vol_list is None:
raise ExecutionError("Failed to get the volume list")
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Unable to delete volume % s" % volume)
g.log.info("Volume deleted successfully : %s" % volume)
GlusterBaseClass.tearDown.im_func(self)
def tearDown(self):
vol_list = get_volume_list(self.mnode)
if vol_list is None:
raise ExecutionError("Failed to get volume list")
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed Cleanup the volume")
g.log.info("Volume deleted successfully %s", volume)
# Setting quorum ratio to 51%
ret = set_volume_options(self.mnode, 'all',
{'cluster.server-quorum-ratio': '51%'})
if not ret:
raise ExecutionError("Failed to set server quorum ratio on %s" %
self.volname)
# Peer probe servers since we are doing peer detach in setUpClass
for server in self.servers:
ret = is_peer_connected(server, self.servers)
if not ret:
ret = peer_probe_servers(server, self.servers)
if not ret:
raise ExecutionError(
"Peer probe failed to one of the node")
g.log.info("Peer probe successful")
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# unmount the volume
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Volume unmount failed for %s" % self.volname)
# get volumes list and clean up all the volumes
vol_list = get_volume_list(self.mnode)
if vol_list is None:
raise ExecutionError("Error while getting vol list")
else:
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if ret is True:
g.log.info("Volume deleted successfully : %s", volume)
else:
raise ExecutionError("Failed Cleanup the"
" Volume %s" % volume)
# peer probe all the servers
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Peer probe failed to all the servers from "
"the node.")
GlusterBaseClass.tearDown.im_func(self)
def tearDown(self):
"""
tearDown for every test
"""
ret = is_glusterd_running(self.servers)
if ret:
ret = start_glusterd(self.servers)
if not ret:
raise ExecutionError("Failed to start glusterd on %s" %
self.servers)
# Takes 5 seconds to restart glusterd into peer connected state
sleep(5)
g.log.info("Glusterd started successfully on %s", self.servers)
# checking for peer status from every node
ret = is_peer_connected(self.mnode, self.servers)
if not ret:
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to peer probe failed in "
"servers %s" % self.servers)
# stopping the volume and Cleaning up the volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed Cleanup the Volume %s" % self.volname)
g.log.info("Volume deleted successfully : %s", self.volname)
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def setUp(self):
"""
"""
GlusterBaseClass.setUp.im_func(self)
# Peer probe servers
g.log.info("Peer Probe servers '%s'", self.servers)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError(
"Failed to peer probe some or all servers %s "
"into the cluster", self.servers)
g.log.info("Successfully peer probed all servers '%s' to the cluster",
self.servers)
# Validate if peers are connected from each server
g.log.info(
"Validating if servers %s are connected from other servers "
"in the cluster", self.servers)
for server in self.servers:
ret = is_peer_connected(server, self.servers)
if not ret:
raise ExecutionError(
"Some or all servers %s are not "
"in connected state from node %s", self.servers,
self.mnode)
g.log.info(
"Successfully validated servers %s are all "
"in connected state from node %s", self.servers, self.mnode)
g.log.info(
"Successfully validated all servers %s are in connected "
"state from other servers in the cluster", self.servers)
def tearDown(self):
# Cleanup and umount volume
g.log.info("Starting to Unmount Volume %s", self.volname)
ret = umount_volume(self.mounts[0].client_system,
self.mounts[0].mountpoint,
mtype=self.mount_type)
self.assertTrue(ret, ("Failed to Unmount Volume %s" % self.volname))
g.log.info("Successfully Unmounted Volume %s", self.volname)
# Clean up all volumes and peer probe to form cluster
vol_list = get_volume_list(self.mnode)
if vol_list is not None:
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed to cleanup volume")
g.log.info("Volume deleted successfully : %s", volume)
g.log.info("Successful in umounting the volume and Cleanup")
# Peer probe detached servers
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
GlusterBaseClass.tearDown.im_func(self)
def tearDown(self):
# UnMount Volume
g.log.info("Starting to Unmount Volume %s", self.volname)
ret = umount_volume(self.mounts[0].client_system,
self.mounts[0].mountpoint,
mtype=self.mount_type)
self.assertTrue(ret, ("Failed to Unmount Volume %s" % self.volname))
g.log.info("Successfully Unmounted Volume %s", self.volname)
# Clean up all volumes and peer probe to form cluster
vol_list = get_volume_list(self.mnode)
if vol_list is not None:
for volume in vol_list:
# check all bricks are online
ret = wait_for_bricks_to_be_online(self.mnode, volume)
if not ret:
raise ExecutionError("Failed to bring bricks online"
"for volume %s" % volume)
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed to cleanup volume")
g.log.info("Volume deleted successfully : %s", volume)
# Peer probe detached servers
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe peer "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
self.get_super_method(self, 'tearDown')()
def test_volume_status_xml(self):
# create a two node cluster
ret = peer_probe_servers(self.servers[0], self.servers[1])
self.assertTrue(
ret,
"Peer probe failed to %s from %s" % (self.mnode, self.servers[1]))
# create a distributed volume with single node
number_of_bricks = 1
servers_info_from_single_node = {}
servers_info_from_single_node[self.servers[0]] = self.all_servers_info[
self.servers[0]]
bricks_list = form_bricks_list(self.mnode, self.volname,
number_of_bricks, self.servers[0],
servers_info_from_single_node)
ret, _, _ = volume_create(self.servers[0], self.volname, bricks_list)
self.assertEqual(ret, 0, "Volume creation failed")
g.log.info("Volume %s created successfully", self.volname)
# Get volume status
ret, _, err = volume_status(self.servers[1], self.volname)
self.assertNotEqual(ret, 0, ("Unexpected: volume status is success for"
" %s, even though volume is not started "
"yet" % self.volname))
self.assertIn("is not started", err, ("volume status exited with"
" incorrect error message"))
# Get volume status with --xml
vol_status = get_volume_status(self.servers[1], self.volname)
self.assertIsNone(vol_status, ("Unexpected: volume status --xml for %s"
" is success even though the volume is"
" not stared yet" % self.volname))
# start the volume
ret, _, _ = volume_start(self.servers[1], self.volname)
self.assertEqual(ret, 0, "Failed to start volume %s" % self.volname)
# Get volume status
ret, _, _ = volume_status(self.servers[1], self.volname)
self.assertEqual(ret, 0,
("Failed to get volume status for %s" % self.volname))
# Get volume status with --xml
vol_status = get_volume_status(self.servers[1], self.volname)
self.assertIsNotNone(vol_status,
("Failed to get volume "
"status --xml for %s" % self.volname))
# Verify there are no crashes while executing gluster volume status
status = True
glusterd_log = (self._get_test_specific_glusterd_log(
self.mnode).split("\n"))
for line in glusterd_log:
if ' E ' in glusterd_log:
status = False
g.log.info("Unexpected! Error found %s", line)
self.assertTrue(status, "Error found in glusterd logs")
def tearDown(self):
# Add the removed services in firewall
for service in ('glusterfs', 'rpc-bind'):
for option in ("", " --permanent"):
cmd = ("firewall-cmd --zone=public --add-service={}{}".format(
service, option))
ret, _, _ = g.run(self.node_to_probe, cmd)
if ret:
raise ExecutionError("Failed to add firewall service %s "
"on %s" %
(service, self.node_to_probe))
# Detach servers from cluster
pool = nodes_from_pool_list(self.mnode)
self.assertIsNotNone(pool, "Failed to get pool list")
for node in pool:
if not peer_detach(self.mnode, node):
raise ExecutionError("Failed to detach %s from %s" %
(node, self.mnode))
# Create a cluster
if not peer_probe_servers(self.mnode, self.servers):
raise ExecutionError("Failed to probe peer "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# stopping the volume and Cleaning up the volume
self.get_super_method(self, 'tearDown')()
ret = is_glusterd_running(self.servers)
if ret:
ret = start_glusterd(self.servers)
if not ret:
raise ExecutionError("Failed to start glusterd on %s" %
self.servers)
# Takes 5 seconds to restart glusterd into peer connected state
sleep(5)
g.log.info("Glusterd started successfully on %s", self.servers)
# checking for peer status from every node
ret = is_peer_connected(self.mnode, self.servers)
if not ret:
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to peer probe failed in "
"servers %s" % self.servers)
g.log.info("All peers are in connected state")
vol_list = get_volume_list(self.mnode)
if vol_list is None:
raise ExecutionError("Failed to get the volume list")
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed Cleanup the Volume")
g.log.info("Volume deleted successfully")
def tearDown(self):
# Peer probe detached servers
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
# clean up all volumes and detaches peers from cluster
vol_list = get_volume_list(self.mnode)
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed to Cleanup the "
"Volume %s" % volume)
g.log.info("Volume deleted successfully : %s", volume)
# Calling GlusterBaseClass tearDown
GlusterBaseClass.tearDown.im_func(self)
def scratch_cleanup(cls, error_or_failure_exists):
"""
This scratch_cleanup script will run only when the code
currently running goes into execution or assertion error.
Args:
error_or_failure_exists (bool): If set True will cleanup setup
atlast of testcase only if exectution or assertion error in
teststeps. False will skip this scratch cleanup step.
Returns (bool): True if setup cleanup is successful.
False otherwise.
"""
if error_or_failure_exists:
ret = stop_glusterd(cls.servers)
if not ret:
g.log.error("Failed to stop glusterd")
cmd_list = ("pkill pidof glusterd",
"rm /var/run/glusterd.socket")
for server in cls.servers:
for cmd in cmd_list:
ret, _, _ = g.run(server, cmd, "root")
if ret:
g.log.error("Failed to stop glusterd")
return False
for server in cls.servers:
cmd_list = ("rm -rf /var/lib/glusterd/vols/*",
"rm -rf /var/lib/glusterd/snaps/*",
"rm -rf /var/lib/glusterd/peers/*",
"rm -rf {}/*/*".format(
cls.all_servers_info[server]['brick_root']))
for cmd in cmd_list:
ret, _, _ = g.run(server, cmd, "root")
if ret:
g.log.error(
"failed to cleanup server {}".format(server))
return False
ret = restart_glusterd(cls.servers)
if not ret:
g.log.error("Failed to start glusterd")
return False
sleep(2)
ret = wait_for_glusterd_to_start(cls.servers)
if not ret:
g.log.error("Failed to bring glusterd up")
return False
ret = peer_probe_servers(cls.mnode, cls.servers)
if not ret:
g.log.error("Failed to peer probe servers")
return False
for client in cls.clients:
cmd_list = ("umount /mnt/*", "rm -rf /mnt/*")
for cmd in cmd_list:
ret = g.run(client, cmd, "root")
if ret:
g.log.error(
"failed to unmount/already unmounted {}".format(
client))
return True
def test_uuid_in_volume_info_xml(self):
# create a two node cluster
ret = peer_probe_servers(self.servers[0], self.servers[1])
self.assertTrue(
ret,
"Peer probe failed to %s from %s" % (self.mnode, self.servers[1]))
# create a 2x2 volume
servers_info_from_two_node_cluster = {}
for server in self.servers[0:2]:
servers_info_from_two_node_cluster[server] = self.all_servers_info[
server]
self.volume['servers'] = self.servers[0:2]
self.volume['voltype']['replica_count'] = 2
self.volume['voltype']['dist_count'] = 2
ret = setup_volume(self.mnode, servers_info_from_two_node_cluster,
self.volume)
self.assertTrue(ret, ("Failed to create"
"and start volume %s" % self.volname))
# probe a new node from cluster
ret = peer_probe_servers(self.mnode, self.servers[2])
self.assertTrue(
ret,
"Peer probe failed to %s from %s" % (self.mnode, self.servers[2]))
# check gluster vol info --xml from newly probed node
xml_output = get_volume_info(self.servers[2], self.volname)
self.assertIsNotNone(xml_output,
("Failed to get volume info --xml for"
"volume %s from newly probed node %s" %
(self.volname, self.servers[2])))
# volume info --xml should have non zero UUID for host and brick
uuid_with_zeros = '00000000-0000-0000-0000-000000000000'
len_of_uuid = len(uuid_with_zeros)
number_of_bricks = int(xml_output[self.volname]['brickCount'])
for i in range(number_of_bricks):
uuid = xml_output[self.volname]['bricks']['brick'][i]['hostUuid']
self.assertEqual(len(uuid), len_of_uuid, "Invalid uuid length")
self.assertNotEqual(uuid, uuid_with_zeros,
("Invalid uuid %s" % uuid))
def tearDown(self):
"""
tearDown for every test
"""
# Peer probe detached server
ret = peer_probe_servers(self.mnode, self.random_server)
if not ret:
raise ExecutionError(ret, "Failed to probe detached server")
g.log.info("peer probe is successful for %s", self.random_server)
# Calling GlusterBaseClass tearDown
GlusterBaseClass.tearDown.im_func(self)
def test_peer_probe_snapd_running(self):
'''
-> Create Volume
-> Create snap for that volume
-> Enable uss
-> Check snapd running or not
-> Probe a new node while snapd is running
'''
# Performing node detach, Here detached node considering as extra
# server
extra_node = self.servers[-1]
ret, _, _ = peer_detach(self.mnode, extra_node)
self.assertEqual(ret, 0, "Peer detach failed for %s" % extra_node)
g.log.info("Peer detach success for %s", extra_node)
# Removing detached node from 'self.servers' list, it's because of
# 'self.setup_volume' function checking peer status of 'self.servers'
# list before creating volume
self.servers.remove(extra_node)
# Creating volume
ret = self.setup_volume()
self.assertTrue(ret, "Failed Create volume %s" % self.volname)
g.log.info("Volume created successfully %s", self.volname)
# Adding node back into self.servers list
self.servers.append(extra_node)
# creating Snap
ret, _, _ = snap_create(self.mnode, self.volname, 'snap1')
self.assertEqual(ret, 0,
"Snap creation failed for volume %s" % self.volname)
g.log.info("Snap created successfully for volume %s", self.volname)
# Enabling Snapd(USS)
ret, _, _ = enable_uss(self.mnode, self.volname)
self.assertEqual(ret, 0,
"Failed to enable USS for volume %s" % self.volname)
g.log.info("USS Enabled successfully on volume %s", self.volname)
# Checking snapd running or not
ret = is_snapd_running(self.mnode, self.volname)
self.assertTrue(ret, "Snapd not running for volume %s" % self.volname)
g.log.info("snapd running for volume %s", self.volname)
# Probing new node
ret = peer_probe_servers(self.mnode, extra_node)
self.assertTrue(ret,
"Peer Probe failed for new server %s" % extra_node)
g.log.info("Peer Probe success for new server %s", extra_node)
def tearDown(self):
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to peer probe servers")
# stopping the volume and Cleaning up the volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed Cleanup the Volume %s" % self.volname)
g.log.info("Volume deleted successfully : %s", self.volname)
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def test_volume_status_xml(self):
# create a two node cluster
ret = peer_probe_servers(self.servers[0], self.servers[1])
self.assertTrue(
ret,
"Peer probe failed to %s from %s" % (self.mnode, self.servers[1]))
# create a distributed volume with single node
number_of_bricks = 1
servers_info_from_single_node = {}
servers_info_from_single_node[self.servers[0]] = self.all_servers_info[
self.servers[0]]
bricks_list = form_bricks_list(self.mnode, self.volname,
number_of_bricks, self.servers[0],
servers_info_from_single_node)
ret, _, _ = volume_create(self.servers[0], self.volname, bricks_list)
self.assertEqual(ret, 0, "Volume creation failed")
g.log.info("Volume %s created successfully", self.volname)
# Get volume status
ret, _, err = volume_status(self.servers[1], self.volname)
self.assertNotEqual(ret, 0, ("Unexpected: volume status is success for"
" %s, even though volume is not started "
"yet" % self.volname))
self.assertIn("is not started", err, ("volume status exited with"
" incorrect error message"))
# Get volume status with --xml
vol_status = get_volume_status(self.servers[1], self.volname)
self.assertIsNone(vol_status, ("Unexpected: volume status --xml for %s"
" is success even though the volume is"
" not stared yet" % self.volname))
# start the volume
ret, _, _ = volume_start(self.servers[1], self.volname)
self.assertEqual(ret, 0, "Failed to start volume %s" % self.volname)
# Get volume status
ret, _, _ = volume_status(self.servers[1], self.volname)
self.assertEqual(ret, 0,
("Failed to get volume status for %s" % self.volname))
# Get volume status with --xml
vol_status = get_volume_status(self.servers[1], self.volname)
self.assertIsNotNone(vol_status,
("Failed to get volume "
"status --xml for %s" % self.volname))
def tearDown(self):
"""
tearDown for every test
"""
# checking for peer status from every node
ret = is_peer_connected(self.mnode, self.servers)
if not ret:
ret = peer_probe_servers(self.mnode, self.random_server)
if not ret:
raise ExecutionError("Failed to peer probe failed in "
"servers %s" % self.random_server)
g.log.info("All peers are in connected state")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
# stopping the volume and Cleaning up the volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed to Cleanup the Volume %s" %
self.volname)
g.log.info("Volume deleted successfully : %s", self.volname)
# calling GlusterBaseClass tearDown
GlusterBaseClass.tearDown.im_func(self)
def tearDown(self):
"""Detach servers from cluster"""
pool = nodes_from_pool_list(self.mnode)
self.assertIsNotNone(pool, "Failed to get pool list")
for node in pool:
if not peer_detach(self.mnode, node):
raise ExecutionError("Failed to detach %s from %s" %
(node, self.mnode))
# Create a cluster
if not peer_probe_servers(self.mnode, self.servers):
raise ExecutionError("Failed to probe peer "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# Unmount and clean volume
if not self.unmount_volume_and_cleanup_volume([self.mounts[0]]):
raise ExecutionError("Failed to Cleanup Volume")
# Probe detached node in case it's still detached
if self.is_peer_detached:
if not peer_probe_servers(self.mnode, self.servers[5]):
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""
tearDown for every test
"""
if self.detach_peer:
ret = peer_probe_servers(self.mnode, self.servers[5])
if not ret:
raise ExecutionError("Peer probe failed for detached "
"server %s" % self.servers[5])
# stopping the volume and Cleaning up the volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed Cleanup the Volume %s" % self.volname)
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# stopping and cleaning up the volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed to Cleanup the Volume %s" %
self.volname)
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# stopping and cleaning up the volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed to Cleanup the Volume %s" %
self.volname)
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
GlusterBaseClass.tearDown.im_func(self)
def tearDown(self):
# Reset firewall services to the zone
if not self.firewall_added:
ret = self._add_firewall_services(self.servers[:2])
if not ret:
raise ExecutionError("Failed to add firewall services")
# Reload firewall services
ret = self._reload_firewall_service(self.servers[:2])
if not ret:
raise ExecutionError("Failed to reload firewall services")
# Cleanup the volumes and unmount it, if mounted
vol_list = get_volume_list(self.mnode)
if vol_list is not None:
for volume in vol_list:
ret = is_mounted(volume,
mpoint="/mnt/distribute-vol",
mserver=self.mnode,
mclient=self.servers[1],
mtype="glusterfs")
if ret:
ret, _, _ = umount_volume(mclient=self.servers[1],
mpoint="/mnt/distribute-vol")
if ret:
raise ExecutionError("Failed to unmount volume")
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed to cleanup volume")
g.log.info("Volume cleaned up successfully : %s", volume)
# Peer probe detached servers
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# UnMount Volume
g.log.info("Starting to Unmount Volume %s", self.volname)
ret = umount_volume(self.mounts[0].client_system,
self.mounts[0].mountpoint,
mtype=self.mount_type)
self.assertTrue(ret, ("Failed to Unmount Volume %s" % self.volname))
g.log.info("Successfully Unmounted Volume %s", self.volname)
# Clean up all volumes and peer probe to form cluster
vol_list = get_volume_list(self.mnode)
if vol_list is not None:
for volume in vol_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed to cleanup volume")
g.log.info("Volume deleted successfully : %s", volume)
# Peer probe detached servers
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached "
"servers %s" % self.servers)
g.log.info("Peer probe success for detached "
"servers %s", self.servers)
bricks = get_servers_bricks_dict(self.servers, self.all_servers_info)
# Checking brick dir and cleaning it.
for server in self.servers:
for brick in bricks[server]:
if get_dir_contents(server, brick):
cmd = "rm -rf " + brick + "/*"
ret, _, _ = g.run(server, cmd)
if ret:
raise ExecutionError("Failed to delete the brick "
"dirs of deleted volume.")
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""
tearDown for every test
"""
# stopping the volume and Cleaning up the volume
ret = self.cleanup_volume()
if not ret:
raise ExecutionError("Failed Cleanup the Volume %s" % self.volname)
# Checking peers are in connected state or not
ret = self.validate_peers_are_connected()
if not ret:
# Peer probe detached servers
pool = nodes_from_pool_list(self.mnode)
for node in pool:
peer_detach(self.mnode, node)
ret = peer_probe_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Failed to probe detached servers %s" %
self.servers)
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
