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 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:
result = INSTANCE.setInterfaceBandwidth(
instance,
port=request.POST.get('netk_name'),
bandwidth=request.POST.get('bandwidth'))
SSH.close()
LIBMG.close()
if result.get('status') == 'success' or result == 0:
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 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
def migrateInstace(data):
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')
pathf = os.path.dirname(volume.get('disk_path'))
