def online(request):
if 'uuid' in request.POST and request.POST['uuid']:
uuid = request.POST['uuid'].strip('\n')
vm = VM.objects.get(uuid=uuid)
vm.state = 'Online'
vm.save()
request_dict = dict(vm_uuid=uuid, type='end')
communicate(request_dict, vm.host.ip, vm.host.monitor_port)
return HttpResponse("Ok")
def start_monitor(request):
uuid = request.POST["uuid"]
vm = VM.objects.get(uuid=uuid)
if vm.state == "Online":
request_dict = dict(vm_uuid=uuid, type="stop")
communicate(request_dict, vm.host.ip, vm.host.monitor_port)
return HttpResponse(json.dumps(dict(result="stop")))
else:
request_dict = dict(vm_uuid=uuid, type="query")
response = communicate(request_dict, vm.host.ip, vm.host.monitor_port)
return HttpResponse(json.dumps(response))
def execute_nat(application_id):
try:
application = PortApplication.objects.get(id=application_id)
host = application.vm.host
request_dict = dict(request_id=application_id, request_type='add_nat_rule',
request_userid=application.applicant.id, protocol=application.protocol,
host_port=application.host_port, guest_port=application.vm_port,
vm_name=application.vm.name, vm_uuid=application.vm.uuid)
response = communicate(request_dict, host.ip, host.vm_manager_port)
if response and response['request_result'] == 'success':
application.state = 'success'
nat_rules = json.loads(application.vm.nat_rules)
rule = dict(host_port=application.host_port, guest_port=application.vm_port, protocol=application.protocol)
nat_rules.append(json.dumps(rule))
application.vm.nat_rules = json.dumps(nat_rules)
application.vm.save()
elif not response:
application.state = response['request_result']
application.error = response['error_information']
else:
application.state = 'network_error'
application.save()
return application
except ObjectDoesNotExist:
return None
def delete_vm(application_id):
try:
application = DeleteApplication.objects.get(id=application_id)
host = application.host
request_dict = dict(request_id=application.id, request_type='delete', request_userid=application.applicant.id,
vm_name=application.vm.name, vm_uuid=application.vm.uuid)
response = communicate(request_dict, host.ip, host.vm_manager_port)
if response and response['request_result'] == 'success':
print(response)
application.state = 'success'
application.vm.state = 'deleted'
application.vm.save()
ports = json.loads(host.ports_info)
nat_rules = json.loads(application.vm.nat_rules)
for rule in nat_rules:
ports["free"].append(rule["host_port"])
ports["used"].remove(rule["host_port"])
ports["free"].append(application.vm.info.ssh_port)
ports["used"].remove(application.vm.info.ssh_port)
host.ports_info = json.dumps(ports)
host.save()
elif response:
print(response)
application.state = response['request_result']
application.error = response['error_information']
application.save()
return application
except ObjectDoesNotExist:
return None
def control_vm(request):
request_type = request.POST["request_type"]
vm = VM.objects.get(uuid=request.POST["uuid"])
operation = OperationRecord(vm=vm, user=request.user, type=request_type)
operation.save()
host = vm.host
request_dict = dict(
request_id=operation.id,
request_type=request_type,
request_userid=request.user.id,
vm_name=vm.name,
vm_uuid=vm.uuid,
)
response = communicate(request_dict, host.ip, host.vm_manager_port)
if response and response["request_result"] == "success":
operation.result = "success"
print request_type
if request_type == "start":
vm.state = "Online"
elif request_type == "shutdown":
vm.state = "Offline"
else:
vm.state = "Hibernating"
vm.save()
elif response:
operation.result = response["request_result"]
operation.information = response["error_information"]
else:
operation.result = response["network_error"]
operation.save()
return HttpResponse(json.dumps(dict(request_result=operation.result, error_information=operation.information)))
def start_vm(request):
request_type = request.POST["request_type"]
vm = VM.objects.get(uuid=request.POST["uuid"])
operation = OperationRecord(vm=vm, user=request.user, type=request_type)
operation.save()
host = vm.host
request_dict = dict(
request_id=operation.id,
request_type=request_type,
request_userid=request.user.id,
vm_name=vm.name,
vm_uuid=vm.uuid,
)
communicate(dict(vm_uuid=vm.uuid, type="stop"), vm.host.ip, vm.host.monitor_port)
response = communicate(request_dict, host.ip, host.vm_manager_port)
if response and response["request_result"] == "success":
return HttpResponse(json.dumps(dict(request_result="success")))
elif response:
operation.result = response["request_result"]
operation.information = response["error_information"]
else:
operation.result = response["network_error"]
operation.save()
return HttpResponse(json.dumps(dict(request_result=operation.result, error_information=operation.information)))
def create_vm(application_id):
host_list = Host.objects.filter(state='Online')
try:
application = CreateApplication.objects.get(id=application_id)
if host_list.count() > 0:
i, max_length, max_index = 0, 0, 0
while i < host_list.count():
ports = json.loads(host_list[i].ports_info)
if len(ports["free"]) > max_length:
max_index = i
max_length = len(ports["free"])
i += 1
if max_length > 0:
host = host_list[max_index]
ports = json.loads(host.ports_info)
port = ports["free"][0]
ports["free"].remove(port)
ports["used"].append(port)
request_dict = dict(request_id=application_id, request_type='new', port=port,
request_userid=application.applicant.id, request_memory=application.memory)
response = communicate(request_dict, host.ip, host.vm_manager_port)
if response and response['request_response'] == 'received':
application.state = 'In line'
application.host = host
elif not response:
ports["free"].append(port)
ports["used"].remove(port)
application.state = response['request_response']
host.ports_info = json.dumps(ports)
host.save()
else:
application.state = 'error'
application.error = 'Run of out port'
else:
application.state = 'error'
application.error = 'No host'
application.save()
return application
except ObjectDoesNotExist:
return None
