mirror of
https://github.com/retspen/webvirtcloud
synced 2024-12-26 16:15:25 +00:00
304 lines
16 KiB
Python
304 lines
16 KiB
Python
from django.contrib import messages
|
|
from django.shortcuts import render, get_object_or_404
|
|
from django.http import HttpResponseRedirect
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.urls import reverse
|
|
from libvirt import libvirtError
|
|
from admin.decorators import superuser_only
|
|
from computes.models import Compute
|
|
from create.models import Flavor
|
|
from create.forms import FlavorAddForm, NewVMForm
|
|
from appsettings.models import AppSettings
|
|
from instances.models import Instance
|
|
from vrtManager.create import wvmCreate
|
|
from vrtManager import util
|
|
from logs.views import addlogmsg
|
|
from webvirtcloud.settings import QEMU_CONSOLE_LISTEN_ADDRESSES
|
|
|
|
|
|
@superuser_only
|
|
def create_instance_select_type(request, compute_id):
|
|
"""
|
|
:param request:
|
|
:param compute_id:
|
|
:return:
|
|
"""
|
|
conn = None
|
|
error_messages = list()
|
|
storages = list()
|
|
networks = list()
|
|
hypervisors = list()
|
|
meta_prealloc = False
|
|
compute = get_object_or_404(Compute, pk=compute_id)
|
|
appsettings = AppSettings.objects.all()
|
|
|
|
try:
|
|
conn = wvmCreate(compute.hostname, compute.login, compute.password, compute.type)
|
|
instances = conn.get_instances()
|
|
all_hypervisors = conn.get_hypervisors_machines()
|
|
# Supported hypervisors by webvirtcloud: i686, x86_64(for now)
|
|
supported_arch = ["x86_64", "i686", "aarch64", "armv7l", "ppc64", "ppc64le", "s390x"]
|
|
hypervisors = [hpv for hpv in all_hypervisors.keys() if hpv in supported_arch]
|
|
default_machine = appsettings.get(key="INSTANCE_MACHINE_DEFAULT_TYPE").value
|
|
default_arch = appsettings.get(key="INSTANCE_ARCH_DEFAULT_TYPE").value
|
|
|
|
if request.method == 'POST':
|
|
if 'create_xml' in request.POST:
|
|
xml = request.POST.get('dom_xml', '')
|
|
try:
|
|
name = util.get_xml_path(xml, '/domain/name')
|
|
except util.etree.Error as err:
|
|
name = None
|
|
if name in instances:
|
|
error_msg = _("A virtual machine with this name already exists")
|
|
error_messages.append(error_msg)
|
|
else:
|
|
try:
|
|
conn._defineXML(xml)
|
|
return HttpResponseRedirect(reverse('instances:instance', args=[compute_id, name]))
|
|
except libvirtError as lib_err:
|
|
error_messages.append(lib_err)
|
|
|
|
except libvirtError as lib_err:
|
|
error_messages.append(lib_err)
|
|
|
|
return render(request, 'create_instance_w1.html', locals())
|
|
|
|
|
|
@superuser_only
|
|
def create_instance(request, compute_id, arch, machine):
|
|
"""
|
|
:param request:
|
|
:param compute_id:
|
|
:param arch:
|
|
:param machine:
|
|
:return:
|
|
"""
|
|
|
|
conn = None
|
|
error_messages = list()
|
|
storages = list()
|
|
networks = list()
|
|
hypervisors = list()
|
|
firmwares = list()
|
|
meta_prealloc = False
|
|
compute = get_object_or_404(Compute, pk=compute_id)
|
|
flavors = Flavor.objects.filter().order_by('id')
|
|
appsettings = AppSettings.objects.all()
|
|
|
|
try:
|
|
conn = wvmCreate(compute.hostname, compute.login, compute.password, compute.type)
|
|
|
|
default_firmware = appsettings.get(key="INSTANCE_FIRMWARE_DEFAULT_TYPE").value
|
|
default_cpu_mode = appsettings.get(key="INSTANCE_CPU_DEFAULT_MODE").value
|
|
instances = conn.get_instances()
|
|
videos = conn.get_video_models(arch, machine)
|
|
cache_modes = sorted(conn.get_cache_modes().items())
|
|
default_cache = appsettings.get(key="INSTANCE_VOLUME_DEFAULT_CACHE").value
|
|
default_io = appsettings.get(key="INSTANCE_VOLUME_DEFAULT_IO").value
|
|
default_zeroes = appsettings.get(key="INSTANCE_VOLUME_DEFAULT_DETECT_ZEROES").value
|
|
default_discard = appsettings.get(key="INSTANCE_VOLUME_DEFAULT_DISCARD").value
|
|
default_disk_format = appsettings.get(key="INSTANCE_VOLUME_DEFAULT_FORMAT").value
|
|
default_disk_owner_uid = int(appsettings.get(key="INSTANCE_VOLUME_DEFAULT_OWNER_UID").value)
|
|
default_disk_owner_gid = int(appsettings.get(key="INSTANCE_VOLUME_DEFAULT_OWNER_GID").value)
|
|
default_scsi_disk_model = appsettings.get(key="INSTANCE_VOLUME_DEFAULT_SCSI_CONTROLLER").value
|
|
listener_addr = QEMU_CONSOLE_LISTEN_ADDRESSES
|
|
mac_auto = util.randomMAC()
|
|
disk_devices = conn.get_disk_device_types(arch, machine)
|
|
disk_buses = conn.get_disk_bus_types(arch, machine)
|
|
default_bus = appsettings.get(key="INSTANCE_VOLUME_DEFAULT_BUS").value
|
|
networks = sorted(conn.get_networks())
|
|
nwfilters = conn.get_nwfilters()
|
|
storages = sorted(conn.get_storages(only_actives=True))
|
|
default_graphics = appsettings.get(key="QEMU_CONSOLE_DEFAULT_TYPE").value
|
|
|
|
dom_caps = conn.get_dom_capabilities(arch, machine)
|
|
caps = conn.get_capabilities(arch)
|
|
|
|
virtio_support = conn.is_supports_virtio(arch, machine)
|
|
hv_supports_uefi = conn.supports_uefi_xml(dom_caps["loader_enums"])
|
|
# Add BIOS
|
|
label = conn.label_for_firmware_path(arch, None)
|
|
if label: firmwares.append(label)
|
|
# Add UEFI
|
|
loader_path = conn.find_uefi_path_for_arch(arch, dom_caps["loaders"])
|
|
label = conn.label_for_firmware_path(arch, loader_path)
|
|
if label: firmwares.append(label)
|
|
firmwares = list(set(firmwares))
|
|
|
|
except libvirtError as lib_err:
|
|
error_messages.append(lib_err)
|
|
|
|
if conn:
|
|
if not storages:
|
|
msg = _("You haven't defined any storage pools")
|
|
error_messages.append(msg)
|
|
if not networks:
|
|
msg = _("You haven't defined any network pools")
|
|
error_messages.append(msg)
|
|
|
|
if request.method == 'POST':
|
|
if 'create_flavor' in request.POST:
|
|
form = FlavorAddForm(request.POST)
|
|
if form.is_valid():
|
|
data = form.cleaned_data
|
|
create_flavor = Flavor(label=data['label'], vcpu=data['vcpu'], memory=data['memory'], disk=data['disk'])
|
|
create_flavor.save()
|
|
return HttpResponseRedirect(request.get_full_path())
|
|
if 'delete_flavor' in request.POST:
|
|
flavor_id = request.POST.get('flavor', '')
|
|
delete_flavor = Flavor.objects.get(id=flavor_id)
|
|
delete_flavor.delete()
|
|
return HttpResponseRedirect(request.get_full_path())
|
|
if 'create' in request.POST:
|
|
firmware = dict()
|
|
volume_list = list()
|
|
is_disk_created = False
|
|
clone_path = ""
|
|
form = NewVMForm(request.POST)
|
|
if form.is_valid():
|
|
data = form.cleaned_data
|
|
if data['meta_prealloc']:
|
|
meta_prealloc = True
|
|
if instances:
|
|
if data['name'] in instances:
|
|
msg = _("A virtual machine with this name already exists")
|
|
error_messages.append(msg)
|
|
if Instance.objects.filter(name__exact=data['name']):
|
|
messages.warning(request, _("There is an instance with same name. Are you sure?"))
|
|
if not error_messages:
|
|
if data['hdd_size']:
|
|
if not data['mac']:
|
|
error_msg = _("No Virtual Machine MAC has been entered")
|
|
error_messages.append(error_msg)
|
|
else:
|
|
try:
|
|
path = conn.create_volume(
|
|
data['storage'],
|
|
data['name'],
|
|
data['hdd_size'],
|
|
default_disk_format,
|
|
meta_prealloc,
|
|
default_disk_owner_uid,
|
|
default_disk_owner_gid,
|
|
)
|
|
volume = dict()
|
|
volume['device'] = 'disk'
|
|
volume['path'] = path
|
|
volume['type'] = conn.get_volume_type(path)
|
|
volume['cache_mode'] = data['cache_mode']
|
|
volume['bus'] = default_bus
|
|
if volume['bus'] == 'scsi':
|
|
volume['scsi_model'] = default_scsi_disk_model
|
|
volume['discard_mode'] = default_discard
|
|
volume['detect_zeroes_mode'] = default_zeroes
|
|
volume['io_mode'] = default_io
|
|
|
|
volume_list.append(volume)
|
|
is_disk_created = True
|
|
|
|
except libvirtError as lib_err:
|
|
error_messages.append(lib_err)
|
|
elif data['template']:
|
|
templ_path = conn.get_volume_path(data['template'])
|
|
dest_vol = conn.get_volume_path(data["name"] + ".img", data['storage'])
|
|
if dest_vol:
|
|
error_msg = _("Image has already exist. Please check volumes or change instance name")
|
|
error_messages.append(error_msg)
|
|
else:
|
|
clone_path = conn.clone_from_template(
|
|
data['name'],
|
|
templ_path,
|
|
data['storage'],
|
|
meta_prealloc,
|
|
default_disk_owner_uid,
|
|
default_disk_owner_gid,
|
|
)
|
|
volume = dict()
|
|
volume['path'] = clone_path
|
|
volume['type'] = conn.get_volume_type(clone_path)
|
|
volume['device'] = 'disk'
|
|
volume['cache_mode'] = data['cache_mode']
|
|
volume['bus'] = default_bus
|
|
if volume['bus'] == 'scsi':
|
|
volume['scsi_model'] = default_scsi_disk_model
|
|
volume['discard_mode'] = default_discard
|
|
volume['detect_zeroes_mode'] = default_zeroes
|
|
volume['io_mode'] = default_io
|
|
|
|
volume_list.append(volume)
|
|
is_disk_created = True
|
|
else:
|
|
if not data['images']:
|
|
error_msg = _("First you need to create or select an image")
|
|
error_messages.append(error_msg)
|
|
else:
|
|
for idx, vol in enumerate(data['images'].split(',')):
|
|
try:
|
|
path = conn.get_volume_path(vol)
|
|
volume = dict()
|
|
volume['path'] = path
|
|
volume['type'] = conn.get_volume_type(path)
|
|
volume['device'] = request.POST.get('device' + str(idx), '')
|
|
volume['bus'] = request.POST.get('bus' + str(idx), '')
|
|
if volume['bus'] == 'scsi':
|
|
volume['scsi_model'] = default_scsi_disk_model
|
|
volume['cache_mode'] = data['cache_mode']
|
|
volume['discard_mode'] = default_discard
|
|
volume['detect_zeroes_mode'] = default_zeroes
|
|
volume['io_mode'] = default_io
|
|
|
|
volume_list.append(volume)
|
|
except libvirtError as lib_err:
|
|
error_messages.append(lib_err)
|
|
if data['cache_mode'] not in conn.get_cache_modes():
|
|
error_msg = _("Invalid cache mode")
|
|
error_messages.append(error_msg)
|
|
|
|
if 'UEFI' in data["firmware"]:
|
|
firmware["loader"] = data["firmware"].split(":")[1].strip()
|
|
firmware["secure"] = 'no'
|
|
firmware["readonly"] = 'yes'
|
|
firmware["type"] = 'pflash'
|
|
if 'secboot' in firmware["loader"] and machine != 'q35':
|
|
messages.warning(
|
|
request, "Changing machine type from '%s' to 'q35' "
|
|
"which is required for UEFI secure boot." % machine)
|
|
machine = 'q35'
|
|
firmware["secure"] = 'yes'
|
|
|
|
if not error_messages:
|
|
uuid = util.randomUUID()
|
|
try:
|
|
conn.create_instance(name=data['name'],
|
|
memory=data['memory'],
|
|
vcpu=data['vcpu'],
|
|
vcpu_mode=data['vcpu_mode'],
|
|
uuid=uuid,
|
|
arch=arch,
|
|
machine=machine,
|
|
firmware=firmware,
|
|
volumes=volume_list,
|
|
networks=data['networks'],
|
|
virtio=data['virtio'],
|
|
listen_addr=data["listener_addr"],
|
|
nwfilter=data["nwfilter"],
|
|
graphics=data["graphics"],
|
|
video=data["video"],
|
|
console_pass=data["console_pass"],
|
|
mac=data['mac'],
|
|
qemu_ga=data['qemu_ga'])
|
|
create_instance = Instance(compute_id=compute_id, name=data['name'], uuid=uuid)
|
|
create_instance.save()
|
|
msg = _("Instance is created")
|
|
messages.success(request, msg)
|
|
addlogmsg(request.user.username, create_instance.name, msg)
|
|
return HttpResponseRedirect(reverse('instances:instance', args=[compute_id, data['name']]))
|
|
except libvirtError as lib_err:
|
|
if data['hdd_size'] or len(volume_list) > 0:
|
|
if is_disk_created:
|
|
for vol in volume_list:
|
|
conn.delete_volume(vol['path'])
|
|
error_messages.append(lib_err)
|
|
conn.close()
|
|
return render(request, 'create_instance_w2.html', locals())
|