def set_root(params, object=None):
"""
Set a root state to provide object existence.
All arguments match the base class.
Create a ramdisk, virtual group, thin pool and logical volume
for each object (all off).
"""
vm_name = params["vms"]
mount_loc = LVMBackend._get_images_mount_loc(params)
logging.info("Creating original logical volume for %s", vm_name)
lv_utils.vg_ramdisk(None, params["vg_name"], params["ramdisk_vg_size"],
params["ramdisk_basedir"],
params["ramdisk_sparse_filename"],
params["use_tmpfs"] == "yes")
lv_utils.lv_create(
params["vg_name"],
params["lv_name"],
params["lv_size"],
# NOTE: call by key to keep good argument order which wasn't
# accepted upstream for backward API compatibility
pool_name=params["pool_name"],
pool_size=params["pool_size"])
lv_utils.lv_take_snapshot(params["vg_name"], params["lv_name"],
params["lv_pointer_name"])
if mount_loc:
if not os.path.exists(mount_loc):
os.mkdir(mount_loc)
lv_utils.lv_mount(params["vg_name"],
params["lv_pointer_name"],
mount_loc,
create_filesystem="ext4")
super(LVMBackend, LVMBackend).set_root(params, object)
def set_root(run_params):
"""
Create a ramdisk, virtual group, thin pool and logical volume
for each vm (all offline).
:param run_params: configuration parameters
:type run_params: {str, str}
:raises: :py:class:`exceptions.TestError` if the root state already exists
"""
vms = run_params.objects("vms")
for vm_name in vms:
vm_params = run_params.object_params(vm_name)
if lv_utils.vg_check(vm_params["vg_name"]):
if vm_params.get("force_create", "no") == "yes":
logging.info("Removing the previously created %s", vm_name)
if vm_params.get("image_raw_device", "yes") == "no":
mount_loc = os.path.dirname(vm_params["image_name"])
try:
lv_utils.lv_umount(vm_params["vg_name"],
vm_params["lv_pointer_name"])
except lv_utils.LVException:
pass
logging.debug("Removing previous volume group of %s", vm_name)
lv_utils.vg_ramdisk_cleanup(vm_params["ramdisk_sparse_filename"],
os.path.join(vm_params["ramdisk_basedir"],
vm_params["vg_name"]),
vm_params["vg_name"],
None,
vm_params["use_tmpfs"] == "yes")
else:
raise exceptions.TestError("The root state of %s already exists" % vm_name)
logging.info("Preparing original logical volume for %s", vm_name)
lv_utils.vg_ramdisk(None,
vm_params["vg_name"],
vm_params["ramdisk_vg_size"],
vm_params["ramdisk_basedir"],
vm_params["ramdisk_sparse_filename"],
vm_params["use_tmpfs"] == "yes")
lv_utils.lv_create(vm_params["vg_name"],
vm_params["lv_name"],
vm_params["lv_size"],
# NOTE: call by key to keep good argument order which wasn't
# accepted upstream for backward API compatibility
pool_name=vm_params["pool_name"],
pool_size=vm_params["pool_size"])
lv_utils.lv_take_snapshot(vm_params["vg_name"],
vm_params["lv_name"],
vm_params["lv_pointer_name"])
if vm_params.get("image_raw_device", "yes") == "no":
mount_loc = os.path.dirname(vm_params["image_name"])
if not os.path.exists(mount_loc):
os.mkdir(mount_loc)
lv_utils.lv_mount(vm_params["vg_name"], vm_params["lv_pointer_name"],
mount_loc, create_filesystem="ext4")
def test_basic_workflow(self):
"""
Check the basic workflow works using ramdisk
"""
ramdisk_filename = vg_ramdisk_dir = loop_device = None
vg_name = "avocado_testing_vg_e5kj3erv11a"
lv_name = "avocado_testing_lv_lk0ff33al5h"
ramdisk_basedir = os.path.join(self.tmpdir, "foo", "bar")
mount_loc = os.path.join(self.tmpdir, "lv_mount_location")
os.mkdir(mount_loc)
try:
# Create ramdisk vg
self.assertFalse(os.path.exists(ramdisk_basedir))
self.assertFalse(lv_utils.vg_check(vg_name))
spec = lv_utils.vg_ramdisk(False, vg_name, 10, ramdisk_basedir,
"sparse_file")
ramdisk_filename, vg_ramdisk_dir, vg_name, loop_device = spec
# Check it was created properly
self.assertTrue(ramdisk_filename)
self.assertTrue(vg_ramdisk_dir)
self.assertTrue(vg_name)
self.assertTrue(loop_device)
self.assertTrue(os.path.exists(ramdisk_basedir))
self.assertTrue(glob.glob(os.path.join(ramdisk_basedir, "*")))
self.assertTrue(lv_utils.vg_check(vg_name))
vgs = lv_utils.vg_list()
self.assertIn(vg_name, vgs)
# Can't create existing vg
self.assertRaises(lv_utils.LVException, lv_utils.vg_create,
vg_name, loop_device)
# Create and check LV
lv_utils.lv_create(vg_name, lv_name, 1)
lv_utils.lv_check(vg_name, lv_name)
self.assertIn(vg_name, process.run("lvs --all",
sudo=True).stdout_text)
self.assertIn(lv_name, lv_utils.lv_list())
lv_utils.lv_mount(vg_name, lv_name, mount_loc, "ext2")
lv_utils.lv_umount(vg_name, lv_name)
lv_utils.lv_remove(vg_name, lv_name)
self.assertNotIn(lv_name, lv_utils.lv_list())
# Cleanup ramdisk vgs
lv_utils.vg_ramdisk_cleanup(ramdisk_filename, vg_ramdisk_dir,
vg_name, loop_device)
self.assertTrue(os.path.exists(ramdisk_basedir))
self.assertFalse(glob.glob(os.path.join(ramdisk_basedir, "*")))
except BaseException as details:
try:
process.run("mountpoint %s && umount %s"
% (mount_loc, mount_loc), shell=True, sudo=True)
except BaseException as details:
print("Fail to unmount LV: %s" % details)
try:
lv_utils.lv_remove(vg_name, lv_name)
except BaseException as details:
print("Fail to cleanup LV: %s" % details)
try:
lv_utils.vg_ramdisk_cleanup(ramdisk_filename, vg_ramdisk_dir,
vg_name, loop_device)
except BaseException as details:
print("Fail to cleanup vg_ramdisk: %s" % details)
def test_basic_workflow(self):
"""
Check the basic workflow works using ramdisk
"""
ramdisk_filename = vg_ramdisk_dir = loop_device = None
vg_name = "avocado_testing_vg_e5kj3erv11a"
lv_name = "avocado_testing_lv_lk0ff33al5h"
ramdisk_basedir = os.path.join(self.tmpdir, "foo", "bar")
mount_loc = os.path.join(self.tmpdir, "lv_mount_location")
os.mkdir(mount_loc)
try:
# Create ramdisk vg
self.assertFalse(os.path.exists(ramdisk_basedir))
self.assertFalse(lv_utils.vg_check(vg_name))
spec = lv_utils.vg_ramdisk(False, vg_name, 10, ramdisk_basedir,
"sparse_file")
ramdisk_filename, vg_ramdisk_dir, vg_name, loop_device = spec
# Check it was created properly
self.assertTrue(ramdisk_filename)
self.assertTrue(vg_ramdisk_dir)
self.assertTrue(vg_name)
self.assertTrue(loop_device)
self.assertTrue(os.path.exists(ramdisk_basedir))
self.assertTrue(glob.glob(os.path.join(ramdisk_basedir, "*")))
self.assertTrue(lv_utils.vg_check(vg_name))
vgs = lv_utils.vg_list()
self.assertIn(vg_name, vgs)
# Can't create existing vg
self.assertRaises(lv_utils.LVException, lv_utils.vg_create,
vg_name, loop_device)
# Create and check LV
lv_utils.lv_create(vg_name, lv_name, 1)
lv_utils.lv_check(vg_name, lv_name)
self.assertIn(vg_name, process.run("lvs --all",
sudo=True).stdout_text)
self.assertIn(lv_name, lv_utils.lv_list())
lv_utils.lv_mount(vg_name, lv_name, mount_loc, "ext2")
lv_utils.lv_umount(vg_name, lv_name)
lv_utils.lv_remove(vg_name, lv_name)
self.assertNotIn(lv_name, lv_utils.lv_list())
# Cleanup ramdisk vgs
lv_utils.vg_ramdisk_cleanup(ramdisk_filename, vg_ramdisk_dir,
vg_name, loop_device)
self.assertTrue(os.path.exists(ramdisk_basedir))
self.assertFalse(glob.glob(os.path.join(ramdisk_basedir, "*")))
except BaseException as details:
try:
process.run("mountpoint %s && umount %s"
% (mount_loc, mount_loc), shell=True, sudo=True)
except BaseException as details:
print("Fail to unmount LV: %s" % details)
try:
lv_utils.lv_remove(vg_name, lv_name)
except BaseException as details:
print("Fail to cleanup LV: %s" % details)
try:
lv_utils.vg_ramdisk_cleanup(ramdisk_filename, vg_ramdisk_dir,
vg_name, loop_device)
except BaseException as details:
print("Fail to cleanup vg_ramdisk: %s" % details)
def setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
pkg = ""
smm = SoftwareManager()
self.disk = self.params.get('lv_disks', default=None)
self.vg_name = self.params.get('vg_name', default='avocado_vg')
self.lv_name = self.params.get('lv_name', default='avocado_lv')
self.fs_name = self.params.get('fs', default='ext4').lower()
if self.fs_name == 'xfs':
pkg = 'xfsprogs'
if self.fs_name == '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 == 'SuSE':
pkg = 'btrfsprogs'
else:
pkg = 'btrfs-progs'
if pkg and not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("Package %s could not be installed" % pkg)
self.lv_snap_name = self.params.get(
'lv_snapshot_name', default='avocado_sn')
self.ramdisk_basedir = self.params.get(
'ramdisk_basedir', default=os.path.join(self.workdir, 'ramdisk'))
self.ramdisk_sparse_filename = self.params.get(
'ramdisk_sparse_filename', default='virtual_hdd')
if 'delete' not in str(self.name.name):
if lv_utils.vg_check(self.vg_name):
self.cancel('Volume group %s already exists' % self.vg_name)
if lv_utils.lv_check(self.vg_name, self.lv_name):
self.cancel('Logical Volume %s already exists' % self.lv_name)
if lv_utils.lv_check(self.vg_name, self.lv_snap_name):
self.cancel('Snapshot %s already exists' % self.lv_snap_name)
self.mount_loc = os.path.join(self.workdir, 'mountpoint')
if not os.path.isdir(self.mount_loc):
os.makedirs(self.mount_loc)
if self.disk:
# converting bytes to megabytes, and using only 45% of the size
self.lv_size = int(lv_utils.get_diskspace(self.disk)) / 2330168
else:
self.lv_size = '1G'
self.lv_size = self.params.get('lv_size', default=self.lv_size)
self.lv_snapshot_size = self.params.get('lv_snapshot_size',
default=self.lv_size)
self.ramdisk_vg_size = self.params.get('ramdisk_vg_size',
default=self.lv_size)
self.ramdisks.append(lv_utils.vg_ramdisk(self.disk, self.vg_name,
self.ramdisk_vg_size,
self.ramdisk_basedir,
self.ramdisk_sparse_filename))
def test_snapshot(self):
"""
General logical volume setup.
A volume group with given name is created in the ramdisk. It then
creates a logical volume. Takes a snapshot from the logical and
merges snapshot with the logical volume.
"""
self.ramdisks.append(lv_utils.vg_ramdisk(self.disk, self.vg_name,
self.ramdisk_vg_size,
self.ramdisk_basedir,
self.ramdisk_sparse_filename))
lv_utils.lv_create(self.vg_name, self.lv_name, self.lv_size)
lv_utils.lv_take_snapshot(self.vg_name, self.lv_name,
self.lv_snapshot_name,
self.lv_snapshot_size)
lv_utils.lv_revert(self.vg_name, self.lv_name, self.lv_snapshot_name)
def create_lv(self):
"""
General logical volume setup.
A volume group with given name is created in the ramdisk. It then
creates a logical volume.
"""
self.ramdisks.append(
lv_utils.vg_ramdisk(self.disk, self.vg_name, self.ramdisk_vg_size,
self.ramdisk_basedir,
self.ramdisk_sparse_filename))
lv_utils.lv_create(self.vg_name, self.lv_name, self.lv_size)
lv_utils.lv_mount(self.vg_name,
self.lv_name,
self.mount_loc,
create_filesystem=self.fs_name)
lv_utils.lv_umount(self.vg_name, self.lv_name)
def test_snapshot(self):
"""
General logical volume setup.
A volume group with given name is created in the ramdisk. It then
creates a logical volume. Takes a snapshot from the logical and
merges snapshot with the logical volume.
"""
self.ramdisks.append(lv_utils.vg_ramdisk(self.disk, self.vg_name,
self.ramdisk_vg_size,
self.ramdisk_basedir,
self.ramdisk_sparse_filename))
lv_utils.lv_create(self.vg_name, self.lv_name, self.lv_size)
lv_utils.lv_mount(self.vg_name, self.lv_name, self.mount_loc,
create_filesystem=self.fs_name)
lv_utils.lv_umount(self.vg_name, self.lv_name)
lv_utils.lv_take_snapshot(self.vg_name, self.lv_name,
self.lv_snapshot_name,
self.lv_snapshot_size)
lv_utils.lv_revert(self.vg_name, self.lv_name, self.lv_snapshot_name)