def setUpClass(cls):
# Calling GlusterBaseClass setUpClass
cls.get_super_method(cls, 'setUpClass')()
# Override Volume
if cls.volume_type == "replicated":
cls.volume['voltype'] = {
'type': 'replicated',
'replica_count': 2,
'transport': 'tcp'}
# 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 %s" % cls.clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
cls.clients)
# Setup Volume and Mount Volume
g.log.info("Starting to Setup Volume and Mount Volume")
ret = cls.setup_volume_and_mount_volume(cls.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 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)
# 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)
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
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 %s" %
cls.clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
cls.clients)
def setUpClass(cls):
"""
setup volume, mount volume and initialize necessary variables
which is used in tests
"""
# calling GlusterBaseClass setUpClass
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",
cls.clients)
# Overriding the volume type to specifically test the volume type
if cls.volume_type == "distributed":
cls.volume['voltype'] = {
'type': 'distributed',
'dist_count': 1,
'transport': 'tcp'}
# 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")
g.log.info("Successful in Setup and Mount Volume %s", cls.volname)
def setUp(self):
"""
Setup and mount volume or raise ExecutionError
"""
# Calling GlusterBaseClass setUp
self.get_super_method(self, 'setUp')()
self.all_mounts_procs, self.io_validation_complete = [], False
# Setup Volume
ret = self.setup_volume_and_mount_volume([self.mounts[0]])
if not ret:
raise ExecutionError("Failed to Setup and Mount Volume")
# Upload io scripts for running IO on mounts
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")
# 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=3)
if not self.add_brick_list:
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)
def setUpClass(cls):
"""Upload the necessary scripts to run tests.
"""
# 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)
cls.counter = 1
# Temporary code:
# Additional checks to gather infomartion from all
# servers for Bug 1810901 and setting log level to debug.
ret = set_volume_options(cls.mnode, 'all',
{'cluster.daemon-log-level': 'DEBUG'})
if not ret:
g.log.error('Failed to set cluster.daemon-log-level to DEBUG')
def setUpClass(cls):
# Calling GlusterBaseClass setUpClass
GlusterBaseClass.setUpClass.im_func(cls)
# Overriding the volume type to specifically test the volume type
# change from replicated to arbiter
if cls.volume_type == "replicated":
cls.volume['voltype'] = {
'type': 'replicated',
'replica_count': 2,
'dist_count': 1,
'transport': 'tcp'}
if cls.volume_type == "distributed-replicated":
cls.volume['voltype'] = {
'type': 'distributed-replicated',
'dist_count': 2,
'replica_count': 2,
'transport': 'tcp'}
# 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)
cls.counter = 1
def setUp(self):
GlusterBaseClass.setUp.im_func(self)
# check whether peers are in connected state
ret = self.validate_peers_are_connected()
if not ret:
raise ExecutionError("Peers are not in connected state")
# detach all the nodes
ret = peer_detach_servers(self.mnode, self.servers)
if not ret:
raise ExecutionError("Peer detach failed to all the servers from "
"the node.")
g.log.info("Peer detach SUCCESSFUL.")
# Uploading file_dir script in all client direcotries
g.log.info(
"Upload io scripts to clients %s for running IO on "
"mounts", self.clients)
script_local_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
self.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
ret = upload_scripts(self.clients, script_local_path)
if not ret:
raise ExecutionError("Failed to upload IO scripts to clients %s",
self.clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
self.clients)
def setUpClass(cls):
cls.get_super_method(cls, 'setUpClass')()
cls.script_path = '/usr/share/glustolibs/io/scripts'
for file_ops in ('file_dir_ops.py', 'fd_writes.py'):
ret = upload_scripts(cls.clients,
'{}/{}'.format(cls.script_path, file_ops))
if not ret:
raise ExecutionError('Failed to upload IO scripts to client')
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 setUpClass(cls):
# Calling GlusterBaseClass setUpClass
cls.get_super_method(cls, 'setUpClass')()
cls.script = "/usr/share/glustolibs/io/scripts/file_lock.py"
if not upload_scripts(cls.clients, [cls.script]):
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 test_add_bricks_io_mount_point(self):
# Mount volume
ret = self.mount_volume(self.mounts)
self.assertTrue(ret, 'Mount volume: FAIL')
g.log.info('Mounted Volume %s: Success', self.volname)
# Upload io scripts for running IO on mounts
g.log.info(
"Upload io scripts to clients %s for running IO on "
"mounts", self.clients)
script_location = "/usr/share/glustolibs/io/scripts/file_dir_ops.py"
ret = upload_scripts(self.clients, script_location)
if not ret:
clients = ", ".join(self.clients)
g.log.error("Failed to upload IO scripts to clients %s", clients)
raise ExecutionError("Failed to upload IO scripts to clients %s" %
clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
self.clients)
# Start IO on mounts
g.log.info("Starting IO on all mounts...")
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 2 "
"--max-num-of-dirs 2 "
"--num-of-files 10 %s" %
(script_location, index + 10, mount_obj.mountpoint))
proc = g.run_async(mount_obj.client_system,
cmd,
user=mount_obj.user)
# Expand volume
g.log.debug("Expanding volume %s", self.volname)
ret = expand_volume(mnode=self.mnode,
volname=self.volname,
servers=self.servers,
all_servers_info=self.all_servers_info)
self.assertTrue(ret, "Expand volume %s: Fail" % self.volname)
g.log.info("Volume %s expanded: Success", self.volname)
# Validate IO on current mount point
g.log.debug('Validating IO on mount point %s:%s',
mount_obj.client_system, mount_obj.mountpoint)
self.assertTrue(
validate_io_procs([proc],
[mount_obj]), 'IO Failed on client %s:%s' %
(mount_obj.client_system, mount_obj.mountpoint))
g.log.debug("Unmounting mount points")
self.assertTrue(self.unmount_volume(self.mounts),
'Unmount end points: Fail')
g.log.info("Unmount mount points: Success")
g.log.info('Add brick during IO operations successfully')
def setUpClass(cls):
cls.get_super_method(cls, 'setUpClass')()
if cls.volume_type == 'distributed-dispersed':
raise SkipTest('BZ #1707813 limits the functionality of fallocate')
if cls.volume_type == 'dispersed':
raise SkipTest('BZ #1339144 is being hit intermittently')
cls.script_path = '/usr/share/glustolibs/io/scripts/fd_writes.py'
ret = upload_scripts(cls.clients, cls.script_path)
if not ret:
raise ExecutionError('Failed to upload IO script to client')
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)
def setUpClass(cls):
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 setUpClass(cls):
GlusterBaseClass.setUpClass.im_func(cls)
# 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 ")
g.log.info("Successfully uploaded IO scripts to clients %s")
def setUpClass(cls):
NfsGaneshaVolumeBaseClass.setUpClass.im_func(cls)
# Upload io scripts for running IO on mounts
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")
cls.counter = 1
def setUpClass(cls):
cls.get_super_method(cls, 'setUpClass')()
cls.first_client = cls.mounts[0].client_system
cls.mountpoint = cls.mounts[0].mountpoint
cls.is_io_running = False
# Upload IO scripts for running IO on mounts
cls.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
if not file_exists(cls.first_client, cls.script_upload_path):
if not upload_scripts(cls.first_client, cls.script_upload_path):
raise ExecutionError(
"Failed to upload IO scripts to client %s" %
cls.first_client)
def setUpClass(cls):
"""Setup Volume, Create Mounts and upload the necessary scripts to run
tests.
"""
# Sets up volume, mounts
GlusterVolumeBaseClass.setUpClass.im_func(cls)
# Upload io scripts for running IO on mounts
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")
def setUpClass(cls):
# Calling GlusterBaseClass setUpClass
cls.get_super_method(cls, 'setUpClass')()
# Check for availability of atleast 4 clients
if len(cls.clients) < 4:
raise SkipTest("This test requires atleast 4 clients")
# 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)
def setUpClass(cls):
# Calling GlusterBaseClass setUpClass
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 %s" %
cls.clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
cls.clients)
def setUpClass(cls):
"""
Upload the necessary scripts to run tests.
"""
# calling GlusterBaseClass setUpClass
GlusterBaseClass.setUpClass.im_func(cls)
# 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_abs_path = "/usr/share/glustolibs/io/scripts/file_dir_ops.py"
cls.script_upload_path = script_abs_path
ret = upload_scripts(cls.clients, script_abs_path)
if not ret:
raise ExecutionError("Failed to upload IO scripts to clients")
def setUpClass(cls):
"""
Upload the necessary scripts to run tests.
"""
# calling GlusterBaseClass setUpClass
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")
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)
# Setup Volume and Mount Volume
ret = cls.setup_volume_and_mount_volume(cls.mounts, True)
if not ret:
raise ExecutionError("Failed to Setup_Volume and Mount_Volume")
def calculate_hash(host, filename):
""" Function to import DHT Hash library.
Args:
filename (str): the name of the file
Returns:
An integer representation of the hash
TODO: For testcases specifically testing hashing routine
consider using a baseline external Davies-Meyer hash_value.c
Creating comparison hash from same library we are testing
may not be best practice here. (Holloway)
"""
try:
# Check if libglusterfs.so.0 is available locally
glusterfs = ctypes.cdll.LoadLibrary("libglusterfs.so.0")
g.log.debug("Library libglusterfs.so.0 loaded locally")
computed_hash = (
ctypes.c_uint32(glusterfs.gf_dm_hashfn(filename,
len(filename))))
hash_value = int(computed_hash.value)
except OSError:
script_path = ("/usr/share/glustolibs/scripts/"
"compute_hash.py")
if not file_exists(host, script_path):
if upload_scripts(host, script_path,
'/usr/share/glustolibs/scripts/'):
g.log.info("Successfully uploaded script "
"compute_hash.py!")
else:
g.log.error('Unable to upload the script to node {0}'
.format(host))
return 0
else:
g.log.info("compute_hash.py already present!")
cmd = ("/usr/bin/env python {0} {1}".format(script_path,
filename))
ret, out, _ = g.run(host, cmd)
if ret:
g.log.error('Unable to run the script on node {0}'
.format(host))
return 0
hash_value = int(out.split('\n')[0])
return hash_value
def setUpClass(cls):
cls.get_super_method(cls, 'setUpClass')()
# Check for availability of atleast 4 clients
if len(cls.clients) < 4:
raise SkipTest("This test requires atleast 4 clients")
# 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 {}".format(
cls.clients))
# Install time package on all clients needed for measurement of ls
ret = yum_install_packages(cls.clients, 'time')
if not ret:
raise ExecutionError("Failed to install TIME package on all nodes")
def setUpClass(cls):
cls.get_super_method(cls, 'setUpClass')()
# Check for the default dist_count value and override it if required
if cls.default_volume_type_config['distributed']['dist_count'] <= 2:
cls.default_volume_type_config['distributed']['dist_count'] = 4
else:
cls.default_volume_type_config[cls.voltype]['dist_count'] = 3
# 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 setUp(self):
# SettingUp volume and Mounting the volume
self.get_super_method(self, 'setUp')()
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)
# Upload io scripts for running IO on mounts
g.log.info(
"Upload io scripts to clients %s for running IO on "
"mounts", self.clients)
self.script_upload_path = ("/usr/share/glustolibs/io/scripts/"
"file_dir_ops.py")
ret = upload_scripts(self.clients, self.script_upload_path)
if not ret:
raise ExecutionError("Failed to upload IO scripts to clients")
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
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 %s" %
cls.clients)
g.log.info("Successfully uploaded IO scripts to clients %s",
cls.clients)
# Cloning posix test suite
cls.dir_name = "repo_dir"
link = "https://github.com/ffilz/ntfs-3g-pjd-fstest.git"
ret = git_clone_and_compile(cls.clients,
link,
cls.dir_name,
compile_option=False)
if not ret:
raise ExecutionError("Failed to clone test repo")
g.log.info("Successfully cloned test repo on client")
cmd = "cd /root/repo_dir; sed 's/ext3/glusterfs/g' tests/conf; make"
for client in cls.clients:
ret, _, _ = g.run(client, cmd)
if ret == 0:
g.log.info("Test repo successfully compiled on"
"client %s" % client)
else:
raise ExecutionError("Failed to compile test repo")
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")
