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 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 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 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 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 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 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 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 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 _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 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 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 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 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 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_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 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 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 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 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()
