def tearDown(self):
"""If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
Unmount Volume and Cleanup Volume
"""
# Wait for IO to complete if io validation is not executed in the
# test method
if not self.io_validation_complete:
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
# List all files and dirs created
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
# 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")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
Unmount Volume and Cleanup Volume
"""
# Wait for IO to complete if io validation is not executed in the
# test method
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO on all mounts: Success")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories: Successful")
# 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("Unmount Volume and Cleanup Volume: Fail")
g.log.info("Unmount Volume and Cleanup Volume: Success")
# Calling GlusterBaseClass tearDown
GlusterBaseClass.tearDown.im_func(self)
def tearDown(self):
"""
If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
Cleanup and umount volume
"""
g.log.info("Starting to Unmount Volume and Cleanup Volume")
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# 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
GlusterBaseClass.tearDown.im_func(self)
def tearDown(self):
"""
If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status.
Cleanup and umount volume
"""
if not self.io_validation_complete:
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
if not list_all_files_and_dirs_mounts(self.mounts):
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
# Delete user
for mount_object in self.mounts:
for user in self.users:
if not del_user(mount_object.client_system, user):
raise ExecutionError("Failed to delete user: {}"
.format(user))
g.log.info("Successfully deleted all users")
# Cleanup and umount 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")
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""
If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
Unmount Volume and Cleanup Volume
"""
# Wait for IO to complete if io validation is not executed in the
# test method
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# 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 tearDown(self):
"""
If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
Cleanup and umount volume
"""
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
# 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 tearDown(self):
"""
tearDown for every test
"""
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
ret, _, _ = profile_stop(random.choice(self.servers), self.volname)
self.assertEqual(
ret, 0,
("Volume profile failed to stop for volume %s" % self.volname))
# unmounting the volume and Cleaning up the volume
ret = self.unmount_volume_and_cleanup_volume(self.mounts)
if ret:
g.log.info("Volume deleted successfully : %s", self.volname)
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""
tearDown for every test
"""
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
# unmounting the volume and Cleaning up the volume
ret = self.unmount_volume_and_cleanup_volume(self.mounts)
if ret:
g.log.info("Volume deleted successfully : %s", self.volname)
else:
raise ExecutionError("Failed Cleanup the Volume %s" % self.volname)
# Calling GlusterBaseClass tearDown
GlusterBaseClass.tearDown.im_func(self)
def setUp(self):
# Calling GlusterBaseClass setUp
GlusterBaseClass.setUp.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")
# Form brick list for expanding volume
self.add_brick_list = form_bricks_list_to_add_brick(
self.mnode,
self.volname,
self.servers,
self.all_servers_info,
distribute_count=1)
if not self.add_brick_list:
g.log.error("Volume %s: Failed to form bricks list for expand",
self.volname)
raise ExecutionError("Volume %s: Failed to form bricks list for"
"expand" % self.volname)
g.log.info("Volume %s: Formed bricks list for expand", self.volname)
# Start IO on mounts
g.log.info("Starting IO on all mounts...")
all_mounts_procs = []
for index, mount_obj in enumerate(self.mounts, start=1):
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 10 %s" %
(self.script_upload_path, index + 10, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
# Wait for IO to complete
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
def setUpClass(cls):
# Calling GlusterBaseClass setUpClass
GlusterBaseClass.setUpClass.im_func(cls)
# Setup Volume and Mount Volume
g.log.info("Starting to Setup Volume and Mount Volume")
ret = cls.setup_volume_and_mount_volume(mounts=cls.mounts)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
g.log.info("Successful in Setup Volume and Mount Volume")
# Upload io scripts for running IO on mounts
g.log.info("Upload io scripts to clients %s for running IO on "
"mounts", cls.clients)
script_local_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
cls.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
ret = upload_scripts(cls.clients, script_local_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)
# Start IO on mounts
g.log.info("Starting IO on all mounts...")
cls.all_mounts_procs = []
for index, mount_obj in enumerate(cls.mounts, start=1):
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 1 "
"--num-of-files 2 %s" % (cls.script_upload_path,
index + 10,
mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system, cmd,
user=mount_obj.user)
cls.all_mounts_procs.append(proc)
# Wait for IO to complete
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(cls.all_mounts_procs, cls.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(cls.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
def tearDown(self):
if self.proc:
ret = wait_for_io_to_complete([self.proc], [self.mounts[0]])
if not ret:
raise ExecutionError('Wait for IO completion failed on client')
if not self.unmount_volume_and_cleanup_volume(mounts=self.mounts):
raise ExecutionError('Not able to unmount and cleanup '
'{}'.format(self.volname))
self.get_super_method(self, 'tearDown')()
def tearDown(self):
if self.all_mounts_procs:
ret = wait_for_io_to_complete(self.all_mounts_procs,
[self.mounts[1]] *
len(self.all_mounts_procs))
if not ret:
raise ExecutionError('Wait for IO completion failed on some '
'of the clients')
ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts)
if not ret:
raise ExecutionError("Not able to unmount and cleanup volume")
self.get_super_method(self, 'tearDown')()
def tearDown(self):
if self.all_mounts_procs:
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if ret:
raise ExecutionError(
"Wait for IO completion failed on some of the clients")
# Unmount and cleanup the volume
if not self.unmount_volume_and_cleanup_volume(self.mounts):
raise ExecutionError("Unable to unmount and cleanup volume")
self.get_super_method(self, 'tearDown')()
def tearDown(self):
if self.is_io_running:
if not wait_for_io_to_complete(self.all_mounts_procs,
[self.mounts[0]]):
raise ExecutionError("IO failed on some of the clients")
if not self.unmount_volume_and_cleanup_volume([self.mounts[0]]):
raise ExecutionError("Failed to cleanup Volume")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# Wait for I/O to complete
if self.is_io_running:
if wait_for_io_to_complete(self.list_of_io_processes, self.mounts):
raise ExecutionError("Failed to wait for I/O to complete")
# Unmounting and cleaning volume
ret = self.unmount_volume_and_cleanup_volume(self.mounts)
if not ret:
raise ExecutionError("Unable to delete volume %s" % self.volname)
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# If I/O processes are running wait for it to complete
if self.is_io_running:
if not wait_for_io_to_complete(self.list_of_io_processes,
[self.mounts[0]]):
raise ExecutionError("Failed to wait for I/O to complete")
if not self.unmount_volume_and_cleanup_volume([self.mounts[0]]):
raise ExecutionError("Failed to Cleanup Volume")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
"""
# Wait for IO to complete if io validation is not executed in the
# test method
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
GlusterVolumeBaseClass.tearDown.im_func(self)
def tearDown(self):
# Wait if any IOs are pending from the test
if self.all_mounts_procs:
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if ret:
raise ExecutionError(
"Wait for IO completion failed on some of the clients")
# Unmount and cleanup the volume
if not self.unmount_volume_and_cleanup_volume(self.mounts):
raise ExecutionError("Unable to unmount and cleanup volume")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
if self.offline_bricks:
ret, _, _ = volume_start(self.mnode, self.volname, force=True)
if ret:
raise ExecutionError('Not able to force start volume to bring '
'offline bricks online')
if self.all_mount_procs:
ret = wait_for_io_to_complete(self.all_mount_procs, self.mounts)
if not ret:
raise ExecutionError('Wait for IO completion failed')
ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts)
if not ret:
raise ExecutionError('Failed to unmount and cleanup volume')
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""setUp starts the io from all the mounts.
IO creates deep dirs and files.
"""
# Wait for IO to complete if io validation is not executed in the
# test method
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
NfsGaneshaIOBaseClass.tearDown.im_func(self)
def tearDown(self):
# If cp is running then wait for it to complete
if self.cp_running:
if not wait_for_io_to_complete(self.io_proc, [self.mounts[0]]):
g.log.error("I/O failed to stop on clients")
ret, _, _ = g.run(self.first_client, "rm -rf /mnt/huge_file.txt")
if ret:
g.log.error("Failed to remove huge file from /mnt.")
# Unmounting and cleaning volume
ret = self.unmount_volume_and_cleanup_volume([self.mounts[0]])
if not ret:
raise ExecutionError("Unable to delete volume %s" % self.volname)
self.get_super_method(self, 'tearDown')()
def tearDown(self):
"""
If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
Cleanup and umount volume
"""
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
# umount all volumes
for mount_point in self.mount_points:
ret, _, _ = umount_volume(self.client, mount_point)
if ret:
raise ExecutionError("Failed to umount on volume %s " %
self.volname)
g.log.info("Successfully umounted %s on client %s", self.volname,
self.client)
ret = rmdir(self.client, mount_point)
if not ret:
raise ExecutionError(
"Failed to remove directory mount directory.")
g.log.info("Mount directory is removed successfully")
# stopping all volumes
volume_list = get_volume_list(self.mnode)
for volume in volume_list:
ret = cleanup_volume(self.mnode, volume)
if not ret:
raise ExecutionError("Failed to cleanup Volume %s" % volume)
g.log.info("Volume: %s cleanup is done", volume)
g.log.info("Successfully Cleanedup all Volumes")
# calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# Wait for IO to complete if io validation is not executed in the
# test method
if not self.io_validation_complete:
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# Stopping the 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):
# Calling GlusterBaseClass setUp
GlusterBaseClass.setUp.im_func(self)
# Start IO on mounts
g.log.info("Starting IO on all mounts...")
self.all_mounts_procs = []
for index, mount_obj in enumerate(self.mounts, start=1):
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 10 %s" %
(self.script_upload_path, index + 10, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
self.all_mounts_procs.append(proc)
# Wait for IO to complete
g.log.info("Wait for IO to complete")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
# DHT Layout validation
g.log.debug("Verifying hash layout values %s:%s", self.clients[0],
self.mounts[0].mountpoint)
ret = validate_files_in_dir(self.clients[0],
self.mounts[0].mountpoint,
test_type=LAYOUT_IS_COMPLETE,
file_type=FILETYPE_DIRS)
self.assertTrue(ret, "LAYOUT_IS_COMPLETE: FAILED")
g.log.info("LAYOUT_IS_COMPLETE: PASS")
def tearDown(self):
# Remove the temporary dir created for test
ret, _, _ = g.run(self.mounts[0].client_system, "rm -rf /mnt/tmp/")
if ret:
raise ExecutionError("Failed to remove /mnt/tmp create for test")
# If I/O processes are running wait for it to complete
if self.is_io_running:
if not wait_for_io_to_complete(self.list_of_io_processes,
[self.mounts[0]]):
raise ExecutionError("Failed to wait for I/O to complete")
if not self.unmount_volume_and_cleanup_volume([self.mounts[0]]):
raise ExecutionError("Failed to Cleanup Volume")
# Calling GlusterBaseClass tearDown
self.get_super_method(self, 'tearDown')()
def tearDown(self):
# If test method failed before validating IO, tearDown waits for the
# IO's to complete and checks for the IO exit status
if not self.io_validation_complete:
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# Cleanup and umount volume
ret = self.unmount_volume_and_cleanup_volume(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 tearDown(self):
# Disable brickmux on cluster
if not disable_brick_mux(self.mnode):
raise ExecutionError("Failed to disable brickmux on cluster")
# If I/O processes are running wait from them to complete
if self.is_io_running:
if not wait_for_io_to_complete(self.list_of_io_processes,
self.mounts):
raise ExecutionError("Failed to wait for I/O to complete")
# Unmounting and cleaning volume
ret = self.unmount_volume_and_cleanup_volume([self.mounts[0]])
if not ret:
raise ExecutionError("Unable to delete volume %s" % self.volname)
self.get_super_method(self, 'tearDown')()
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)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
g.log.info("Successful in Setup Volume and Mount Volume")
# Start IO on mounts
g.log.info("Starting IO on all mounts...")
all_mounts_procs = []
for index, mount_obj in enumerate(self.mounts, start=1):
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 15 "
"--max-num-of-dirs 5 "
"--num-of-files 5 %s" % (
self.script_upload_path,
index + 10, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system, cmd,
user=mount_obj.user)
all_mounts_procs.append(proc)
# Wait for IO to complete
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
def setUpClass(cls):
# Calling GlusterBaseClass setUpClass
cls.get_super_method(cls, 'setUpClass')()
# Setup Volume and Mount Volume
ret = cls.setup_volume_and_mount_volume(mounts=cls.mounts)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
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)
# Start IO on mounts
cls.all_mounts_procs = []
for index, mount_obj in enumerate(cls.mounts, start=1):
cmd = ("/usr/bin/env python %s create_deep_dirs_with_files "
"--dirname-start-num %d "
"--dir-depth 1 "
"--dir-length 5 "
"--max-num-of-dirs 10 "
"--num-of-files 60 %s" %
(cls.script_upload_path, index + 10, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
cls.all_mounts_procs.append(proc)
cls.io_validation_complete = False
# Wait for IO to complete
if not cls.io_validation_complete:
g.log.info("Wait for IO to complete")
ret = wait_for_io_to_complete(cls.all_mounts_procs, cls.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
ret = list_all_files_and_dirs_mounts(cls.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
def tearDown(self):
"""
If test method failed before validating IO, tearDown waits for the
IO's to complete and checks for the IO exit status
Cleanup and umount volume
"""
if not self.io_validation_complete:
g.log.info("Wait for IO to complete as IO validation did not "
"succeed in test method")
ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
if not ret:
raise ExecutionError("IO failed on some of the clients")
g.log.info("IO is successful on all mounts")
# List all files and dirs created
g.log.info("List all files and directories:")
ret = list_all_files_and_dirs_mounts(self.mounts)
if not ret:
raise ExecutionError("Failed to list all files and dirs")
g.log.info("Listing all files and directories is successful")
# Clear arbiter brick folders before replacing bricks.
if self.bricks_to_clean:
for brick in self.bricks_to_clean:
g.log.info('Clearing brick %s', brick)
node, brick_path = brick.split(':')
ret, _, err = g.run(node, 'rm -rf %s' % brick_path)
self.assertFalse(ret, err)
g.log.info('Clearing brick %s is successful', brick)
g.log.info('Clearing for all brick is successful')
# 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')()
