def diskRefer(**kwargs):
try:
UUID = kwargs["image"]
inhost = [
x[0] for x in redisMgnt().control(
type="select", Dict=['nodeIP'], table="host_nodeinfo")
]
f = redisMgnt().control(type="select",
Dict=['path', 'image'],
table="disk_diskregister",
Where={'UUID': '"{}"'.format(UUID)})
path = f[0][0] + f[0][1]
rn = Random().randint(0, len(inhost) - 1)
obj = domain_opera.virConn(inhost[rn]).getVolObj(path)
AllSize = domain_opera.vol_edit(obj).size()["AllSize"]
UseSize = domain_opera.vol_edit(obj).size()["UseSize"]
if AllSize * 1024 * 1024 * 1024 != kwargs['size']:
return diskRefer(image=kwargs['image'],
size=kwargs['size'])
else:
# print(AllSize)
redisMgnt().control(type="update",
Dict={
'AllSize': '"{}"'.format(AllSize),
'UseSize': '"{}"'.format(UseSize)
},
table="disk_diskregister",
Where={'UUID': '"{}"'.format(UUID)})
return 200
except Exception, msg:
return {'error': 451}
def imageRegister(path=None, SysType=None):
def createName():
str1 = ""
chars = 'abcdHIGKL1234567890'
length = len(chars) - 1
random = Random()
for i in range(10):
str1 += chars[random.randint(0, 13)]
return str1
id = createName()
now = datetime.datetime.now()
time = now.strftime("%Y:%m:%d %H:%M:%S")
cf = ConfigParser.ConfigParser()
cf.read("/git_csdn/kvm/conf/kvm.conf")
image_path = cf.get('image', 'pool_path')
a = str(path).split('/')
name = a[-1]
del a[0]
del a[-1]
path = "/"
for i in a:
path += i + "/"
rg = {
'image': '"{}"'.format(name),
'path': '"{}"'.format(path),
'time': '"{}"'.format(time),
'UUID': '"{}"'.format(id),
'systemType': '"{}"'.format(SysType),
}
redisMgnt().control(type='insert', Dict=rg, table="imageregister")
def diskRegister(path=None):
def createName():
str1 = ""
chars = '1234567890ABCDEFabcdef'
length = len(chars) - 1
random = Random()
for i in range(10):
str1 += chars[random.randint(0, 13)]
return str1
id = createName()
now = datetime.datetime.now()
time = now.strftime("%Y:%m:%d %H:%M:%S")
cf = ConfigParser.ConfigParser()
cf.read("/git_csdn/kvm/src/global.conf")
pool_name = cf.get("storage", "pool_name")
a = str(path).split('/')
name = a[-1]
del a[0]
del a[-1]
path = "/"
for i in a:
path += i + "/"
rg = [{
'image': name,
'path': path,
'time': "'{}'".format(time),
'st': "'N'",
'UUID': "'{}'".format(id),
}]
pyHost = redisMgnt().control(type='select',
Dict=['UUID', 'nodeIP'],
table='host_nodeinfo',
Where={'nodeSTATUS': "'0'"})
for i in [m[1] for m in pyHost]:
obj = domain_opera.virConn(i).getStoragePoolObject(pool_name, "name")
domain_opera.storage_edit(obj).refer()
hl = [m[1] for m in pyHost]
ho = hl[Random().randint(0, len(hl) - 1)]
volObject = domain_opera.virConn(ho).getVolObj(rg[0]['path'] +
rg[0]['image'])
rg[0]['AllSize'] = "'{}'".format(
domain_opera.vol_edit(volObject).size()["AllSize"])
rg[0]['UseSize'] = "'{}'".format(
domain_opera.vol_edit(volObject).size()["UseSize"])
rg[0]['image'] = "'{}'".format(rg[0]['image'])
rg[0]['path'] = "'{}'".format(rg[0]['path'])
rcode = redisMgnt().control(type='insert',
Dict=rg[0],
table='disk_diskregister')
if rcode == 200:
return {'code': 200}
def createMachine(data):
try:
conn = redisMgnt()
machineName = data['name']
inHost = data['host']
iso = data['sys']
beizhu = data['info']
memoryUse = int(data['memory']) * 1024 * 1024
cpuUse = data['cpu']
disk = data['disk']
network = data['network']
# create a new domain xml
with open('/git_csdn/kvm/src/temple/newMachine.xml') as f:
newXML = f.read()
domainXML = xmltodict.parse(newXML)
domainXML['domain']['name'] = machineName
domainXML['domain']['memory']['#text'] = memoryUse
domainXML['domain']['currentMemory']['#text'] = memoryUse
domainXML['domain']['vcpu']['#text'] = cpuUse
aliveDISK = conn.control(type="select", Dict=['path', 'image'], table='disk_diskregister',
Where={'UUID': "'{}'".format(disk)})
dp = "{}{}".format(aliveDISK[0][0], aliveDISK[0][1])
domainXML['domain']['devices']['disk'][0]['source']['@file'] = dp
aliveIMAGE = conn.control(type="select", Dict=['path', 'image'], table='imageregister',
Where={'UUID': '"{}"'.format(iso)})
sp = "{}{}".format(aliveIMAGE[0][0], aliveIMAGE[0][1])
domainXML['domain']['devices']['disk'][1]['source']['@file'] = sp
target = script.getNetworkTarget()
domainXML['domain']['devices']['interface']['target']['@dev'] = target
domainXML['domain']['devices']['interface']['source']['@network'] = network
aliveVNCPort = script.vncPortGet()
domainXML['domain']['devices']['graphics']['@port'] = aliveVNCPort
domainXML['domain']['devices']['graphics']['@autoport'] = 'no'
domainXML['domain']['devices']['graphics']['@keymap'] = 'en-us'
bronXML = xmltodict.unparse(domainXML)
# get install host
if inHost != 'auto':
k = conn.control(type="select", Dict=['nodeIP'], table='host_nodeinfo',
Where={'UUID': "'{}'".format(inHost)})
host = k[0][0]
if domain_opera.virConn(host).defineXML(bronXML) == 200:
domain_control_refer(num='onlyHost',UUID=inHost)
domain_control_monitor(num='only',UUID=redisMgnt().control(type='select',Dict=['UUID'],table='domain_machineinfo',Where={'vName':"'{}'".format(machineName)})[0][0])
script.vncConfig()
script.nodeVncPort()
return {'code' : 200}
else:
return {'error': 451}
except Exception, msg:
print msg
def domainInfo(UUID=None):
try:
k = redisMgnt().control(type='select',Dict=['vName','CurMemory', 'MaxCpu', 'network','rStatus'],table='domain_machineinfo',Where={"UUID":"'{}'".format(UUID)})[0]
n = redisMgnt().control(type='select',Dict=['memLv','cpuLV','rStatus'],table='domain_checkinfo',Where={"UUID":"'{}'".format(UUID)})[0]
memLv,cpuLv = 0 if n[1] == "None" else str(n[1]).split("%")[0],0 if n[2] == "None" else str(n[2]).split("%")[0]
fn = json.loads(k[3])
sid = redisMgnt().control(type='select',Dict=['SYSTEM_ID'],table="domain_sys_info",Where={'UUID':"'{}'".format(UUID)})[0][0]
stmp = redisMgnt().control(type='select',Dict=['systemType','Type'],table="imageregister",Where={'UUID':"'{}'".format(sid)})[0]
sysType,sysImage = str(stmp[0]),redisMgnt().control(type='select',Dict=['ICO'],table='imageico',Where={'TYPE':"'{}'".format(stmp[1])})[0][0]
vName,memory,cpu,network,mac,status = str(k[0]),str(k[1]),str(k[2]),str(fn[0].keys()[0]),str(fn[0][fn[0].keys()[0]]['netDevMac']),"running" if k[4] == '1' else "stop"
DomainInfo = {"vName" : vName,"memory" : memory,"memLv":memLv,"cpu":cpu,"cpuLv":cpuLv,"status":status,"network":network,"UUID":UUID,'mac':mac,'sysType':sysType,'sysImage':sysImage,'url':'http://vnc.wangwenjie.pub:6080/vnc_lite.html?path=websockify%2f%3ftoken='}
#print {'type': 'domainInfo', 'status': 'ok', 'user': UUID, 'des': 'get ok','module': 'api-domain_control-domainInfo'}
return DomainInfo
except Exception,msg:
print(msg)
def diskRefer(**kwargs):
try:
conn = redisMgnt()
imageName = kwargs["image"]
inhost = [
x[0] for x in conn.control(
type="select", Dict=['nodeIP'], table="host_nodeinfo")
]
path = "{}{}".format(
conn.control(type="select",
Dict=['path'],
table="disk_diskregister",
Where={'image': '"{}"'.format(imageName)})[0][0],
imageName)
rn = Random().randint(0, len(inhost) - 1)
obj = domain_opera.virConn(inhost[rn]).getVolObj(path)
AllSize = domain_opera.vol_edit(obj).size()["AllSize"]
UseSize = domain_opera.vol_edit(obj).size()["UseSize"]
# print(AllSize)
conn.control(type="update",
Dict={
'AllSize': '"{}"'.format(AllSize),
'UseSize': '"{}"'.format(UseSize)
},
table="disk_diskregister",
Where={'image': '"{}"'.format(imageName)})
conn.__exit__()
return 200
except Exception, msg:
print(msg)
def domainEjectCdrom(UUID,ACTION,CDUUID=None):
try:
conn = redisMgnt()
host = conn.control(type='select', Dict=['inHost'], table='domain_machineinfo', Where={'UUID': "'{}'".format(UUID)})[
0][0]
object = domain_opera.domain_edit(domain_opera.virConn(host).getDomainObject(str=UUID,type='uuid'))
xml = object.dumpxml()
disk = re.findall("(\<disk type='file' device='cdrom'\>)(.+?)(\<\/disk\>)", xml, re.S)
m = ""
for i in disk[0]:
m += i
diskXMLtoJson = xmltodict.parse(m)
if ACTION == 'eject':
diskXMLtoJson['disk']['source']['@file'] = ""
elif ACTION == 'mount':
path = conn.control(type='select',Dict=['image','path'],table='imageregister',Where={'UUID':"'{}'".format(CDUUID)})[0]
str = path[1] + path[0]
f = json.dumps(diskXMLtoJson)
diskXMLtoJson = json.loads(f)
diskXMLtoJson['disk']['source'] = {'@file':str}
diskJsontoXML = xmltodict.unparse(diskXMLtoJson)
object.deviceUpdate(diskJsontoXML)
conn.__exit__()
return {'code' : 200}
except Exception,msg:
print(msg)
return {'code' : 451}
def storageUpdate():
try:
conn = redisMgnt()
nl = [ x[0] for x in conn.control(type='select',Dict=['nodeIP'],table='host_nodeinfo')]
cf = ConfigParser.ConfigParser()
cf.read("/git_csdn/kvm/conf/kvm.conf")
n = cf.get("storage","pool_name")
conn.control(type='delete',table="storageinfo")
for i in nl:
obj = domain_opera.virConn(str(i)).getStoragePoolObject(str=n,type='name')
m = domain_opera.storage_edit(_obj=obj).info()
f = {}
f['UUID'] = domain_opera.storage_edit(_obj=obj).uuid()
f['inHost'] = i
f['t_Usage'] = m['Usage']
f['t_All'] = m['All']
f['t_Free'] = m['Free']
for k in f.keys():
f[k] = "'{}'".format(f[k])
conn.control(type='insert',Dict=f,table='storageinfo')
conn.__exit__()
print({'status': 'ok', 'task': 'refer storage info', 'module': 'domain_control-storageUpdate'})
return {'code' : 200}
except Exception,msg:
print(msg)
return {'error' : 452}
def hostDelete(host):
try:
f = dbMgnt.redisMgnt().control(type='delete',
table='host_nodeinfo',
Where={'UUID': "{}".format(host)})
return f
except Exception, msg:
print(msg)
def diskInfo(UUID):
try:
dI = ['image', 'AllSize', 'Dhost', 'status', 'UseSize']
tmp = list(redisMgnt().control(
type='select',
Dict=['image', 'AllSize', 'Dhost', 'st', 'UseSize'],
table='disk_diskregister',
Where={'UUID': "'{}'".format(UUID)})[0])
if not tmp[2].encode("utf-8") == str(" "):
tmp[2] = redisMgnt().control(type='select',
Dict=['vName'],
table='domain_machineinfo',
Where={'UUID':
"'{}'".format(tmp[2])})[0][0]
return dict(zip(dI, tmp))
except Exception, msg:
print(msg)
def diskUseCheck():
try:
conn = redisMgnt()
d = conn.control(type='select',
Dict=['disk', 'UUID'],
table='domain_machineinfo')
_tmp = {}
for k in d:
f = json.loads(k[0])
for i in f:
if i[i.keys()[0]]["devType"] == 'disk':
f = i[i.keys()[0]]["devPath"]
a = f.split("/")
name = a[-1]
del a[-1]
path = ""
for i in a:
path += i + "/"
DescHost = k[1]
_tmp['{}{}'.format(path, name)] = DescHost
disk1 = conn.control(type="select",
table="disk_diskregister",
Dict=['path', 'image', 'Dhost', 'st', 'UUID'])
diskList = {}
for i in disk1:
diskList[i[4]] = {
'path': i[0],
'image': i[1],
'Dhost': i[2],
'st': i[3]
}
for m in diskList.keys():
str = "{}{}".format(diskList[m]['path'], diskList[m]['image'])
if str in [x for x in _tmp.keys()]:
diskList[m]['st'] = "'Y'"
diskList[m]['Dhost'] = "'{}'".format(_tmp[str])
else:
diskList[m]['st'] = "'N'"
diskList[m]['Dhost'] = "' '"
if diskRefer(image=diskList[m]['image']) == 200:
diskList[m]['path'] = "'{}'".format(diskList[m]['path'])
diskList[m]['image'] = "'{}'".format(diskList[m]['image'])
conn.control(type='update',
Dict=diskList[m],
table='disk_diskregister',
Where={'UUID': "'{}'".format(m)})
conn.__exit__()
print({
'status': 'ok',
'task': 'refer disk use check',
'module': 'disk_control-diskUseCheck'
})
return {'code': 200}
except Exception, msg:
print(msg)
return {'code': 451}
def domainIsCdrom(UUID):
try:
conn = redisMgnt()
a = json.loads(conn.control(type='select',Dict=['disk'],table='domain_machineinfo',Where={'UUID':"'{}'".format(UUID)})[0][0])
for i in a:
if i[i.keys()[0]]['devType'] == "cdrom" and i[i.keys()[0]]['devPath'] == 'None':
return {'code':"200"}
else:
return {'code':"201"}
except Exception,msg:
pass
def networkTargetUseCheck():
try:
a = redisMgnt().control(type='select',
Dict=['network', 'UUID'],
table='domain_machineinfo')
redisMgnt().control(type='delete', table='target')
for i in a:
UUID = i[1]
k = json.loads(i[0])
for s in k:
target = s[s.keys()[0]]['netTarget']
redisMgnt().control(type="insert",
Dict={
'target_UUID': '"{}"'.format(target),
'dhost_UUID': '"{}"'.format(UUID),
'type': '"network"'
},
table='target')
return {'code': 200}
except Exception, msg:
return {'error': 454}
def diskDelete(**kwargs):
try:
UUID = kwargs["UUID"]
inhost = [
x[0] for x in redisMgnt().control(
type="select", Dict=['nodeIP'], table="host_nodeinfo")
]
f = redisMgnt().control(type="select",
Dict=['path', 'image'],
table="disk_diskregister",
Where={'UUID': '"{}"'.format(UUID)})
path = f[0][0] + f[0][1]
rn = Random().randint(0, len(inhost) - 1)
obj = domain_opera.virConn(inhost[rn]).getVolObj(path)
domain_opera.vol_edit(obj).delete()
redisMgnt().control(type="delete",
table="disk_diskregister",
Where={'UUID': '"{}"'.format(UUID)})
return 200
except Exception, msg:
print(msg)
return 202
def IsoPathLookupByUUID(UUID):
try:
cf = ConfigParser.ConfigParser()
cf.read("/git_csdn/kvm/src/global.conf")
isoPath = cf.get('image', 'image_path')
conn = redisMgnt()
image = conn.control(type='select',
Dict=['image'],
table='imageregister',
Where={'UUID': "'{}'".format(UUID)})[0][0]
return isoPath + image
except Exception, msg:
pass
def nodeVncPort():
try:
tmp = []
domL = []
f = redisMgnt().control(type='select',
Dict=['UUID', 'grapPort', 'inHost'],
table='domain_machineinfo')
for i in f:
domL.append({i[0]: {'grapPort': i[1], 'inHost': i[2]}})
for i in domL:
tmp.append(i[i.keys()[0]]['grapPort'])
cb = redisMgnt()
cb.control(
type='delete',
table='vncinfo',
)
cb.control(type='insert',
table='vncinfo',
Dict={'PORT': "'{}'".format(json.dumps(tmp))})
return {'code': 200}
except Exception:
return {'error': 452}
def vncPortGet():
cf = ConfigParser.ConfigParser()
cf.read("/git_csdn/kvm/src/global.conf")
port_min = int(cf.get('vnc', 'vnc_port_min'))
port_max = int(cf.get('vnc', 'vnc_port_max'))
m = json.loads(redisMgnt().control(type='select',
Dict=['PORT'],
table='vncinfo')[0][0])
random = Random()
rp = random.randint(port_min, port_max)
if rp in m:
return vncPortGet()
else:
return rp
def getNetworkTarget():
try:
tr = Random().randint(500, 5000)
str = "vif1.{}".format(tr)
#str = "vif1.65531"
ff = redisMgnt().control(type="select",
Dict=['dhost_UUID'],
table='target',
Where={'target_UUID': '"{}"'.format(str)})
if ff:
return getNetworkTarget()
else:
return str
except Exception, msg:
print(msg)
def vncConfig():
try:
cf = ConfigParser.ConfigParser()
cf.read("/git_csdn/kvm/src/global.conf")
vncPath = cf.get('vnc', 'vnc_path') + 'vnc_tokens'
domL = []
f = redisMgnt().control(type='select',
Dict=['UUID', 'grapPort', 'inHost'],
table='domain_machineinfo')
for i in f:
domL.append({i[0]: {'grapPort': i[1], 'inHost': i[2]}})
string = ''
for i in domL:
bs = '{}: {}:{}\n'.format(i.keys()[0], i[i.keys()[0]]['inHost'],
i[i.keys()[0]]['grapPort'])
string += bs
with open(vncPath, 'w') as f:
f.write(string)
return {'code': 200}
except Exception:
return {'error': 452}
def host_register(*args):
try:
host = args[0]
memory = task.task_distribution({
'task': 'MemoryUsage',
'data': {}
}, host)
cpu = task.task_distribution({'task': 'CpuInfo', 'data': {}}, host)
operainfo = task.task_distribution({
'task': 'OperaInfo',
'data': {}
}, host)
memory, cpu, operainfo = memory['value'][0], cpu['value'][
0], operainfo['value'][0]
info = args[1]
virType = args[2]
id = script.random_str(36)
nodeRegInfo = {
"nodeIP": "'{}'".format(host),
"nodeSTATUS": "0",
"nodeMem": "{}".format(int(memory['totalmemory']) / 1024),
"nodeCpu": "{}".format(cpu['physical']),
"nodeCpuVersion": "'{}'".format(cpu['type']),
"nodeKernelVersion": "'{}'".format(operainfo['version']),
"nodeKenrelJ": "'{}'".format('None'),
"nodeSysVersion": "'{}'".format(operainfo['name']),
"UUID": "'{}'".format(id),
"virtype": "'{}'".format(virType),
"hostname": "'{}'".format(operainfo['hostname']),
"info": "'{}'".format(info)
}
conn = dbMgnt.redisMgnt()
f = conn.control(type='insert',
Dict=nodeRegInfo,
table='host_nodeinfo')
conn.__exit__()
return f
except Exception, msg:
print msg
def userRegister(**userList):
try:
conn = redisMgnt()
if userList['type'] == 'add':
user = userList['user']
try:
mdPassword = hashlib.md5(userList['password']).hexdigest()
conn.control(type="insert",
table='userinfo',
Dict={
'user': "******".format(user),
'password': "******".format(mdPassword)
})
print {
'action': 'add-user',
'status': 'ok',
'user': user,
'module': 'userRegister'
}
return {'code': 200}
except Exception:
print {
'action': 'add-user',
'status': 'faild',
'user': user,
'module': 'userRegister'
}
elif userList['type'] == 'delete':
user = userList['user']
try:
conn.control(type="delete",
table='userinfo',
Where={'user': "******".format(user)})
print {
'action': 'delete-user',
'status': 'ok',
'user': user,
'module': 'userRegister'
}
except Exception:
print {
'action': 'add-user',
'status': 'faild',
'user': user,
'module': 'userRegister'
}
elif userList['type'] == 'alert':
user = userList['user']
try:
mdPassword = hashlib.md5(userList['password']).hexdigest()
conn.control(type="update",
table='userinfo',
Dict={'password': "******".format(mdPassword)},
Where={'user': "******".format(user)})
print {
'action': 'alert-user-password',
'status': 'ok',
'user': user,
'module': 'userRegister'
}
except Exception:
print {
'action': 'alert-user-password',
'status': 'faild',
'user': user,
'module': 'userRegister'
}
elif userList['type'] == 'show':
try:
f = conn.control(type="select",
table='userinfo',
Dict=[
'user', 'password', 'role', 'mail', 'tel',
'lastlogin'
])
user_info = []
for i in f:
user_info.append({
"username": i[0],
"password": i[1],
"role": i[2],
'mail': i[3],
'tel': i[4],
'last': i[5]
})
print {
'action': 'show',
'status': 'ok',
'user': '******',
'module': 'userRegister'
}
return user_info
except Exception, msg:
print(msg)
print {
'action': 'show',
'status': 'faild',
'user': '******',
'module': 'userRegister'
}
conn.__exit__()
def domain_control_monitor(num=None,UUID=None):
try:
if num == 'all':
#Generate Host object list
hostObj = [domain_opera.virConn(x[0]) for x in
redisMgnt().control(type='select', Dict=['nodeIP'], table="host_nodeinfo")]
#start cycle
domainMonitorInfo = []
for i in hostObj:
for k in [ x for x in i.getAllDomains(flags=0)]:
domainObj = domain_opera.domain_edit(object=k)
if domainObj.isActive() == 0:
tmp = {
'UUID' : "'{}'".format(domainObj.UUIDString()),
'cpuLV': "'None'",
'memLv': "'None'",
'rss': "'None'",
'vName': "'{}'".format(domainObj.name()),
'rStatus': "'None'",
'disk': "'None'",
'network': "'None'"}
domainMonitorInfo.append(tmp)
else:
cl = domainObj.getcpuInfo()
ml = domainObj.getmemoryInfo()
di = redisMgnt().control(type='select',Dict=['network','disk'],table='domain_machineinfo',Where={'UUID':"'{}'".format(domainObj.UUIDString())})
f = json.loads(di[0][0])[0]
nl = domainObj.getinterfaceInfo(gdict=[f[f.keys()[0]]['netTarget']])
diskL = json.loads(di[0][1])
diski = []
for i in diskL:
if i[i.keys()[0]]['devType'] == 'disk':
diski.append(i.keys()[0])
else:
pass
dl = domainObj.getdiskInfo(gdict=diski)
dic = {
'cpuLV': "'%.2f%%'" % (
float(cl['system_time'] + float(cl['user_time'])) / cl['cpu_time'] / cl['cpuNr'] * 100),
'rStatus': "'running'",
}
if ml['virito'] == 0:
dic['memLv'] = "'None'"
dic['rss'] = "'{}'".format(ml['rss'])
elif ml['virito'] == 1:
dic['memLv'] = "'%.2f%%'" % (
(float(ml['available']) - float(ml['unused'])) / float(ml['available']) * 100)
dic['rss'] = "'{}'".format(ml['rss'])
dic['vName'] = "'{}'".format(domainObj.name())
dic['UUID'] = "'{}'".format(domainObj.UUIDString())
dic["network"] = "'{}'".format(json.dumps(nl))
dic["disk"] = "'{}'".format(json.dumps(dl))
domainMonitorInfo.append(dic)
redisMgnt().control(type='delete',table='domain_checkinfo')
for i in domainMonitorInfo:
redisMgnt().control(type='insert',Dict=i,table="domain_checkinfo")
return {'code' : '200'}
elif num == 'only':
hostList = [x[0] for x in redisMgnt().control(type='select', Dict=['nodeIP'], table="host_nodeinfo")]
domainMonitorInfo = []
for k in range(len(hostList)):
hostUUID = [x.UUIDString() for x in domain_opera.virConn(hostList[k]).getAllDomains(flags=0)]
hostObj = [domain_opera.domain_edit(object=x) for x in
domain_opera.virConn(hostList[k]).getAllDomains(flags=0)]
if UUID in hostUUID:
ind = hostUUID.index(UUID)
domainObj = hostObj[ind]
if domainObj.isActive() == 0:
tmp = {
'UUID': "'{}'".format(domainObj.UUIDString()),
'cpuLV': "'None'",
'memLv': "'None'",
'rss': "'None'",
'vName': "'{}'".format(domainObj.name()),
'rStatus': "'None'",
'disk': "'None'",
'network': "'None'"}
domainMonitorInfo.append(tmp)
else:
cl = domainObj.getcpuInfo()
ml = domainObj.getmemoryInfo()
di = redisMgnt().control(type='select', Dict=['network', 'disk'],
table='domain_machineinfo',
Where={'UUID': "'{}'".format(domainObj.UUIDString())})
f = json.loads(di[0][0])[0]
nl = domainObj.getinterfaceInfo(gdict=[f[f.keys()[0]]['netTarget']])
diskL = json.loads(di[0][1])
diski = []
for i in diskL:
if i[i.keys()[0]]['devType'] == 'disk':
diski.append(i.keys()[0])
else:
pass
dl = domainObj.getdiskInfo(gdict=diski)
dic = {
'cpuLV': "'%.2f%%'" % (
float(cl['system_time'] + float(cl['user_time'])) / cl['cpu_time'] / cl[
'cpuNr'] * 100),
'rStatus': "'running'",
}
if ml['virito'] == 0:
dic['memLv'] = "'None'"
dic['rss'] = "'{}'".format(ml['rss'])
elif ml['virito'] == 1:
dic['memLv'] = "'%.2f%%'" % (
(float(ml['available']) - float(ml['unused'])) / float(ml['available']) * 100)
dic['rss'] = "'{}'".format(ml['rss'])
dic['vName'] = "'{}'".format(domainObj.name())
dic['UUID'] = "'{}'".format(domainObj.UUIDString())
dic["network"] = "'{}'".format(json.dumps(nl))
dic["disk"] = "'{}'".format(json.dumps(dl))
domainMonitorInfo.append(dic)
redisMgnt().control(type='delete',table='domain_checkinfo',Where={'UUID':"'{}'".format(UUID)})
for i in domainMonitorInfo:
redisMgnt().control(type='insert', Dict=i, table="domain_checkinfo")
return {'code': '200'}
except Exception,msg:
print(msg)
return {"error" : 454}
def domain_crontrol_function(UUID=None,ACTION=None,Dict=None):
try:
UUID = str(UUID).strip("\'")
ACTION = ACTION
domainInhost = redisMgnt().control(type='select',Dict=['inHost'],table='domain_machineinfo',Where={'UUID' : "'{}'".format(UUID)})[0][0]
domainObject=domain_opera.virConn(domainInhost).getDomainObject(str=UUID,type='uuid')
if ACTION == 'start':
if domain_opera.domain_edit(object=domainObject).start() == 200:
redisMgnt().control(type='update',Dict={'rStatus' : "'1'"},table='domain_machineinfo',Where={'UUID':"'{}'".format(UUID)})
print {'type': 'domainCrontrol', 'status': 'ok', 'des': 'start ok', 'user': '******'.format(UUID),'module': 'api-domain_crontrol-domain_crontrol_function'}
return {'code' : 200}
else:
print {'type': 'domainCrontrol', 'status': 'faild', 'des': 'start faild', 'user': '******'.format(UUID),'module': 'api-domain_crontrol-domain_crontrol_function'}
return {'code' : 455}
elif ACTION == 'destroy':
if domain_opera.domain_edit(object=domainObject).destroy() == 200:
redisMgnt().control(type='update', Dict={'rStatus': "'0'"}, table='domain_machineinfo',
Where={'UUID': "'{}'".format(UUID)})
print {'type': 'domainCrontrol', 'status': 'ok', 'des': 'destroy ok', 'user': '******'.format(UUID),'module': 'api-domain_crontrol-domain_crontrol_function'}
return {'code': 200}
else:
print {'type': 'domainCrontrol', 'status': 'faild', 'des': 'destroy faild', 'user': '******'.format(UUID),'module': 'api-domain_crontrol-domain_crontrol_function'}
return {'code':455}
elif ACTION == 'restart':
if domain_opera.domain_edit(object=domainObject).reboot() == 200:
redisMgnt().control(type='update', Dict={'rStatus': "'0'"}, table='domain_machineinfo',
Where={'UUID': "'{}'".format(UUID)})
print {'type': 'domainCrontrol', 'status': 'ok', 'des': 'restart ok', 'user': '******'.format(UUID),'module': 'api-domain_crontrol-domain_crontrol_function'}
return {'code': 200}
else:
print {'type': 'domainCrontrol', 'status': 'faild', 'des': 'restart faild', 'user': '******'.format(UUID),'module': 'api-domain_crontrol-domain_crontrol_function'}
return {'code':455}
elif ACTION == 'delete':
if domain_opera.domain_edit(object=domainObject).undefine() == 200:
redisMgnt().control(type="delete", table='domain_machineinfo', Where={'UUID': "'{}'".format(UUID)})
redisMgnt().control(type="delete", table='domain_checkinfo', Where={'UUID': "'{}'".format(UUID)})
redisMgnt().control(type="update", table='disk_diskregister', Dict={'st': "'N'", 'Dhost': "' '"},
Where={'Dhost': "'{}'".format(UUID)})
print {'type' : 'domainCrontrol','status':'ok','des' :'delete ok','user':'******'.format(UUID),'module':'api-domain_crontrol-domain_crontrol_function'}
return {'code': 200}
else:
print {'type': 'domainCrontrol', 'status': 'faild', 'des': 'delete faild', 'user': '******'.format(UUID),
'module': 'api-domain_crontrol-domain_crontrol_function'}
return {'code':455}
elif ACTION == 'ejectCDROM':
pass
except Exception,msg:
print(msg)
return {'error' : 453 }
def domain_control_refer(num=None,UUID=None):
try:
if num == 'all':
hostList = [ x[0] for x in redisMgnt().control(type='select',Dict=['nodeIP'],table="host_nodeinfo") ]
hostObj = [ domain_opera.virConn(x[0]) for x in redisMgnt().control(type='select',Dict=['nodeIP'],table="host_nodeinfo") ]
iL = []
for d in range(len(hostList)):
domainObjList = [ domain_opera.domain_edit(object=k) for k in hostObj[d].getAllDomains(flags=0)]
inHost = hostList[d]
for i in domainObjList:
st = i.isActive()
doc = i.dumpxml()
xdc = xmltodict.parse(xml_input=doc)
xobj = script.domainXMLjx(xml=xdc)
diskList = xobj.diskInfo()
grphList = xobj.graphicel()
netList = xobj.interfaceList()
confList = xobj.configInfo()
nC = {
'UUID': "'{}'".format(i.UUIDString()),
'inHost': "'{}'".format(inHost),
'vName': "'{}'".format(i.name()),
'rStatus': "'{}'".format(st),
'MaxMemory': "'{}'".format((confList['MaxMemory'])),
'CurMemory': "'{}'".format(confList['CurMemory']),
'MaxCpu': "'{}'".format(confList['MaxCpu']),
'CurCpu': "'{}'".format(confList['CurCpu']),
'grapType': "'{}'".format(grphList['grapType']),
'grapPort': "'{}'".format(grphList['grapPort']),
'grapCType': "'{}'".format(grphList['grapCType']),
'disk': "'{}'".format(json.dumps(diskList)),
'network': "'{}'".format(json.dumps(netList))
}
iL.append(nC)
redisMgnt().control(type='delete',table='domain_machineinfo')
for i in iL:
redisMgnt().control(type="insert",Dict=i,table='domain_machineinfo')
print {'task':"refer domain info",'status':'ok','module':'domain_control-domain_crontrol_refer'}
return {"code" : 200}
elif num == 'only':
hostList = [x[0] for x in redisMgnt().control(type='select', Dict=['nodeIP'], table="host_nodeinfo")]
LK = []
for k in range(len(hostList)):
hostUUID = [ x.UUIDString() for x in domain_opera.virConn(hostList[k]).getAllDomains(flags=0)]
hostObj = [domain_opera.domain_edit(object=x) for x in domain_opera.virConn(hostList[k]).getAllDomains(flags=0)]
inHost = hostList[k]
if hostObj:
for i in hostUUID:
if UUID in hostUUID:
ind = hostUUID.index(UUID)
OBJ = hostObj[ind]
st = OBJ.isActive()
doc = OBJ.dumpxml()
xdc = xmltodict.parse(xml_input=doc)
xobj = script.domainXMLjx(xml=xdc)
diskList = xobj.diskInfo()
grphList = xobj.graphicel()
netList = xobj.interfaceList()
confList = xobj.configInfo()
nC = {
'UUID': "'{}'".format(OBJ.UUIDString()),
'inHost': "'{}'".format(inHost),
'vName': "'{}'".format(OBJ.name()),
'rStatus': "'{}'".format(st),
'MaxMemory': "'{}'".format((confList['MaxMemory'])),
'CurMemory': "'{}'".format(confList['CurMemory']),
'MaxCpu': "'{}'".format(confList['MaxCpu']),
'CurCpu': "'{}'".format(confList['CurCpu']),
'grapType': "'{}'".format(grphList['grapType']),
'grapPort': "'{}'".format(grphList['grapPort']),
'grapCType': "'{}'".format(grphList['grapCType']),
'disk': "'{}'".format(json.dumps(diskList)),
'network': "'{}'".format(json.dumps(netList))
}
LK.append(nC)
break
else:
continue
for i in LK:
redisMgnt().control(type='delete',table='domain_machineinfo',Where={'UUID':"'{}'".format(UUID)})
redisMgnt().control(type="insert",Dict=i,table='domain_machineinfo')
return {"code" : 200}
if num == 'onlyHost':
#get the UUID -> ip
inHost = redisMgnt().control(type='select',Dict=['nodeIP'],table='host_nodeinfo',Where={'UUID':"'{}'".format(UUID)})[0][0]
#bron host object
hostObj = [ domain_opera.domain_edit(object=x) for x in domain_opera.virConn(inHost).getAllDomains(flags=0)]
if hostObj:
domainObjectInfo = []
for domainObject in hostObj:
st = domainObject.isActive()
doc = domainObject.dumpxml()
xdc = xmltodict.parse(xml_input=doc)
xobj = script.domainXMLjx(xml=xdc)
diskList = xobj.diskInfo()
grphList = xobj.graphicel()
netList = xobj.interfaceList()
confList = xobj.configInfo()
nC = {
'UUID': "'{}'".format(domainObject.UUIDString()),
'inHost': "'{}'".format(inHost),
'vName': "'{}'".format(domainObject.name()),
'rStatus': "'{}'".format(st),
'MaxMemory': "'{}'".format((confList['MaxMemory'])),
'CurMemory': "'{}'".format(confList['CurMemory']),
'MaxCpu': "'{}'".format(confList['MaxCpu']),
'CurCpu': "'{}'".format(confList['CurCpu']),
'grapType': "'{}'".format(grphList['grapType']),
'grapPort': "'{}'".format(grphList['grapPort']),
'grapCType': "'{}'".format(grphList['grapCType']),
'disk': "'{}'".format(json.dumps(diskList)),
'network': "'{}'".format(json.dumps(netList))
}
domainObjectInfo.append(nC)
for i in domainObjectInfo:
redisMgnt().control(type='delete',table='domain_machineinfo',Where={'UUID':"{}".format(i['UUID'])})
redisMgnt().control(type='insert',table='domain_machineinfo',Dict=i)
return {"code" : 200}
except Exception,msg:
print(msg)
return {"error" : 454}
