def setUp(self):
"""
Setup and mount volume or raise ExecutionError
"""
GlusterBaseClass.setUp.im_func(self)
# Setup Volume
ret = self.setup_volume_and_mount_volume(self.mounts)
if not ret:
g.log.error("Failed to Setup and Mount Volume")
raise ExecutionError("Failed to Setup and Mount Volume")
self.files = ('a.txt', 'b.txt', 'sub_folder/c.txt', 'sub_folder/d.txt')
def tearDownClass(cls):
"""
Clean up the volume and umount volume from client
"""
# stopping the volume
g.log.info("Starting to Unmount Volume and Cleanup Volume")
ret = cls.unmount_volume_and_cleanup_volume(mounts=cls.mounts)
if not ret:
raise ExecutionError("Failed to Unmount Volume and Cleanup Volume")
g.log.info("Successful in Unmount Volume and Cleanup Volume")
# calling GlusterBaseClass tearDownClass
GlusterBaseClass.tearDownClass.im_func(cls)
def setUpClass(cls):
"""
Create and start volume
"""
cls.get_super_method(cls, 'setUpClass')()
# Create and start volume
g.log.info("Starting volume setup process %s", cls.volname)
ret = cls.setup_volume()
if not ret:
raise ExecutionError("Failed to setup "
"and start volume %s" % cls.volname)
g.log.info("Successfully created and started the volume: %s",
cls.volname)
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)
g.log.info("Volume deleted successfully : %s", self.volname)
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def setUpClass(cls):
cls.get_super_method(cls, 'setUpClass')()
# Upload io scripts for running IO on mounts
g.log.info(
"Upload io scripts to clients %s for running IO on "
"mounts", cls.clients)
cls.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
ret = upload_scripts(cls.clients, cls.script_upload_path)
if not ret:
raise ExecutionError("Failed to upload IO scripts " "to clients ")
g.log.info("Successfully uploaded IO scripts to clients %s")
def setUp(self):
# Calling GlusterBaseClass setUp
self.get_super_method(self, 'setUp')()
# Setup Volume and Mount Volume
g.log.info("Starting to Setup Volume and Mount Volume")
ret = self.setup_volume_and_mount_volume(mounts=self.mounts,
volume_create_force=False)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
g.log.info("Successful in Setup Volume and Mount Volume")
self.bricks_list = get_all_bricks(self.mnode, self.volname)
def setUp(self):
"""
setUp method for every test
"""
# Creating Volume
ret = self.setup_volume_and_mount_volume(self.mounts)
if not ret:
raise ExecutionError("Volume creation or mount failed: %s" %
self.volname)
g.log.info("Volme created and mounted successfully : %s", self.volname)
# calling GlusterBaseClass setUp
GlusterBaseClass.setUp.im_func(self)
def setUpClass(cls):
# Calling GlusterBaseClass setUpClass
cls.get_super_method(cls, 'setUpClass')()
# Upload IO scripts for running IO on mounts
cls.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
ret = upload_scripts(cls.clients, [cls.script_upload_path])
if not ret:
raise ExecutionError("Failed to upload IO scripts to clients %s" %
cls.clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
cls.clients)
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')()
def setUpClass(cls):
"""
Create and start volume
"""
GlusterBaseClass.setUpClass.im_func(cls)
# Create and start volume
g.log.info("Starting volume setup process %s", cls.volname)
ret = cls.setup_volume()
if not ret:
raise ExecutionError("Failed to setup "
"and start volume %s" % cls.volname)
g.log.info("Successfully created and started the volume: %s",
cls.volname)
def setUpClass(cls):
"""
setup volume and initialize necessary variables which is used in tests
"""
# calling GlusterBaseClass setUpClass
cls.get_super_method(cls, 'setUpClass')()
# Setup Volume
ret = cls.setup_volume()
if not ret:
raise ExecutionError("Failed to Setup_Volume %s" % cls.volname)
g.log.info("Successful in Setup Volume %s", cls.volname)
cls.autodel_enable = {'auto-delete': 'enable'}
def setUp(self):
# Uploading file_dir script in all client direcotries
g.log.info(
"Upload io scripts to clients %s for running IO on "
"mounts", self.clients[0])
self.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
ret = upload_scripts(self.clients[0], self.script_upload_path)
if not ret:
raise ExecutionError("Failed to upload IO scripts to clients %s" %
self.clients[0])
g.log.info("Successfully uploaded IO scripts to clients %s",
self.clients[0])
# SettingUp volume and Mounting the volume
self.get_super_method(self, 'setUp')()
g.log.info("Starting to SetUp 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)
def setUpClass(cls):
"""
Setup and mount volume
"""
GlusterBaseClass.setUpClass.im_func(cls)
# Setup Volume and Mount Volume
g.log.info("Starting volume setup and mount %s",
cls.volname)
ret = cls.setup_volume_and_mount_volume(cls.mounts)
if not ret:
raise ExecutionError("Failed to Setup "
"and Mount_Volume %s" % cls.volname)
g.log.info("Successfully set and mounted the volume: %s", cls.volname)
def tearDown(self):
self.get_super_method(self, 'tearDown')()
# Unmount the volume
ret = umount_volume(mclient=self.mounts[0].client_system,
mpoint=self.mounts[0].mountpoint)
if not ret:
raise ExecutionError("Unable to umount the volume")
g.log.info("Unmounting of the volume %s succeeded", self.volname)
# The reason for volume reset is, metadata-cache is enabled
# by group, can't disable the group in glusterfs.
ret, _, _ = volume_reset(self.mnode, self.volname)
if ret:
raise ExecutionError("Unable to reset the volume {}".
format(self.volname))
g.log.info("Volume: %s reset successful ", self.volname)
# Cleanup the volume
if not self.cleanup_volume():
raise ExecutionError("Unable to perform volume clenaup")
g.log.info("Volume cleanup is successfull")
def setUp(self):
"""
- Setup Volume and Mount Volume
"""
# Calling GlusterBaseClass setUpClass
GlusterBaseClass.setUpClass.im_func(self)
# Setup Volume and Mount Volume
g.log.info("Starting to Setup Volume and Mount Volume")
ret = self.setup_volume_and_mount_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
g.log.info("Successful in Setup Volume and Mount Volume")
def setUp(self):
GlusterBaseClass.setUp.im_func(self)
g.log.info("Starting to Setup Volume %s", self.volname)
self.all_mounts_procs = []
self.io_validation_complete = False
# Setup Volume and Mount Volume
g.log.info("Starting to Setup Volume and Mount Volume")
ret = self.setup_volume_and_mount_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
g.log.info("Successful in Setup Volume and Mount Volume")
def setUpClass(cls):
"""
Setup nfs-ganesha if not exists.
Upload IO scripts to clients
"""
cls.get_super_method(cls, 'setUpClass')()
# Setup nfs-ganesha if not exists.
ret = cls.setup_nfs_ganesha()
if not ret:
raise ExecutionError("Failed to setup nfs-ganesha cluster")
g.log.info("nfs-ganesha cluster is healthy")
# Upload IO scripts for running IO on mounts
cls.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
ret = upload_scripts(cls.clients, cls.script_upload_path)
if not ret:
raise ExecutionError("Failed to upload IO scripts to clients %s" %
cls.clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
cls.clients)
def tearDown(self):
status_info = get_rebalance_status(self.mnode, self.volname)
status = status_info['aggregate']['statusStr']
if 'in progress' in status:
# Stop rebalance on the volume
g.log.info("Stop Rebalance on volume %s", self.volname)
ret, _, _ = rebalance_stop(self.mnode, self.volname)
if ret != 0:
raise ExecutionError("Volume %s: Rebalance stop failed" %
self.volname)
g.log.info("Volume %s: Rebalance stop success", self.volname)
# Unmount Volume and Cleanup Volume
g.log.info("Starting to Unmount Volume and Cleanup Volume")
ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to Unmount Volume and Cleanup Volume")
g.log.info("Successful in Unmount Volume and Cleanup Volume")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def setUp(self):
"""
setup volume, mount volume and initialize necessary variables
which is used in tests
"""
# calling GlusterBaseClass setUpClass
self.get_super_method(self, 'setUp')()
# Setup Volume and Mount Volume
g.log.info("Starting to Setup Volume and Mount Volume")
ret = self.setup_volume_and_mount_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
g.log.info("Successful in Setup Volume and Mount Volume")
# Verfiy glustershd process releases its parent process
g.log.info("Verifying Self Heal Daemon process is daemonized")
ret = is_shd_daemonized(self.servers)
if not ret:
raise ExecutionError("Self Heal Daemon process was still"
" holding parent process.")
g.log.info("Self Heal Daemon processes are online")
def setUpClass(cls):
"""
setup volume and initialize necessary variables
"""
cls.get_super_method(cls, 'setUpClass')()
g.log.info("Starting %s:", cls.__name__)
# Setup volume and mount
g.log.info("Starting to Setup Volume")
ret = cls.setup_volume()
if not ret:
raise ExecutionError("Failed to Setup_Volume")
g.log.info("Successful in Setup Volume")
def tearDown(self):
"""
Cleanup and umount volume
"""
# Cleanup and umount volume
g.log.info("Starting to Unmount Volume and Cleanup Volume")
ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to umount the vol & cleanup Volume")
g.log.info("Successful in umounting the volume and Cleanup")
# Calling GlusterBaseClass teardown
self.get_super_method(self, 'tearDown')()
def setUp(self):
self.get_super_method(self, 'setUp')()
# Setup Volume
if not self.setup_volume_and_mount_volume([self.mounts[0]]):
raise ExecutionError("Failed to Setup and mount volume")
self.first_client = self.mounts[0].client_system
self.second_vol_name = "second_volume"
self.second_mountpoint = "/mnt/{}".format(self.second_vol_name)
self.is_second_volume_created = False
def tearDownClass(cls):
"""
Clean up the volume & mount
"""
# stopping the volume and clean up the volume
g.log.info("Starting to Cleanup Volume")
ret = cls.unmount_volume_and_cleanup_volume(cls.mounts)
if not ret:
raise ExecutionError("Failed to Cleanup Volume and mount")
g.log.info("Successful in Cleanup Volume and mount")
# calling GlusterBaseClass tearDownClass
cls.get_super_method(cls, 'tearDownClass')()
def setUp(self):
self.get_super_method(self, 'setUp')()
self.num_of_dirs = 2
# For test_ec_quota_errors_on_limit only one client is needed
if 'on_limit' in self.id().split('.')[-1]:
self.num_of_dirs = 1
self.mounts = [self.mounts[0]]
ret = self.setup_volume_and_mount_volume(mounts=self.mounts)
self.all_mount_procs = []
self.offline_bricks = []
if not ret:
raise ExecutionError('Failed to setup and mount volume')
def setUpClass(cls):
"""
setup volume and mount volume
calling GlusterBaseClass setUpClass
"""
GlusterBaseClass.setUpClass.im_func(cls)
# Setup Volume and Mount Volume
g.log.info("Starting to Setup and Mount Volume %s", cls.volname)
ret = cls.setup_volume_and_mount_volume(mounts=cls.mounts)
if not ret:
raise ExecutionError("Failed to Setup_Volume "
"and Mount_Volume %s" % cls.volname)
g.log.info("Successful in Setup and Mount Volume %s", cls.volname)
def setUpClass(cls):
"""
setup volume and initialize necessary variables
"""
GlusterBaseClass.setUpClass.im_func(cls)
g.log.info("Starting %s:", cls.__name__)
# Setup volume and mount
g.log.info("Starting to Setup Volume")
ret = cls.setup_volume()
if not ret:
raise ExecutionError("Failed to Setup_Volume")
g.log.info("Successful in Setup Volume")
def setUp(self):
# Calling GlusterBaseClass setUp
self.get_super_method(self, 'setUp')()
self.all_mounts_procs = []
self.io_validation_complete = False
# Setup Volume and Mount Volume
g.log.info("Starting to Setup Volume and Mount Volume")
ret = self.setup_volume_and_mount_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
g.log.info("Successful in Setup Volume and Mount Volume")
def tearDownClass(cls):
"""
Clean up the volume & mount
"""
# stopping the volume and clean up the volume
g.log.info("Starting to Cleanup Volume")
ret = cls.cleanup_volume()
if not ret:
raise ExecutionError("Failed to Cleanup Volume and mount")
g.log.info("Successful in Cleanup Volume and mount")
# calling GlusterBaseClass tearDownClass
GlusterBaseClass.tearDownClass.im_func(cls)
def tearDown(self):
# Deleting all snapshot
g.log.info("Deleting all snapshots created")
ret, _, _ = snap_delete_all(self.mnode)
if ret != 0:
raise ExecutionError("Snapshot Delete Failed")
g.log.info("Successfully deleted all snapshots")
# Disable uss for volume
g.log.info("Disabling uss for volume")
ret, _, _ = disable_uss(self.mnode, self.volname)
if ret != 0:
raise ExecutionError("Failed to disable uss")
g.log.info("Successfully disabled uss for volume" "%s", self.volname)
# Unmount and cleanup original 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 umount and cleanup Volume")
g.log.info("Successful in umounting the volume and Cleanup")
def setUp(self):
"""
setUp method for every test
"""
# calling GlusterBaseClass setUp
GlusterBaseClass.setUp.im_func(self)
self.volume_list = []
# create a volume
ret = setup_volume(self.mnode, self.all_servers_info,
self.volume)
self.volume_list.append(self.volname)
if not ret:
raise ExecutionError("Volume creation failed: %s" % self.volname)
# Creating another volume
second_volume = "second_volume"
self.volume['name'] = second_volume
ret = setup_volume(self.mnode, self.all_servers_info,
self.volume)
self.volume_list.append(second_volume)
if not ret:
raise ExecutionError("Volume creation failed: %s" % second_volume)
