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 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