def listStorage(request):
if request.method == "GET":
vMserverId = request.GET.get('id')
vmServer = VMServer.selectOneHost(id=vMserverId)
try:
VMS = LibvirtManage(uri=vmServer.uri)
SERVER = VMS.genre(model='server')
if SERVER:
storageList = SERVER.getVmStorageInfo()
VMS.close()
else:
return render_to_response(
'404.html', context_instance=RequestContext(request))
except Exception, e:
return render_to_response('404.html',
context_instance=RequestContext(request))
return render_to_response('vmStorage/list_storage.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机实例",
"url": '#'
}, {
"name": "存储池管理",
"url": "/listStorage/?id=%d" % vmServer.id
}],
"vmServer":
vmServer,
"storageList":
storageList
},
context_instance=RequestContext(request))
def configNetwork(request):
if request.method == "GET":
vmServerId = request.GET.get('id')
vmServer = VMServer.selectOneHost(id=vmServerId)
try:
VMS = LibvirtManage(uri=vmServer.uri)
NETWORK = VMS.genre(model='network')
if NETWORK:
netList = NETWORK.listNetwork()
insList = NETWORK.listInterface()
else:
return render_to_response(
'404.html', context_instance=RequestContext(request))
except Exception, e:
netList = None
return render_to_response('vmNetwork/add_network.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "网络管理",
"url": '/addNetwork'
}],
"vmServer":
vmServer,
"netList":
netList,
"insList":
insList
},
context_instance=RequestContext(request))
def handleNetwork(request):
if request.method == "POST":
op = request.POST.get('op')
server_id = request.POST.get('server_id')
netkName = request.POST.get('netkName')
if op in ['delete'] and request.user.has_perm('VManagePlatform.change_vmserverinstance'):
try:
vmServer = VMServer.selectOneHost(id=server_id)
except:
return JsonResponse({"code":500,"data":None,"msg":"主机不存在。"})
try:
VMS = LibvirtManage(uri=vmServer.uri)
SSH = BRManage(hostname=vmServer.server_ip,port=22)
OVS = SSH.genre(model='ovs')
BRCTL = SSH.genre(model='brctl')
except Exception,e:
return JsonResponse({"code":500,"msg":"服务器连接失败。。","data":e})
try:
NETWORK = VMS.genre(model='network')
netk = NETWORK.getNetwork(netk_name=netkName)
if op == 'delete':
try:
if netkName.startswith('ovs'):OVS.ovsDelBr(brName=netkName)
elif netkName.startswith('br'):
BRCTL.brctlDownBr(brName=netkName)
# BRCTL.brctlDelBr(brName=netkName)
SSH.close()
except:
pass
status = NETWORK.deleteNetwork(netk)
VMS.close()
if status == 0:return JsonResponse({"code":200,"data":None,"msg":"网络删除成功"})
else:return JsonResponse({"code":500,"data":None,"msg":"网络删除失败"})
except Exception,e:
return JsonResponse({"code":500,"msg":"获取网络失败。","data":e})
def updateVMserver():
serverList = VMServer.listVmServer()
for server in serverList:
VMS = LibvirtManage(server.uri)
SERVER = VMS.genre(model='server')
server_id = server.id
if SERVER:
if server.status == 0:
data = SERVER.getVmServerInfo()
VMServer.updateVmServer(server_id=server_id,instance=data.get('ins'),
mem=data.get('mem'),cpu_total=data.get('cpu_total'),
mem_per=data.get('mem_per'))
elif server.status == 1:
result = VMServer.updateVmServerStatus(server_id=server_id, status=0)
if isinstance(result, str):return result
VMS.close()
else:
result = VMServer.updateVmServerStatus(server_id=server_id, status=1)
if isinstance(result, str):return result
def addStorage(request):
if request.method == "POST" and request.user.has_perm(
'VManagePlatform.add_vmserverinstance'):
pool_xml = StorageTypeXMLConfig(
pool_type=request.POST.get('pool_type'),
pool_name=request.POST.get('pool_name'),
pool_spath=request.POST.get('pool_spath'),
pool_tpath=request.POST.get('pool_tpath'),
pool_host=request.POST.get('pool_host'))
if pool_xml:
try:
vMserver = VMServer.selectOneHost(
id=request.POST.get('pool_server'))
try:
VMS = LibvirtManage(uri=vMserver.uri)
except:
return JsonResponse({
"code": 500,
"msg": "连接虚拟服务器失败。",
"data": None
})
STORAGE = VMS.genre(model='storage')
pool = STORAGE.getStoragePool(
pool_name=request.POST.get('pool_name'))
if pool is False:
storage = STORAGE.createStoragePool(pool_xml)
VMS.close()
if storage:
return JsonResponse({
"code": 200,
"msg": "存储池添加成功",
"data": None
})
else:
return JsonResponse({
"code": 500,
"msg": "创建存储池失败。",
"data": None
})
else:
VMS.close()
return JsonResponse({
"code": 400,
"msg": "存储池已经存在。",
"data": None
})
except Exception, e:
return JsonResponse({"code": 500, "msg": "找到主机资源", "data": e})
else:
return JsonResponse({
"code": 500,
"msg": "不支持的存储类型或者您没有权限操作此项",
"data": None
})
def cloneInstace(data, user=None):
server_id = data.get('server_id')
insName = data.get('vm_name')
try:
vMserver = VMServer.selectOneHost(id=server_id)
except:
return False
try:
VMS = LibvirtManage(uri=vMserver.uri)
except Exception, e:
return False
def updateVMinstance(host=None):
if host is None:
serverList = VMServer.listVmServer()
for server in serverList:
if server.status == 0:
VMS = LibvirtManage(server.uri)
SERVER = VMS.genre(model='server')
if SERVER:
dataList = SERVER.getVmInstanceBaseInfo(server_ip=server.server_ip,server_id=server.id)
for ds in dataList:
result = VmServerInstance.objects.filter(server=server,name=ds.get('name'))
if result:VmServerInstance.objects.filter(server=server,name=ds.get('name')).update(server=server,cpu=ds.get('cpu'),
mem=ds.get('mem'),status=ds.get('status'),
name=ds.get('name'),token=ds.get('token'),
vnc=ds.get('vnc'),
)
else:VmServerInstance.objects.create(server=server,cpu=ds.get('cpu'),
mem=ds.get('mem'),vnc=ds.get('vnc'),
status=ds.get('status'),name=ds.get('name'),
token=ds.get('token'))
VMS.close()
else:
server = VMServer.selectOneHostBy(host)
if server and server.status == 0:
VMS = LibvirtManage(server.uri)
SERVER = VMS.genre(model='server')
if SERVER:
dataList = SERVER.getVmInstanceBaseInfo(server_ip=server.server_ip,server_id=server.id)
for ds in dataList:
result = VmServerInstance.objects.filter(server=server,name=ds.get('name'))
if result:VmServerInstance.objects.filter(server=server,name=ds.get('name')).update(server=server,cpu=ds.get('cpu'),
mem=ds.get('mem'),vnc=ds.get('vnc'),
status=ds.get('status'),name=ds.get('name'),
token=ds.get('token'))
else:VmServerInstance.objects.create(server=server,cpu=ds.get('cpu'),
mem=ds.get('mem'),status=ds.get('status'),
name=ds.get('name'),token=ds.get('token'),
vnc=ds.get('vnc'))
VMS.close()
def viewVmServer(request):
if request.GET.get('op') == "view":
sid = request.GET.get('id')
vServer = VMServer.selectOneHost(sid)
VMS = LibvirtManage(vServer.uri)
SERVER = VMS.genre(model='server')
if SERVER: vmServer = SERVER.getVmServerInfo()
else:
return render_to_response('404.html',
context_instance=RequestContext(request))
if vmServer:
vmServer['id'] = vServer.id
vmServer['server_ip'] = vServer.server_ip
vmServer['name'] = vServer.hostname
vmStorage = SERVER.getVmStorageInfo()
vmInstance = SERVER.getVmInstanceInfo(server_ip=vServer.server_ip)
vmIns = vmInstance.get('active').get('number') + vmInstance.get(
'inactice').get('number')
vmInsList = []
for vm in vmIns:
vm['netk'] = ','.join(vm.get('netk'))
vm['disk'] = vm.get('disks')
vm.pop('disks')
vmInsList.append(vm)
VMS.close()
return render_to_response('vmServer/index_server.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机管理器",
"url": '#'
}, {
"name": "主机列表",
"url": "/listServer"
}, {
"name": vmServer.get('name'),
"url": "/viewServer?op=view&id=" + str(vServer.id)
}],
"vmServer":
vmServer,
"model":
"instance",
"vmStorage":
vmStorage,
"vmInstance":
vmInsList
},
context_instance=RequestContext(request))
def addVmServer(request):
if request.method == "GET":
return render_to_response('vmServer/add_server.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机管理器",
"url": '#'
}, {
"name": "添加主机",
"url": "/addServer"
}]
},
context_instance=RequestContext(request))
elif request.method == "POST":
VMS = LibvirtManage(request.POST.get('vm_uri'))
SERVER = VMS.genre(model='server')
if SERVER:
VMS.close()
server = VMServer.insertVmServer(
server_ip=request.POST.get('vm_host'),
uri=request.POST.get('vm_uri'),
vm_type=request.POST.get('vm_type'),
hostname=request.POST.get('vm_hostname'),
status=0,
)
if server:
return JsonResponse({
"code": 200,
"msg": "服务器添加成功",
"data": None
})
else:
return JsonResponse({
"code": 500,
"msg": "服务器添加失败，写入数据库失败",
"data": None
})
else:
return JsonResponse({
"code": 500,
"msg": "服务器添加失败，注意URI连通性。",
"data": None
})
def revertSnapShot(data,user):
try:
vMserver = VMServer.selectOneHost(id=data.get('server_id'))
VMS = LibvirtManage(uri=vMserver.uri)
INSTANCE = VMS.genre(model='instance')
instance = INSTANCE.queryInstance(name=str(data.get('vm_name')))
status = INSTANCE.revertSnapShot(instance, data.get('snap_name'))
VMS.close()
desc = u'快照恢复{snap_name}'.format(snap_name=data.get('snap_name'))
if status==0:status = status
else:status = 1
result = VmLogs.objects.create(desc=desc,user=user,status=status,action='revert_snap',object=data.get('vm_name'))
if result:return True
else:return False
except Exception,e:
return e
def handleStorage(request):
if request.method == "POST":
op = request.POST.get('op')
server_id = request.POST.get('server_id')
pool_name = request.POST.get('pool_name')
if op in [
'delete', 'disable'
] and request.user.has_perm('VManagePlatform.change_vmserverinstance'):
try:
vMserver = VMServer.selectOneHost(id=server_id)
VMS = LibvirtManage(uri=vMserver.uri)
except Exception, e:
return JsonResponse({
"code": 500,
"msg": "服务器连接失败。。",
"data": e
})
if op == 'delete':
STORAGE = VMS.genre(model='storage')
pool = STORAGE.getStoragePool(pool_name=pool_name)
if pool:
result = STORAGE.deleteStoragePool(pool=pool)
VMS.close()
if result:
return JsonResponse({
"code": 200,
"msg": "存储池删除成功。",
"data": None
})
else:
return JsonResponse({
"code": 500,
"msg": "存储池删除失败。",
"data": None
})
else:
return JsonResponse({
"code": 500,
"msg": "存储池不存在。",
"data": e
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "不支持操作或者您没有权限操作此项"
})
def run_vnc(request):
'''
Call the VNC proxy for remote control
'''
token = request.GET.get('token', 'false')
server_id = request.GET.get('vs', 'false')
vm_name = request.GET.get('vm', 'false')
vnc = request.GET.get('vnc', 'false')
if server_id:
vMserver = VMServer.selectOneHost(id=server_id)
token_file = vMserver.server_ip + '.' + str(vm_name)
tokenStr = token + ': ' + vMserver.server_ip + ':' + str(vnc)
TokenUntils.writeVncToken(filename=token_file, token=tokenStr)
return render(request, 'vnc/vnc_auto.html', {
"vnc_port": settings.VNC_PROXY_PORT,
"vnc_token": token,
})
def viewStorage(request):
if request.method == "GET":
vMserverId = request.GET.get('id')
pool_name = request.GET.get('pool')
vmServer = VMServer.selectOneHost(id=vMserverId)
try:
VMS = LibvirtManage(uri=vmServer.uri)
STORAGE = VMS.genre(model='storage')
if STORAGE:
storage = STORAGE.getStorageInfo(pool_name)
VMS.close()
else:
return render_to_response(
'404.html', context_instance=RequestContext(request))
except Exception, e:
return render_to_response('404.html',
context_instance=RequestContext(request))
return render_to_response('vmStorage/view_storage.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机实例",
"url": '#'
}, {
"name": "存储池管理",
"url": "/listStorage/?id=%d" % vmServer.id
}, {
"name":
"存储池详情",
"url":
"/viewStorage/?id=%d&pool={{ ds.pool_name }}" % vmServer.id
}],
"vmServer":
vmServer,
"storage":
storage
},
context_instance=RequestContext(request))
def listVmServer(request):
hostList = VMServer.listVmServer()
return render_to_response('vmServer/list_server.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机管理器",
"url": '#'
}, {
"name": "主机列表",
"url": "/listServer"
}],
"dataList":
hostList,
"model":
"server"
},
context_instance=RequestContext(request))
def listInstance(request):
if request.method == "GET":
vMserverId = request.GET.get('id')
vmServer = VMServer.selectOneHost(id=vMserverId)
try:
VMS = LibvirtManage(vmServer.uri)
SERVER = VMS.genre(model='server')
userList = User.objects.all()
if SERVER:
inStanceList = SERVER.getVmInstanceBaseInfo(
server_ip=vmServer.server_ip, server_id=vmServer.id)
VMS.close()
else:
return render_to_response(
'404.html', context_instance=RequestContext(request))
except:
inStanceList = None
return render_to_response('vmInstance/list_instance.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机实例",
"url": '#'
}, {
"name": "虚拟机实例列表",
"url": "/listInstance?id=%s" % vMserverId
}],
"inStanceList":
inStanceList,
"vmServer":
vmServer,
"userList":
userList
},
context_instance=RequestContext(request))
def index(request):
vmRun = 0
vmStop = 0
serRun = 0
serStop = 0
try:
logList = VmLogs.objects.all().order_by("-id")[0:20]
vmList = VmInstance.countInstnace()
serList = VMServer.countServer()
for vm in vmList:
if vm.status == 1: vmRun = vmRun + 1
else: vmStop = vmStop + 1
for ser in serList:
if ser.status == 0: serRun = serRun + 1
else: serStop = serStop + 1
except:
logList = None
vmList = []
serList = []
totalInfo = {
"vmRun": vmRun,
"vmStop": vmStop,
"serTotal": len(serList),
"serStop": serStop,
"vmTotal": len(vmList),
"serRun": serRun
}
return render_to_response('index.html', {
"user": request.user,
"localtion": [{
"name": "首页",
"url": '/'
}],
"logList": logList,
"totalInfo": totalInfo,
"msgTotal": serStop + vmStop
},
context_instance=RequestContext(request))
}, {
"name": "网络管理",
"url": '/addNetwork'
}],
"vmServer":
vmServer,
"netList":
netList,
"insList":
insList
},
context_instance=RequestContext(request))
elif request.method == "POST" and request.user.has_perm(
'VManagePlatform.change_vmserverinstance'):
try:
vmServer = VMServer.selectOneHost(id=request.POST.get('server_id'))
except:
return JsonResponse({"code": 500, "data": None, "msg": "主机不存在。"})
try:
VMS = LibvirtManage(uri=vmServer.uri)
NETWORK = VMS.genre(model='network')
if request.POST.get('network-mode') == 'bridge':
SSH = BRManage(hostname=vmServer.server_ip, port=22)
OVS = SSH.genre(model='ovs')
BRCTL = SSH.genre(model='brctl')
if NETWORK and OVS:
status = NETWORK.getNetwork(
netk_name=request.POST.get('bridge-name'))
if status:
VMS.close()
return JsonResponse({
def viewInstance(request):
if request.method == "GET":
vMserverId = request.GET.get('id')
vmServer = VMServer.selectOneHost(id=vMserverId)
serverList = VMServer.listVmServer()
try:
VMS = LibvirtManage(vmServer.uri)
INSTANCE = VMS.genre(model='instance')
SERVER = VMS.genre(model='server')
NETWORK = VMS.genre(model='network')
if INSTANCE:
instance = INSTANCE.queryInstance(
name=str(request.GET.get('vm_name')))
'''获取存储池'''
poolInfo = SERVER.getVmStorageInfo()
'''获取网络设备'''
netkInfo = NETWORK.listNetwork()
'''获取cdrom设备'''
imgList = INSTANCE.getMediaDevice(instance)
'''获取iso存储池的iso列表'''
isoList = SERVER.getVmIsoList()
'''获取实例的xml文件'''
insXml = INSTANCE.getInsXMLDesc(instance, flag=0)
'''获取实例信息'''
insInfo = INSTANCE.getVmInstanceInfo(
instance,
server_ip=vmServer.server_ip,
vMname=request.GET.get('vm_name'))
insInfo['cpu_per'] = INSTANCE.getCpuUsage(instance)
snapList = INSTANCE.snapShotList(instance)
VMS.close()
else:
return render_to_response(
'404.html', context_instance=RequestContext(request))
except Exception, e:
snapList = None
insInfo = None
return render_to_response('vmInstance/view_instance.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机实例",
"url": '#'
}, {
"name": "虚拟机实例列表",
"url": "/listInstance"
}],
"inStance":
insInfo,
"vmServer":
vmServer,
"snapList":
snapList,
"poolInfo":
poolInfo,
"netkInfo":
netkInfo,
"imgList":
imgList,
"isoList":
isoList,
"serverList":
serverList,
"insXml":
insXml
},
context_instance=RequestContext(request))
def modfInstance(request):
if request.method == "POST":
if CommTools.argsCkeck(args=['op', 'server_id', 'vm_name'],
data=request.POST) and request.user.has_perm(
'VManagePlatform.change_vmserverinstance'):
vMserver = VMServer.selectOneHost(id=request.POST.get('server_id'))
LIBMG = LibvirtManage(uri=vMserver.uri)
SERVER = LIBMG.genre(model='server')
STROAGE = LIBMG.genre(model='storage')
INSTANCE = LIBMG.genre(model='instance')
NETWORK = LIBMG.genre(model='network')
if SERVER:
instance = INSTANCE.queryInstance(
name=str(request.POST.get('vm_name')))
if instance is False:
LIBMG.close()
return JsonResponse({
"code": 404,
"data": None,
"msg": "虚拟机不存在，或者已经被删除。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "虚拟主机链接失败。"
})
#调整磁盘
if request.POST.get('device') == 'disk':
if request.POST.get('op') == 'attach':
if instance.state()[0] == 5:
return JsonResponse({
"code": 500,
"data": None,
"msg": "请先启动虚拟机。"
})
storage = STROAGE.getStoragePool(
pool_name=request.POST.get('pool_name'))
if storage:
volume = STROAGE.createVolumes(
pool=storage,
volume_name=request.POST.get('vol_name'),
drive=request.POST.get('vol_drive'),
volume_capacity=request.POST.get('vol_size'))
if volume:
volPath = volume.path()
volume_name = volume.name()
else:
LIBMG.close()
return JsonResponse({
"code": 500,
"data": None,
"msg": "卷已经存在。"
})
status = INSTANCE.addInstanceDisk(instance, volPath)
LIBMG.close()
if status:
recordLogs.delay(
user=request.user,
action='attach_disk',
status=0,
vm_name=request.POST.get('vm_name'))
return JsonResponse({
"code": 200,
"data": None,
"msg": "操作成功。"
})
else:
STROAGE.deleteVolume(storage, volume_name)
recordLogs.delay(
user=request.user,
action='attach_disk',
status=1,
vm_name=request.POST.get('vm_name'))
return JsonResponse({
"code": 500,
"data": None,
"msg": "操作失败。"
})
else:
LIBMG.close()
return JsonResponse({
"code": 404,
"data": None,
"msg": "存储池不存在，或者已经被删除。"
})
elif request.POST.get('op') == 'detach':
status = INSTANCE.delInstanceDisk(
instance, volPath=request.POST.get('disk'))
LIBMG.close()
recordLogs.delay(user=request.user,
action='detach_disk',
status=status,
vm_name=request.POST.get('vm_name'))
if status == 0:
return JsonResponse({
"code": 200,
"data": None,
"msg": "操作成功。"
})
else:
LIBMG.close()
return JsonResponse({
"code": 500,
"data": status,
"msg": "操作失败。"
})
#调整网卡
elif request.POST.get('device') == 'netk':
if request.POST.get('op') == 'attach':
result = INSTANCE.addInstanceInterface(
instance, brName=request.POST.get('netk_name'))
recordLogs.delay(user=request.user,
action='attach_netk',
status=result,
vm_name=request.POST.get('vm_name'))
if result == 0:
return JsonResponse({
"code": 200,
"data": None,
"msg": "操作成功。"
})
else:
return JsonResponse({
"code": 500,
"data": status,
"msg": "添加失败。"
})
elif request.POST.get('op') == 'detach':
result = INSTANCE.delInstanceInterface(
instance, interName=request.POST.get('netk_name'))
recordLogs.delay(user=request.user,
action='detach_netk',
status=result,
vm_name=request.POST.get('vm_name'))
if result == 0:
return JsonResponse({
"code": 200,
"data": None,
"msg": "操作成功。"
})
else:
return JsonResponse({
"code": 500,
"data": status,
"msg": "添加失败。"
})
#调整内存大小
elif request.POST.get('device') == 'mem':
if request.POST.get('op') == 'attach':
result = INSTANCE.setMem(instance,
mem=int(request.POST.get('mem')))
recordLogs.delay(user=request.user,
action='attach_mem',
status=result,
vm_name=request.POST.get('vm_name'))
if result == 0:
return JsonResponse({
"code": 200,
"data": None,
"msg": "操作成功。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "不能设置虚拟机内存超过宿主机机器的物理内存"
})
#调整cpu个数
elif request.POST.get('device') == 'cpu':
if request.POST.get('op') == 'attach':
result = INSTANCE.setVcpu(instance,
cpu=int(request.POST.get('cpu')))
LIBMG.close()
recordLogs.delay(user=request.user,
action='attach_cpu',
status=result,
vm_name=request.POST.get('vm_name'))
if result == 0:
return JsonResponse({
"code": 200,
"data": None,
"msg": "操作成功。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "不能设置虚拟机CPU超过宿主机机器的物理CPU个数"
})
#调整带宽
elif request.POST.get('device') == 'bandwidth':
SSH = BRManage(hostname=vMserver.server_ip, port=22)
OVS = SSH.genre(model='ovs')
BRCTL = SSH.genre(model='brctl')
mode = INSTANCE.getInterFace(instance,
request.POST.get('netk_name'))
if request.POST.get('op') == 'attach':
if mode.get('type') == 'openvswitch':
if int(request.POST.get('bandwidth')) == 0:
result = OVS.ovsCleanBandwidth(
port=request.POST.get('netk_name'))
else:
result = OVS.ovsConfBandwidth(
port=request.POST.get('netk_name'),
bandwidth=request.POST.get('bandwidth'))
else:
if int(request.POST.get('bandwidth')) == 0:
result = INSTANCE.cleanInterfaceBandwidth(
instance, request.POST.get('netk_name'))
result = INSTANCE.setInterfaceBandwidth(
instance,
port=request.POST.get('netk_name'),
bandwidth=request.POST.get('bandwidth'))
SSH.close()
LIBMG.close()
if result.get('status') == 'success':
return JsonResponse({
"code": 200,
"data": None,
"msg": "操作成功。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "未设置带宽，不需要清除"
})
LIBMG.close()
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "暂时不支持的操作或者您没有权限操作操作此项。"
})
def handleInstance(request):
if request.method == "POST":
op = request.POST.get('op')
server_id = request.POST.get('server_id')
insName = request.POST.get('vm_name')
if op in [
'start', 'reboot', 'shutdown', 'halt', 'suspend', 'resume',
'xml', 'migrate', 'delete', 'mount', 'umount', 'clone'
] and request.user.has_perm('VManagePlatform.change_vmserverinstance'):
try:
vMserver = VMServer.selectOneHost(id=server_id)
except:
return JsonResponse({
"code": 500,
"data": None,
"msg": "主机不存在。"
})
try:
VMS = LibvirtManage(uri=vMserver.uri)
except Exception, e:
return JsonResponse({
"code": 500,
"msg": "服务器连接失败。。",
"data": e
})
try:
INSTANCE = VMS.genre(model='instance')
instance = INSTANCE.queryInstance(name=str(insName))
except Exception, e:
return JsonResponse({
"code": 500,
"msg": "虚拟机强制关闭失败。。",
"data": e
})
if op == 'halt':
result = INSTANCE.destroy(instance)
elif op == 'start':
result = INSTANCE.start(instance)
elif op == 'reboot':
result = INSTANCE.reboot(instance)
elif op == 'shutdown':
result = INSTANCE.shutdown(instance)
elif op == 'suspend':
result = INSTANCE.suspend(instance)
elif op == 'resume':
result = INSTANCE.resume(instance)
elif op == 'delete':
INSTANCE.delDisk(instance)
VmInstance.deleteInstance(server=vMserver, name=insName)
result = INSTANCE.delete(instance)
elif op == 'migrate':
migrateInstace.delay(request.POST)
VMS.close()
return JsonResponse({
"code": 200,
"data": None,
"msg": "迁移任务提交成功."
})
elif op == 'umount':
result = INSTANCE.umountIso(instance,
dev=request.POST.get('dev'),
image=request.POST.get('iso'))
elif op == 'mount':
result = INSTANCE.mountIso(instance,
dev=request.POST.get('dev'),
image=request.POST.get('iso'))
elif op == 'clone':
cloneInstace.delay(data=request.POST, user=request.user)
VMS.close()
return JsonResponse({
"code": 200,
"data": None,
"msg": "克隆任务提交成功."
})
elif op == 'xml':
try:
result = INSTANCE.defineXML(xml=request.POST.get('xml'))
except Exception, e:
result = e
def addInstance(request):
if request.method == "GET":
try:
vMserverId = request.GET.get('id')
vmServer = VMServer.selectOneHost(id=vMserverId)
userList = User.objects.all()
tempList = TempInstance.listVmTemp()
VMS = LibvirtManage(vmServer.uri)
SERVER = VMS.genre(model='server')
NETWORK = VMS.genre(model='network')
if SERVER: vStorage = SERVER.getVmStorageInfo()
else:
return render_to_response(
'404.html', context_instance=RequestContext(request))
except:
vStorage = None
vMImages = SERVER.getVmIsoList()
netkList = NETWORK.listNetwork()
VMS.close()
return render_to_response('vmInstance/add_instance.html', {
"user":
request.user,
"localtion": [{
"name": "首页",
"url": '/'
}, {
"name": "虚拟机实例",
"url": '#'
}, {
"name": "添加虚拟机",
"url": "/addInstance"
}],
"vmServer":
vmServer,
"vStorage":
vStorage,
"vMImages":
vMImages,
"netkList":
netkList,
"tempList":
tempList,
"userList":
userList
},
context_instance=RequestContext(request))
elif request.method == "POST":
op = request.POST.get('op')
if op in [
'custom', 'xml', 'template'
] and request.user.has_perm('VManagePlatform.add_vmserverinstance'):
try:
vMserver = VMServer.selectOneHost(
id=request.POST.get('server_id'))
VMS = LibvirtManage(uri=vMserver.uri)
INSTANCE = VMS.genre(model='instance')
SERVER = VMS.genre(model='server')
STORAGE = VMS.genre(model='storage')
NETWORK = VMS.genre(model='network')
except Exception, e:
return JsonResponse({
"code": 500,
"msg": "虚拟服务器连接失败，请注意连通性。",
"data": e
})
if SERVER:
if op == 'custom':
netks = [
str(i) for i in request.POST.get('netk').split(',')
]
if INSTANCE:
instance = INSTANCE.queryInstance(
name=str(request.POST.get('vm_name')))
if instance:
return JsonResponse({
"code": 500,
"msg": "虚拟机已经存在",
"data": None
})
else:
networkXml = ''
radStr = CommTools.radString(4)
for nt in netks:
netkType = NETWORK.getNetworkType(nt)
netXml = Const.CreateNetcard(nkt_br=nt,
ntk_name=nt +
'-' + radStr,
mode=netkType)
networkXml = netXml + networkXml
pool = STORAGE.getStoragePool(
pool_name=request.POST.get('storage'))
volume_name = request.POST.get('vm_name') + '.img'
if pool:
volume = STORAGE.createVolumes(
pool,
volume_name=volume_name,
volume_capacity=request.POST.get('disk'))
if volume:
disk_path = volume.path()
volume_name = volume.name()
disk_xml = Const.CreateDisk(
volume_path=disk_path)
else:
return JsonResponse({
"code": 500,
"msg": "添加虚拟机失败，存储池里面以存在以主机名命名的磁盘",
"data": None
})
else:
return JsonResponse({
"code": 500,
"msg": "添加虚拟机失败，存储池已经被删除掉",
"data": None
})
dom_xml = Const.CreateIntanceConfig(
dom_name=request.POST.get('vm_name'),
maxMem=int(SERVER.getServerInfo().get('mem')),
mem=int(request.POST.get('mem')),
cpu=request.POST.get('cpu'),
disk=disk_xml,
iso_path=request.POST.get('system'),
network=networkXml)
dom = SERVER.createInstance(dom_xml)
recordLogs.delay(
user=request.user,
action=op,
status=dom,
vm_name=request.POST.get('vm_name'))
if dom == 0:
VMS.close()
VmInstance.insertInstance(
dict(
server=vMserver,
name=request.POST.get('vm_name'),
cpu=request.POST.get('cpu'),
mem=request.POST.get('mem'),
owner=request.POST.get('owner'),
status=1,
))
return JsonResponse({
"code": 200,
"data": None,
"msg": "虚拟主机添加成功。"
})
else:
STORAGE.deleteVolume(pool, volume_name)
VMS.close()
return JsonResponse({
"code": 500,
"data": None,
"msg": "虚拟主机添加失败。"
})
elif op == 'xml':
domXml = request.POST.get('xml')
dom = SERVER.defineXML(xml=domXml)
VMS.close()
recordLogs.delay(user=request.user,
action=op,
status=dom,
vm_name=request.POST.get('vm_name'))
if dom:
return JsonResponse({
"code": 200,
"data": None,
"msg": "虚拟主机添加成功。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "虚拟主机添加失败。"
})
elif op == 'template':
try:
temp = TempInstance.selectVmTemp(
id=request.POST.get('temp'))
if INSTANCE:
instance = INSTANCE.queryInstance(
name=str(request.POST.get('vm_name')))
if instance:
return JsonResponse({
"code": 500,
"msg": "虚拟机已经存在",
"data": None
})
else:
pool = STORAGE.getStoragePool(
pool_name=request.POST.get('storage'))
volume_name = request.POST.get('vm_name') + '.img'
if pool:
volume = STORAGE.createVolumes(
pool,
volume_name=volume_name,
volume_capacity=temp.disk)
if volume:
disk_path = volume.path()
volume_name = volume.name()
disk_xml = Const.CreateDisk(
volume_path=disk_path)
else:
return JsonResponse({
"code": 500,
"msg": "添加虚拟机失败，存储池里面以存在以主机名命名的磁盘",
"data": None
})
else:
return JsonResponse({
"code": 500,
"msg": "添加虚拟机失败，存储池已经被删除掉",
"data": None
})
dom_xml = Const.CreateIntanceConfig(
dom_name=request.POST.get('vm_name'),
maxMem=int(SERVER.getServerInfo().get('mem')),
mem=temp.mem,
cpu=temp.cpu,
disk=disk_xml,
iso_path=request.POST.get('system'),
network=None)
dom = SERVER.createInstance(dom_xml)
recordLogs.delay(
user=request.user,
action=op,
status=dom,
vm_name=request.POST.get('vm_name'))
if dom == 0:
VMS.close()
return JsonResponse({
"code": 200,
"data": None,
"msg": "虚拟主机添加成功。"
})
else:
STORAGE.deleteVolume(pool, volume_name)
VMS.close()
return JsonResponse({
"code": 500,
"data": None,
"msg": "虚拟主机添加失败。"
})
except:
return JsonResponse({
"code": 500,
"data": None,
"msg": "虚拟主机添加失败。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "虚拟服务器连接失败，请注意连通性。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "不支持的操作或者您没有权限添加虚拟机"
})
def handleVolume(request):
if request.method == "POST":
op = request.POST.get('op')
server_id = request.POST.get('server_id')
pool_name = request.POST.get('pool_name')
if op in [
'delete', 'add'
] and request.user.has_perm('VManagePlatform.change_vmserverinstance'):
try:
vmServer = VMServer.selectOneHost(id=server_id)
except:
return JsonResponse({
"code": 500,
"data": None,
"msg": "主机不存在。"
})
VMS = LibvirtManage(uri=vmServer.uri)
STORAGE = VMS.genre(model='storage')
if STORAGE:
pool = STORAGE.getStoragePool(pool_name=pool_name)
if pool:
volume = STORAGE.getStorageVolume(
pool=pool, volume_name=request.POST.get('vol_name'))
if op == 'add':
if volume:
return JsonResponse({
"code": 500,
"data": None,
"msg": "卷已经存在"
})
else:
status = STORAGE.createVolumes(
pool=pool,
volume_name=request.POST.get('vol_name'),
flags=0,
volume_capacity=int(
request.POST.get('vol_size')),
drive=request.POST.get('vol_drive'))
VMS.close()
if status:
return JsonResponse({
"code": 200,
"data": None,
"msg": "卷创建成功。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "卷创建失败。"
})
elif op == 'delete':
if volume:
status = STORAGE.deleteVolume(
pool=pool,
volume_name=request.POST.get('vol_name'))
VMS.close()
if isinstance(status, str):
return JsonResponse({
"code": 500,
"data": status,
"msg": "卷删除失败。"
})
else:
return JsonResponse({
"code": 200,
"data": None,
"msg": "卷删除成功。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "卷删除失败，卷不存在。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "存储池不存在。"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "主机连接失败。"
})
else:
return JsonResponse({"code": 500, "data": None, "msg": "不支持操作。"})
else:
return JsonResponse({"code": 500, "data": None, "msg": "不支持的HTTP操作。"})
def migrateInstace(data):
try:
vMserver = VMServer.selectOneHost(id=data.get('server_id'))
except Exception, e:
return e
try:
vMserver = VMServer.selectOneHost(id=data.get('server_id'))
except Exception, e:
return e
try:
VMS = LibvirtManage(uri=vMserver.uri)
#获取要迁移的虚拟机硬盘情况
INSTANCE = VMS.genre(model='instance')
instance = INSTANCE.queryInstance(name=str(data.get('vm_name')))
source_instance = INSTANCE.getVmInstanceInfo(
server_ip=vMserver.server_ip, vm_name=data.get('vm_name'))
except Exception, e:
return e
try:
#连接远程宿主机，获取存储池，然后在存储池里面创建跟迁移的虚拟机相同的硬盘
vMTargetserver = VMServer.selectOneHost(id=data.get('server_tid'))
except Exception, e:
return e
targetUri = str(vMTargetserver.uri).replace('qemu+',
'').replace('/system', '')
TargetVMS = LibvirtManage(uri=vMTargetserver.uri)
TargetStorage = TargetVMS.genre(model='storage')
#获取被迁移的虚拟机磁盘配置，并且到远程服务器上创建，相同的磁盘配置
for volume in source_instance.get('disks'):
if volume.get('disk_sn').startswith('vd'):
pool_name = volume.get('disk_pool')
if pool_name:
#判断远程服务器上是否存在相同的存储池
pool = TargetStorage.getStoragePool(pool_name=pool_name)
if pool:
volume_name = volume.get('disk_path')
def handleSnapshot(request):
if request.method == "POST":
op = request.POST.get('op')
server_id = request.POST.get('server_id')
insName = request.POST.get('vm_name')
snapName = request.POST.get('snap_name')
if op in [
'view', 'resume', 'delete', 'add'
] and request.user.has_perm('VManagePlatform.change_vmserverinstance'):
try:
vMserver = VMServer.selectOneHost(id=server_id)
except:
return JsonResponse({
"code": 500,
"data": None,
"msg": "主机不存在。"
})
try:
VMS = LibvirtManage(uri=vMserver.uri)
except Exception, e:
return JsonResponse({
"code": 500,
"msg": "服务器连接失败。。",
"data": e
})
try:
INSTANCE = VMS.genre(model='instance')
instance = INSTANCE.queryInstance(name=str(insName))
if op == 'view':
snap = INSTANCE.snapShotView(instance, snapName)
VMS.close()
if snap:
return JsonResponse({
"code":
200,
"data":
snap.replace('<', '<').replace('>', '>'),
"msg":
"查询成功."
})
else:
return JsonResponse({
"code": 500,
"data": "查无结果",
"msg": "查无结果"
})
elif op == 'resume':
revertSnapShot.delay(request.POST, str(request.user))
VMS.close()
return JsonResponse({
"code": 200,
"data": None,
"msg": "快照恢复任务提交成功。"
})
elif op == 'add':
snapInstace.delay(request.POST, str(request.user))
VMS.close()
return JsonResponse({
"code": 200,
"data": None,
"msg": "快照任务提交成功."
})
elif op == 'delete':
snap = INSTANCE.snapShotDelete(instance, snapName)
VMS.close()
recordLogs.delay(user=str(request.user),
action=op + '_snap',
status=snap,
vm_name=insName)
if snap == 0:
return JsonResponse({
"code": 200,
"data": None,
"msg": "快照删除成功"
})
else:
return JsonResponse({
"code": 500,
"data": None,
"msg": "快照删除失败"
})
except Exception, e:
return JsonResponse({
"code": 500,
"msg": "虚拟机快照操作失败。。",
"data": e
})
