def setup_nvdimm(self):
"""
Setup pmem devices
"""
self.plib = pmem.PMem()
regions = sorted(self.plib.run_ndctl_list('-R'),
key=lambda i: i['size'],
reverse=True)
if not regions:
self.plib.enable_region()
regions = sorted(self.plib.run_ndctl_list('-R'),
key=lambda i: i['size'],
reverse=True)
self.region = self.plib.run_ndctl_list_val(regions[0], 'dev')
if self.plib.run_ndctl_list('-N -r %s' % self.region):
self.plib.destroy_namespace(region=self.region, force=True)
self.plib.create_namespace(region=self.region)
disk_id = "/dev/%s" % self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list('-N -r %s' % self.region)[0], 'blockdev')
self.mnt_dir = '/pmem'
self.part_obj = partition.Partition(disk_id, mountpoint=self.mnt_dir)
self.log.info("Creating file system")
self.part_obj.mkfs(fstype='ext4', args='-b 64k -F')
self.log.info("Mounting disk %s", disk_id)
if not os.path.exists(self.mnt_dir):
os.makedirs(self.mnt_dir)
try:
self.part_obj.mount(args='-o dax')
except partition.PartitionError:
self.cancel("Mounting disk %s on directory failed" % disk_id)
return os.path.join(self.mnt_dir, "file")
def setUp(self):
"""
Build 'ndctl' and setup the binary.
"""
if "powerpc" not in cpu.get_cpu_arch():
self.cancel("Test supported only on POWER arch")
deps = []
self.dist = distro.detect()
self.package = self.params.get('package', default='distro')
if self.dist.name not in ['SuSE', 'rhel']:
self.cancel('Unsupported OS %s' % self.dist.name)
self.smm = SoftwareManager()
if self.package == 'upstream':
deps.extend(['gcc', 'make', 'automake', 'autoconf'])
if self.dist.name == 'SuSE':
deps.extend(['libtool',
'libkmod-devel', 'libudev-devel', 'systemd-devel',
'libuuid-devel-static', 'libjson-c-devel',
'keyutils-devel', 'kmod-bash-completion'])
elif self.dist.name == 'rhel':
deps.extend(['libtool',
'kmod-devel', 'libuuid-devel', 'json-c-devel',
'systemd-devel', 'keyutils-libs-devel', 'jq',
'parted', 'libtool'])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
locations = ["https://github.com/pmem/ndctl/archive/master.zip"]
tarball = self.fetch_asset("ndctl.zip", locations=locations,
expire='7d')
archive.extract(tarball, self.teststmpdir)
os.chdir("%s/ndctl-master" % self.teststmpdir)
process.run('./autogen.sh', sudo=True, shell=True)
process.run("./configure CFLAGS='-g -O2' --prefix=/usr "
"--disable-docs "
"--sysconfdir=/etc --libdir="
"/usr/lib64", shell=True, sudo=True)
build.make(".")
self.ndctl = os.path.abspath('./ndctl/ndctl')
self.daxctl = os.path.abspath('./daxctl/daxctl')
else:
deps.extend(['ndctl'])
if self.dist.name == 'rhel':
deps.extend(['daxctl'])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
self.ndctl = 'ndctl'
self.daxctl = 'daxctl'
self.plib = pmem.PMem(self.ndctl, self.daxctl)
if not self.plib.check_buses():
self.cancel("Test needs atleast one region")
def setup_pmem_disk(self, mnt_args):
if not self.disk:
self.plib = pmem.PMem()
regions = sorted(self.plib.run_ndctl_list(
'-R'), key=lambda i: i['size'], reverse=True)
if not regions:
self.plib.enable_region()
regions = sorted(self.plib.run_ndctl_list(
'-R'), key=lambda i: i['size'], reverse=True)
region = self.plib.run_ndctl_list_val(regions[0], 'dev')
if self.plib.run_ndctl_list("-N -r %s" % region):
self.plib.destroy_namespace(region=region, force=True)
if 'dax' in mnt_args:
self.plib.create_namespace(region=region)
self.disk = "/dev/%s" % self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list('-N -r %s' % region)[0], 'blockdev')
else:
self.plib.create_namespace(
region=region, mode='devdax')
self.devdax_file = "/dev/%s" % self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list('-N -r %s' % region)[0], 'chardev')
def setup_nvdimm(self):
self.logflag = self.params.get('logdev', default=False)
self.plib = pmem.PMem()
self.plib.enable_region()
regions = sorted(self.plib.run_ndctl_list('-R'),
key=lambda i: i['size'],
reverse=True)
if not regions:
self.cancel("Nvdimm test with no region support")
self.region = self.plib.run_ndctl_list_val(regions[0], 'dev')
if self.plib.is_region_legacy(self.region):
if not len(regions) > 1:
self.cancel("Not supported with single legacy region")
if self.logflag:
self.log.info("Using loop devices as log devices")
check = 2
mount = True
if disk.freespace('/') / 1073741824 > check:
self.disk_mnt = ''
mount = False
else:
self.cancel('Need %s GB to create loop devices' % check)
self._create_loop_device(None, '2038M', mount)
self.log_test = self.devices.pop()
self.log_scratch = self.devices.pop()
namespaces = self.plib.run_ndctl_list('-N -r %s' % self.region)
pmem_dev = self.plib.run_ndctl_list_val(namespaces[0], 'blockdev')
self.test_dev = "/dev/%s" % pmem_dev
region_2 = self.plib.run_ndctl_list_val(regions[1], 'dev')
namespaces = self.plib.run_ndctl_list('-N -r %s' % region_2)
pmem_dev = self.plib.run_ndctl_list_val(namespaces[0], 'blockdev')
self.scratch_dev = "/dev/%s" % pmem_dev
self.devices.extend([self.test_dev, self.scratch_dev])
else:
if self.logflag:
if not len(regions) > 1:
self.log.info('Using 10% space of device for logdev')
self.region_ldev = self.region
region_size = self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list('-r %s' %
self.region_ldev)[0], 'size')
logdev_size = int(region_size * 0.10)
dev_size = region_size - logdev_size
size_align = self.get_size_alignval()
dev_size = dev_size // 2
dev_size = (dev_size // size_align) * size_align
logdev_size = logdev_size // 2
logdev_size = (logdev_size // size_align) * size_align
else:
dev_size = self.get_half_region_size(self.region)
self.region_ldev = self.plib.run_ndctl_list_val(
regions[1], 'dev')
logdev_size = self.get_half_region_size(
region=self.region_ldev)
self.plib.destroy_namespace(region=self.region, force=True)
self.plib.destroy_namespace(region=self.region_ldev,
force=True)
# XFS restrict max log size to 2136997888, which is 10M less
# than 2GB, not 16M page-aligned, hence rounding-off to nearest
# 16M align value 2130706432, which is 16M less than 2GiB
logdev_size = min(logdev_size, 2130706432)
# log device to be created in sector mode
self.plib.create_namespace(region=self.region_ldev,
mode='sector',
sector_size='512',
size=logdev_size)
self.plib.create_namespace(region=self.region_ldev,
mode='sector',
sector_size='512',
size=logdev_size)
namespaces = self.plib.run_ndctl_list('-N -r %s -m sector' %
self.region_ldev)
log_dev = self.plib.run_ndctl_list_val(namespaces[0],
'blockdev')
self.log_test = "/dev/%s" % log_dev
log_dev = self.plib.run_ndctl_list_val(namespaces[1],
'blockdev')
self.log_scratch = "/dev/%s" % log_dev
else:
self.plib.destroy_namespace(region=self.region, force=True)
dev_size = self.get_half_region_size(self.region)
self.log_test = None
self.log_scratch = None
self.plib.create_namespace(region=self.region, size=dev_size)
self.plib.create_namespace(region=self.region, size=dev_size)
namespaces = self.plib.run_ndctl_list('-N -r %s -m fsdax' %
self.region)
pmem_dev = self.plib.run_ndctl_list_val(namespaces[0], 'blockdev')
self.test_dev = "/dev/%s" % pmem_dev
pmem_dev = self.plib.run_ndctl_list_val(namespaces[1], 'blockdev')
self.scratch_dev = "/dev/%s" % pmem_dev
self.devices.extend([self.test_dev, self.scratch_dev])
def setUp(self):
"""
Build 'ndctl' and setup the binary.
"""
deps = []
self.dist = distro.detect()
self.package = self.params.get('package', default='upstream')
self.preserve_setup = self.params.get('preserve_change', default=False)
self.mode_to_use = self.params.get('modes', default='fsdax')
if self.dist.name not in ['SuSE', 'rhel']:
self.cancel('Unsupported OS %s' % self.dist.name)
# DAX wont work with reflink, disabling here
self.reflink = '-m reflink=0'
self.smm = SoftwareManager()
if self.package == 'upstream':
deps.extend(['gcc', 'make', 'automake', 'autoconf'])
if self.dist.name == 'SuSE':
deps.extend([
'libtool', 'libkmod-devel', 'libudev-devel',
'systemd-devel', 'libuuid-devel-static', 'libjson-c-devel',
'keyutils-devel', 'kmod-bash-completion'
])
elif self.dist.name == 'rhel':
deps.extend([
'libtool', 'kmod-devel', 'libuuid-devel', 'json-c-devel',
'systemd-devel', 'keyutils-libs-devel', 'jq', 'parted',
'libtool'
])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
git_branch = self.params.get('git_branch', default='pending')
location = "https://github.com/pmem/ndctl/archive/"
location = location + git_branch + ".zip"
tarball = self.fetch_asset("ndctl.zip",
locations=location,
expire='7d')
archive.extract(tarball, self.teststmpdir)
os.chdir("%s/ndctl-%s" % (self.teststmpdir, git_branch))
process.run('./autogen.sh', sudo=True, shell=True)
process.run(
"./configure CFLAGS='-g -O2' --prefix=/usr "
"--disable-docs "
"--sysconfdir=/etc --libdir="
"/usr/lib64",
shell=True,
sudo=True)
build.make(".")
self.ndctl = os.path.abspath('./ndctl/ndctl')
self.daxctl = os.path.abspath('./daxctl/daxctl')
else:
deps.extend(['ndctl'])
if self.dist.name == 'rhel':
deps.extend(['daxctl'])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
self.ndctl = 'ndctl'
self.daxctl = 'daxctl'
self.opt_dict = {
'-B': 'provider',
'-D': 'dev',
'-R': 'dev',
'-N': 'dev'
}
self.modes = ['raw', 'sector', 'fsdax', 'devdax']
self.part = None
self.disk = None
self.plib = pmem.PMem(self.ndctl, self.daxctl)
if not self.plib.check_buses():
self.cancel("Test needs atleast one region")
def test_no_binaries(self):
with unittest.mock.patch('avocado.utils.path.find_command',
return_value=False):
with self.assertRaises(pmem.PMemException):
pmem.PMem()
def setUp(self):
"""
Build 'ndctl' and setup the binary.
"""
deps = []
self.dist = distro.detect()
self.package = self.params.get('package', default='upstream')
self.preserve_setup = self.params.get('preserve_change', default=False)
self.mode_to_use = self.params.get('modes', default='fsdax')
location = self.params.get('location', default='.')
ndctl_project_version = self.params.get('ndctl_project_version',
default='')
url = "https://github.com/pmem/ndctl.git"
if self.dist.name not in ['SuSE', 'rhel']:
self.cancel('Unsupported OS %s' % self.dist.name)
# DAX wont work with reflink, disabling here
self.reflink = '-m reflink=0'
self.smm = SoftwareManager()
if self.package == 'upstream':
deps.extend(['gcc', 'make', 'automake', 'autoconf'])
if self.dist.name == 'SuSE':
deps.extend([
'libtool', 'libkmod-devel', 'libudev-devel',
'systemd-devel', 'libuuid-devel-static', 'libjson-c-devel',
'keyutils-devel', 'kmod-bash-completion',
'bash-completion-devel'
])
elif self.dist.name == 'rhel':
deps.extend([
'libtool', 'bash-completion', 'parted', 'kmod-devel',
'libuuid-devel', 'json-c-devel', 'systemd-devel',
'keyutils-libs-devel', 'jq'
])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
if ndctl_project_version:
ndctl_tag_name = "v" + ndctl_project_version
# Clone the 'main' branch
git.get_repo(url,
branch='main',
destination_dir=self.teststmpdir)
os.chdir(self.teststmpdir)
# Checkout the desired tag
git_helper = GitRepoHelper(url,
destination_dir=self.teststmpdir)
git_helper.checkout(branch=ndctl_tag_name, commit=None)
if (float(ndctl_project_version) < 73):
self.autotools_build_system()
else:
self.meson_build_system(deps)
# default to the meson way of building ndctl library
else:
# Clone the 'pending' branch
git_branch = self.params.get('git_branch', default='pending')
git.get_repo(url,
branch=git_branch,
destination_dir=self.teststmpdir)
os.chdir(self.teststmpdir)
self.meson_build_system(deps)
elif self.package == 'local':
self.ndctl = os.path.abspath(os.path.join(location, 'ndctl/ndctl'))
self.daxctl = os.path.abspath(
os.path.join(location, 'daxctl/daxctl'))
else:
deps.extend(['ndctl'])
if self.dist.name == 'rhel':
deps.extend(['daxctl'])
for pkg in deps:
if not self.smm.check_installed(pkg) and not \
self.smm.install(pkg):
self.cancel('%s is needed for the test to be run' % pkg)
self.ndctl = 'ndctl'
self.daxctl = 'daxctl'
self.opt_dict = {
'-B': 'provider',
'-D': 'dev',
'-R': 'dev',
'-N': 'dev'
}
self.modes = ['raw', 'sector', 'fsdax', 'devdax']
self.part = None
self.disk = None
self.plib = pmem.PMem(self.ndctl, self.daxctl)
if not self.plib.check_buses():
self.cancel("Test needs atleast one region")
def setUp(self):
"""
Build xfstest
Source: git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git
"""
self.use_dd = False
root_fs = process.system_output("df -T / | awk 'END {print $2}'",
shell=True).decode("utf-8")
if root_fs in ['ext3', 'ext4']:
self.use_dd = True
self.dev_type = self.params.get('type', default='loop')
sm = SoftwareManager()
self.detected_distro = distro.detect()
packages = [
'e2fsprogs', 'automake', 'gcc', 'quota', 'attr', 'make',
'xfsprogs', 'gawk'
]
if self.detected_distro.name in ['Ubuntu', 'debian']:
packages.extend([
'xfslibs-dev', 'uuid-dev', 'libuuid1', 'libattr1-dev',
'libacl1-dev', 'libgdbm-dev', 'uuid-runtime', 'libaio-dev',
'fio', 'dbench', 'libbtrfs-dev'
])
if self.detected_distro.version in ['14']:
packages.extend(['libtool'])
elif self.detected_distro.version in ['18', '20']:
packages.extend(['libtool-bin', 'libgdbm-compat-dev'])
else:
packages.extend(['libtool-bin'])
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
elif self.detected_distro.name in ['centos', 'fedora', 'rhel', 'SuSE']:
if self.dev_type == 'nvdimm':
packages.extend(['ndctl', 'parted'])
if self.detected_distro.name == 'rhel':
packages.extend(['daxctl'])
packages.extend([
'acl', 'bc', 'dump', 'indent', 'libtool', 'lvm2', 'xfsdump',
'psmisc', 'sed', 'libacl-devel', 'libattr-devel',
'libaio-devel', 'libuuid-devel', 'openssl-devel',
'xfsprogs-devel'
])
if self.detected_distro.name == 'SuSE':
packages.extend(['libbtrfs-devel', 'libcap-progs'])
else:
packages.extend(['btrfs-progs-devel'])
if self.detected_distro.name == 'rhel' and\
self.detected_distro.version.startswith('8'):
packages.remove('indent')
packages.remove('btrfs-progs-devel')
if self.detected_distro.name in ['centos', 'fedora']:
packages.extend(['fio', 'dbench'])
else:
self.cancel("test not supported in %s" % self.detected_distro.name)
for package in packages:
if not sm.check_installed(package) and not sm.install(package):
self.cancel("Fail to install %s required for this test." %
package)
self.skip_dangerous = self.params.get('skip_dangerous', default=True)
self.test_range = self.params.get('test_range', default=None)
self.scratch_mnt = self.params.get('scratch_mnt',
default='/mnt/scratch')
self.test_mnt = self.params.get('test_mnt', default='/mnt/test')
self.disk_mnt = self.params.get('disk_mnt', default='/mnt/loop_device')
self.fs_to_test = self.params.get('fs', default='ext4')
if process.system('which mkfs.%s' % self.fs_to_test,
ignore_status=True):
self.cancel('Unknown filesystem %s' % self.fs_to_test)
mount = True
self.devices = []
self.log_devices = []
shutil.copyfile(self.get_data('local.config'),
os.path.join(self.teststmpdir, 'local.config'))
shutil.copyfile(self.get_data('group'),
os.path.join(self.teststmpdir, 'group'))
if self.dev_type == 'loop':
base_disk = self.params.get('disk', default=None)
loop_size = self.params.get('loop_size', default='7GiB')
if not base_disk:
# Using root for file creation by default
check = (int(loop_size.split('GiB')[0]) * 2) + 1
if disk.freespace('/') / 1073741824 > check:
self.disk_mnt = ''
mount = False
else:
self.cancel('Need %s GB to create loop devices' % check)
self._create_loop_device(base_disk, loop_size, mount)
elif self.dev_type == 'nvdimm':
self.test_dev = self.params.get('disk_test', default=None)
self.scratch_dev = self.params.get('disk_scratch', default=None)
self.log_test = self.params.get('log_test', default='')
self.log_scratch = self.params.get('log_scratch', default='')
logflag = self.params.get('logdev', default=False)
self.plib = pmem.PMem()
regions = sorted(self.plib.run_ndctl_list('-R'),
key=lambda i: i['size'],
reverse=True)
if not (self.test_dev and self.scratch_dev):
if not regions:
self.plib.enable_region()
regions = sorted(self.plib.run_ndctl_list('-R'),
key=lambda i: i['size'],
reverse=True)
region = self.plib.run_ndctl_list_val(regions[0], 'dev')
if not self.plib.is_region_legacy(region):
self.plib.destroy_namespace(region=region, force=True)
self.plib.create_namespace(region=region,
size='21G',
sector_size='512')
pmem_dev = self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list('-N -r %s' % region)[0],
'blockdev')
if logflag:
if not (self.log_test and self.log_scratch):
self.plib.create_namespace(region=region,
size='3G',
mode='sector',
sector_size='512')
log_dev = self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list('-N -r %s -m sector' %
region)[0],
'blockdev')
else:
self.plib.enable_region()
if not len(regions) > 1 and logflag:
self.cancel("Cannot use logdev with one region")
else:
reg_2 = self.plib.run_ndctl_list_val(regions[1], 'dev')
self.plib.create_namespace(region=reg_2,
size='3G',
mode='sector',
sector_size='512')
log_dev = self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list(' -N -r %s -m sector' %
reg_2)[0], 'blockdev')
pmem_dev = self.plib.run_ndctl_list_val(
self.plib.run_ndctl_list('-N -r %s' % region)[0],
'blockdev')
if process.system('parted -s -a optimal /dev/%s mklabel gpt --'
' mkpart primary xfs 1MiB 10GiB mkpart '
'primary xfs 10GiB 20GiB' % pmem_dev,
shell=True):
self.cancel("Failed to setup PMEM partitions")
self.test_dev = "/dev/%sp1" % pmem_dev
self.scratch_dev = "/dev/%sp2" % pmem_dev
self.devices.extend([self.test_dev, self.scratch_dev])
if logflag and not (self.log_test and self.log_scratch):
if process.system('parted -s -a optimal /dev/%s mklabel gpt --'
' mkpart primary xfs 1MiB 1GiB mkpart '
'primary xfs 1GiB 2GiB' % log_dev,
shell=True):
self.cancel("Failed to setup logdev partitions")
self.log_test = "/dev/%s1" % log_dev
self.log_scratch = "/dev/%s2" % log_dev
else:
self.test_dev = self.params.get('disk_test', default=None)
self.scratch_dev = self.params.get('disk_scratch', default=None)
self.devices.extend([self.test_dev, self.scratch_dev])
# mkfs for devices
if self.devices:
cfg_file = os.path.join(self.teststmpdir, 'local.config')
self.mkfs_opt = self.params.get('mkfs_opt', default='')
self.mount_opt = self.params.get('mount_opt', default='')
with open(cfg_file, "r") as sources:
lines = sources.readlines()
with open(cfg_file, "w") as sources:
for line in lines:
if line.startswith('export TEST_DEV'):
sources.write(
re.sub(r'export TEST_DEV=.*',
'export TEST_DEV=%s' % self.devices[0],
line))
elif line.startswith('export TEST_DIR'):
sources.write(
re.sub(r'export TEST_DIR=.*',
'export TEST_DIR=%s' % self.test_mnt, line))
elif line.startswith('export SCRATCH_DEV'):
sources.write(
re.sub(r'export SCRATCH_DEV=.*',
'export SCRATCH_DEV=%s' % self.devices[1],
line))
elif line.startswith('export SCRATCH_MNT'):
sources.write(
re.sub(r'export SCRATCH_MNT=.*',
'export SCRATCH_MNT=%s' % self.scratch_mnt,
line))
break
with open(cfg_file, "a") as sources:
if self.log_test:
sources.write('export USE_EXTERNAL=yes\n')
sources.write('export TEST_LOGDEV="%s"\n' % self.log_test)
self.log_devices.append(self.log_test)
if self.log_scratch:
sources.write('export SCRATCH_LOGDEV="%s"\n' %
self.log_scratch)
self.log_devices.append(self.log_scratch)
if self.mkfs_opt:
sources.write('MKFS_OPTIONS="%s"\n' % self.mkfs_opt)
if self.mount_opt:
sources.write('MOUNT_OPTIONS="%s"\n' % self.mount_opt)
self.logdev_opt = self.params.get('logdev_opt', default='')
for dev in self.log_devices:
dev_obj = partition.Partition(dev)
dev_obj.mkfs(fstype=self.fs_to_test, args=self.mkfs_opt)
for ite, dev in enumerate(self.devices):
dev_obj = partition.Partition(dev)
if self.logdev_opt:
dev_obj.mkfs(fstype=self.fs_to_test,
args='%s %s=%s' %
(self.mkfs_opt, self.logdev_opt,
self.log_devices[ite]))
else:
dev_obj.mkfs(fstype=self.fs_to_test, args=self.mkfs_opt)
git.get_repo('git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git',
destination_dir=self.teststmpdir)
build.make(self.teststmpdir)
self.available_tests = self._get_available_tests()
self.test_list = self._create_test_list(self.test_range)
self.log.info("Tests available in srcdir: %s",
", ".join(self.available_tests))
if not self.test_range:
self.exclude = self.params.get('exclude', default=None)
self.gen_exclude = self.params.get('gen_exclude', default=None)
self.share_exclude = self.params.get('share_exclude', default=None)
if self.exclude or self.gen_exclude or self.share_exclude:
self.exclude_file = os.path.join(self.teststmpdir, 'exclude')
if self.exclude:
self._create_test_list(self.exclude,
self.fs_to_test,
dangerous=False)
if self.gen_exclude:
self._create_test_list(self.gen_exclude,
"generic",
dangerous=False)
if self.share_exclude:
self._create_test_list(self.share_exclude,
"shared",
dangerous=False)
if self.detected_distro.name is not 'SuSE':
if process.system('useradd 123456-fsgqa',
sudo=True,
ignore_status=True):
self.log.warn('useradd 123456-fsgqa failed')
if process.system('useradd fsgqa', sudo=True, ignore_status=True):
self.log.warn('useradd fsgqa failed')
else:
if process.system('useradd -m -U fsgqa',
sudo=True,
ignore_status=True):
self.log.warn('useradd fsgqa failed')
if process.system('groupadd sys', sudo=True, ignore_status=True):
self.log.warn('groupadd sys failed')
if not os.path.exists(self.scratch_mnt):
os.makedirs(self.scratch_mnt)
if not os.path.exists(self.test_mnt):
os.makedirs(self.test_mnt)
