def test_empty(self):
mock_result = process.CmdResult(
command='lsblk --json',
stdout=b'{"blockdevices": []}')
with unittest.mock.patch('avocado.utils.disk.process.run',
return_value=mock_result):
self.assertEqual(disk.get_disks(), [])
def test_disks(self):
mock_result = process.CmdResult(
command='lsblk --json',
stdout=LSBLK_OUTPUT)
with unittest.mock.patch('avocado.utils.disk.process.run',
return_value=mock_result):
self.assertEqual(disk.get_disks(), ['/dev/vda'])
def test_disks(self):
mock_result = process.CmdResult(
command='lsblk --json --paths --inverse',
stdout=LSBLK_OUTPUT)
with unittest.mock.patch('avocado.utils.disk.process.run',
return_value=mock_result):
self.assertEqual(disk.get_disks(), ['/dev/vda'])
def test_empty(self):
mock_result = process.CmdResult(
command='lsblk --json --paths --inverse',
stdout=b'{"blockdevices": []}')
with unittest.mock.patch('avocado.utils.disk.process.run',
return_value=mock_result):
self.assertEqual(disk.get_disks(), [])
def setUp(self):
"""
fs_mark
"""
lv_needed = self.params.get('lv', default=False)
self.lv_create = False
raid_needed = self.params.get('raid', default=False)
self.raid_create = False
smm = SoftwareManager()
if raid_needed:
if not smm.check_installed('mdadm') and not smm.install('mdadm'):
self.cancel("mdadm is needed for the test to be run")
tarball = self.fetch_asset('https://github.com/josefbacik/fs_mark/'
'archive/master.zip')
archive.extract(tarball, self.teststmpdir)
self.sourcedir = os.path.join(self.teststmpdir, 'fs_mark-master')
os.chdir(self.sourcedir)
process.run('make')
build.make(self.sourcedir)
self.disk = self.params.get('disk', default=None)
self.num = self.params.get('num_files', default='1024')
self.size = self.params.get('size', default='1000')
self.fstype = self.params.get('fs', default='')
self.fs_create = False
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':
if not smm.check_installed("btrfs-tools") and not \
smm.install("btrfs-tools"):
self.cancel('btrfs-tools is needed for the test to be run')
self.dirs = self.disk
if self.disk is not None:
if self.disk in disk.get_disks():
if raid_needed:
raid_name = '/dev/md/mdsraid'
self.create_raid(self.disk, raid_name)
self.raid_create = True
self.disk = raid_name
self.dirs = self.disk
if lv_needed:
self.disk = self.create_lv(self.disk)
self.lv_create = True
self.dirs = self.disk
if self.fstype:
self.dirs = self.workdir
self.create_fs(self.disk, self.dirs, self.fstype)
self.fs_create = True
self.link = "/tmp/link"
os.symlink(self.dirs, self.link)
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
smm = SoftwareManager()
packages = ['gcc']
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'])
if raid_needed:
packages.append('mdadm')
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.disk = self.params.get('disk', default=None)
self.target = self.disk
if self.disk is not None:
if self.disk in disk.get_disks():
if raid_needed:
raid_name = '/dev/md/mdsraid'
self.create_raid(self.disk, raid_name)
self.raid_create = True
self.disk = raid_name
self.target = self.disk
if lv_needed:
self.disk = self.create_lv(self.disk)
self.lv_create = True
self.target = self.disk
if self.fstype:
self.target = self.workdir
self.create_fs(self.disk, self.target, self.fstype)
self.fs_create = True
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.disk_type = self.params.get('disk_type', default='')
fs_args = self.params.get('fs_args', default='')
mnt_args = self.params.get('mnt_args', default='')
self.fio_file = 'fiotest-image'
self.fs_create = False
self.lv_create = False
self.raid_create = False
self.devdax_file = None
fstype = self.params.get('fs', default='')
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")
lv_needed = self.params.get('lv', default=False)
raid_needed = self.params.get('raid', default=False)
if distro.detect().name in ['Ubuntu', 'debian']:
pkg_list = ['libaio-dev']
if fstype == 'btrfs':
pkg_list.append('btrfs-progs')
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")
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=/usr')
os.chdir(self.sourcedir)
out = process.system_output("./configure --prefix=/usr",
shell=True)
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.disk = self.workdir
self.dirs = self.disk
if self.disk in disk.get_disks():
if raid_needed:
raid_name = '/dev/md/mdsraid'
self.create_raid(self.disk, raid_name)
self.raid_create = True
self.disk = raid_name
if lv_needed:
self.disk = self.create_lv(self.disk)
self.lv_create = True
self.dirs = self.disk
if fstype:
self.dirs = self.workdir
self.create_fs(self.disk, self.dirs, fstype, fs_args, mnt_args)
self.fs_create = True
build.make(self.sourcedir)
def setUp(self):
'''
Build Dbench
Source:
http://samba.org/ftp/tridge/dbench/dbench-3.04.tar.gz
'''
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)
if not self.disk:
self.cancel("Provide the test disks to proceed !")
self.md_name = self.params.get('raid_name', default='md127')
self.mountpoint = self.params.get('dir', default='/mnt')
self.disk_obj = Partition(self.disk, mountpoint=self.mountpoint)
self.pre_cleanup()
self.clear_disk(self.disk_obj, self.disk)
if not os.path.exists(self.mountpoint):
os.mkdir(self.mountpoint)
sm = SoftwareManager()
pkgs = ["gcc", "patch"]
if raid_needed:
pkgs.append('mdadm')
for pkg in pkgs:
if not sm.check_installed(pkg) and not sm.install(pkg):
self.error('%s is needed for the test to be run' % pkg)
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 == 'Ubuntu':
if not sm.check_installed("btrfs-tools") and not \
sm.install("btrfs-tools"):
self.cancel('btrfs-tools is needed for the test to be run')
self.results = []
tarball = self.fetch_asset(
'http://samba.org/ftp/tridge/dbench/dbench-3.04.tar.gz')
archive.extract(tarball, self.teststmpdir)
cb_version = os.path.basename(tarball.split('.tar.')[0])
self.sourcedir = os.path.join(self.teststmpdir, cb_version)
os.chdir(self.sourcedir)
patch = self.params.get('patch', default='dbench_startup.patch')
process.run('patch -p1 < %s' % self.get_data(patch), shell=True)
process.run('./configure')
build.make(self.sourcedir)
if self.disk is not None:
if self.disk in disk.get_disks():
if raid_needed:
raid_name = '/dev/%s' % self.md_name
self.create_raid(self.disk, raid_name)
self.raid_create = True
self.disk = raid_name
if lv_needed:
self.disk = self.create_lv(self.disk)
self.lv_create = True
if fstype:
self.create_fs(self.disk, fstype)
self.fs_create = True
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):
'''
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
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)
self.disk = self.params.get('disk', default=None)
self.mount_point = self.params.get('dir', default=self.workdir)
self.script = self.params.get('script')
fstype = self.params.get('fs', default='')
self.fsstress_run = self.params.get('fsstress_loop', default='1')
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 == 'Ubuntu':
if not smm.check_installed("btrfs-tools") and not \
smm.install("btrfs-tools"):
self.cancel('btrfs-tools is needed for the test to be run')
if self.disk is not None:
if self.disk in disk.get_disks():
if raid_needed:
raid_name = '/dev/md/mdsraid'
self.create_raid(self.disk, raid_name)
self.raid_create = True
self.disk = raid_name
self.mount_point = self.disk
if lv_needed:
self.disk = self.create_lv(self.disk)
self.lv_create = True
self.mount_point = self.disk
if fstype:
self.mount_point = self.workdir
self.create_fs(self.disk, self.mount_point, fstype)
self.fs_create = True
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')
process.system('./configure', ignore_status=True)
build.make(ltp_dir)
build.make(ltp_dir, extra_args='install')
fsstress_dir = os.path.join(ltp_dir,
'testcases/kernel/fs/fsstress')
os.chdir(fsstress_dir)
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 IOZone
Source:
http://www.iozone.org/src/current/iozone3_434.tar
'''
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.base_dir = os.path.abspath(self.basedir)
smm = SoftwareManager()
packages = ['gcc', 'make', 'patch']
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 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':
if not smm.check_installed("btrfs-tools") and not \
smm.install("btrfs-tools"):
self.cancel(
'btrfs-tools is needed for the test to be run')
tarball = self.fetch_asset(
'http://www.iozone.org/src/current/iozone3_434.tar')
archive.extract(tarball, self.teststmpdir)
version = os.path.basename(tarball.split('.tar')[0])
self.sourcedir = os.path.join(self.teststmpdir, version)
make_dir = os.path.join(self.sourcedir, 'src', 'current')
os.chdir(make_dir)
patch = self.params.get('patch', default='makefile.patch')
patch = self.get_data(patch)
process.run('patch -p3 < %s' % patch, shell=True)
d_distro = distro.detect()
arch = d_distro.arch
if arch == 'ppc':
build.make(make_dir, extra_args='linux-powerpc')
elif arch == 'ppc64' or arch == 'ppc64le':
build.make(make_dir, extra_args='linux-powerpc64')
elif arch == 'x86_64':
build.make(make_dir, extra_args='linux-AMD64')
else:
build.make(make_dir, extra_args='linux')
self.dirs = self.disk
if self.disk is not None:
if self.disk in disk.get_disks():
if raid_needed:
raid_name = '/dev/md/mdsraid'
self.create_raid(self.disk, raid_name)
self.raid_create = True
self.disk = raid_name
self.dirs = self.disk
if lv_needed:
self.disk = self.create_lv(self.disk)
self.lv_create = True
self.dirs = self.disk
if fstype:
self.dirs = self.workdir
self.create_fs(self.disk, self.dirs, fstype)
self.fs_create = True
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)
