# -*- coding: utf-8 -*-
import os
from errors import LVMError
from utils import Exec
class LVM(object):
'''
'''
BIN_PATH = '/sbin'
LVM = os.path.join(BIN_PATH, 'lvm')
LVMDISKSCAN = os.path.join(BIN_PATH, 'lvmdiskscan')
LVDISPLAY = os.path.join(BIN_PATH, 'lvdisplay')
LVCREATE = os.path.join(BIN_PATH, 'lvcreate')
LVCHANGE = os.path.join(BIN_PATH, 'lvchange')
LVCONVERT = os.path.join(BIN_PATH, 'lvconvert')
LVRENAME = os.path.join(BIN_PATH, 'lvrename')
LVEXTEND = os.path.join(BIN_PATH, 'lvextend')
LVREDUCE = os.path.join(BIN_PATH, 'lvreduce')
LVREMOVE = os.path.join(BIN_PATH, 'lvremove')
PVCREATE = os.path.join(BIN_PATH, 'pvcreate')
PVREMOVE = os.path.join(BIN_PATH, 'pvremove')
PVMOVE = os.path.join(BIN_PATH, 'pvmove')
VGCREATE = os.path.join(BIN_PATH, 'vgcreate')
VGCHANGE = os.path.join(BIN_PATH, 'vgchange')
VGEXTEND = os.path.join(BIN_PATH, 'vgextend')
VGREDUCE = os.path.join(BIN_PATH, 'vgreduce')
VGREMOVE = os.path.join(BIN_PATH, 'vgremove')
DMSETUP = os.path.join(BIN_PATH, 'dmsetup')
def __init__(self):
'''
'''
self.reload()
def __str__(self):
'''
'''
s = ''
for vgname, vg in self._vgs.iteritems():
s += 'VG %s (total: %s, allocated: %s, free: %s)\n' % (vgname,
vg.total, vg.allocated, vg.free)
s += ' * PV(s):\n'
for pv in vg.pvs:
s += (' %s (total: %s, allocated: %s, free: %s, format: %s)'
'\n' % (pv.name, pv.total, pv.allocated, pv.free, pv.format))
s += ' * LV(s):\n'
for lv in vg.lvs:
s += ' %s (path: %s, size: %s)' % (lv.name, lv.path,
lv.total)
return s
def _reload_pvs(self):
'''
'''
self._pvs = {}
# execute query command
(rc, output) = Exec.call([self.LVM,
"pvs",
"--nosuffix",
"--noheadings",
"--units", "b",
"--separator", "~",
"-o", ("pv_uuid,pv_name,vg_name,pv_fmt,"
"pv_attr,dev_size,pv_size,pv_free,"
"pv_used,pv_pe_count,"
"pv_pe_alloc_count")],
merge_output = False)
if rc != 0:
raise LVMError("error getting list of PV")
# parse command output
for line in output[0].splitlines():
# extract tokens
(
p_uuid,
p_name,
p_vg,
p_format,
p_attr,
p_devsize,
p_size,
p_free,
p_used,
p_extent,
p_ext_alloc,
) = line.strip().split("~")
# if the PV is not used, set VG to None
if not len(p_vg):
p_vg = None
else:
p_vg_obj = self._vgs[p_vg]
# create PV object
pv = self._PV(self, p_vg_obj, p_uuid, p_name, p_format, p_attr,
int(p_devsize), int(p_size), int(p_free), int(p_used),
int(p_extent), int(p_ext_alloc))
# register obj
self._pvs[p_name] = pv
if p_vg:
self._vgs[p_vg].pvs[p_name] = pv
def _reload_vgs(self):
'''
'''
self._vgs = {}
# execute query command
(rc, output) = Exec.call([self.LVM,
"vgs",
"--nosuffix",
"--noheadings",
"--units", "b",
"--separator", "~",
"-o", ("vg_uuid,vg_name,vg_fmt,vg_attr,"
"vg_size,vg_free,vg_extent_size,"
"vg_extent_count,vg_free_count")],
merge_output = False)
if rc != 0:
raise LVMError("error getting list of VG")
# parse command output
for line in output[0].splitlines():
# extract tokens
(
v_uuid,
v_name,
v_format,
v_attr,
v_size,
v_free,
v_ext_size,
v_extent,
v_ext_free,
) = line.strip().split("~")
# create VG object
vg = self._VG(self, v_uuid, v_name, v_format, v_attr, int(v_size),
int(v_free), int(v_ext_size), int(v_extent),
int(v_ext_free))
# register object
self._vgs[v_name] = vg
def _reload_lvs(self):
'''
'''
# execute query command
(rc, output) = Exec.call([self.LVM,
"lvs",
"--nosuffix",
"--noheadings",
"--units", "b",
"--separator", "~",
"-o", ("lv_uuid,lv_name,vg_name,lv_attr,"
"lv_size")],
merge_output = False)
if rc != 0:
raise LVMError("error getting list of LV")
# parse command output
for line in output[0].splitlines():
# extract tokens
(
l_uuid,
l_name,
l_vg,
l_attr,
l_size,
) = line.strip().split("~")
# create LV object
lv = self._LV(self, self._vgs[l_vg], l_uuid, l_name, l_attr, l_size)
# register object
self._vgs[l_vg].lvs[l_name] = lv
def reload(self):
# VG must be reloaded before PV
self._reload_vgs()
self._reload_pvs()
self._reload_lvs()
def get_pv(self, path):
'''
'''
return self._pvs[path]
def get_vg(self, name):
'''
'''
return self._vgs[name]
def get_lv(self, vgname, name):
'''
'''
return self._vgs[vgname].lvs[name]
def dm_create(self, name, table):
'''
'''
rc = Exec.silent([self.DMSETUP,
'create',
name],
input=table)
if rc:
raise LVMError("failed to create DM device")
def dm_remove(self, dm_name, force=True):
'''
'''
# build command arguments
argv = [self.DMSETUP, 'remove']
if force is True:
argv.append('--force')
argv.append(dm_name)
# execute command
if Exec.silent(argv):
raise LVMError("failed to remove DM")
def dm_get_table(self, name):
'''
'''
rc, output = Exec.call([self.DMSETUP,
'table',
'--showkeys',
name],
merge_output=False)
table = str(output[0]).strip()
if rc or not len(table):
raise LVMError("failed to get DM table")
return table
def dm_set_table(self, name, table):
'''
'''
rc = Exec.silent([self.DMSETUP,
'load',
name],
input=table)
if rc:
raise LVMError("failed to change DM table")
class _Vol(object):
'''
'''
def __init__(self, mngr, vg, uuid, name, attrs):
self._mngr = mngr
self.vg = vg
self.uuid = uuid
self.name = name
self.attrs = attrs
class _PV(_Vol):
'''
'''
def __init__(self, mngr, vg, uuid, name, format, attrs, device_size,
size, free, used, extent_total, extent_used):
super(LVM._PV, self).__init__(mngr, vg, uuid, name, attrs)
self.format = format
self.device_size = device_size
self.size = size
self.free = free
self.used = used
self.extent_total = extent_total
self.extent_used = extent_used
class _VG(_Vol):
'''
'''
def __init__(self, mngr, uuid, name, format, attrs, size, free,
extent_size, extent_total, extent_free):
super(LVM._VG, self).__init__(mngr, self, uuid, name, attrs)
self.pvs = {}
self.lvs = {}
self.format = format
self.size = size
self.free = free
self.extent_size = extent_size
self.extent_total = extent_total
self.extent_free = extent_free
def create(self, name, size):
'''
'''
# execute create command
if Exec.silent([self.LVCREATE,
"-l", int(size),
"-n", name,
self.name]) != 0:
raise LVMError("error creating LV")
def remove(self, name):
'''
'''
# execute create command
if Exec.silent([self.LVREMOVE,
"-f",
"%s/%s" % (self.name, name)]) != 0:
raise LVMError("error removing LV")
class _LV(_Vol):
'''
'''
def __init__(self, mngr, vg, uuid, name, attrs, size):
super(LVM._LV, self).__init__(mngr, vg, uuid, name, attrs)
self.size = size
def dm_name(self):
'''
'''
return '%s-%s' % (self.vg.name.replace('-', '--'),
self.name.replace('-', '--'))
def dm_table(self):
'''
'''
return self._mngr.dm_get_table(self.dm_name())