def setUp(self):
"""
Checking if the required packages are installed,
if not found packages will be installed.
"""
smm = SoftwareManager()
if not smm.check_installed("mdadm"):
self.log.info("Mdadm must be installed before continuing the test")
if SoftwareManager().install("mdadm") is False:
self.cancel("Unable to install mdadm")
disks = self.params.get('disks', default='').strip(" ")
if not disks:
self.cancel('No disks given')
required_disks = self.params.get('required_disks', default=1)
disks = disks.split()
raidlevel = str(self.params.get('raid', default='0'))
if len(disks) < required_disks:
self.cancel("Minimum %d disks required for %s" % (required_disks,
raidlevel))
spare_disks = self.params.get('spare_disks', default='').strip(" ")
if spare_disks:
spare_disks = spare_disks.split()
raid = self.params.get('raidname', default='/dev/md/mdsraid')
metadata = str(self.params.get('metadata', default='1.2'))
self.remove_add_disk = ''
if raidlevel not in ['0', 'linear']:
self.remove_add_disk = disks[-1]
self.sraid = softwareraid.SoftwareRaid(raid, raidlevel, disks,
metadata, spare_disks)
def create_raid(self, l_disk, l_raid_name):
"""
creates a softwareraid with given raid name on given disk
:param l_disk: disk name on which raid will be created
:l_raid_name: name of the softwareraid
:return: None
"""
self.log.info("creating softwareraid on {}".format(l_disk))
self.sw_raid = softwareraid.SoftwareRaid(l_raid_name, '0',
l_disk.split(), '1.2')
self.sw_raid.create()
def create_raid(self, l_disk, l_raid_name):
self.sraid = softwareraid.SoftwareRaid(l_raid_name, '0',
l_disk.split(), '1.2')
self.sraid.create()
def setUp(self):
"""
Build tiobench.
Source:
https://github.com/mkuoppal/tiobench.git
"""
self.fstype = self.params.get('fs', default='')
self.fs_create = False
lv_needed = self.params.get('lv', default=False)
self.lv_create = False
raid_needed = self.params.get('raid', default=False)
self.raid_create = False
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default="/mnt")
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
smm = SoftwareManager()
packages = ['gcc', 'mdadm']
if self.fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs is not supported with RHEL 7.4 onwards")
if distro.detect().name == 'Ubuntu':
packages.extend(['btrfs-tools'])
for package in packages:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("%s package required for this test." % package)
locations = ["https://github.com/mkuoppal/tiobench/archive/master.zip"]
tarball = self.fetch_asset("tiobench.zip", locations=locations)
archive.extract(tarball, self.teststmpdir)
os.chdir(os.path.join(self.teststmpdir, "tiobench-master"))
build.make(".")
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sw_raid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk is not None:
if self.disk:
self.pre_cleanup()
if raid_needed:
self.create_raid(self.disk, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if self.fstype:
self.create_fs(self.target, self.dir, self.fstype)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
else:
self.cancel("Please provide a valid disk name")
def setUp(self):
'''
To check and install dependencies for the test
'''
self.fs_create = False
lv_needed = self.params.get('lv', default=False)
self.lv_create = False
raid_needed = self.params.get('raid', default=False)
self.raid_create = False
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default='/mnt')
self.fstype = self.params.get('fs', default='ext4')
self.args = self.params.get('args', default='')
smm = SoftwareManager()
packages = ['gcc', 'make', 'automake', 'autoconf']
if raid_needed:
packages.append('mdadm')
for package in packages:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("%s is needed for the test to be run" % package)
if self.fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs is not supported with \
RHEL 7.4 onwards")
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sw_raid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk is not None:
self.pre_cleanup()
if self.disk in disk.get_disks():
if raid_needed:
self.create_raid(self.disk, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if self.fstype:
self.create_fs(self.target, self.dir, self.fstype)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
else:
self.cancel("please provide valid disk")
url = "https://github.com/linux-test-project/ltp/"
url += "archive/master.zip"
tarball = self.fetch_asset("ltp-master.zip",
locations=[url],
expire='7d')
archive.extract(tarball, self.teststmpdir)
ltp_dir = os.path.join(self.teststmpdir, "ltp-master")
os.chdir(ltp_dir)
build.make(ltp_dir, extra_args='autotools')
self.ltpbin_dir = os.path.join(ltp_dir, 'bin')
if not os.path.isdir(self.ltpbin_dir):
os.mkdir(self.ltpbin_dir)
process.system('./configure --prefix=%s' % self.ltpbin_dir,
ignore_status=True)
build.make(ltp_dir)
build.make(ltp_dir, extra_args='install')
def setUp(self):
"""
Use distro provided bonnie++ bin
if not available Build bonnie++ from below
Source:
http://www.coker.com.au/bonnie++/experimental/bonnie++-1.03e.tgz
"""
self.fstype = self.params.get('fs', default='')
self.fs_create = False
lv_needed = self.params.get('lv', default=False)
self.lv_create = False
raid_needed = self.params.get('raid', default=False)
self.raid_create = False
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default='/mnt')
self.uid_to_use = self.params.get('uid-to-use',
default=getpass.getuser())
self.number_to_stat = self.params.get('number-to-stat', default=2048)
self.data_size = self.params.get('data_size_to_pass', default=0)
smm = SoftwareManager()
# Install the package from web
deps = ['gcc', 'make']
if distro.detect().name == 'Ubuntu':
deps.extend(['g++'])
else:
deps.extend(['gcc-c++'])
if self.fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs not supported with RHEL 7.4 onwards")
elif distro.detect().name == 'Ubuntu':
deps.extend(['btrfs-tools'])
if raid_needed:
deps.append('mdadm')
for package in deps:
if not smm.check_installed(package) and not smm.install(package):
self.cancel("%s package required for this test" % package)
if process.system("which bonnie++", ignore_status=True):
tarball = self.fetch_asset('http://www.coker.com.au/bonnie++/'
'bonnie++-1.03e.tgz', expire='7d')
archive.extract(tarball, self.teststmpdir)
self.source = os.path.join(self.teststmpdir,
os.path.basename(
tarball.split('.tgz')[0]))
os.chdir(self.source)
process.run('./configure')
build.make(self.source)
build.make(self.source, extra_args='install')
if not os.path.exists(self.dir):
os.mkdir(self.dir)
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sw_raid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk is not None:
self.pre_cleanup()
if self.disk in disk.get_disks():
if raid_needed:
self.create_raid(self.disk, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if self.fstype:
self.create_fs(self.target, self.dir, self.fstype)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
else:
self.cancel("please provide valid disk")
def setUp(self):
"""
Build 'fio'.
"""
default_url = "https://brick.kernel.dk/snaps/fio-git-latest.tar.gz"
url = self.params.get('fio_tool_url', default=default_url)
self.disk = self.params.get('disk', default=None)
self.dir = self.params.get('dir', default='/mnt')
self.disk_type = self.params.get('disk_type', default='')
fstype = self.params.get('fs', default='')
fs_args = self.params.get('fs_args', default='')
mnt_args = self.params.get('mnt_args', default='')
lv_needed = self.params.get('lv', default=False)
raid_needed = self.params.get('raid', default=False)
self.fio_file = 'fiotest-image'
self.fs_create = False
self.lv_create = False
self.raid_create = False
self.devdax_file = None
if fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs is not supported with \
RHEL 7.4 onwards")
if distro.detect().name in ['Ubuntu', 'debian']:
pkg_list = ['libaio-dev']
if fstype == 'btrfs':
pkg_list.append('btrfs-progs')
elif distro.detect().name is 'SuSE':
pkg_list = ['libaio1', 'libaio-devel']
else:
pkg_list = ['libaio', 'libaio-devel']
if self.disk_type == 'nvdimm':
pkg_list.extend(['autoconf', 'pkg-config'])
if distro.detect().name == 'SuSE':
pkg_list.extend(
['ndctl', 'libnuma-devel', 'libndctl-devel'])
else:
pkg_list.extend([
'ndctl', 'daxctl', 'numactl-devel', 'ndctl-devel',
'daxctl-devel'
])
if raid_needed:
pkg_list.append('mdadm')
smm = SoftwareManager()
for pkg in pkg_list:
if pkg and not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel(
"Package %s is missing and could not be installed" % pkg)
tarball = self.fetch_asset(url)
archive.extract(tarball, self.teststmpdir)
self.sourcedir = os.path.join(self.teststmpdir, "fio")
fio_flags = ""
self.ld_path = ""
self.raid_name = '/dev/md/sraid'
self.vgname = 'avocado_vg'
self.lvname = 'avocado_lv'
self.err_mesg = []
if self.disk_type == 'nvdimm':
self.setup_pmem_disk(mnt_args)
self.log.info("Building PMDK for NVDIMM fio engines")
pmdk_url = self.params.get('pmdk_url', default='')
tar = self.fetch_asset(pmdk_url, expire='7d')
archive.extract(tar, self.teststmpdir)
version = os.path.basename(tar.split('.tar.')[0])
pmdk_src = os.path.join(self.teststmpdir, version)
build.make(pmdk_src)
build.make(pmdk_src,
extra_args='install prefix=%s' % self.teststmpdir)
os.chdir(self.sourcedir)
ext_flags = '`PKG_CONFIG_PATH=%s/lib/pkgconfig pkg-config --cflags\
--libs libpmem libpmemblk`' % self.teststmpdir
self.ld_path = "LD_LIBRARY_PATH=%s/lib" % self.teststmpdir
out = process.system_output('./configure --extra-cflags='
'"%s"' % ext_flags,
shell=True)
fio_flags = "LDFLAGS='%s'" % ext_flags
for eng in ['PMDK libpmem', 'PMDK dev-dax', 'libnuma']:
for line in out.decode().splitlines():
if line.startswith(eng) and 'no' in line:
self.cancel("PMEM engines not built with fio")
if not self.disk:
self.dir = self.workdir
self.target = self.disk
self.lv_disk = self.disk
self.part_obj = Partition(self.disk, mountpoint=self.dir)
self.sraid = softwareraid.SoftwareRaid(self.raid_name, '0',
self.disk.split(), '1.2')
dmesg.clear_dmesg()
if self.disk in disk.get_disks():
self.pre_cleanup()
if raid_needed:
self.create_raid(self.target, self.raid_name)
self.raid_create = True
self.target = self.raid_name
if lv_needed:
self.lv_disk = self.target
self.target = self.create_lv(self.target)
self.lv_create = True
if fstype:
self.create_fs(self.target, self.dir, fstype, fs_args,
mnt_args)
self.fs_create = True
else:
self.cancel("Missing disk %s in OS" % self.disk)
build.make(self.sourcedir, extra_args=fio_flags)
