def get_wvmStorage(self, pool):
storage = wvmStorage(self.host,
self.login,
self.passwd,
self.conn,
pool)
return storage
def get_wvmStorage(self, pool):
storage = wvmStorage(self.host,
self.login,
self.passwd,
self.conn,
pool)
return storage
def create_volume(request, compute_id, pool):
compute = get_object_or_404(Compute, pk=compute_id)
meta_prealloc = False
conn = wvmStorage(compute.hostname, compute.login, compute.password,
compute.type, pool)
storages = conn.get_storages()
form = CreateVolumeForm(request.POST or None)
if form.is_valid():
data = form.cleaned_data
if data['meta_prealloc'] and data['format'] == 'qcow2':
meta_prealloc = True
disk_owner_uid = int(app_settings.INSTANCE_VOLUME_DEFAULT_OWNER_UID)
disk_owner_gid = int(app_settings.INSTANCE_VOLUME_DEFAULT_OWNER_GID)
name = conn.create_volume(
data['name'],
data['size'],
data['format'],
meta_prealloc,
disk_owner_uid,
disk_owner_gid,
)
messages.success(request,
_(f"Image file {name} is created successfully"))
else:
for msg_err in form.errors.values():
messages.error(request, msg_err.as_text())
return redirect(reverse('storage', args=[compute.id, pool]))
def get_volumes(request, compute_id, pool):
data = {}
compute = get_object_or_404(Compute, pk=compute_id)
try:
conn = wvmStorage(compute.hostname, compute.login, compute.password,
compute.type, pool)
conn.refresh()
except libvirtError:
pass
data['vols'] = sorted(conn.get_volumes())
return HttpResponse(json.dumps(data))
def get_volumes(request, compute_id, pool):
data = {}
compute = get_object_or_404(Compute, pk=compute_id)
try:
conn = wvmStorage(compute.hostname,
compute.login,
compute.password,
compute.type,
pool)
conn.refresh()
except libvirtError as liberr:
pass
data['vols'] = sorted(conn.get_volumes())
return HttpResponse(json.dumps(data))
def do_execute(self, quick_model: create_models.QuickVM):
disks_path = []
compute = compute_models.Compute.objects.get(id=quick_model.compute_id)
conn = wvmStorage(compute.hostname, compute.login, compute.password,
compute.type, self.target_disk_pool_name)
pool_dir = util.get_xml_path(conn.pool.XMLDesc(), 'target/path')
backing_file = quick_model.backing_file
if backing_file:
backing_file = backing_file
backing_pool = conn.get_storage(self.backing_pool_name)
vol = backing_pool.storageVolLookupByName(backing_file)
backing_file = vol.path() # 绝对路径
meta_prealloc = False
disk_name = quick_model.token + '-backing'
data = {
'name': disk_name,
'size': 1, # GB 后端镜像不需要指定磁盘大小
'format': self.disk_format,
'is_use_backing': True,
}
conn.create_volume(data['name'], data['size'], data['format'],
meta_prealloc, data["is_use_backing"],
backing_file)
disks_path.append(
os.path.join(pool_dir,
'%s.%s' % (disk_name, self.disk_format)))
# 创建数据盘
if quick_model.disk:
disks = [x.strip() for x in quick_model.disk.split(',')]
for i, disk in enumerate(disks, start=1):
meta_prealloc = False
disk_name = quick_model.token + '-disk' + str(i)
data = {
'name': disk_name,
'size': int(disk), # GB
'format': 'qcow2',
}
conn.create_volume(data['name'], data['size'], data['format'],
meta_prealloc)
disks_path.append(
os.path.join(pool_dir,
'%s.%s' % (disk_name, self.disk_format)))
quick_model.disks_path = ','.join(disks_path)
quick_model.save()
return quick_model.disks_path
def get_volumes(request, compute_id, pool):
"""
:param request:
:param compute_id: compute id
:param pool: pool name
:return: volumes list of pool
"""
data = {}
compute = get_object_or_404(Compute, pk=compute_id)
try:
conn = wvmStorage(compute.hostname, compute.login, compute.password, compute.type, pool)
conn.refresh()
data["vols"] = sorted(conn.get_volumes())
except libvirtError:
pass
return HttpResponse(json.dumps(data))
def create_volume(request, compute_id, pool):
"""
:param request:
:param compute_id: compute id
:param pool: pool name
:return:
"""
compute = get_object_or_404(Compute, pk=compute_id)
meta_prealloc = False
conn = wvmStorage(compute.hostname, compute.login, compute.password,
compute.type, pool)
storages = conn.get_storages()
form = CreateVolumeForm(request.POST or None)
if form.is_valid():
data = form.cleaned_data
if data["meta_prealloc"] and data["format"] == "qcow2":
meta_prealloc = True
disk_owner_uid = int(app_settings.INSTANCE_VOLUME_DEFAULT_OWNER_UID)
disk_owner_gid = int(app_settings.INSTANCE_VOLUME_DEFAULT_OWNER_GID)
name = conn.create_volume(
data["name"],
data["size"],
data["format"],
meta_prealloc,
disk_owner_uid,
disk_owner_gid,
)
messages.success(
request,
_("Image file %(name)s is created successfully") % {"name": name})
else:
for msg_err in form.errors.values():
messages.error(request, msg_err.as_text())
return redirect(reverse("storage", args=[compute.id, pool]))
def storage(request, compute_id, pool):
"""
:param request:
:return:
"""
if not request.user.is_superuser:
return HttpResponseRedirect(reverse('index'))
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()
error_messages = []
compute = get_object_or_404(Compute, pk=compute_id)
meta_prealloc = False
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 lib_err:
error_messages.append(lib_err)
if request.method == 'POST':
if 'start' in request.POST:
try:
conn.start()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
error_messages.append(lib_err.message)
if 'stop' in request.POST:
try:
conn.stop()
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
error_messages.append(lib_err.message)
if 'delete' in request.POST:
try:
conn.delete()
return HttpResponseRedirect(reverse('storages', args=[compute_id]))
except libvirtError as lib_err:
error_messages.append(lib_err.message)
if 'set_autostart' in request.POST:
try:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
error_messages.append(lib_err.message)
if 'unset_autostart' in request.POST:
try:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
error_messages.append(lib_err.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)
messages.success(request, _("Image file {} is created successfully".format(data['name']+".img")))
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
error_messages.append(lib_err)
else:
for msg_err in form.errors.values():
error_messages.append(msg_err.as_text())
if 'del_volume' in request.POST:
volname = request.POST.get('volname', '')
try:
vol = conn.get_volume(volname)
vol.delete(0)
messages.success(request, _('Volume: {} is deleted.'.format(volname)))
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
error_messages.append(lib_err.message)
if 'iso_upload' in request.POST:
if str(request.FILES['file']) in conn.update_volumes():
error_msg = _("ISO image already exist")
error_messages.append(error_msg)
else:
handle_uploaded_file(path, request.FILES['file'])
messages.success(request, _('ISO: {} is uploaded.'.format(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")
error_messages.append(msg)
if not error_messages:
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)
messages.success(request, _("{} image cloned as {} successfully".format(data['image'], data['name'] + ".img")))
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
error_messages.append(lib_err)
else:
for msg_err in form.errors.values():
error_messages.append(msg_err.as_text())
conn.close()
return render(request, 'storage.html', locals())
def storage(request, host_id, pool):
"""
Storage pool block
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
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
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(reverse('storages',
args=[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)
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)
conn.close()
return render_to_response('storage.html',
locals(),
context_instance=RequestContext(request))
def instances(request, host_id):
"""
Instances block
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
errors = []
instances = []
time_refresh = 8000
get_instances = []
cnt_max = settings.vf_cnt_max
conn = None
meta_prealloc = False
compute = Compute.objects.get(id=host_id)
memory_range = [2048, 4096, 6144, 8192, 16384]
ifaces_all = util.get_free_vfs()
ifaces_all = sorted(ifaces_all.iteritems(),key=lambda ax:ax[0])
try:
conn = wvmInstances(compute.hostname,
compute.login,
compute.password,
compute.type)
conn_create = wvmCreate(compute.hostname,
compute.login,
compute.password,
compute.type)
conn_storage = wvmStorage(compute.hostname,
compute.login,
compute.password,
compute.type,
'Images')
state = conn_storage.is_active()
if state:
conn_storage.refresh()
volumes = conn_storage.update_volumes()
conn_storage.close()
else:
volumes = None
get_images = volumes
get_instances = conn.get_instances()
except libvirtError as err:
pass
# 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()
instances.append({'name': instance,
'status': conn.get_instance_status(instance),
'uuid': uuid,
'memory': conn.get_instance_memory(instance),
'vcpu': conn.get_instance_vcpu(instance),
'has_managed_save_image': conn.get_instance_managed_save_image(instance)})
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())
if 'create' in request.POST:
volumes = {}
interfaces = []
vm_vfs_info = {}
form = NewVMForm(request.POST)
if form.is_valid():
data = form.cleaned_data
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']:
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_create.get_volume_path(data['template'])
clone_path = conn_create.clone_from_template(data['name'], templ_path, metadata=meta_prealloc)
volumes[clone_path] = conn_create.get_volume_type(clone_path)
ifaces_all = request.POST.getlist('interfaces')
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:
template_ver3_flag = True
if data['template'].find("WiseGrid_V3") == -1:
template_ver3_flag = False
conn_create.create_instance(data['name'], data['cur_memory'], data['cur_vcpu'],
uuid, volumes, ifaces_all, False, True, template_ver3_flag)
create_instance = Instance(compute_id=host_id, name=data['name'], uuid=uuid)
create_instance.save()
vm_vfs_info[data['name']] = ifaces_all
if not errors:
util.update_vfs_fro_vm(vm_vfs_info)
return HttpResponseRedirect(reverse('instance', args=[host_id, data['name']]))
except libvirtError as err:
if data['hdd_size']:
conn_create.delete_volume(volumes.keys()[0])
errors.append(err)
else:
print form.errors
errors.append(form.errors)
conn.close()
conn_create.close()
except libvirtError as err:
errors.append(err)
hd_resources = util.load_hd_resources()
mem_left = hd_resources["mem"]
vcpu_left = hd_resources["vcpu"]
memory_range = [ memory for memory in memory_range if memory/1024 <= mem_left ]
vcpu_range = xrange(1, int(vcpu_left) + 1)
vcpu_memory_left_flag = True
if len(list(vcpu_range)) == 0 or len(memory_range) == 0:
vcpu_memory_left_flag = False
return render_to_response('instances.html', locals(), context_instance=RequestContext(request))
def storage(request, host_id, pool):
"""
Storage pool block
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
if not request.user.is_staff:
raise PermissionDenied
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
try:
conn = wvmStorage(compute.hostname,
compute.login,
compute.password,
compute.type,
compute.hypervisor,
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(reverse('storages', args=[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)
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)
conn.close()
return render_to_response('storage.html', locals(), context_instance=RequestContext(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 storage(request, compute_id, pool):
"""
:param request:
:param compute_id:
:param pool:
:return:
"""
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()
compute = get_object_or_404(Compute, pk=compute_id)
meta_prealloc = False
form = CreateVolumeForm()
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
if request.method == "POST":
if "start" in request.POST:
conn.start()
return HttpResponseRedirect(request.get_full_path())
if "stop" in request.POST:
conn.stop()
return HttpResponseRedirect(request.get_full_path())
if "delete" in request.POST:
conn.delete()
return HttpResponseRedirect(reverse("storages", args=[compute_id]))
if "set_autostart" in request.POST:
conn.set_autostart(1)
return HttpResponseRedirect(request.get_full_path())
if "unset_autostart" in request.POST:
conn.set_autostart(0)
return HttpResponseRedirect(request.get_full_path())
if "del_volume" in request.POST:
volname = request.POST.get("volname", "")
vol = conn.get_volume(volname)
vol.delete(0)
messages.success(
request,
_("Volume: %(volume)s is deleted.") % {"vol": volname})
return redirect(reverse("storage", args=[compute.id, pool]))
# return HttpResponseRedirect(request.get_full_path())
if "iso_upload" in request.POST:
if str(request.FILES["file"]) in conn.update_volumes():
error_msg = _("ISO image already exist")
messages.error(request, error_msg)
else:
handle_uploaded_file(path, request.FILES["file"])
messages.success(
request,
_("ISO: %(file)s is uploaded.") %
{"file": 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"]
meta_prealloc = 0
if img_name in conn.update_volumes():
msg = _("Name of volume already in use")
messages.error(request, msg)
if data["convert"]:
format = data["format"]
if data["meta_prealloc"] and data["format"] == "qcow2":
meta_prealloc = True
else:
format = None
try:
name = conn.clone_volume(data["image"], data["name"],
format, meta_prealloc)
messages.success(
request,
_("%(image)s image cloned as %(clone)s successfully") %
{
"image": data["image"],
"name": name
},
)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as lib_err:
messages.error(request, lib_err)
else:
for msg_err in form.errors.values():
messages.error(request, msg_err.as_text())
conn.close()
return render(request, "storage.html", locals())
def storage(request, host_id, pool):
"""
Storage pool block
"""
if not request.user.is_authenticated():
return HttpResponseRedirect("/login")
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)
try:
conn = wvmStorage(compute.hostname, compute.login, compute.password, compute.type, pool)
storages = conn.get_storages()
state = conn.is_active()
size, free, usage = conn.get_size()
if state:
percent = (free * 100) / size
else:
percent = 0
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.message)
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("/storages/%s/" % 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
img_name = data["name"] + ".img"
if img_name in conn.update_volumes():
msg = _("Volume name already use")
errors.append(msg)
if not errors:
conn.create_volume(data["name"], data["size"], data["format"])
return HttpResponseRedirect(request.get_full_path())
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"
vol_name = request.POST.get("image", "")
if img_name in conn.update_volumes():
msg = _("Name of volume name already use")
errors.append(msg)
if not errors:
overlay = data["overlay"]
if data["convert"]:
format = data["format"]
else:
format = None
try:
conn.clone_volume(vol_name, data["name"], overlay, format)
return HttpResponseRedirect(request.get_full_path())
except libvirtError as error_msg:
errors.append(error_msg.message)
conn.close()
return render_to_response("storage.html", locals(), context_instance=RequestContext(request))
def main(argv):
parser = argparse.ArgumentParser(
"Backup KVM domain to destination pool Full or incrementally")
parser.add_argument("host", help="DNS name or ip address of KVM host")
parser.add_argument("domain", help="Domain name")
parser.add_argument("pool", help="Destination Pool Name")
parser.add_argument('-u',
'--username',
dest='username',
required=True,
help="Username for libvirt connection.")
parser.add_argument('-p',
action=Password,
nargs='?',
dest='password',
help='Enter your password for libvirt connection')
parser.add_argument(
'-f',
'--force',
dest='force',
action="store_true",
help="Force to make a full backup. Else it decides backup type")
parser.add_argument('-m',
'--not-merge',
dest="merge",
action="store_false",
help="Destination Pool Name")
parser.add_argument('-t',
'--conntype',
dest='conntype',
default='TCP',
choices=['SSH', 'TCP', 'TLS'],
type=str,
help="Connection type of libvirt")
parser.add_argument('-c',
'--compress',
dest='compress',
action="store_true",
help="Compress Disk Images of Domain")
parser.add_argument(
'-e',
'--exclude',
dest='exclude',
nargs="+",
type=str,
help="Exclude specified disks of domain. ex: -e abc.qcow2 bcd.qcow2")
parser.add_argument(
'-v',
'--verbose',
dest='verbose',
default='INFO',
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
type=str,
help="Log level of application")
args = parser.parse_args()
if not (os.path.exists("log") and os.path.isdir("log")):
os.mkdir("log")
Log(args.verbose, args.domain)
global log
log = logging.getLogger("BackupLogs")
try:
conn_type = getattr(connection, "CONN_" + args.conntype)
pool = wvmStorage(args.host, args.username, args.password, conn_type,
args.pool)
inst = wvmInstance(args.host, args.username, args.password, conn_type,
args.domain)
log.info("Dom UUID: {}".format(inst.get_uuid()))
log.info("Dom Disk Device: {}".format(inst.get_disk_device()))
log.info("Pool Name: {}, {} ".format(pool.get_name(),
pool.get_pretty_capacity()))
log.info("Excluded Disks: {}".format(args.exclude))
start = datetime.now()
start_backup(inst, pool, args.exclude, args.force, args.compress,
args.merge)
log.info("Backup of {} Completion Time: {} sec. ".format(
args.domain, str(datetime.now() - start)))
except libvirtError as err:
log.error(err.get_error_message())
exit(1)
