def setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
self.disk = self.params.get('disk', default=None)
vg_name = self.params.get('vg_name', default='avocado_vg')
lv_name = self.params.get('lv_name', default='avocado_lv')
self.lv_size = self.params.get('lv_size', default='1G')
self.fs_name = self.params.get('fs_name', default='ext4')
lv_snapshot_name = self.params.get('lv_snapshot_name',
default='avocado_sn')
self.lv_snapshot_size = self.params.get('lv_snapshot_size',
default='1G')
self.ramdisk_vg_size = self.params.get('ramdisk_vg_size',
default='10000')
self.ramdisk_basedir = self.params.get('ramdisk_basedir',
default=self.workdir)
self.ramdisk_sparse_filename = self.params.get(
'ramdisk_sparse_filename', default='virtual_hdd')
if lv_utils.vg_check(vg_name):
self.skip('Volume group %s already exists' % vg_name)
self.vg_name = vg_name
if lv_utils.lv_check(vg_name, lv_name):
self.skip('Logical Volume %s already exists' % lv_name)
self.lv_name = lv_name
if lv_utils.lv_check(vg_name, lv_snapshot_name):
self.skip('Snapshot %s already exists' % lv_snapshot_name)
self.mount_loc = 'avocado_%s' % self.fs_name
os.mkdir(self.mount_loc)
self.lv_snapshot_name = lv_snapshot_name
def setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
self.disk = self.params.get('disk', default=None)
vg_name = self.params.get('vg_name', default='avocado_vg')
lv_name = self.params.get('lv_name', default='avocado_lv')
self.lv_size = self.params.get('lv_size', default='1G')
self.fs_name = self.params.get('fs_name', default='ext4')
lv_snapshot_name = self.params.get(
'lv_snapshot_name', default='avocado_sn')
self.lv_snapshot_size = self.params.get(
'lv_snapshot_size', default='1G')
self.ramdisk_vg_size = self.params.get(
'ramdisk_vg_size', default='10000')
self.ramdisk_basedir = self.params.get(
'ramdisk_basedir', default=self.workdir)
self.ramdisk_sparse_filename = self.params.get(
'ramdisk_sparse_filename', default='virtual_hdd')
if lv_utils.vg_check(vg_name):
self.skip('Volume group %s already exists' % vg_name)
self.vg_name = vg_name
if lv_utils.lv_check(vg_name, lv_name):
self.skip('Logical Volume %s already exists' % lv_name)
self.lv_name = lv_name
if lv_utils.lv_check(vg_name, lv_snapshot_name):
self.skip('Snapshot %s already exists' % lv_snapshot_name)
self.mount_loc = 'avocado_%s' % self.fs_name
os.mkdir(self.mount_loc)
self.lv_snapshot_name = lv_snapshot_name
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 setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
pkg = ""
smm = SoftwareManager()
self.disk = self.params.get('disks', default=None)
vg_name = self.params.get('vg_name', default='avocado_vg')
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':
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)
lv_snapshot_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 lv_utils.vg_check(vg_name):
self.cancel('Volume group %s already exists' % vg_name)
self.vg_name = vg_name
if lv_utils.lv_check(vg_name, lv_name):
self.cancel('Logical Volume %s already exists' % lv_name)
self.lv_name = lv_name
if lv_utils.lv_check(vg_name, lv_snapshot_name):
self.cancel('Snapshot %s already exists' % lv_snapshot_name)
self.mount_loc = os.path.join(self.workdir, 'mountpoint')
if not os.path.isdir(self.mount_loc):
os.makedirs(self.mount_loc)
self.lv_snapshot_name = lv_snapshot_name
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)
def pre_cleanup(self):
"""
cleanup the disk and directory before test starts on it
"""
self.log.info("Pre_cleaning of disk and diretories...")
disk_list = [
'/dev/mapper/avocado_vg-avocado_lv', self.raid_name, self.disk
]
for disk in disk_list:
self.delete_fs(disk)
self.log.info("checking ...lv/vg existance...")
if lv_utils.lv_check(self.vgname, self.lvname):
self.log.info("found lv existance... deleting it")
self.delete_lv()
elif lv_utils.vg_check(self.vgname):
self.log.info("found vg existance ... deleting it")
lv_utils.vg_remove(self.vgname)
else:
self.log.info("No VG/LV detected")
self.log.info("checking for sraid existance...")
if self.sraid.exists():
self.log.info("found sraid existance... deleting it")
self.delete_raid()
else:
self.log.info("No softwareraid detected ")
self.log.info("\n End of pre_cleanup")
def is_lv_deleted():
lv_utils.lv_remove(self.vgname, self.lvname)
time.sleep(5)
lv_utils.vg_remove(self.vgname)
if lv_utils.lv_check(self.vgname, self.lvname):
return False
return True
def delete_lv(self):
"""
Clear all PV,VG, LV and snapshots created by the test.
"""
if lv_utils.lv_check(self.vg_name, self.lv_name):
lv_utils.lv_remove(self.vg_name, self.lv_name)
if lv_utils.vg_check(self.vg_name):
lv_utils.vg_remove(self.vg_name)
def setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
pkg = ""
smm = SoftwareManager()
self.disk = self.params.get('disks', default=None)
vg_name = self.params.get('vg_name', default='avocado_vg')
lv_name = self.params.get('lv_name', default='avocado_lv')
self.lv_size = self.params.get('lv_size', default='1G')
self.fs_name = self.params.get('fs', default='ext4').lower()
if self.fs_name == 'xfs':
pkg = 'xfsprogs'
if self.fs_name == 'btrfs':
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 is missing and could not be installed" % pkg)
lv_snapshot_name = self.params.get(
'lv_snapshot_name', default='avocado_sn')
self.lv_snapshot_size = self.params.get(
'lv_snapshot_size', default='1G')
self.ramdisk_vg_size = self.params.get(
'ramdisk_vg_size', default='10000')
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 lv_utils.vg_check(vg_name):
self.cancel('Volume group %s already exists' % vg_name)
self.vg_name = vg_name
if lv_utils.lv_check(vg_name, lv_name):
self.cancel('Logical Volume %s already exists' % lv_name)
self.lv_name = lv_name
if lv_utils.lv_check(vg_name, lv_snapshot_name):
self.cancel('Snapshot %s already exists' % lv_snapshot_name)
self.mount_loc = os.path.join(self.workdir, 'mountpoint')
if not os.path.isdir(self.mount_loc):
os.makedirs(self.mount_loc)
self.lv_snapshot_name = lv_snapshot_name
def setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
pkg = ""
smm = SoftwareManager()
self.disk = self.params.get('disk', default=None)
vg_name = self.params.get('vg_name', default='avocado_vg')
lv_name = self.params.get('lv_name', default='avocado_lv')
self.lv_size = self.params.get('lv_size', default='1G')
self.fs_name = self.params.get('fs', default='ext4').lower()
if self.fs_name == 'xfs':
pkg = 'xfsprogs'
if self.fs_name == 'btrfs':
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 is missing and could not be installed" %
pkg)
lv_snapshot_name = self.params.get('lv_snapshot_name',
default='avocado_sn')
self.lv_snapshot_size = self.params.get('lv_snapshot_size',
default='1G')
self.ramdisk_vg_size = self.params.get('ramdisk_vg_size',
default='10000')
self.ramdisk_basedir = self.params.get('ramdisk_basedir',
default=self.workdir)
self.ramdisk_sparse_filename = self.params.get(
'ramdisk_sparse_filename', default='virtual_hdd')
if lv_utils.vg_check(vg_name):
self.cancel('Volume group %s already exists' % vg_name)
self.vg_name = vg_name
if lv_utils.lv_check(vg_name, lv_name):
self.cancel('Logical Volume %s already exists' % lv_name)
self.lv_name = lv_name
if lv_utils.lv_check(vg_name, lv_snapshot_name):
self.cancel('Snapshot %s already exists' % lv_snapshot_name)
self.mount_loc = self.srcdir
self.lv_snapshot_name = 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.
"""
lv_utils.vg_create(self.vg_name, self.device)
if not lv_utils.vg_check(self.vg_name):
self.fail('Volume group %s not created' % self.vg_name)
lv_utils.lv_create(self.vg_name, self.lv_name, self.lv_size)
if not lv_utils.lv_check(self.vg_name, self.lv_name):
self.fail('Logical Volume %s not created' % self.lv_name)
def check(cls, params, object=None):
"""
Check whether a given state exists.
All arguments match the base class.
"""
vm_name = params["vms"]
params["lv_snapshot_name"] = params["check_state"]
logging.debug("Checking %s for state '%s'", vm_name,
params["check_state"])
if lv_utils.lv_check(params["vg_name"], params["lv_snapshot_name"]):
logging.info("Off snapshot '%s' of %s exists",
params["check_state"], vm_name)
return True
else:
logging.info("Off snapshot '%s' of %s doesn't exist",
params["check_state"], vm_name)
return False
def check_root(cls, params, object=None):
"""
Check whether a root state or essentially the object exists.
All arguments match the base class.
"""
vm_name = params["vms"]
image_name = params["image_name"]
logging.debug("Checking whether %s exists (root state requested)",
vm_name)
if lv_utils.lv_check(params["vg_name"], params["lv_name"]):
logging.info("The required virtual machine %s's %s (%s) exists",
vm_name, image_name, params["lv_name"])
return True
else:
logging.info(
"The required virtual machine %s's %s (%s) doesn't exist",
vm_name, image_name, params["lv_name"])
return False
def check_root(params, object=None):
"""
Check whether a root state or essentially the object exists.
All arguments match the base class.
"""
vm_name = params["vms"]
check_opts = params.get_dict("check_opts")
print_pos, print_neg = check_opts["print_pos"] == "yes", check_opts[
"print_neg"] == "yes"
logging.debug("Checking whether %s exists (root off state requested)",
vm_name)
condition = lv_utils.lv_check(params["vg_name"], params["lv_name"])
if condition and print_pos:
logging.info("The required virtual machine %s exists", vm_name)
if not condition and print_neg:
logging.info("The required virtual machine %s doesn't exist",
vm_name)
return condition
def check(params, object=None):
"""
Check whether a given state exists.
All arguments match the base class.
"""
vm_name = params["vms"]
check_opts = params.get_dict("check_opts")
print_pos, print_neg = check_opts["print_pos"] == "yes", check_opts[
"print_neg"] == "yes"
params["lv_snapshot_name"] = params["check_state"]
logging.debug("Checking %s for off state '%s'", vm_name,
params["check_state"])
condition = lv_utils.lv_check(params["vg_name"],
params["lv_snapshot_name"])
if condition and print_pos:
logging.info("Off snapshot '%s' of %s exists",
params["check_state"], vm_name)
if not condition and print_neg:
logging.info("Off snapshot '%s' of %s doesn't exist",
params["check_state"], vm_name)
return condition
def setUp(self):
"""
Check existence of input PV,VG, LV and snapshots prior to Test.
"""
pkgs = [""]
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()
self.lv_size = self.params.get('lv_size', default='0')
if self.fs_name == 'xfs':
pkgs = ['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':
pkgs = ['btrfsprogs']
else:
pkgs = ['btrfs-progs']
if distro.detect().name in ['Ubuntu', 'debian']:
pkgs.extend(['lvm2'])
for pkg in pkgs:
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')
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.lv_size:
# converting to megabytes
if self.lv_size.endswith('G'):
self.lv_size = int(self.lv_size.strip('G')) * 1024
elif self.lv_size.endswith('M'):
self.lv_size = int(self.lv_size.strip('M'))
else:
self.lv_size = int(self.lv_size) / 1024 / 1024
if self.disk:
disk_size = lv_utils.get_devices_total_space(self.disk.split())
# converting bytes to megabytes
disk_size = disk_size / (1024 * 1024)
if self.lv_size:
if self.lv_size > disk_size:
self.cancel("lv size provided more than size of disks")
else:
self.lv_size = disk_size
self.device = self.disk
else:
if not self.lv_size:
self.lv_size = 1024 * 1024 * 1024
try:
self.device = disk.create_loop_device(self.lv_size)
except DiskError:
self.cancel("Could not create loop device")
# converting bytes to megabytes
self.lv_size = self.lv_size / (1024 * 1024)
# Using only 45% of lv size, to accomodate lv snapshot also.
self.lv_size = (self.lv_size * 45) / 100
self.lv_snapshot_size = self.params.get('lv_snapshot_size',
default=self.lv_size)
def _check_state(vm, vm_params, print_pos=False, print_neg=False):
"""
Check for an online/offline state of a vm object.
We use LVM for offline snapshots and QCOW2 for online snapshots.
"""
vm_name = vm_params["vms"]
if vm_params["check_type"] == "offline":
vm_params["lv_snapshot_name"] = vm_params["check_state"]
if vm_params.get("check_state", "root") in OFFLINE_ROOTS:
logging.debug("Checking whether %s exists (root offline state requested)", vm_name)
if vm_params.get("image_format", "qcow2") != "raw":
logging.debug("Checking using %s image", vm_params.get("image_format", "qcow2"))
condition = os.path.exists("%s.%s" % (vm_params["image_name"],
vm_params.get("image_format", "qcow2")))
else:
logging.debug("Checking using raw image")
condition = os.path.exists(vm_params["image_name"])
if not condition and vm_params.get("vg_name") is not None:
condition = lv_utils.lv_check(vm_params["vg_name"], vm_params["lv_name"])
if not condition:
if print_neg:
logging.info("The required virtual machine %s doesn't exist", vm_name)
return False
else:
if print_pos:
logging.info("The required virtual machine %s exists", vm_name)
return True
else:
logging.debug("Checking %s for offline state '%s'", vm_name, vm_params["check_state"])
if not lv_utils.lv_check(vm_params["vg_name"], vm_params["lv_snapshot_name"]):
if print_neg:
logging.info("Offline snapshot '%s' of %s doesn't exist",
vm_params["check_state"], vm_name)
return False
else:
if print_pos:
logging.info("Offline snapshot '%s' of %s exists",
vm_params["check_state"], vm_name)
return True
else:
if vm_params.get("check_state", "boot") in ONLINE_ROOTS:
logging.debug("Checking whether %s is online (root online state requested)", vm_name)
try:
state_exists = vm.is_alive()
except ValueError:
state_exists = False
if state_exists and print_pos:
logging.info("The required virtual machine %s is online", vm_name)
elif not state_exists and print_neg:
logging.info("The required virtual machine %s is offline", vm_name)
return state_exists
else:
if vm_params["check_type"] == "ramfile":
state_dir = vm_params.get("image_name", "")
state_dir = os.path.dirname(state_dir)
state_file = os.path.join(state_dir, vm_params["check_state"])
state_file = "%s.state" % state_file
if not os.path.exists(state_file):
if print_neg:
logging.info("Ramfile snapshot '%s' of %s doesn't exist",
vm_params["check_state"], vm_name)
return False
else:
if print_pos:
logging.info("Ramfile snapshot '%s' of %s exists",
vm_params["check_state"], vm_name)
return True
else:
logging.debug("Checking %s for online state '%s'",
vm_name, vm_params["check_state"])
vm_image = "%s.%s" % (vm_params["image_name"],
vm_params.get("image_format", "qcow2"))
if not os.path.exists(vm_image):
return False
qemu_img = vm_params.get("qemu_img_binary", "/usr/bin/qemu-img")
online_snapshots_dump = process.system_output("%s snapshot -l %s -U" % (qemu_img, vm_image)).decode()
logging.debug("Listed online states:\n%s", online_snapshots_dump)
state_tuples = re.findall("\d+\s+([\w\.]+)\s+([\w\.]+)\s+\d{4}-\d\d-\d\d",
online_snapshots_dump)
for state_tuple in state_tuples:
logging.debug("Detected online state '%s' of size %s",
state_tuple[0], state_tuple[1])
if state_tuple[0] == vm_params["check_state"]:
if print_pos:
logging.info("Online snapshot '%s' of %s exists",
vm_params["check_state"], vm_name)
return True
# at this point we didn't find the online state in the listed ones
if print_neg:
logging.info("Online snapshot '%s' of %s doesn't exist",
vm_params["check_state"], vm_name)
return False
