def has_space(self, percentage=100): """ See if we have enough space to try a snapshot. """ ret = False for vgname in self._vgnames: use = self._use_dev(vgname) if use is not None and not use: continue vg = lvm.vgOpen(vgname, 'r') if not vg: return False vgfsize = vg.getFreeSize() lvssize = 0 for lv in vg.listLVs(): if not self._use_dev(vgname, lv): continue lvssize += lv.getSize() vg.close() if not lvssize: continue ret = True if (lvssize * percentage) > (100 * vgfsize): return False return ret
def create_delete_logical_volume(): vg_name = find_vg_with_free_space() print('Using volume group ', vg_name, ' for example') if vg_name: vg = lvm.vgOpen(vg_name, 'w') lv = vg.createLvLinear('python_lvm_ok_to_delete', vg.getFreeSize()) if lv: print('New lv, id= ', lv.getUuid()) #Create a tag lv.addTag('Demo_tag') #Get the tags tags = lv.getTags() for t in tags: #Remove tag lv.removeTag(t) lv.deactivate() #Try to rename lv.rename("python_lvm_renamed") print('LV name= ', lv.getName()) lv.remove() vg.close() else: print('No free space available to create demo lv!')
def do_remove_storage(_): """Destroys logical volume and volume group created for local storage. Returns tuple of success flag and list of devices which were used in destroyed VG. Result of the function will be additionally processed, so it does not return readable statuses of performed operation. """ all_names = lvm.listVgNames() if KD_VG_NAME not in all_names: return True, [] vg = lvm.vgOpen(KD_VG_NAME, 'w') try: silent_call(['umount', '-f', LOCAL_STORAGE_MOUNT_POINT]) pvs = [item.getName() for item in vg.listPVs()] for lv in vg.listLVs(): lv.deactivate() lv.remove() vg.remove() remove_ls_mount() return True, pvs except Exception as err: return False, u'Exception: {}'.format(err) finally: vg.close()
def del_snapshots(self, devices=[]): """ Remove snapshots. """ if not lvm: return [] ret = [] togo = {} for dev in devices: vgname, lvname = dev.split('/') if vgname not in togo: togo[vgname] = set([lvname]) else: togo[vgname].add(lvname) for vgname in togo: vg = lvm.vgOpen(vgname, 'w') for lvname in togo[vgname]: lv = _vg_name2lv(vg, lvname) if not lv: continue if not _is_snap(lv): # No snapshot means don't try to delete! continue ret.append(_lv_data(vg, lv)) lv.remove() vg.close() return ret
def in_vg(vg_name, device): vg = lvm.vgOpen(vg_name, 'r') pv_list = vg.listPVs() for pv in pv_list: if pv.getName() == device: return True return False
def test_vg_uuids(self): device_names = TestLvm._get_pv_device_names() TestLvm._create_thin_lv(device_names[0:2], 'thin') TestLvm._create_thick_lv(device_names[2:4], 'thick') vgs_uuids = lvm.listVgUuids() self.assertTrue(len(vgs_uuids) > 0) self.assertTrue(isinstance(vgs_uuids, tuple)) vgs_uuids = list(vgs_uuids) vgs_names = lvm.listVgNames() for vg_name in vgs_names: vg = lvm.vgOpen(vg_name, "r") #TODO Write/fix BUG, vg uuid don't match between #lvm.listVgUuids and vg.getUuid() vg_uuid_search = vg.getUuid().replace('-', '') self.assertTrue(vg_uuid_search in vgs_uuids) vgs_uuids.remove(vg_uuid_search) vg.close() self.assertTrue(len(vgs_uuids) == 0)
def testVgGetName(self): vgname_list = lvm.listVgNames() for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') self.assertEqual(vg.getName(), vg_name) vg.close()
def del_snapshots(self, devices=[]): """ Remove snapshots. """ if not lvm: return [] ret = [] togo = {} for dev in devices: vgname,lvname = dev.split('/') if vgname not in togo: togo[vgname] = set([lvname]) else: togo[vgname].add(lvname) for vgname in togo: vg = lvm.vgOpen(vgname, 'w') for lvname in togo[vgname]: lv = _vg_name2lv(vg, lvname) if not lv: continue if not _is_snap(lv): # No snapshot means don't try to delete! continue ret.append(_lv_data(vg, lv)) lv.remove() vg.close() return ret
def test_pv_lookup_from_vg(self): device_names = TestLvm._get_pv_device_names() TestLvm._create_thin_lv(device_names[0:2], 'thin') TestLvm._create_thick_lv(device_names[2:4], 'thick') vg_names = TestLvm._vg_names() self.assertTrue(len(vg_names) > 0) for vg_name in vg_names: vg = lvm.vgOpen(vg_name, 'w') pvs = vg.listPVs() for p in pvs: name = p.getName() uuid = p.getUuid() pv_name_lookup = vg.pvFromName(name) pv_uuid_lookup = vg.pvFromUuid(uuid) self.assertTrue( pv_name_lookup.getName() == pv_uuid_lookup.getName()) self.assertTrue( pv_name_lookup.getUuid() == pv_uuid_lookup.getUuid()) self.assertTrue(name == pv_name_lookup.getName()) self.assertTrue(uuid == pv_uuid_lookup.getUuid()) pv_name_lookup = None pv_uuid_lookup = None p = None pvs = None vg.close()
def testPvLookupFromVG(self): vg_names = lvm.listVgNames() for vg_name in vg_names: vg = lvm.vgOpen(vg_name, 'w') pvs = vg.listPVs() for p in pvs: name = p.getName() uuid = p.getUuid() pv_name_lookup = vg.pvFromName(name) pv_uuid_lookup = vg.pvFromUuid(uuid) self.assertTrue(pv_name_lookup.getName() == \ pv_uuid_lookup.getName()) self.assertTrue(pv_name_lookup.getUuid() == \ pv_uuid_lookup.getUuid()) self.assertTrue(name == pv_name_lookup.getName()) self.assertTrue(uuid == pv_uuid_lookup.getUuid()) pv_name_lookup = None pv_uuid_lookup = None p = None pvs = None vg.close()
def _removeThick(self): vg_name = 'full_vg' vg = lvm.vgOpen(vg_name, 'w') pvs = vg.listPVs() lvs = vg.listLVs() pe_devices = [] #Remove old snapshots first, then lv for l in lvs: attr = l.getAttr() if attr[0] == 's': l.remove() for l in vg.listLVs(): l.remove() for p in pvs: pe_devices.append(p.getName()) for pv in pe_devices: vg.reduce(pv) vg.remove() vg.close()
def createThinVolume(version, vg_name, lv_name): vg = lvm.vgOpen(vg_name,'w') thinpoolname = get_post_data('thinpool', '') size = int(get_post_data('size', 1000000)) vg.createLvThin(thinpoolname, lv_name, size) vg.close() return
def testVgTags(self): vg_name_list = lvm.listVgNames() for vg_name in vg_name_list: vg = lvm.vgOpen(vg_name, 'w') self._testTags(vg) vg.close()
def has_space(self, percentage=100): """ See if we have enough space to try a snapshot. """ ret = False for vgname in self._vgnames: use = self._use_dev(vgname) if use is not None and not use: continue vg = lvm.vgOpen(vgname, 'r') if not vg: return False vgfsize = vg.getFreeSize() lvssize = 0 for lv in vg.listLVs(): if not self._use_dev(vgname, lv): continue lvssize += lv.getSize() vg.close() if not lvssize: continue ret = True if (lvssize * percentage) > (100*vgfsize): return False return ret
def lv_path(vg_name, lv_name): if lv_exists(vg_name, lv_name): vg = lvm.vgOpen(vg_name, 'r') for lv in vg.listLVs(): if lv.getName() == lv_name: lv_path = lv.getProperty('lv_path') return lv_path[0]
def lv_exists(vg_name, lv_name): if not vg_exists(vg_name): return False vg = lvm.vgOpen(vg_name, 'r') for lv in vg.listLVs(): if lv.getName() == lv_name: return True
def _get_pv_test(self, mode='r'): vg_name_list = lvm.listVgNames() for vgname in vg_name_list: vg = lvm.vgOpen(vgname, mode) pvs = vg.listPVs() if len(pvs): return pvs[0] return None
def _get_pv_test(self): vg_name_list = lvm.listVgNames() for vgname in vg_name_list: vg = lvm.vgOpen(vgname, "w") pvs = vg.listPVs() if len(pvs): return pvs[0], vg return None, None
def vg_exists(vg_name): vg = None try: vg = lvm.vgOpen(vg_name, 'r') except Exception as e: # log.debug(e) return False return vg
def add_devices_to_localstorage(devices): """Initializes KD volume group: Creates vg if it not exists, activates it if not active. Adds devices to VG. """ all_names = lvm.listVgNames() if KD_VG_NAME not in all_names: vg = lvm.vgCreate(KD_VG_NAME) else: vg = lvm.vgOpen(KD_VG_NAME, 'w') try: pvs = {item.getName(): item for item in vg.listPVs()} lv = None for dev in devices: if dev in pvs: continue lvm.pvCreate(dev) vg.extend(dev) new_pv = [ item for item in vg.listPVs() if item.getName() == dev ][0] pvs[dev] = new_pv for item in vg.listLVs(): if item.getName() == KD_LV_NAME: lv = item break #dev = os.path.join('/dev', KD_VG_NAME, KD_LV_NAME) if not os.path.isdir(LOCAL_STORAGE_MOUNT_POINT): os.makedirs(LOCAL_STORAGE_MOUNT_POINT) if not lv: lv = vg.createLvLinear(KD_LV_NAME, vg.getFreeSize()) dev = lv.getProperty('lv_path')[0] ok, message = make_fs(dev) if not ok: return ERROR, {'message': message} else: dev = lv.getProperty('lv_path')[0] if vg.getFreeSize(): lv.resize(lv.getSize() + vg.getFreeSize()) if not is_mounted(LOCAL_STORAGE_MOUNT_POINT): ok, message = mount(dev, LOCAL_STORAGE_MOUNT_POINT) if not ok: return ERROR, {'message': message} extend_fs_size(LOCAL_STORAGE_MOUNT_POINT) pv_info = { key: {'size': item.getDevSize()} for key, item in pvs.iteritems() } finally: vg.close() make_permanent_mount(dev, LOCAL_STORAGE_MOUNT_POINT) return OK, { 'lsUsage': get_fs_usage(LOCAL_STORAGE_MOUNT_POINT), 'PV': pv_info }
def testVgGetUuid(self): vgname_list = lvm.listVgNames() for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') uuid = vg.getUuid() self.assertNotEqual(uuid, None) self.assertTrue(len(uuid) > 0) vg.close()
def volume_group(name, mode='r'): with restored_ipc_ns(): vg = None try: vg = lvm.vgOpen(name, mode) yield vg finally: if vg is not None: vg.close()
def testVGsetGetProp(self): vg_name = 'full_vg' vg = lvm.vgOpen(vg_name, 'w') self.assertTrue(vg is not None) if vg: vg_mda_copies = vg.getProperty('vg_mda_copies') vg.setProperty('vg_mda_copies', vg_mda_copies[0]) vg.close()
def testLvMisc(self): #Need to look at lack of vg_write in vg create #For this to work cleanly we will remove an existing lv & vg and then #put it back so that the test framework can clean it up. vg_name_list = lvm.listVgNames() if len(vg_name_list): vg_name = vg_name_list[0] vg = lvm.vgOpen(vg_name, "w") vg_mda_copies = vg.getProperty('vg_mda_copies') vg.setProperty('vg_mda_copies', vg_mda_copies[0]) pvs = vg.listPVs() lvs = vg.listLVs() pe_devices = [] for p in pvs: pe_devices.append(p.getName()) self.assertEquals(len(lvs), 1) lv = lvs[0] lv_name = lv.getName() lv_size = lv.getSize() lv.remove() lv = None vg.reduce(pe_devices[0]) vg.remove() vg.close() nvg = lvm.vgCreate(vg_name) for p in pe_devices: nvg.extend(p) #2MiB extent size new_extent = 1024 * 1024 * 2 nvg.setExtentSize(new_extent) self.assertEqual(nvg.getExtentSize(), new_extent) v = nvg.createLvLinear(lv_name, lv_size) lv_find_name = nvg.lvFromName(lv_name) lv_find_uuid = nvg.lvFromUuid(v.getUuid()) self.assertTrue(lv_find_name.getName() == v.getName()) self.assertTrue(lv_find_uuid.getUuid() == v.getUuid()) nvg.close()
def print_lvm_stuff(): vg_names = lvm.listVgNames() for vg_name in vg_names: vg = lvm.vgOpen(vg_name, 'r') print '==================================' print\ 'VG name:{}\nID:{}\nSize:{}\nExtentCount:{}\nExtentSize:{}\nFreeExtentCount:{}\nFreeSize:{}\nMaxLv:{}\nMaxPv:{}\nPvCount:{}\nSeqno:{}\nClustered:{}\nExported:{}\nPartial:{}'.format( vg.getName(), vg.getUuid(), vg.getSize(), vg.getExtentCount(), vg.getExtentSize(), vg.getFreeExtentCount(), vg.getFreeSize(), vg.getMaxLv(), vg.getMaxPv(), vg.getPvCount(), vg.getSeqno(), vg.isClustered(), vg.isExported(), vg.isPartial() ) print '\\\\\\\\\\\\\\\\PVs\\\\\\\\\\\\\\\\\\\\\\\\\\' pv_list = vg.listPVs() for pv in pv_list: print\ 'PV name:{}\nID:{}\nSize:{}\nMdaCount:{}\nFree:{}\nDevSize:{}\n'.format( pv.getName(), pv.getUuid(), pv.getSize(), pv.getMdaCount(), pv.getFree(), pv.getDevSize() ) print '\\\\\\\\\\\\\\\\PVs\\\\\\\\\\\\\\\\\\\\\\\\\\' print '\\\\\\\\\\\\\\\\LVs\\\\\\\\\\\\\\\\\\\\\\\\\\' lv_list = vg.listLVs() for lv in lv_list: print\ 'LV name:{}\nID:{}\nSize:{}\nAttr:{}\nOrigin:{}\nActive:{}\nSuspended:{}'.format( lv.getName(), lv.getUuid(), lv.getSize(), lv.getAttr(), lv.getOrigin(), lv.isActive(), lv.isSuspended() ) print '\\\\\\\\\\\\\\\\LVs\\\\\\\\\\\\\\\\\\\\\\\\\\' vg.close() return True
def snapshot(self, percentage=100, prefix='', postfix=None, tags={}): """ Attempt to take a snapshot, note that errors can happen after this function succeeds. """ if postfix is None: postfix = '%s%s' % (self.postfix_static, datetime.now().strftime("%Y%m%d%H%M%S.%f")) ret = [] for vgname in self._vgnames: use = self._use_dev(vgname) if use is not None and not use: continue vg = lvm.vgOpen(vgname, 'w') if not vg: raise _ResultError( _("Unknown error when opening volume group ") + vgname) for lv in vg.listLVs(): lvname = lv.getName() if not self._use_dev(vgname, lv): continue nlvname = "%s%s%s" % (prefix, lvname, postfix) nlv = lv.snapshot(nlvname, (lv.getSize() * percentage) / 100) if not nlv: # Failed here ... continuing seems bad. vg.close() raise _ResultError( _("Unknown error when creating snapshot ") + nlvname) odev = "%s/%s" % (vgname, lvname) ndev = "%s/%s" % (vgname, nlvname) # FIXME: yum_fssnapshot_pre_lv_name=<blah> eq_tags = set() for val in (ndev, odev, '*'): for tag in tags.get(val, []): if '=' in tag: eq_tag_key, eq_tag_val = tag.split('=', 1) if eq_tag_key in eq_tags: continue eq_tags.add(eq_tag_key) nlv.addTag(tag) ret.append((odev, ndev)) vg.close() return ret
def testVGremoveRestore(self): #Store off the list of physical devices pe_devices = [] vg = lvm.vgOpen('full_vg', 'w') pvs = vg.listPVs() for p in pvs: pe_devices.append(p.getName()) vg.close() self._removeThick() self._createThick(pe_devices)
def testVgGetName(self): device_names = self._get_pv_device_names() self._createThinLV(device_names[0:2], 'thin') self._createThickLV(device_names[2:4], 'thick') vgname_list = self._vg_names() self.assertTrue(len(vgname_list) > 0) for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') self.assertEqual(vg.getName(), vg_name) vg.close()
def test_vg_get_name(self): device_names = TestLvm._get_pv_device_names() TestLvm._create_thin_lv(device_names[0:2], 'thin') TestLvm._create_thick_lv(device_names[2:4], 'thick') vgname_list = TestLvm._vg_names() self.assertTrue(len(vgname_list) > 0) for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') self.assertEqual(vg.getName(), vg_name) vg.close()
def testVgFromPVLookups(self): vgname_list = lvm.listVgNames() for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') vg_name = vg.getName() pv_list = vg.listPVs() for pv in pv_list: vg_name_from_pv = lvm.vgNameFromPvid(pv.getUuid()) self.assertEquals(vg_name, vg_name_from_pv) self.assertEqual(vg_name, lvm.vgNameFromDevice(pv.getName())) vg.close()
def test_vg_reduce(self): # Test the case where we try to reduce a vg where the last PV has # no metadata copies. In this case the reduce should fail. vg_name = TestLvm.VG_P + 'reduce_test' device_names = TestLvm._get_pv_device_names() for d in device_names: lvm.pvRemove(d) lvm.pvCreate(device_names[0], 0, 0) # Size all, pvmetadatacopies 0 lvm.pvCreate(device_names[1]) lvm.pvCreate(device_names[2]) lvm.pvCreate(device_names[3]) vg = lvm.vgCreate(vg_name) vg.extend(device_names[3]) vg.extend(device_names[2]) vg.extend(device_names[1]) vg.extend(device_names[0]) vg.close() vg = None vg = lvm.vgOpen(vg_name, 'w') vg.reduce(device_names[3]) vg.reduce(device_names[2]) self.assertRaises(lvm.LibLVMError, vg.reduce, device_names[1]) vg.close() vg = None vg = lvm.vgOpen(vg_name, 'w') vg.remove() vg.close()
def find_vg_with_free_space(): free_space = 0 rc = None vg_names = lvm.listVgNames() for v in vg_names: vg = lvm.vgOpen(v, 'r') c_free = vg.getFreeSize() if c_free > free_space: free_space = c_free rc = v vg.close() return rc
def snapshot(self, percentage=100, prefix='', postfix=None, tags={}): """ Attempt to take a snapshot, note that errors can happen after this function succeeds. """ if postfix is None: postfix = self.postfix ret = [] for vgname in self._vgnames: use = self._use_dev(vgname) if use is not None and not use: continue vg = lvm.vgOpen(vgname, 'w') if not vg: return False for lv in vg.listLVs(): lvname = lv.getName() if not self._use_dev(vgname, lv): continue nlvname = "%s%s%s" % (prefix, lvname, postfix) nlv = lv.snapshot(nlvname, (lv.getSize() * percentage) / 100) if not nlv: # Failed here ... continuing seems bad. vg.close() return None odev = "%s/%s" % (vgname, lvname) ndev = "%s/%s" % (vgname, nlvname) # FIXME: yum_fssnapshot_pre_lv_name=<blah> eq_tags = set() for val in (ndev, odev, '*'): for tag in tags.get(val, []): if '=' in tag: eq_tag_key, eq_tag_val = tag.split('=', 1) if eq_tag_key in eq_tags: continue eq_tags.add(eq_tag_key) nlv.addTag(tag) ret.append((odev, ndev)) vg.close() return ret
def snapshot(self, percentage=100, prefix='', postfix=None, tags={}): """ Attempt to take a snapshot, note that errors can happen after this function succeeds. """ if postfix is None: postfix = '%s%s' % (self.postfix_static, datetime.now().strftime("%Y%m%d%H%M%S.%f")) ret = [] for vgname in self._vgnames: use = self._use_dev(vgname) if use is not None and not use: continue vg = lvm.vgOpen(vgname, 'w') if not vg: return False for lv in vg.listLVs(): lvname = lv.getName() if not self._use_dev(vgname, lv): continue nlvname = "%s%s%s" % (prefix, lvname, postfix) nlv = lv.snapshot(nlvname, (lv.getSize() * percentage) / 100) if not nlv: # Failed here ... continuing seems bad. vg.close() return None odev = "%s/%s" % (vgname, lvname) ndev = "%s/%s" % (vgname, nlvname) # FIXME: yum_fssnapshot_pre_lv_name=<blah> eq_tags = set() for val in (ndev, odev, '*'): for tag in tags.get(val, []): if '=' in tag: eq_tag_key,eq_tag_val = tag.split('=', 1) if eq_tag_key in eq_tags: continue eq_tags.add(eq_tag_key) nlv.addTag(tag) ret.append((odev, ndev)) vg.close() return ret
def testVgGetUuid(self): device_names = self._get_pv_device_names() self._createThinLV(device_names[0:2], 'thin') self._createThickLV(device_names[2:4], 'thick') vgname_list = self._vg_names() self.assertTrue(len(vgname_list) > 0) for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') uuid = vg.getUuid() self.assertNotEqual(uuid, None) self.assertTrue(len(uuid) > 0) vg.close()
def testVgTags(self): device_names = self._get_pv_device_names() i = 0 for d in device_names: if i % 2 == 0: self._createThinLV([d], "thin_lv%d" % i) else: self._createThickLV([d], "thick_lv%d" % i) i += 1 for vg_name in self._vg_names(): vg = lvm.vgOpen(vg_name, 'w') self._testTags(vg) vg.close()
def test_vg_tags(self): device_names = TestLvm._get_pv_device_names() i = 0 for d in device_names: if i % 2 == 0: TestLvm._create_thin_lv([d], "thin_lv%d" % i) else: TestLvm._create_thick_lv([d], "thick_lv%d" % i) i += 1 for vg_name in TestLvm._vg_names(): vg = lvm.vgOpen(vg_name, 'w') self._test_tags(vg) vg.close()
def test_vg_get_uuid(self): device_names = TestLvm._get_pv_device_names() TestLvm._create_thin_lv(device_names[0:2], 'thin') TestLvm._create_thick_lv(device_names[2:4], 'thick') vgname_list = TestLvm._vg_names() self.assertTrue(len(vgname_list) > 0) for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') uuid = vg.getUuid() self.assertNotEqual(uuid, None) self.assertTrue(len(uuid) > 0) vg.close()
def initialize(config_dict): global pools pools = config_dict['block_pools'] global target_name target_name = config_dict['target_name'] # fail early if can't access any vg for pool in pools: vg_name, thin_pool = get_vg_lv(pool) test_vg = lvm.vgOpen(vg_name) test_vg.close() # Allowed multi-pool configs: # two thinpools from a single vg: ok # two vgs: ok # vg and a thinpool from that vg: BAD # if thin_pool and vg_name in pools: raise TargetdError(-1, "VG pool and thin pool from same VG not supported") return dict( disk_list=disk_list, pv_list=pv_list, pv_create=pv_create, pv_destroy=pv_destroy, vg_list=vg_list, vg_create=vg_create, vg_destroy=vg_destroy, vol_list=vol_list, vol_create=vol_create, vol_destroy=vol_destroy, vol_copy=vol_copy, export_list=export_list, export_create=export_create, export_destroy=export_destroy, initiator_set_auth=initiator_set_auth, initiator_list=initiator_list, access_group_list=access_group_list, access_group_create=access_group_create, access_group_destroy=access_group_destroy, access_group_init_add=access_group_init_add, access_group_init_del=access_group_init_del, access_group_map_list=access_group_map_list, access_group_map_create=access_group_map_create, access_group_map_destroy=access_group_map_destroy, )
def testVgGetters(self): vg_name_list = lvm.listVgNames() for vg_name in vg_name_list: vg = lvm.vgOpen(vg_name, 'r') self.assertTrue(type(vg.isClustered()) == bool) self.assertTrue(type(vg.isExported()) == bool) self.assertTrue(type(vg.isPartial()) == bool) #Loop through the list invoking the method for method_name in TestLvm.RETURN_NUMERIC: method = getattr(vg, method_name) result = method() self.assertTrue(type(result) == int) vg.close()
def _get_lv(lv_vol_type=None, lv_name=None): vg_name_list = TestLvm._vg_names() for vg_name in vg_name_list: vg = lvm.vgOpen(vg_name, "w") lvs = vg.listLVs() for lv in lvs: attr = lv.getAttr() if lv_vol_type or lv_name: if lv_vol_type is not None and attr[0] == lv_vol_type: return lv, vg elif lv_name is not None and lv_name == lv.getName(): return lv, vg else: return lv, vg vg.close() return None, None
def vgopen(pool_name): """ Helper function to check/close vg for us. """ global lib_calls pool_check(pool_name) with contextlib.closing(lvm.vgOpen(pool_name, "w")) as vg: yield vg # Clean library periodically lib_calls += 1 if lib_calls > 50: try: # May not be present if using older library lvm.gc() except AttributeError: pass lib_calls = 0
def testDupeLvCreate(self): """ Try to create a lv with the same name expecting a failure Note: This was causing a seg. fault previously """ vgs = lvm.listVgNames() if len(vgs): vg_name = vgs[0] vg = lvm.vgOpen(vg_name, "w") lvs = vg.listLVs() if len(lvs): lv = lvs[0] lv_name = lv.getName() self.assertRaises(lvm.LibLVMError, vg.createLvLinear, lv_name, lv.getSize())
def old_snapshots(self): """ List data for old snapshots. """ ret = [] for vgname in self._vgnames: # We could filter out the VGs using _use_dev() but this way we'll # see stuff after changing config. options. vg = lvm.vgOpen(vgname, 'w') for lv in vg.listLVs(): if not _is_snap(lv): # No snapshot means, we don't care. continue ret.append(_lv_data(vg, lv)) vg.close() return ret
def testVgUuids(self): vgs_uuids = lvm.listVgUuids() self.assertTrue(isinstance(vgs_uuids, tuple)) vgs_uuids = list(vgs_uuids) vgs_names = lvm.listVgNames() for vg_name in vgs_names: vg = lvm.vgOpen(vg_name, "r") #TODO Write/fix BUG, vg uuid don't match between lvm.listVgUuids # and vg.getUuid() vg_uuid_search = vg.getUuid().replace('-', '') self.assertTrue(vg_uuid_search in vgs_uuids) vgs_uuids.remove(vg_uuid_search) self.assertTrue(len(vgs_uuids) == 0)
def test_vg_from_pv_lookups(self): device_names = TestLvm._get_pv_device_names() TestLvm._create_thin_lv(device_names[0:2], 'thin') TestLvm._create_thick_lv(device_names[2:4], 'thick') vgname_list = TestLvm._vg_names() self.assertTrue(len(vgname_list) > 0) for vg_name in vgname_list: vg = lvm.vgOpen(vg_name, 'r') vg_name = vg.getName() pv_list = vg.listPVs() for pv in pv_list: vg_name_from_pv = lvm.vgNameFromPvid(pv.getUuid()) self.assertEquals(vg_name, vg_name_from_pv) self.assertEqual(vg_name, lvm.vgNameFromDevice(pv.getName())) vg.close()