def storages(request, host_id):
"""
Storage pool block
"""
errors = []
compute = Compute.objects.get(id=host_id)
try:
conn = wvmStorages(compute.hostname, compute.login, compute.password,
compute.type)
storages = conn.get_storages_info()
secrets = conn.get_secrets()
if request.method == 'POST':
if 'create' in request.POST:
form = AddStgPool(request.POST)
if form.is_valid():
data = form.cleaned_data
if data['name'] in storages:
msg = _("Pool name already use")
errors.append(msg)
if data['stg_type'] == 'rbd':
if not data['secret']:
msg = _("You need create secret for pool")
errors.append(msg)
if not data['ceph_pool'] and not data[
'ceph_host'] and not data['ceph_user']:
msg = _(
"You need input all fields for creating ceph pool"
)
errors.append(msg)
if not errors:
if data['stg_type'] == 'rbd':
conn.create_storage_ceph(data['stg_type'],
data['name'],
data['ceph_pool'],
data['ceph_host'],
data['ceph_user'],
data['secret'])
else:
conn.create_storage(data['stg_type'], data['name'],
data['source'], data['target'])
url = '/%s/storage/%s/' % (host_id, data['name'])
object = {'response': {}}
return redirect_or_json(object, url, request)
else:
errors = [error for error in form.errors]
conn.close()
except libvirtError as err:
errors.append(err)
object = {
'response': {
'storages': storages,
'secrets': secrets,
},
'errors': [str(error) for error in errors]
}
return render(object, 'storages.html', locals(), request)
def console(request):
"""
VNC instance block
"""
if request.method == 'GET':
token = request.GET.get('token', '')
try:
temptoken = token.split('-', 1)
host = int(temptoken[0])
uuid = temptoken[1]
instance = Instance.objects.get(compute_id=host, uuid=uuid)
conn = wvmInstance(instance.compute.hostname, instance.compute.login,
instance.compute.password, instance.compute.type,
instance.name)
vnc_websocket_port = conn.get_vnc_websocket_port()
vnc_passwd = conn.get_vnc_passwd()
except:
vnc_websocket_port = None
vnc_passwd = None
ws_port = vnc_websocket_port if vnc_websocket_port else WS_PORT
ws_host = request.get_host()
if ':' in ws_host:
ws_host = re.sub(':[0-9]+', '', ws_host)
response = render(None, 'console.html', locals(), request)
response.set_cookie('token', token)
return response
def console(request):
"""
VNC instance block
"""
if request.method == "GET":
token = request.GET.get("token", "")
try:
temptoken = token.split("-", 1)
host = int(temptoken[0])
uuid = temptoken[1]
instance = Instance.objects.get(compute_id=host, uuid=uuid)
conn = wvmInstance(
instance.compute.hostname,
instance.compute.login,
instance.compute.password,
instance.compute.type,
instance.name,
)
vnc_websocket_port = conn.get_vnc_websocket_port()
vnc_passwd = conn.get_vnc_passwd()
except:
vnc_websocket_port = None
vnc_passwd = None
ws_port = vnc_websocket_port if vnc_websocket_port else WS_PORT
ws_host = request.get_host()
if ":" in ws_host:
ws_host = re.sub(":[0-9]+", "", ws_host)
response = render(None, "console.html", locals(), request)
response.set_cookie("token", token)
return response
def storages(request, host_id):
"""
Storage pool block
"""
errors = []
compute = Compute.objects.get(id=host_id)
try:
conn = wvmStorages(compute.hostname,
compute.login,
compute.password,
compute.type)
storages = conn.get_storages_info()
secrets = conn.get_secrets()
if request.method == 'POST':
if 'create' in request.POST:
form = AddStgPool(request.POST)
if form.is_valid():
data = form.cleaned_data
if data['name'] in storages:
msg = _("Pool name already use")
errors.append(msg)
if data['stg_type'] == 'rbd':
if not data['secret']:
msg = _("You need create secret for pool")
errors.append(msg)
if not data['ceph_pool'] and not data['ceph_host'] and not data['ceph_user']:
msg = _("You need input all fields for creating ceph pool")
errors.append(msg)
if not errors:
if data['stg_type'] == 'rbd':
conn.create_storage_ceph(data['stg_type'], data['name'],
data['ceph_pool'], data['ceph_host'],
data['ceph_user'], data['secret'])
else:
conn.create_storage(data['stg_type'], data['name'], data['source'], data['target'])
url = '/%s/storage/%s/' % (host_id, data['name'])
object = {'response': {}}
return redirect_or_json(object, url, request)
else:
errors = [error for error in form.errors]
conn.close()
except libvirtError as err:
errors.append(err)
object = {
'response': {
'storages': storages,
'secrets': secrets,
},
'errors': [str(error) for error in errors]
}
return render(object, 'storages.html', locals(), request)
def secrets(request, host_id):
"""
Networks block
"""
errors = []
secrets_all = []
compute = Compute.objects.get(id=host_id)
try:
conn = wvmSecrets(compute.hostname,
compute.login,
compute.password,
compute.type)
secrets = conn.get_secrets()
for uuid in secrets:
secrt = conn.get_secret(uuid)
try:
secret_value = conn.get_secret_value(uuid)
except:
secret_value = ''
secrets_all.append({'usage': secrt.usageID(),
'uuid': secrt.UUIDString(),
'usageType': secrt.usageType(),
'value': secret_value
})
if request.method == 'POST':
if 'create' in request.POST:
form = AddSecret(request.POST)
if form.is_valid():
data = form.cleaned_data
conn.create_secret(data['ephemeral'], data['private'], data['usage_type'], data['data'])
return HttpResponseRedirect(request.get_full_path())
if 'delete' in request.POST:
uuid = request.POST.get('uuid', '')
conn.delete_secret(uuid)
return HttpResponseRedirect(request.get_full_path())
if 'set_value' in request.POST:
uuid = request.POST.get('uuid', '')
value = request.POST.get('value', '')
conn.set_secret_value(uuid, value)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as err:
errors.append(err)
return render(None, 'secrets.html', locals(), request)
def instance_status(request):
payload = json.loads(request.body)
machines = []
def query_hypervisor(hostnames, host_id):
compute = Compute.objects.get(id=host_id)
object = {}
def query_machine(hostname):
try:
conn = wvmInstance(compute.hostname, compute.login,
compute.password, compute.type, hostname)
object[hostname] = {
'status': conn.get_status(),
'cur_memory': conn.get_cur_memory(),
'disks': conn.get_disk_device(),
'vcpu': conn.get_vcpu()
}
except libvirtError:
status = None
pool = WorkerPool(min(len(hostnames), 20))
for hostname in hostnames:
pool.add_task(query_machine, hostname)
pool.run_tasks()
for key in object:
val = object[key]
val['hostname'] = key
val['hypervisor_id'] = host_id
machines.append(val)
pool = WorkerPool(min(len(payload), 10))
for host_id in payload:
pool.add_task(query_hypervisor, payload[host_id], host_id)
pool.run_tasks()
return render({'response': {
'machines': machines
}}, 'instance.html', locals(), request)
def overview(request, host_id):
"""
Overview page.
"""
errors = []
time_refresh = TIME_JS_REFRESH
compute = Compute.objects.get(id=host_id)
try:
conn = wvmHostDetails(compute.hostname, compute.login,
compute.password, compute.type)
hostname, host_arch, host_memory, logical_cpu, model_cpu, uri_conn = conn.get_node_info(
)
hypervisor = conn.hypervisor_type()
mem_usage = conn.get_memory_usage()
conn.close()
except libvirtError as err:
errors.append(err)
return render(None, 'hostdetail.html', locals(), request)
def infrastructure(request):
"""
Infrastructure page.
"""
compute = Compute.objects.filter()
hosts_vms = {}
for host in compute:
if connection_manager.host_is_up(host.hostname, host.login, host.password, host.type):
try:
conn = wvmHostDetails(host, host.login, host.password, host.type)
host_info = conn.get_node_info()
host_mem = conn.get_memory_usage()
hosts_vms[host.id, host.name, 1, host_info[3], host_info[2],
host_mem['percent']] = conn.get_host_instances()
conn.close()
except libvirtError:
hosts_vms[host.id, host.name, 3, 0, 0, 0] = None
else:
hosts_vms[host.id, host.name, 2, 0, 0, 0] = None
return render(None, 'infrastructure.html', locals(), request)
def overview(request, host_id):
"""
Overview page.
"""
errors = []
time_refresh = TIME_JS_REFRESH
compute = Compute.objects.get(id=host_id)
try:
conn = wvmHostDetails(compute.hostname,
compute.login,
compute.password,
compute.type)
hostname, host_arch, host_memory, logical_cpu, model_cpu, uri_conn = conn.get_node_info()
hypervisor = conn.hypervisor_type()
mem_usage = conn.get_memory_usage()
conn.close()
except libvirtError as err:
errors.append(err)
return render(None, 'hostdetail.html', locals(), request)
def interfaces(request, host_id):
"""
Interfaces block
"""
errors = []
ifaces_all = []
compute = Compute.objects.get(id=host_id)
try:
conn = wvmInterfaces(compute.hostname, compute.login, compute.password,
compute.type)
ifaces = conn.get_ifaces()
try:
netdevs = conn.get_net_device()
except:
netdevs = ['eth0', 'eth1']
for iface in ifaces:
ifaces_all.append(conn.get_iface_info(iface))
if request.method == 'POST':
if 'create' in request.POST:
form = AddInterface(request.POST)
if form.is_valid():
data = form.cleaned_data
conn.create_iface(data['name'], data['itype'],
data['start_mode'], data['netdev'],
data['ipv4_type'], data['ipv4_addr'],
data['ipv4_gw'], data['ipv6_type'],
data['ipv6_addr'], data['ipv6_gw'],
data['stp'], data['delay'])
return HttpResponseRedirect(request.get_full_path())
conn.close()
except libvirtError as err:
errors.append(err)
return render(None, 'interfaces.html', locals(), request)
def instance_status(request):
payload = json.loads(request.body)
machines = []
def query_hypervisor(hostnames, host_id):
compute = Compute.objects.get(id=host_id)
object = {}
def query_machine(hostname):
try:
conn = wvmInstance(compute.hostname,
compute.login,
compute.password,
compute.type, hostname)
object[hostname] = {
'status': conn.get_status(),
'cur_memory': conn.get_cur_memory(),
'disks': conn.get_disk_device(),
'vcpu': conn.get_vcpu()
}
except libvirtError:
status = None
pool = WorkerPool(min(len(hostnames), 20))
for hostname in hostnames:
pool.add_task(query_machine, hostname)
pool.run_tasks()
for key in object:
val = object[key]
val['hostname'] = key
val['hypervisor_id'] = host_id
machines.append(val)
pool = WorkerPool(min(len(payload), 10))
for host_id in payload:
pool.add_task(query_hypervisor, payload[host_id], host_id)
pool.run_tasks()
return render({'response': {'machines': machines}}, 'instance.html', locals(), request)
def interface(request, host_id, iface):
"""
Interface block
"""
errors = []
ifaces_all = []
compute = Compute.objects.get(id=host_id)
try:
conn = wvmInterface(compute.hostname, compute.login, compute.password,
compute.type, iface)
start_mode = conn.get_start_mode()
state = conn.is_active()
mac = conn.get_mac()
itype = conn.get_type()
ipv4 = conn.get_ipv4()
ipv4_type = conn.get_ipv4_type()
ipv6 = conn.get_ipv6()
ipv6_type = conn.get_ipv6_type()
bridge = conn.get_bridge()
if request.method == 'POST':
if 'stop' in request.POST:
conn.stop_iface()
return HttpResponseRedirect(request.get_full_path())
if 'start' in request.POST:
conn.start_iface()
return HttpResponseRedirect(request.get_full_path())
if 'delete' in request.POST:
conn.delete_iface()
return HttpResponseRedirect('/%s/interfaces' % host_id)
conn.close()
except libvirtError as err:
errors.append(err)
return render(None, 'interface.html', locals(), request)
def infrastructure(request):
"""
Infrastructure page.
"""
compute = Compute.objects.filter()
hosts_vms = {}
for host in compute:
if connection_manager.host_is_up(host.hostname, host.login,
host.password, host.type):
try:
conn = wvmHostDetails(host, host.login, host.password,
host.type)
host_info = conn.get_node_info()
host_mem = conn.get_memory_usage()
hosts_vms[host.id, host.name, 1, host_info[3], host_info[2],
host_mem['percent']] = conn.get_host_instances()
conn.close()
except libvirtError:
hosts_vms[host.id, host.name, 3, 0, 0, 0] = None
else:
hosts_vms[host.id, host.name, 2, 0, 0, 0] = None
return render(None, 'infrastructure.html', locals(), request)
def instance(request, host_id, vname):
"""
Instance block
"""
def show_clone_disk(disks):
clone_disk = []
for disk in disks:
if disk['image'].count(".") and len(disk['image'].rsplit(".", 1)[1]) <= 7:
name, suffix = disk['image'].rsplit(".", 1)
image = name + "-clone" + "." + suffix
else:
image = disk['image'] + "-clone"
clone_disk.append(
{'dev': disk['dev'], 'storage': disk['storage'], 'image': image, 'format': disk['format']})
return clone_disk
errors = []
messages = []
time_refresh = TIME_JS_REFRESH
compute = Compute.objects.get(id=host_id)
computes = Compute.objects.all()
computes_count = len(computes)
keymaps = QEMU_KEYMAPS
try:
conn = wvmInstance(compute.hostname,
compute.login,
compute.password,
compute.type,
vname)
status = conn.get_status()
autostart = conn.get_autostart()
vcpu = conn.get_vcpu()
cur_vcpu = conn.get_cur_vcpu()
uuid = conn.get_uuid()
memory = conn.get_memory()
cur_memory = conn.get_cur_memory()
description = conn.get_description()
disks = conn.get_disk_device()
media = conn.get_media_device()
networks = conn.get_net_device()
media_iso = sorted(conn.get_iso_media())
vcpu_range = conn.get_max_cpus()
memory_range = [256, 512, 1024, 2048, 4096, 6144, 8192, 16384]
memory_host = conn.get_max_memory()
vcpu_host = len(vcpu_range)
telnet_port = conn.get_telnet_port()
vnc_port = conn.get_vnc_port()
vnc_keymap = conn.get_vnc_keymap()
vnc_password = conn.get_vnc_passwd()
snapshots = sorted(conn.get_snapshot(), reverse=True)
inst_xml = conn._XMLDesc(VIR_DOMAIN_XML_SECURE)
has_managed_save_image = conn.get_managed_save_image()
clone_disks = show_clone_disk(disks)
cpu_usage = conn.cpu_usage()['cpu']
except libvirtError as err:
errors.append(err)
try:
instance = Instance.objects.get(compute_id=host_id, name=vname)
if instance.uuid != uuid:
instance.uuid = uuid
instance.save()
except Instance.DoesNotExist:
instance = Instance(compute_id=host_id, name=vname, uuid=uuid)
instance.save()
try:
if request.method == 'POST':
if 'start' in request.POST:
conn.start()
return HttpResponseRedirect(request.get_full_path() + '#shutdown')
if 'power' in request.POST:
if 'shutdown' == request.POST.get('power', ''):
conn.shutdown()
return HttpResponseRedirect(request.get_full_path() + '#shutdown')
if 'destroy' == request.POST.get('power', ''):
conn.force_shutdown()
return HttpResponseRedirect(request.get_full_path() + '#forceshutdown')
if 'managedsave' == request.POST.get('power', ''):
conn.managedsave()
return HttpResponseRedirect(request.get_full_path() + '#managedsave')
if 'deletesaveimage' in request.POST:
conn.managed_save_remove()
return HttpResponseRedirect(request.get_full_path() + '#managedsave')
if 'suspend' in request.POST:
conn.suspend()
return HttpResponseRedirect(request.get_full_path() + '#suspend')
if 'resume' in request.POST:
conn.resume()
return HttpResponseRedirect(request.get_full_path() + '#suspend')
if 'delete' in request.POST:
if conn.get_status() == 1:
conn.force_shutdown()
if request.POST.get('delete_disk', ''):
print 'yeah'
conn.delete_disk()
try:
instance = Instance.objects.get(compute_id=host_id, name=vname)
instance.delete()
finally:
conn.delete()
return HttpResponseRedirect('/%s/instances' % host_id)
if 'assign_volume' in request.POST:
file = request.POST.get('file', '')
device = request.POST.get('device', '')
conn.assign_volume(file, device)
return HttpResponseRedirect(request.get_full_path() + '#instancedevice')
if 'unassign_volume' in request.POST:
device = request.POST.get('device', '')
conn.unassign_volume(device)
return HttpResponseRedirect(request.get_full_path() + '#instancedevice')
if 'snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_snapshot(name)
return HttpResponseRedirect(request.get_full_path() + '#istaceshapshosts')
if 'external_storage_snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_external_storage_snapshot(name)
return HttpResponseRedirect(request.get_full_path() + '#istaceshapshosts')
if 'umount_iso' in request.POST:
image = request.POST.get('path', '')
first_cd = media[0]['dev'] if len(media) > 0 else request.POST.get('umount_iso', '')
dev = request.POST.get('device', first_cd)
conn.umount_iso(dev, image)
return HttpResponseRedirect(request.get_full_path() + '#instancemedia')
if 'mount_iso' in request.POST:
image = request.POST.get('media', '')
first_cd = media[0]['dev'] if len(media) > 0 else ''
print first_cd
dev = request.POST.get('device', first_cd)
conn.mount_iso(dev, image)
return HttpResponseRedirect(request.get_full_path() + '#instancemedia')
if 'set_autostart' in request.POST:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path() + '#instancesettings')
if 'unset_autostart' in request.POST:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path() + '#instancesettings')
if 'change_settings' in request.POST:
description = request.POST.get('description', '')
vcpu = request.POST.get('vcpu', '')
cur_vcpu = request.POST.get('cur_vcpu', '')
memory = request.POST.get('memory', '')
cur_memory = request.POST.get('cur_memory', '')
conn.change_settings(description, cur_memory, memory, cur_vcpu, vcpu)
return HttpResponseRedirect(request.get_full_path() + '#instancesettings')
if 'change_xml' in request.POST:
xml = request.POST.get('inst_xml', '')
if xml:
conn._defineXML(xml)
return HttpResponseRedirect(request.get_full_path() + '#instancexml')
if 'set_vnc_passwd' in request.POST:
if request.POST.get('auto_pass', ''):
passwd = ''.join([choice(letters + digits) for i in xrange(12)])
else:
passwd = request.POST.get('vnc_passwd', '')
clear = request.POST.get('clear_pass', False)
if not passwd and not clear:
msg = _("Enter the VNC password or select Generate")
errors.append(msg)
if not errors:
conn.set_vnc_passwd(passwd)
return HttpResponseRedirect(request.get_full_path() + '#vnc_pass')
if 'set_vnc_keymap' in request.POST:
keymap = request.POST.get('vnc_keymap', '')
clear = request.POST.get('clear_keymap', False)
if clear:
conn.set_vnc_keymap('')
else:
conn.set_vnc_keymap(keymap)
return HttpResponseRedirect(request.get_full_path() + '#vnc_keymap')
if 'migrate' in request.POST:
compute_id = request.POST.get('compute_id', '')
live = request.POST.get('live_migrate', False)
unsafe = request.POST.get('unsafe_migrate', False)
xml_del = request.POST.get('xml_delete', False)
new_compute = Compute.objects.get(id=compute_id)
conn_migrate = wvmInstances(new_compute.hostname,
new_compute.login,
new_compute.password,
new_compute.type)
conn_migrate.moveto(conn, vname, live, unsafe, xml_del)
conn_migrate.define_move(vname)
conn_migrate.close()
return HttpResponseRedirect('/%s/instance/%s' % (compute_id, vname))
if 'delete_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_delete(snap_name)
return HttpResponseRedirect(request.get_full_path() + '#istaceshapshosts')
if 'revert_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_revert(snap_name)
msg = _("Successful revert snapshot: ")
msg += snap_name
messages.append(msg)
if 'clone' in request.POST:
clone_data = {}
clone_data['name'] = request.POST.get('name', '')
for post in request.POST:
if 'disk' or 'meta' in post:
clone_data[post] = request.POST.get(post, '')
conn.clone_instance(clone_data)
return HttpResponseRedirect('/%s/instance/%s' % (host_id, clone_data['name']))
conn.close()
except libvirtError as err:
errors.append(err)
object = {
'errors': [str(error) for error in errors],
'response': {
'name': vname,
'status': status,
'autostart': autostart,
'vcpu': vcpu,
'cur_vcpu': cur_vcpu,
'uuid': uuid,
'memory': memory,
'cur_memory': cur_memory,
'description': description,
'disks': disks,
'media': media,
'networks': networks,
'media_iso': media_iso,
'vcpu_range': vcpu_range.__len__(),
'memory_host': memory_host,
'vcpu_host': vcpu_host,
'telnet_port': telnet_port,
'vnc_port': vnc_port,
'vnc_keymap': vnc_keymap,
'snapshots': snapshots,
'inst_xml': inst_xml.__str__(),
'has_managed_save_image': has_managed_save_image,
'clone_disks': clone_disks,
'cpu_usage': cpu_usage,
'vnc_password': vnc_password
}
}
return render(object, 'instance.html', locals(), request)
def instances(request, host_id):
"""
Instances block
"""
errors = []
instances = []
time_refresh = 8000
get_instances = []
conn = None
compute = Compute.objects.get(id=host_id)
try:
conn = wvmInstances(compute.hostname,
compute.login,
compute.password,
compute.type)
get_instances = conn.get_instances()
except libvirtError as err:
errors.append(err)
for instance in get_instances:
try:
inst = Instance.objects.get(compute_id=host_id, name=instance)
uuid = inst.uuid
except Instance.DoesNotExist:
uuid = conn.get_uuid(instance)
inst = Instance(compute_id=host_id, name=instance, uuid=uuid)
inst.save()
conn2 = wvmInstance(compute.hostname,
compute.login,
compute.password,
compute.type,
instance)
instances.append({'name': instance,
'status': conn.get_instance_status(instance),
'uuid': uuid,
'memory': conn.get_instance_memory(instance),
'vcpu': conn.get_instance_vcpu(instance),
'storage': conn2.get_disk_device(),
'has_managed_save_image': conn.get_instance_managed_save_image(instance)})
conn2.close()
if conn:
try:
if request.method == 'POST':
name = request.POST.get('name', '')
if 'start' in request.POST:
conn.start(name)
return HttpResponseRedirect(request.get_full_path())
if 'shutdown' in request.POST:
conn.shutdown(name)
return HttpResponseRedirect(request.get_full_path())
if 'destroy' in request.POST:
conn.force_shutdown(name)
return HttpResponseRedirect(request.get_full_path())
if 'managedsave' in request.POST:
conn.managedsave(name)
return HttpResponseRedirect(request.get_full_path())
if 'deletesaveimage' in request.POST:
conn.managed_save_remove(name)
return HttpResponseRedirect(request.get_full_path())
if 'suspend' in request.POST:
conn.suspend(name)
return HttpResponseRedirect(request.get_full_path())
if 'resume' in request.POST:
conn.resume(name)
return HttpResponseRedirect(request.get_full_path())
conn.close()
except libvirtError as err:
errors.append(err)
object = {
'response': {
'instances': instances
},
'errors': [str(error) for error in errors]
}
return render(object, 'instances.html', locals(), request)
def storage(request, host_id, pool):
"""
Storage pool block
"""
def handle_uploaded_file(path, f_name):
target = path + '/' + str(f_name)
destination = open(target, 'wb+')
for chunk in f_name.chunks():
destination.write(chunk)
destination.close()
errors = []
compute = Compute.objects.get(id=host_id)
meta_prealloc = False
conn = None
try:
conn = wvmStorage(compute.hostname,
compute.login,
compute.password,
compute.type,
pool)
storages = conn.get_storages()
state = conn.is_active()
size, free = conn.get_size()
used = (size - free)
if state:
percent = (used * 100) / size
else:
percent = 0
status = conn.get_status()
path = conn.get_target_path()
type = conn.get_type()
autostart = conn.get_autostart()
if state:
conn.refresh()
volumes = conn.update_volumes()
else:
volumes = None
except libvirtError as err:
errors.append(err)
if request.method == 'POST':
if 'start' in request.POST:
try:
conn.start()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'stop' in request.POST:
try:
conn.stop()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'delete' in request.POST:
try:
conn.delete()
return HttpResponseRedirect('/%s/storages' % host_id)
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'set_autostart' in request.POST:
try:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'unset_autostart' in request.POST:
try:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'add_volume' in request.POST:
form = AddImage(request.POST)
if form.is_valid():
data = form.cleaned_data
if data['meta_prealloc'] and data['format'] == 'qcow2':
meta_prealloc = True
try:
conn.create_volume(data['name'], data['size'], data['format'], meta_prealloc)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as err:
errors.append(err)
else:
errors.append('Invalid input.')
if 'del_volume' in request.POST:
volname = request.POST.get('volname', '')
try:
vol = conn.get_volume(volname)
vol.delete(0)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'iso_upload' in request.POST:
if str(request.FILES['file']) in conn.update_volumes():
msg = _("ISO image already exist")
errors.append(msg)
else:
handle_uploaded_file(path, request.FILES['file'])
return HttpResponseRedirect(request.get_full_path())
if 'cln_volume' in request.POST:
form = CloneImage(request.POST)
if form.is_valid():
data = form.cleaned_data
img_name = data['name'] + '.img'
meta_prealloc = 0
if img_name in conn.update_volumes():
msg = _("Name of volume name already use")
errors.append(msg)
if not errors:
if data['convert']:
format = data['format']
if data['meta_prealloc'] and data['format'] == 'qcow2':
meta_prealloc = True
else:
format = None
try:
conn.clone_volume(data['image'], data['name'], format, meta_prealloc)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as err:
errors.append(err)
if conn:
conn.close()
try:
response = {
'type': type,
'path': path,
'status': status,
'usage': percent,
'state': state,
'autostart': autostart,
'pool': pool
}
except:
response = {}
object = {
'errors': [str(error) for error in errors],
'response': response
}
return render(object, 'storage.html', locals(), request)
def servers_list(request):
"""
Servers page.
"""
def get_hosts_status(hosts):
"""
Function return all hosts all vds on host
"""
all_hosts = []
for host in hosts:
if (connection_manager.host_is_up(host.hostname, host.login, host.password, host.type)):
status = 1
else:
status = 'Unknown Error'
all_hosts.append({'id': host.id,
'name': host.name,
'hostname': host.hostname,
'status': status,
'type': host.type,
'login': host.login,
'password': host.password
})
return all_hosts
computes = Compute.objects.filter()
hosts_info = get_hosts_status(computes)
form = None
if request.method == 'POST':
if 'host_del' in request.POST:
compute_id = request.POST.get('host_id', '')
try:
del_inst_on_host = Instance.objects.filter(compute_id=compute_id)
del_inst_on_host.delete()
finally:
del_host = Compute.objects.get(id=compute_id)
del_host.delete()
return HttpResponseRedirect(request.get_full_path())
if 'host_del_by_name' in request.POST:
compute_name = request.POST.get('host_name', '')
try:
del_inst_on_host = Instance.objects.filter(name=compute_name)
del_inst_on_host.delete()
finally:
del_host = Compute.objects.get(name=compute_name)
del_host.delete()
return HttpResponseRedirect(request.get_full_path())
if 'host_tcp_add' in request.POST:
form = ComputeAddTcpForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tcp_host = Compute(name=data['name'],
hostname=data['hostname'],
type=CONN_TCP,
login=data['login'],
password=data['password'])
new_tcp_host.save()
return HttpResponseRedirect(request.get_full_path())
if 'host_ssh_add' in request.POST:
form = ComputeAddSshForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_ssh_host = Compute(name=data['name'],
hostname=data['hostname'],
type=CONN_SSH,
login=data['login'])
new_ssh_host.save()
object = {
'response': {
'id': new_ssh_host.id
}
}
return redirect_or_json(object, request.get_full_path(), request)
else:
object = {
'errors': [error for error in form.errors]
}
return render(object, 'servers.html', locals(), request)
if 'host_tls_add' in request.POST:
form = ComputeAddTlsForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tls_host = Compute(name=data['name'],
hostname=data['hostname'],
type=CONN_TLS,
login=data['login'],
password=data['password'])
new_tls_host.save()
return HttpResponseRedirect(request.get_full_path())
if 'host_edit' in request.POST:
form = ComputeEditHostForm(request.POST)
if form.is_valid():
data = form.cleaned_data
compute_edit = Compute.objects.get(id=data['host_id'])
compute_edit.name = data['name']
compute_edit.hostname = data['hostname']
compute_edit.login = data['login']
compute_edit.password = data['password']
compute_edit.save()
return HttpResponseRedirect(request.get_full_path())
object = {
'errors': {},
'response': {
'hosts_info': hosts_info
}
}
return render(object, 'servers.html', locals(), request)
def servers_list(request):
"""
Servers page.
"""
def get_hosts_status(hosts):
"""
Function return all hosts all vds on host
"""
all_hosts = []
for host in hosts:
if (connection_manager.host_is_up(host.hostname, host.login,
host.password, host.type)):
status = 1
else:
status = 'Unknown Error'
all_hosts.append({
'id': host.id,
'name': host.name,
'hostname': host.hostname,
'status': status,
'type': host.type,
'login': host.login,
'password': host.password
})
return all_hosts
computes = Compute.objects.filter()
hosts_info = get_hosts_status(computes)
form = None
if request.method == 'POST':
if 'host_del' in request.POST:
compute_id = request.POST.get('host_id', '')
try:
del_inst_on_host = Instance.objects.filter(
compute_id=compute_id)
del_inst_on_host.delete()
finally:
del_host = Compute.objects.get(id=compute_id)
del_host.delete()
return HttpResponseRedirect(request.get_full_path())
if 'host_tcp_add' in request.POST:
form = ComputeAddTcpForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tcp_host = Compute(name=data['name'],
hostname=data['hostname'],
type=CONN_TCP,
login=data['login'],
password=data['password'])
new_tcp_host.save()
return HttpResponseRedirect(request.get_full_path())
if 'host_ssh_add' in request.POST:
form = ComputeAddSshForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_ssh_host = Compute(name=data['name'],
hostname=data['hostname'],
type=CONN_SSH,
login=data['login'])
new_ssh_host.save()
object = {'response': {'id': new_ssh_host.id}}
return redirect_or_json(object, request.get_full_path(),
request)
else:
object = {'errors': [error for error in form.errors]}
return render(object, 'servers.html', locals(), request)
if 'host_tls_add' in request.POST:
form = ComputeAddTlsForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_tls_host = Compute(name=data['name'],
hostname=data['hostname'],
type=CONN_TLS,
login=data['login'],
password=data['password'])
new_tls_host.save()
return HttpResponseRedirect(request.get_full_path())
if 'host_edit' in request.POST:
form = ComputeEditHostForm(request.POST)
if form.is_valid():
data = form.cleaned_data
compute_edit = Compute.objects.get(id=data['host_id'])
compute_edit.name = data['name']
compute_edit.hostname = data['hostname']
compute_edit.login = data['login']
compute_edit.password = data['password']
compute_edit.save()
return HttpResponseRedirect(request.get_full_path())
object = {'errors': {}, 'response': {'hosts_info': hosts_info}}
return render(object, 'servers.html', locals(), request)
def network(request, host_id, pool):
"""
Networks block
"""
errors = []
compute = Compute.objects.get(id=host_id)
conn = None
try:
conn = wvmNetwork(compute.hostname,
compute.login,
compute.password,
compute.type,
pool)
networks = conn.get_networks()
state = conn.is_active()
device = conn.get_bridge_device()
autostart = conn.get_autostart()
ipv4_forward = conn.get_ipv4_forward()
ipv4_dhcp_range = conn.get_ipv4_dhcp_range()
ipv4_network = conn.get_ipv4_network()
fixed_address = conn.get_mac_ipaddr()
object = {
'errors': {},
'response': {
'networks': networks,
'state': state,
'device': device,
'autostart': autostart,
'ipv4_forward': ipv4_forward,
'ipv4_dhcp_range': {
'start': str(ipv4_dhcp_range[0]) if ipv4_dhcp_range else None,
'end': str(ipv4_dhcp_range[1] if ipv4_dhcp_range else None)
},
'ipv4_network': str(ipv4_network),
'fixed_address': fixed_address
}
}
except libvirtError as err:
errors.append(err)
object = {
'errors': [str(error) for error in errors]
}
if request.method == 'POST':
if 'start' in request.POST:
try:
conn.start()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'stop' in request.POST:
try:
conn.stop()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'delete' in request.POST:
try:
conn.delete()
return HttpResponseRedirect('/%s/networks' % host_id)
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'set_autostart' in request.POST:
try:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'unset_autostart' in request.POST:
try:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if conn:
conn.close()
return render(object, 'network.html', locals(), request)
def network(request, host_id, pool):
"""
Networks block
"""
errors = []
compute = Compute.objects.get(id=host_id)
conn = None
try:
conn = wvmNetwork(compute.hostname, compute.login, compute.password,
compute.type, pool)
networks = conn.get_networks()
state = conn.is_active()
device = conn.get_bridge_device()
autostart = conn.get_autostart()
ipv4_forward = conn.get_ipv4_forward()
ipv4_dhcp_range = conn.get_ipv4_dhcp_range()
ipv4_network = conn.get_ipv4_network()
fixed_address = conn.get_mac_ipaddr()
object = {
'errors': {},
'response': {
'networks': networks,
'state': state,
'device': device,
'autostart': autostart,
'ipv4_forward': ipv4_forward,
'ipv4_dhcp_range': {
'start':
str(ipv4_dhcp_range[0]) if ipv4_dhcp_range else None,
'end': str(ipv4_dhcp_range[1] if ipv4_dhcp_range else None)
},
'ipv4_network': str(ipv4_network),
'fixed_address': fixed_address
}
}
except libvirtError as err:
errors.append(err)
object = {'errors': [str(error) for error in errors]}
if request.method == 'POST':
if 'start' in request.POST:
try:
conn.start()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'stop' in request.POST:
try:
conn.stop()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'delete' in request.POST:
try:
conn.delete()
return HttpResponseRedirect('/%s/networks' % host_id)
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'set_autostart' in request.POST:
try:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'unset_autostart' in request.POST:
try:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if conn:
conn.close()
return render(object, 'network.html', locals(), request)
def storage(request, host_id, pool):
"""
Storage pool block
"""
def handle_uploaded_file(path, f_name):
target = path + '/' + str(f_name)
destination = open(target, 'wb+')
for chunk in f_name.chunks():
destination.write(chunk)
destination.close()
errors = []
compute = Compute.objects.get(id=host_id)
meta_prealloc = False
conn = None
try:
conn = wvmStorage(compute.hostname, compute.login, compute.password,
compute.type, pool)
storages = conn.get_storages()
state = conn.is_active()
size, free = conn.get_size()
used = (size - free)
if state:
percent = (used * 100) / size
else:
percent = 0
status = conn.get_status()
path = conn.get_target_path()
type = conn.get_type()
autostart = conn.get_autostart()
if state:
conn.refresh()
volumes = conn.update_volumes()
else:
volumes = None
except libvirtError as err:
errors.append(err)
if request.method == 'POST':
if 'start' in request.POST:
try:
conn.start()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'stop' in request.POST:
try:
conn.stop()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'delete' in request.POST:
try:
conn.delete()
return HttpResponseRedirect('/%s/storages' % host_id)
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'set_autostart' in request.POST:
try:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'unset_autostart' in request.POST:
try:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'add_volume' in request.POST:
form = AddImage(request.POST)
if form.is_valid():
data = form.cleaned_data
if data['meta_prealloc'] and data['format'] == 'qcow2':
meta_prealloc = True
try:
conn.create_volume(data['name'], data['size'],
data['format'], meta_prealloc)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as err:
errors.append(err)
else:
errors.append('Invalid input.')
if 'del_volume' in request.POST:
volname = request.POST.get('volname', '')
try:
vol = conn.get_volume(volname)
vol.delete(0)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
if 'iso_upload' in request.POST:
if str(request.FILES['file']) in conn.update_volumes():
msg = _("ISO image already exist")
errors.append(msg)
else:
handle_uploaded_file(path, request.FILES['file'])
return HttpResponseRedirect(request.get_full_path())
if 'cln_volume' in request.POST:
form = CloneImage(request.POST)
if form.is_valid():
data = form.cleaned_data
img_name = data['name'] + '.img'
meta_prealloc = 0
if img_name in conn.update_volumes():
msg = _("Name of volume name already use")
errors.append(msg)
if not errors:
if data['convert']:
format = data['format']
if data['meta_prealloc'] and data['format'] == 'qcow2':
meta_prealloc = True
else:
format = None
try:
conn.clone_volume(data['image'], data['name'], format,
meta_prealloc)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as err:
errors.append(err)
if conn:
conn.close()
try:
response = {
'type': type,
'path': path,
'status': status,
'usage': percent,
'state': state,
'autostart': autostart,
'pool': pool
}
except:
response = {}
object = {'errors': [str(error) for error in errors], 'response': response}
return render(object, 'storage.html', locals(), request)
def instances(request, host_id):
"""
Instances block
"""
errors = []
instances = []
time_refresh = 8000
get_instances = []
conn = None
compute = Compute.objects.get(id=host_id)
try:
conn = wvmInstances(compute.hostname, compute.login, compute.password,
compute.type)
except libvirtError as err:
errors.append(err)
if conn:
try:
if request.method == 'POST':
name = request.POST.get('name', '')
if 'start' in request.POST:
conn.start(name)
return HttpResponseRedirect(request.get_full_path())
if 'shutdown' in request.POST:
conn.shutdown(name)
return HttpResponseRedirect(request.get_full_path())
if 'destroy' in request.POST:
conn.force_shutdown(name)
return HttpResponseRedirect(request.get_full_path())
if 'managedsave' in request.POST:
conn.managedsave(name)
return HttpResponseRedirect(request.get_full_path())
if 'deletesaveimage' in request.POST:
conn.managed_save_remove(name)
return HttpResponseRedirect(request.get_full_path())
if 'suspend' in request.POST:
conn.suspend(name)
return HttpResponseRedirect(request.get_full_path())
if 'resume' in request.POST:
conn.resume(name)
return HttpResponseRedirect(request.get_full_path())
conn.close()
except libvirtError as err:
errors.append(err)
get_instances = conn.get_instances()
for instance in get_instances:
try:
inst = Instance.objects.get(compute_id=host_id, name=instance)
uuid = inst.uuid
except Instance.DoesNotExist:
uuid = conn.get_uuid(instance)
inst = Instance(compute_id=host_id, name=instance, uuid=uuid)
inst.save()
conn2 = wvmInstance(compute.hostname, compute.login, compute.password,
compute.type, instance)
instances.append({
'name':
instance,
'status':
conn.get_instance_status(instance),
'uuid':
uuid,
'memory':
conn.get_instance_memory(instance),
'description':
conn2.get_description(),
'vcpu':
conn.get_instance_vcpu(instance),
'storage':
conn2.get_disk_device(),
'has_managed_save_image':
conn.get_instance_managed_save_image(instance)
})
conn2.close()
object = {
'response': {
'instances': instances
},
'errors': [str(error) for error in errors]
}
return render(object, 'instances.html', locals(), request)
def create(request, host_id):
"""
Create new instance.
"""
conn = None
errors = []
storages = []
networks = []
meta_prealloc = False
compute = Compute.objects.get(id=host_id)
flavors = Flavor.objects.filter().order_by('id')
try:
conn = wvmCreate(compute.hostname,
compute.login,
compute.password,
compute.type)
storages = sorted(conn.get_storages())
networks = sorted(conn.get_networks())
instances = conn.get_instances()
get_images = sorted(conn.get_storages_images())
mac_auto = util.randomMAC()
except libvirtError as err:
errors.append(err)
if conn:
if not storages:
msg = _("You haven't defined have any storage pools")
errors.append(msg)
if not networks:
msg = _("You haven't defined have any network pools")
errors.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_xml' in request.POST:
xml = request.POST.get('from_xml', '')
try:
name = util.get_xml_path(xml, '/domain/name')
except util.libxml2.parserError:
name = None
if name in instances:
msg = _("A virtual machine with this name already exists")
errors.append(msg)
else:
try:
conn._defineXML(xml)
return HttpResponseRedirect('/%s/instance/%s' % (host_id, name))
except libvirtError as err:
errors.append(err.message)
if 'create' in request.POST:
volumes = {}
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")
errors.append(msg)
if not errors:
if data['hdd_size']:
if not data['mac']:
msg = _("No Virtual Machine MAC has been entered")
errors.append(msg)
else:
try:
path = conn.create_volume(data['storage'], data['name'], data['hdd_size'],
metadata=meta_prealloc)
volumes[path] = conn.get_volume_type(path)
except libvirtError as msg_error:
errors.append(msg_error.message)
elif data['template']:
templ_path = conn.get_volume_path(data['template'])
clone_path = conn.clone_from_template(data['name'], templ_path, metadata=meta_prealloc)
volumes[clone_path] = conn.get_volume_type(clone_path)
else:
if not data['images']:
msg = _("First you need to create or select an image")
errors.append(msg)
else:
for vol in data['images'].split(','):
try:
path = conn.get_volume_path(vol)
volumes[path] = conn.get_volume_type(path)
except libvirtError as msg_error:
errors.append(msg_error.message)
if not errors:
uuid = util.randomUUID()
try:
conn.create_instance(data['name'], data['memory'], data['vcpu'], data['host_model'],
uuid, volumes, data['networks'], data['virtio'], data['mac'])
create_instance = Instance(compute_id=host_id, name=data['name'], uuid=uuid)
create_instance.save()
return HttpResponseRedirect('/%s/instance/%s' % (host_id, data['name']))
except libvirtError as err:
if data['hdd_size']:
conn.delete_volume(volumes.keys()[0])
errors.append(err)
conn.close()
object = {
'errors': [force_text(error) for error in errors],
'response': {}
}
return render(object, 'create.html', locals(), request)
def instances_fast(request, host_id):
"""
Instances block
"""
errors = []
instances = []
time_refresh = 8000
get_instances = []
conn = None
compute = Compute.objects.get(id=host_id)
try:
conn = wvmInstances(compute.hostname,
compute.login,
compute.password,
compute.type)
except libvirtError as err:
errors.append(err)
if conn:
try:
if request.method == 'POST':
name = request.POST.get('name', '')
if 'start' in request.POST:
conn.start(name)
return HttpResponseRedirect(request.get_full_path())
if 'shutdown' in request.POST:
conn.shutdown(name)
return HttpResponseRedirect(request.get_full_path())
if 'destroy' in request.POST:
conn.force_shutdown(name)
return HttpResponseRedirect(request.get_full_path())
if 'managedsave' in request.POST:
conn.managedsave(name)
return HttpResponseRedirect(request.get_full_path())
if 'deletesaveimage' in request.POST:
conn.managed_save_remove(name)
return HttpResponseRedirect(request.get_full_path())
if 'suspend' in request.POST:
conn.suspend(name)
return HttpResponseRedirect(request.get_full_path())
if 'resume' in request.POST:
conn.resume(name)
return HttpResponseRedirect(request.get_full_path())
conn.close()
except libvirtError as err:
errors.append(err)
get_instances = conn.get_instances()
results = {}
def query_machine(hostname):
try:
conn2 = wvmInstance(compute.hostname,
compute.login,
compute.password,
compute.type, hostname)
results[hostname] = ({'name': hostname,
#'status': conn.get_instance_status(instance),
#'uuid': uuid,
#'memory': conn.get_instance_memory(instance),
'description': conn2.get_description(),
#'vcpu': conn.get_instance_vcpu(instance),
#'storage': conn2.get_disk_device(),
#'has_managed_save_image': conn.get_instance_managed_save_image(instance)
})
conn2.close()
except libvirtError:
status = None
pool = WorkerPool(min(len(get_instances), 20))
for hostname in get_instances:
pool.add_task(query_machine, hostname)
pool.run_tasks()
for hostname in get_instances:
instances.append(results[hostname])
object = {
'response': {
'instances': instances
},
'errors': [str(error) for error in errors]
}
return render(object, 'instances.html', locals(), request)
def instance(request, host_id, vname):
"""
Instance block
"""
def show_clone_disk(disks):
clone_disk = []
for disk in disks:
if disk['image'].count(".") and len(disk['image'].rsplit(
".", 1)[1]) <= 7:
name, suffix = disk['image'].rsplit(".", 1)
image = name + "-clone" + "." + suffix
else:
image = disk['image'] + "-clone"
clone_disk.append({
'dev': disk['dev'],
'storage': disk['storage'],
'image': image,
'format': disk['format']
})
return clone_disk
errors = []
messages = []
time_refresh = TIME_JS_REFRESH
compute = Compute.objects.get(id=host_id)
computes = Compute.objects.all()
computes_count = len(computes)
keymaps = QEMU_KEYMAPS
try:
conn = wvmInstance(compute.hostname, compute.login, compute.password,
compute.type, vname)
status = conn.get_status()
autostart = conn.get_autostart()
vcpu = conn.get_vcpu()
cur_vcpu = conn.get_cur_vcpu()
uuid = conn.get_uuid()
memory = conn.get_memory()
cur_memory = conn.get_cur_memory()
description = conn.get_description()
disks = conn.get_disk_device()
media = conn.get_media_device()
networks = conn.get_net_device()
media_iso = sorted(conn.get_iso_media())
vcpu_range = conn.get_max_cpus()
memory_range = [256, 512, 1024, 2048, 4096, 6144, 8192, 16384]
memory_host = conn.get_max_memory()
vcpu_host = len(vcpu_range)
telnet_port = conn.get_telnet_port()
vnc_port = conn.get_vnc_port()
vnc_keymap = conn.get_vnc_keymap()
vnc_password = conn.get_vnc_passwd()
snapshots = sorted(conn.get_snapshot(), reverse=True)
inst_xml = conn._XMLDesc(VIR_DOMAIN_XML_SECURE)
has_managed_save_image = conn.get_managed_save_image()
clone_disks = show_clone_disk(disks)
cpu_usage = conn.cpu_usage()['cpu']
except libvirtError as err:
errors.append(err)
try:
instance = Instance.objects.get(compute_id=host_id, name=vname)
if instance.uuid != uuid:
instance.uuid = uuid
instance.save()
except Instance.DoesNotExist:
instance = Instance(compute_id=host_id, name=vname, uuid=uuid)
instance.save()
try:
if request.method == 'POST':
if 'start' in request.POST:
conn.start()
return HttpResponseRedirect(request.get_full_path() +
'#shutdown')
if 'power' in request.POST:
if 'shutdown' == request.POST.get('power', ''):
conn.shutdown()
return HttpResponseRedirect(request.get_full_path() +
'#shutdown')
if 'destroy' == request.POST.get('power', ''):
conn.force_shutdown()
return HttpResponseRedirect(request.get_full_path() +
'#forceshutdown')
if 'managedsave' == request.POST.get('power', ''):
conn.managedsave()
return HttpResponseRedirect(request.get_full_path() +
'#managedsave')
if 'deletesaveimage' in request.POST:
conn.managed_save_remove()
return HttpResponseRedirect(request.get_full_path() +
'#managedsave')
if 'suspend' in request.POST:
conn.suspend()
return HttpResponseRedirect(request.get_full_path() +
'#suspend')
if 'resume' in request.POST:
conn.resume()
return HttpResponseRedirect(request.get_full_path() +
'#suspend')
if 'delete' in request.POST:
if conn.get_status() == 1:
conn.force_shutdown()
if request.POST.get('delete_disk', ''):
print 'yeah'
conn.delete_disk()
try:
instance = Instance.objects.get(compute_id=host_id,
name=vname)
instance.delete()
finally:
conn.delete()
return HttpResponseRedirect('/%s/instances' % host_id)
if 'assign_volume' in request.POST:
file = request.POST.get('file', '')
device = request.POST.get('device', '')
conn.assign_volume(file, device)
return HttpResponseRedirect(request.get_full_path() +
'#instancedevice')
if 'unassign_volume' in request.POST:
device = request.POST.get('device', '')
conn.unassign_volume(device)
return HttpResponseRedirect(request.get_full_path() +
'#instancedevice')
if 'snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_snapshot(name)
return HttpResponseRedirect(request.get_full_path() +
'#istaceshapshosts')
if 'external_storage_snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_external_storage_snapshot(name)
return HttpResponseRedirect(request.get_full_path() +
'#istaceshapshosts')
if 'umount_iso' in request.POST:
image = request.POST.get('path', '')
first_cd = media[0]['dev'] if len(
media) > 0 else request.POST.get('umount_iso', '')
dev = request.POST.get('device', first_cd)
conn.umount_iso(dev, image)
return HttpResponseRedirect(request.get_full_path() +
'#instancemedia')
if 'mount_iso' in request.POST:
image = request.POST.get('media', '')
first_cd = media[0]['dev'] if len(media) > 0 else ''
print first_cd
dev = request.POST.get('device', first_cd)
conn.mount_iso(dev, image)
return HttpResponseRedirect(request.get_full_path() +
'#instancemedia')
if 'set_autostart' in request.POST:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path() +
'#instancesettings')
if 'unset_autostart' in request.POST:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path() +
'#instancesettings')
if 'change_settings' in request.POST:
description = request.POST.get('description', '')
vcpu = request.POST.get('vcpu', '')
cur_vcpu = request.POST.get('cur_vcpu', '')
memory = request.POST.get('memory', '')
cur_memory = request.POST.get('cur_memory', '')
conn.change_settings(description, cur_memory, memory, cur_vcpu,
vcpu)
return HttpResponseRedirect(request.get_full_path() +
'#instancesettings')
if 'change_xml' in request.POST:
xml = request.POST.get('inst_xml', '')
if xml:
conn._defineXML(xml)
return HttpResponseRedirect(request.get_full_path() +
'#instancexml')
if 'set_vnc_passwd' in request.POST:
if request.POST.get('auto_pass', ''):
passwd = ''.join(
[choice(letters + digits) for i in xrange(12)])
else:
passwd = request.POST.get('vnc_passwd', '')
clear = request.POST.get('clear_pass', False)
if not passwd and not clear:
msg = _("Enter the VNC password or select Generate")
errors.append(msg)
if not errors:
conn.set_vnc_passwd(passwd)
return HttpResponseRedirect(request.get_full_path() +
'#vnc_pass')
if 'set_vnc_keymap' in request.POST:
keymap = request.POST.get('vnc_keymap', '')
clear = request.POST.get('clear_keymap', False)
if clear:
conn.set_vnc_keymap('')
else:
conn.set_vnc_keymap(keymap)
return HttpResponseRedirect(request.get_full_path() +
'#vnc_keymap')
if 'migrate' in request.POST:
compute_id = request.POST.get('compute_id', '')
live = request.POST.get('live_migrate', False)
unsafe = request.POST.get('unsafe_migrate', False)
xml_del = request.POST.get('xml_delete', False)
new_compute = Compute.objects.get(id=compute_id)
conn_migrate = wvmInstances(new_compute.hostname,
new_compute.login,
new_compute.password,
new_compute.type)
conn_migrate.moveto(conn, vname, live, unsafe, xml_del)
conn_migrate.define_move(vname)
conn_migrate.close()
return HttpResponseRedirect('/%s/instance/%s' %
(compute_id, vname))
if 'delete_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_delete(snap_name)
return HttpResponseRedirect(request.get_full_path() +
'#istaceshapshosts')
if 'revert_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_revert(snap_name)
msg = _("Successful revert snapshot: ")
msg += snap_name
messages.append(msg)
if 'clone' in request.POST:
clone_data = {}
clone_data['name'] = request.POST.get('name', '')
for post in request.POST:
if 'disk' or 'meta' in post:
clone_data[post] = request.POST.get(post, '')
conn.clone_instance(clone_data)
return HttpResponseRedirect('/%s/instance/%s' %
(host_id, clone_data['name']))
conn.close()
except libvirtError as err:
errors.append(err)
object = {
'errors': [str(error) for error in errors],
'response': {
'name': vname,
'status': status,
'autostart': autostart,
'vcpu': vcpu,
'cur_vcpu': cur_vcpu,
'uuid': uuid,
'memory': memory,
'cur_memory': cur_memory,
'description': description,
'disks': disks,
'media': media,
'networks': networks,
'media_iso': media_iso,
'vcpu_range': vcpu_range.__len__(),
'memory_host': memory_host,
'vcpu_host': vcpu_host,
'telnet_port': telnet_port,
'vnc_port': vnc_port,
'vnc_keymap': vnc_keymap,
'snapshots': snapshots,
'inst_xml': inst_xml.__str__(),
'has_managed_save_image': has_managed_save_image,
'clone_disks': clone_disks,
'cpu_usage': cpu_usage,
'vnc_password': vnc_password
}
}
return render(object, 'instance.html', locals(), request)
def create(request, host_id):
"""
Create new instance.
"""
conn = None
errors = []
storages = []
networks = []
meta_prealloc = False
compute = Compute.objects.get(id=host_id)
flavors = Flavor.objects.filter().order_by('id')
try:
conn = wvmCreate(compute.hostname, compute.login, compute.password,
compute.type)
storages = sorted(conn.get_storages())
networks = sorted(conn.get_networks())
instances = conn.get_instances()
get_images = sorted(conn.get_storages_images())
mac_auto = util.randomMAC()
except libvirtError as err:
errors.append(err)
if conn:
if not storages:
msg = _("You haven't defined have any storage pools")
errors.append(msg)
if not networks:
msg = _("You haven't defined have any network pools")
errors.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_xml' in request.POST:
xml = request.POST.get('from_xml', '')
try:
name = util.get_xml_path(xml, '/domain/name')
except util.libxml2.parserError:
name = None
if name in instances:
msg = _("A virtual machine with this name already exists")
errors.append(msg)
else:
try:
conn._defineXML(xml)
return HttpResponseRedirect('/%s/instance/%s' %
(host_id, name))
except libvirtError as err:
errors.append(err.message)
if 'create' in request.POST:
volumes = {}
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"
)
errors.append(msg)
if not errors:
if data['hdd_size']:
if not data['mac']:
msg = _(
"No Virtual Machine MAC has been entered")
errors.append(msg)
else:
try:
path = conn.create_volume(
data['storage'],
data['name'],
data['hdd_size'],
metadata=meta_prealloc)
volumes[path] = conn.get_volume_type(path)
except libvirtError as msg_error:
errors.append(msg_error.message)
elif data['template']:
templ_path = conn.get_volume_path(data['template'])
clone_path = conn.clone_from_template(
data['name'],
templ_path,
metadata=meta_prealloc)
volumes[clone_path] = conn.get_volume_type(
clone_path)
else:
if not data['images']:
msg = _(
"First you need to create or select an image"
)
errors.append(msg)
else:
for vol in data['images'].split(','):
try:
path = conn.get_volume_path(vol)
volumes[path] = conn.get_volume_type(
path)
except libvirtError as msg_error:
errors.append(msg_error.message)
if not errors:
uuid = util.randomUUID()
try:
conn.create_instance(
data['name'], data['memory'], data['vcpu'],
data['host_model'], uuid, volumes,
data['networks'], data['virtio'],
data['mac'])
create_instance = Instance(compute_id=host_id,
name=data['name'],
uuid=uuid)
create_instance.save()
return HttpResponseRedirect(
'/%s/instance/%s' %
(host_id, data['name']))
except libvirtError as err:
if data['hdd_size']:
conn.delete_volume(volumes.keys()[0])
errors.append(err)
conn.close()
object = {
'errors': [force_text(error) for error in errors],
'response': {}
}
return render(object, 'create.html', locals(), request)
object = {
'errors': [str(error) for error in errors],
'response': {}
}
url = '/%s/network/%s/' % (host_id, data['name'])
return redirect_or_json(object, url, request)
conn.close()
except Compute.DoesNotExist, e:
object['errors'] = e.message
except libvirtError as err:
errors.append(err)
object['errors'] = [str(error) for error in errors]
return render(object, 'networks.html', locals(), request)
def network(request, host_id, pool):
"""
Networks block
"""
errors = []
compute = Compute.objects.get(id=host_id)
conn = None
try:
conn = wvmNetwork(compute.hostname, compute.login, compute.password,
compute.type, pool)
networks = conn.get_networks()
state = conn.is_active()
def instance(request, host_id, vname):
errors = []
messages = []
time_refresh = TIME_JS_REFRESH
compute = Compute.objects.get(id=host_id)
computes = Compute.objects.all()
computes_count = len(computes)
keymaps = QEMU_KEYMAPS
try:
conn = wvmInstance(compute.hostname, compute.login, compute.password,
compute.type, vname)
except libvirtError as err:
errors.append(err)
try:
if request.method == 'POST':
if 'start' in request.POST:
conn.start()
return HttpResponseRedirect(request.get_full_path() +
'#shutdown')
if 'power' in request.POST:
if 'shutdown' == request.POST.get('power', ''):
conn.shutdown()
return HttpResponseRedirect(request.get_full_path() +
'#shutdown')
if 'destroy' == request.POST.get('power', ''):
conn.force_shutdown()
return HttpResponseRedirect(request.get_full_path() +
'#forceshutdown')
if 'managedsave' == request.POST.get('power', ''):
conn.managedsave()
return HttpResponseRedirect(request.get_full_path() +
'#managedsave')
if 'shutdown' in request.POST:
conn.shutdown()
return HttpResponseRedirect(request.get_full_path() +
'#shutdown')
if 'destroy' in request.POST:
conn.force_shutdown()
return HttpResponseRedirect(request.get_full_path() +
'#forceshutdown')
if 'managedsave' in request.POST:
conn.managedsave()
return HttpResponseRedirect(request.get_full_path() +
'#managedsave')
if 'deletesaveimage' in request.POST:
conn.managed_save_remove()
return HttpResponseRedirect(request.get_full_path() +
'#managedsave')
if 'suspend' in request.POST:
conn.suspend()
return HttpResponseRedirect(request.get_full_path() +
'#suspend')
if 'resume' in request.POST:
conn.resume()
return HttpResponseRedirect(request.get_full_path() +
'#suspend')
if 'delete' in request.POST:
if conn.get_status() == 1:
conn.force_shutdown()
if request.POST.get('delete_disk', ''):
conn.delete_disk()
conn.delete()
return HttpResponseRedirect('/%s/instances' % host_id)
if 'assign_volume' in request.POST:
file = request.POST.get('file', '')
device = request.POST.get('device', '')
conn.assign_volume(file, device)
return HttpResponseRedirect(request.get_full_path() +
'#instancedevice')
if 'unassign_volume' in request.POST:
device = request.POST.get('device', '')
conn.unassign_volume(device)
return HttpResponseRedirect(request.get_full_path() +
'#instancedevice')
if 'snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_snapshot(name)
return HttpResponseRedirect(request.get_full_path() +
'#istaceshapshosts')
if 'external_storage_snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_external_storage_snapshot(name)
return HttpResponseRedirect(request.get_full_path() +
'#istaceshapshosts')
if 'umount_iso' in request.POST:
image = request.POST.get('path', '')
media = conn.get_media_device()
first_cd = media[0]['dev'] if len(
media) > 0 else request.POST.get('umount_iso', '')
dev = request.POST.get('device', first_cd)
conn.umount_iso(dev, image)
return HttpResponseRedirect(request.get_full_path() +
'#instancemedia')
if 'mount_iso' in request.POST:
image = request.POST.get('media', '')
media = conn.get_media_device()
first_cd = media[0]['dev'] if len(media) > 0 else ''
dev = request.POST.get('device', first_cd)
conn.mount_iso(dev, image)
# return HttpResponseRedirect(request.get_full_path() + '#instancemedia')
if 'set_autostart' in request.POST:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path() +
'#instancesettings')
if 'unset_autostart' in request.POST:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path() +
'#instancesettings')
if 'change_settings' in request.POST:
description = request.POST.get('description', '')
vcpu = request.POST.get('vcpu', '')
cur_vcpu = request.POST.get('cur_vcpu', '')
memory = request.POST.get('memory', '')
cur_memory = request.POST.get('cur_memory', '')
conn.change_settings(description, cur_memory, memory, cur_vcpu,
vcpu)
return HttpResponseRedirect(request.get_full_path() +
'#instancesettings')
if 'change_xml' in request.POST:
xml = request.POST.get('inst_xml', '')
if xml:
conn._defineXML(xml)
return HttpResponseRedirect(request.get_full_path() +
'#instancexml')
if 'set_vnc_passwd' in request.POST:
if request.POST.get('auto_pass', ''):
passwd = ''.join(
[choice(letters + digits) for i in xrange(12)])
else:
passwd = request.POST.get('vnc_passwd', '')
clear = request.POST.get('clear_pass', False)
if not passwd and not clear:
msg = _("Enter the VNC password or select Generate")
errors.append(msg)
if not errors:
conn.set_vnc_passwd(passwd)
return HttpResponseRedirect(request.get_full_path() +
'#vnc_pass')
if 'set_vnc_keymap' in request.POST:
keymap = request.POST.get('vnc_keymap', '')
clear = request.POST.get('clear_keymap', False)
if clear:
conn.set_vnc_keymap('')
else:
conn.set_vnc_keymap(keymap)
return HttpResponseRedirect(request.get_full_path() +
'#vnc_keymap')
if 'migrate' in request.POST:
compute_id = request.POST.get('compute_id', '')
live = request.POST.get('live_migrate', False)
unsafe = request.POST.get('unsafe_migrate', False)
xml_del = request.POST.get('xml_delete', False)
new_compute = Compute.objects.get(id=compute_id)
conn_migrate = wvmInstances(new_compute.hostname,
new_compute.login,
new_compute.password,
new_compute.type)
conn_migrate.moveto(conn, vname, live, unsafe, xml_del)
conn_migrate.define_move(vname)
conn_migrate.close()
return HttpResponseRedirect('/%s/instance/%s' %
(compute_id, vname))
if 'delete_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_delete(snap_name)
return HttpResponseRedirect(request.get_full_path() +
'#istaceshapshosts')
if 'revert_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_revert(snap_name)
msg = _("Successful revert snapshot: ")
msg += snap_name
messages.append(msg)
if 'clone' in request.POST:
clone_data = {}
clone_data['name'] = request.POST.get('name', '')
for post in request.POST:
if 'disk' or 'meta' in post:
clone_data[post] = request.POST.get(post, '')
conn.clone_instance(clone_data)
return HttpResponseRedirect('/%s/instance/%s' %
(host_id, clone_data['name']))
conn.close()
except libvirtError as err:
errors.append(err)
params = {
'status': 'get_status',
'vcpu': 'get_vcpu',
'cur_vcpu': 'get_cur_vcpu',
'uuid': 'get_uuid',
'memory': 'get_memory',
'cur_memory': 'get_cur_memory',
'description': 'get_description',
'disks': 'get_disk_device',
'media': 'get_media_device',
'vcpu_range': 'get_max_cpus',
'max_memory': 'get_max_memory',
'vnc_port': 'get_vnc_port',
'vnc_keymap': 'get_vnc_keymap',
'vnc_passwd': 'get_vnc_passwd',
}
object = {}
def get_param(param, tocall):
object[param] = getattr(conn, tocall)()
mypool = WorkerPool(5)
for param in params:
mypool.add_task(get_param, param, params[param])
mypool.run_tasks()
# status = conn.get_status()
status = object['status']
autostart = 0 #conn.get_autostart()
# vcpu = conn.get_vcpu()
vcpu = object['vcpu']
# cur_vcpu = conn.get_cur_vcpu()
cur_vcpu = object['cur_vcpu']
# uuid = conn.get_uuid()
uuid = object['uuid']
# memory = conn.get_memory()
memory = object['memory']
# cur_memory = conn.get_cur_memory()
cur_memory = object['cur_memory']
# description = conn.get_description()
description = object['description']
# disks = conn.get_disk_device()
disks = object['disks']
# media = conn.get_media_device()
media = object['media']
networks = 0 #conn.get_net_device()
media_iso = [] #sorted(conn.get_iso_media())
# vcpu_range = conn.get_max_cpus()
vcpu_range = object['vcpu_range']
memory_range = [256, 512, 1024, 2048, 4096, 6144, 8192, 16384]
# memory_host = conn.get_max_memory()
memory_host = object['max_memory']
vcpu_host = len(vcpu_range)
telnet_port = 0 #conn.get_telnet_port()
# vnc_port = conn.get_vnc_port()
vnc_port = object['vnc_port']
# vnc_keymap = conn.get_vnc_keymap()
vnc_keymap = object['vnc_keymap']
vnc_password = object['vnc_passwd']
snapshots = [] #sorted(conn.get_snapshot(), reverse=True)
inst_xml = '' #conn._XMLDesc(VIR_DOMAIN_XML_SECURE)
has_managed_save_image = 0 #conn.get_managed_save_image()
clone_disks = [] #show_clone_disk(disks)
cpu_usage = conn.raw_cpu_usage()
responseObject = {
'name': vname,
'status': status,
'autostart': autostart,
'vcpu': vcpu,
'cur_vcpu': cur_vcpu,
'uuid': uuid,
'memory': memory,
'cur_memory': cur_memory,
'description': description,
'disks': disks,
'media': media,
'networks': networks,
'media_iso': media_iso,
'vcpu_range': vcpu_range.__len__(),
'memory_host': memory_host,
'vcpu_host': vcpu_host,
'telnet_port': telnet_port,
'vnc_port': vnc_port,
'vnc_keymap': vnc_keymap,
'snapshots': snapshots,
'inst_xml': inst_xml.__str__(),
'has_managed_save_image': has_managed_save_image,
'clone_disks': clone_disks,
'cpu_usage': cpu_usage,
'vnc_password': vnc_password
}
try:
responseObject['mac_address'] = conn.desc(
)['domain']['devices']['interface']['mac']['@address']
except:
pass
object = {
'errors': [str(error) for error in errors],
'response': responseObject
}
return render(object, 'instance.html', locals(), request)
def instance(request, host_id, vname):
errors = []
messages = []
time_refresh = TIME_JS_REFRESH
compute = Compute.objects.get(id=host_id)
computes = Compute.objects.all()
computes_count = len(computes)
keymaps = QEMU_KEYMAPS
try:
conn = wvmInstance(compute.hostname,
compute.login,
compute.password,
compute.type,
vname)
except libvirtError as err:
errors.append(err)
try:
if request.method == 'POST':
if 'start' in request.POST:
conn.start()
return HttpResponseRedirect(request.get_full_path() + '#shutdown')
if 'power' in request.POST:
if 'shutdown' == request.POST.get('power', ''):
conn.shutdown()
return HttpResponseRedirect(request.get_full_path() + '#shutdown')
if 'destroy' == request.POST.get('power', ''):
conn.force_shutdown()
return HttpResponseRedirect(request.get_full_path() + '#forceshutdown')
if 'managedsave' == request.POST.get('power', ''):
conn.managedsave()
return HttpResponseRedirect(request.get_full_path() + '#managedsave')
if 'shutdown' in request.POST:
conn.shutdown()
return HttpResponseRedirect(request.get_full_path() + '#shutdown')
if 'destroy' in request.POST:
conn.force_shutdown()
return HttpResponseRedirect(request.get_full_path() + '#forceshutdown')
if 'managedsave' in request.POST:
conn.managedsave()
return HttpResponseRedirect(request.get_full_path() + '#managedsave')
if 'deletesaveimage' in request.POST:
conn.managed_save_remove()
return HttpResponseRedirect(request.get_full_path() + '#managedsave')
if 'suspend' in request.POST:
conn.suspend()
return HttpResponseRedirect(request.get_full_path() + '#suspend')
if 'resume' in request.POST:
conn.resume()
return HttpResponseRedirect(request.get_full_path() + '#suspend')
if 'delete' in request.POST:
if conn.get_status() == 1:
conn.force_shutdown()
if request.POST.get('delete_disk', ''):
conn.delete_disk()
conn.delete()
return HttpResponseRedirect('/%s/instances' % host_id)
if 'assign_volume' in request.POST:
file = request.POST.get('file', '')
device = request.POST.get('device', '')
conn.assign_volume(file, device)
return HttpResponseRedirect(request.get_full_path() + '#instancedevice')
if 'unassign_volume' in request.POST:
device = request.POST.get('device', '')
conn.unassign_volume(device)
return HttpResponseRedirect(request.get_full_path() + '#instancedevice')
if 'snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_snapshot(name)
return HttpResponseRedirect(request.get_full_path() + '#istaceshapshosts')
if 'external_storage_snapshot' in request.POST:
name = request.POST.get('name', '')
conn.create_external_storage_snapshot(name)
return HttpResponseRedirect(request.get_full_path() + '#istaceshapshosts')
if 'umount_iso' in request.POST:
image = request.POST.get('path', '')
media = conn.get_media_device()
first_cd = media[0]['dev'] if len(media) > 0 else request.POST.get('umount_iso', '')
dev = request.POST.get('device', first_cd)
conn.umount_iso(dev, image)
return HttpResponseRedirect(request.get_full_path() + '#instancemedia')
if 'mount_iso' in request.POST:
image = request.POST.get('media', '')
media = conn.get_media_device()
first_cd = media[0]['dev'] if len(media) > 0 else ''
dev = request.POST.get('device', first_cd)
conn.mount_iso(dev, image)
# return HttpResponseRedirect(request.get_full_path() + '#instancemedia')
if 'set_autostart' in request.POST:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path() + '#instancesettings')
if 'unset_autostart' in request.POST:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path() + '#instancesettings')
if 'change_settings' in request.POST:
description = request.POST.get('description', '')
vcpu = request.POST.get('vcpu', '')
cur_vcpu = request.POST.get('cur_vcpu', '')
memory = request.POST.get('memory', '')
cur_memory = request.POST.get('cur_memory', '')
conn.change_settings(description, cur_memory, memory, cur_vcpu, vcpu)
return HttpResponseRedirect(request.get_full_path() + '#instancesettings')
if 'change_xml' in request.POST:
xml = request.POST.get('inst_xml', '')
if xml:
conn._defineXML(xml)
return HttpResponseRedirect(request.get_full_path() + '#instancexml')
if 'set_vnc_passwd' in request.POST:
if request.POST.get('auto_pass', ''):
passwd = ''.join([choice(letters + digits) for i in xrange(12)])
else:
passwd = request.POST.get('vnc_passwd', '')
clear = request.POST.get('clear_pass', False)
if not passwd and not clear:
msg = _("Enter the VNC password or select Generate")
errors.append(msg)
if not errors:
conn.set_vnc_passwd(passwd)
return HttpResponseRedirect(request.get_full_path() + '#vnc_pass')
if 'set_vnc_keymap' in request.POST:
keymap = request.POST.get('vnc_keymap', '')
clear = request.POST.get('clear_keymap', False)
if clear:
conn.set_vnc_keymap('')
else:
conn.set_vnc_keymap(keymap)
return HttpResponseRedirect(request.get_full_path() + '#vnc_keymap')
if 'migrate' in request.POST:
compute_id = request.POST.get('compute_id', '')
live = request.POST.get('live_migrate', False)
unsafe = request.POST.get('unsafe_migrate', False)
xml_del = request.POST.get('xml_delete', False)
new_compute = Compute.objects.get(id=compute_id)
conn_migrate = wvmInstances(new_compute.hostname,
new_compute.login,
new_compute.password,
new_compute.type)
conn_migrate.moveto(conn, vname, live, unsafe, xml_del)
conn_migrate.define_move(vname)
conn_migrate.close()
return HttpResponseRedirect('/%s/instance/%s' % (compute_id, vname))
if 'delete_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_delete(snap_name)
return HttpResponseRedirect(request.get_full_path() + '#istaceshapshosts')
if 'revert_snapshot' in request.POST:
snap_name = request.POST.get('name', '')
conn.snapshot_revert(snap_name)
msg = _("Successful revert snapshot: ")
msg += snap_name
messages.append(msg)
if 'clone' in request.POST:
clone_data = {}
clone_data['name'] = request.POST.get('name', '')
for post in request.POST:
if 'disk' or 'meta' in post:
clone_data[post] = request.POST.get(post, '')
conn.clone_instance(clone_data)
return HttpResponseRedirect('/%s/instance/%s' % (host_id, clone_data['name']))
conn.close()
except libvirtError as err:
errors.append(err)
params = {
'status': 'get_status',
'vcpu': 'get_vcpu',
'cur_vcpu': 'get_cur_vcpu',
'uuid': 'get_uuid',
'memory': 'get_memory',
'cur_memory': 'get_cur_memory',
'description': 'get_description',
'disks': 'get_disk_device',
'media': 'get_media_device',
'vcpu_range': 'get_max_cpus',
'max_memory': 'get_max_memory',
'vnc_port': 'get_vnc_port',
'vnc_keymap': 'get_vnc_keymap',
'vnc_passwd': 'get_vnc_passwd',
}
object = {}
def get_param(param, tocall):
object[param] = getattr(conn, tocall)()
mypool = WorkerPool(5)
for param in params:
mypool.add_task(get_param, param, params[param])
mypool.run_tasks()
# status = conn.get_status()
status = object['status']
autostart = 0 #conn.get_autostart()
# vcpu = conn.get_vcpu()
vcpu = object['vcpu']
# cur_vcpu = conn.get_cur_vcpu()
cur_vcpu = object['cur_vcpu']
# uuid = conn.get_uuid()
uuid = object['uuid']
# memory = conn.get_memory()
memory = object['memory']
# cur_memory = conn.get_cur_memory()
cur_memory = object['cur_memory']
# description = conn.get_description()
description = object['description']
# disks = conn.get_disk_device()
disks = object['disks']
# media = conn.get_media_device()
media = object['media']
networks = 0#conn.get_net_device()
media_iso = []#sorted(conn.get_iso_media())
# vcpu_range = conn.get_max_cpus()
vcpu_range = object['vcpu_range']
memory_range = [256, 512, 1024, 2048, 4096, 6144, 8192, 16384]
# memory_host = conn.get_max_memory()
memory_host = object['max_memory']
vcpu_host = len(vcpu_range)
telnet_port = 0#conn.get_telnet_port()
# vnc_port = conn.get_vnc_port()
vnc_port = object['vnc_port']
# vnc_keymap = conn.get_vnc_keymap()
vnc_keymap = object['vnc_keymap']
vnc_password = object['vnc_passwd']
snapshots = []#sorted(conn.get_snapshot(), reverse=True)
inst_xml = ''#conn._XMLDesc(VIR_DOMAIN_XML_SECURE)
has_managed_save_image = 0#conn.get_managed_save_image()
clone_disks = []#show_clone_disk(disks)
cpu_usage = conn.raw_cpu_usage()
responseObject = {
'name': vname,
'status': status,
'autostart': autostart,
'vcpu': vcpu,
'cur_vcpu': cur_vcpu,
'uuid': uuid,
'memory': memory,
'cur_memory': cur_memory,
'description': description,
'disks': disks,
'media': media,
'networks': networks,
'media_iso': media_iso,
'vcpu_range': vcpu_range.__len__(),
'memory_host': memory_host,
'vcpu_host': vcpu_host,
'telnet_port': telnet_port,
'vnc_port': vnc_port,
'vnc_keymap': vnc_keymap,
'snapshots': snapshots,
'inst_xml': inst_xml.__str__(),
'has_managed_save_image': has_managed_save_image,
'clone_disks': clone_disks,
'cpu_usage': cpu_usage,
'vnc_password': vnc_password
}
try:
responseObject['mac_address'] = conn.desc()['domain']['devices']['interface']['mac']['@address']
except:
pass
object = {
'errors': [str(error) for error in errors],
'response': responseObject
}
return render(object, 'instance.html', locals(), request)
object = {
'errors': [str(error) for error in errors],
'response': {}
}
url = '/%s/network/%s/' % (host_id, data['name'])
return redirect_or_json(object, url, request)
conn.close()
except Compute.DoesNotExist, e:
object['errors'] = e.message
except libvirtError as err:
errors.append(err)
object['errors'] = [str(error) for error in errors]
return render(object, 'networks.html', locals(), request)
def network(request, host_id, pool):
"""
Networks block
"""
errors = []
compute = Compute.objects.get(id=host_id)
conn = None
try:
conn = wvmNetwork(compute.hostname,
compute.login,
compute.password,
compute.type,
