def get_instance_vcpu(self, name):
inst = self.get_instance(name)
cur_vcpu = util.get_xml_path(inst.XMLDesc(0), "/domain/vcpu/@current")
if cur_vcpu:
vcpu = cur_vcpu
else:
vcpu = util.get_xml_path(inst.XMLDesc(0), "/domain/vcpu")
return vcpu
def get_ipv4_dhcp_range(self):
xml = self._XMLDesc(0)
dhcpstart = util.get_xml_path(xml, "/network/ip/dhcp/range[1]/@start")
dhcpend = util.get_xml_path(xml, "/network/ip/dhcp/range[1]/@end")
if not dhcpstart or dhcpend:
return None
return [IP(dhcpstart), IP(dhcpend)]
def get_ipv4(self):
xml = self._XMLDesc()
int_ipv4_ip = util.get_xml_path(xml, "/interface/protocol/ip/@address")
int_ipv4_mask = util.get_xml_path(xml,
"/interface/protocol/ip/@prefix")
if not int_ipv4_ip or not int_ipv4_mask:
return None
else:
return int_ipv4_ip + '/' + int_ipv4_mask
def get_console_listen_addr(self):
listen_addr = util.get_xml_path(self._XMLDesc(0),
"/domain/devices/graphics/@listen")
if listen_addr is None:
listen_addr = util.get_xml_path(
self._XMLDesc(0), "/domain/devices/graphics/listen/@address")
if listen_addr is None:
return "127.0.0.1"
return listen_addr
def get_net_device(self):
netdevice = []
for dev in self.wvm.listAllDevices(0):
xml = dev.XMLDesc(0)
dev_type = util.get_xml_path(xml, '/device/capability/@type')
if dev_type == 'net':
netdevice.append(
util.get_xml_path(xml, '/device/capability/interface'))
return netdevice
def get_ceph_hosts(ctx):
hosts = []
for host in ctx.xpathEval("/pool/source/host"):
name = host.prop("name")
if name:
hosts.append({
'name': name,
'port': host.prop("port")
})
return hosts
ceph_hosts = util.get_xml_path(xml,func=get_ceph_hosts)
secret_uuid = util.get_xml_path(xml,"/pool/source/host")
return ceph_user,secret_uuid,ceph_hosts
def create_volume(self,storage,name,size,format='qcow2',metadata=False):
size = int(size) * 1073741824
stg = self.get_storage(storage)
storage_type = util.get_xml_path(stg.XMLDesc(0),"/pool/@type")
if storage_type == 'dir':
name += '.img'
alloc = 0
else:
alloc = size
metadata = False
xml = """
<volume>
<name>%s</name>
<capacity>%s</capaction>
<allocation>%s</allocation>
<target>
<format type='%s' />
</target>
</volume>
""" % (name,size,alloc,format)
stg.createXML(xml,metadata)
try:
stg.refresh(0)
except:
pass
vol = stg.storageVollLookupByName(name)
return vol.path()
def get_iface_info(self, name):
iface = self.get_iface(name)
xml = iface.XMLDesc(0)
mac = iface.MACString()
itype = util.get_xml_path(xml, "/interface/@type")
state = iface.isActive()
return {'name': name, 'type': itype, 'state': state, 'mac': mac}
def get_net_device(self):
def get_mac_ipaddr(net, mac_host):
def fixed(ctx):
for net in ctx.xpathEval('/network/ip/dhcp/host'):
mac = net.xpathEval('@mac')[0].content
host = net.xpathEval('@ip')[0].content
if mac == mac_host:
return host
return None
return util.get_xml_path(net.XMLDesc(0), func=fixed)
def networks(ctx):
result = []
for net in ctx.xpathEval('/domain/devices/interface'):
mac_host = net.xpathEval('mac/@address')[0].content
nic_host = net.xpathEval(
'source/@network|source/@bridge|source/@dev')[0].content
try:
net = self.get_network(nic_host)
ip = get_mac_ipaddr(net, mac_host)
except:
ip = None
result.append({'mac': mac_host, 'nic': nic_host, 'ip': ip})
return result
return util.get_xml_path(self._XMLDesc(0), func=networks)
def get_console_port(self, console_type=None):
if console_type is None:
console_type = self.get_console_type()
port = util.get_xml_path(
self._XMLDesc(0),
"/domain/devices/graphics[@type='%s']/@port" % console_type)
return port
def get_media_device(self):
def disks(ctx):
result = []
dev = None
volume = None
storage = None
src_fl = None
for media in ctx.xpathEval('/domain/devices/disk'):
device = media.xpathEval('@device')[0].content
if device == 'cdrom':
try:
dev = media.xpathEval('target/@dev')[0].content
try:
src_fl = media.xpathEval('source/@file')[0].content
vol = self.get_volume_by_path(src_fl)
volume = vol.name()
stg = vol.storagePoolLookupByVolume()
storage = stg.name()
except:
src_fl = None
volume = src_fl
except:
pass
finally:
result.append({
'dev': dev,
'image': volume,
'storage': storage,
'path': src_fl
})
return result
return util.get_xml_path(self._XMLDesc(0), func=disks)
def get_host_instances(self):
vname = {}
memory = self.wvm.getInfo()[1] * 1048576
for name in self.get_instances():
dom = self.get_instance(name)
mem = util.get_xml_path(dom.XMLDesc(0), "/domain/currentMemory")
mem = int(mem) * 1024
mem_usage = (mem * 100) / memory
cur_vcpu = util.get_xml_path(dom.XMLDesc(0),
"/domain/vcpu/@current")
if cur_vcpu:
vcpu = cur_vcpu
else:
vcpu = util.get_xml_path(dom.XMLDesc(0), "domain/vcpu")
vname[dom.name()] = (dom.info()[0], vcpu, mem, mem_usage)
return vname
def get_volume_type(self,path):
vol = self.get_volume_by_path(path)
vol_type = util.get_xml_path(vol.XMLDesc(0),"/volume/target/format/@type")
if vol_type == 'unknown':
return 'raw'
if vol_type:
return vol_type
else:
return 'raw'
def get_ipv4_type(self):
try:
xml = self._XMLDesc(VIR_INTERFACE_XML_INACTIVE)
ipaddr = util.get_xml_path(xml, "/interface/protocol/ip/@address")
if ipaddr:
return 'static'
else:
return 'dhcp'
except:
return None
def get_mac_ipaddr(net, mac_host):
def fixed(ctx):
for net in ctx.xpathEval('/network/ip/dhcp/host'):
mac = net.xpathEval('@mac')[0].content
host = net.xpathEval('@ip')[0].content
if mac == mac_host:
return host
return None
return util.get_xml_path(net.XMLDesc(0), func=fixed)
def get_mac_ipaddr(self):
def network(ctx):
result = []
for net in ctx.xpahtEval('/network/ip/dhcp/host'):
host = net.xpathEval('@ip')[0].content
mac = net.xpahtEval('@mac')[0].content
result.append({'host': host, 'mac': mac})
return result
return util.get_xml_path(self._XMLDesc(0), func=network)
def clone_instance(self, clone_data):
global meta_prealloc, target_file
clone_dev_path = []
xml = self._XMLDesc(VIR_DOMAIN_XML_SECURE)
tree = ElementTree.fromstring(xml)
name = tree.find('name')
name.text = clone_data['name']
uuid = tree.find('uuid')
tree.remove(uuid)
for num, net in enumerate(tree.findall('devices/interface')):
elm = net.find('mac')
elm.set('address', clone_data['net-' + str(num)])
for disk in tree.findall('devices/disk'):
if disk.get('device') == 'disk':
elm = disk.find('target')
device_name = elm.get('dev')
if device_name:
target_file = clone_data['disk-' + device_name]
try:
meta_prealloc = clone_data['meta-' + device_name]
except:
meta_prealloc = False
elm.set('dev', device_name)
elm = disk.find('source')
source_file = elm.get('file')
if source_file:
clone_dev_path.append(source_file)
clone_path = os.path.join(os.path.dirname(source_file),
target_file)
elm.set('file', clone_path)
vol = self.get_volume_by_path(source_file)
vol_format = util.get_xml_path(
vol.XMLDesc(0), "/volume/target/format/@type")
if vol_format == 'qcow2' and meta_prealloc:
meta_prealloc = True
vol_clone_xml = """
<volume>
<name>%s</name>
<capacity>0</capacity>
<allocation>0</allocation>
<target>
<format type='%s'/>
</target>
</volume>""" % (target_file, vol_format)
stg = vol.storagePoolLookupByVolume()
stg.createXMLFrom(vol_clone_xml, vol, meta_prealloc)
self._defineXML(ElementTree.tostring(tree))
def get_ipv4_network(self):
xml = self._XMLDesc(0)
if util.get_xml_path(xml, "/network/ip") is None:
return None
addrStr = util.get_xml_path(xml, "/network/ip/@address")
netmaskStr = util.get_xml_path(xml, "/network/ip/@netmask")
prefix = util.get_xml_path(xml, "/network/ip/@prefix")
if prefix:
prefix = int(prefix)
binstr = ((prefix * "1") + ((32 - prefix) * "0"))
netmaskStr = str(IP(int(binstr, base=2)))
if netmaskStr:
netmask = IP(netmaskStr)
gateway = IP(addrStr)
network = IP(gateway.int() & netmask.int())
ret = IP(str(network) + "/" + netmaskStr)
else:
ret = IP(str(addrStr))
return ret
def clone_from_template(self,clone,template,metadata=False):
vol = self.get_volume_by_path(template)
stg = vol.storagePoolLookupByVolume()
storage_type = util.get_xml_path(stg.XMLDesc(0),"/pool/@type")
format = util.get_xml_path(vol.XMLDesc(0),"/volume/target/format/@type")
if storage_type == 'dir':
clone += '.img'
else:
metadata = False
xml = """
<volume>
<name>%s</name>
<capacity>0</capacity>
<allocation>0</allocation>
<target>
<format type='%s' />
</target>
</volume>
""" % (clone,format)
stg.createXMLFrom(xml,vol,metadata)
clone_type = stg.storageVollLookupByName(clone)
return clone_type.path()
def get_snapshot(self):
snapshots = []
snapshot_list = self.instance.snapshotListNames(0)
for snapshot in snapshot_list:
snap = self.instance.snapshotLookupByName(snapshot, 0)
snap_time_create = util.get_xml_path(
snap.getXMLDesc(0), "/domainsnapshot/creationTime")
snapshots.append({
'date':
datetime.fromtimestamp(int(snap_time_create)),
'name':
snapshot
})
return snapshots
def get_rbd_storage_data(stg):
xml = stg.XMLDesc(0)
ceph_user = util.get_xml_path(xml,"/pool/source/auth/@username")
def get_ceph_hosts(ctx):
hosts = []
for host in ctx.xpathEval("/pool/source/host"):
name = host.prop("name")
if name:
hosts.append({
'name': name,
'port': host.prop("port")
})
return hosts
ceph_hosts = util.get_xml_path(xml,func=get_ceph_hosts)
secret_uuid = util.get_xml_path(xml,"/pool/source/host")
return ceph_user,secret_uuid,ceph_hosts
def get_networks_info(self):
get_networks = self.get_networks()
networks = []
for network in get_networks:
net = self.get_network(network)
net_status = net.isActive()
net_bridge = net.bridgeName()
net_forwd = util.get_xml_path(net.XMLDesc(0),
"/network/forward/@mode")
networks.append({
'name': network,
'status': net_status,
'device': net_bridge,
'forward': net_forwd
})
return networks
def get_storages_info(self):
get_storages = self.get_storages()
storages = []
for pool in get_storages:
stg = self.get_storage(pool)
stg_status = stg.isActive()
stg_type = util.get_xml_path(stg.XMLDesc(0), "/pool/@type")
if stg_status:
stg_vol = len(stg.listVolumes())
else:
stg_vol = None
stg_size = stg.info()[1]
storages.append({
'name': pool,
'status': stg_status,
'type': stg_type,
'volumens': stg_vol,
'size': stg_size,
})
return storages
def get_disk_device(self):
def disks(ctx):
result = []
dev = None
volume = None
storage = None
src_fl = None
disk_format = None
for disk in ctx.xpathEval('/domain/devices/disk'):
device = disk.xpathEval('@device')[0].content
if device == 'disk':
try:
dev = disk.xpathEval('target/@dev')[0].content
src_fl = disk.xpathEval(
'source/@file|source/@dev|source/@name|source/@volume'
)[0].content
disk_format = disk.xpathEval('driver/@type')[0].content
try:
vol = self.get_volume_by_path(src_fl)
volume = vol.name()
stg = vol.storagePoolLookupByVolume()
storage = stg.name()
except libvirtError:
volume = src_fl
except:
pass
finally:
result.append({
'dev': dev,
'image': volume,
'storage': storage,
'path': src_fl,
'format': disk_format
})
return result
return util.get_xml_path(self._XMLDesc(0), func=disks)
def create(request, host_id):
"""
Create new instance.
"""
global instances
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
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_storage_images())
cache_modes = sorted(conn.get_cache_modes().items())
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(
reverse('instance', args=[host_id, name]))
except libvirtError as err:
#errrors.append(err.message)
errors.append(err.err)
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)
errors.append(msg_error.err)
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)
errors.append(msg_error.err)
if data['cache_mode'] not in conn.get_cache_modes():
msg = _("Invalid cache mode")
errors.append(msg)
if not errors:
uuid = util.randomUUID()
try:
conn.create_instance(
data['name'], data['memory'], data['vcpu'],
data['host_model'], uuid, volumes,
data['cache_mode'], data['networks'],
data['virtio'], data['mac'])
create_instance = Instance(compute_id=host_id,
name=data['name'],
uuid=uuid)
create_instance.save()
return HttpResponseRedirect(
reverse('instance',
args=[host_id, data['name']]))
except libvirtError as err:
if data['hdd_size']:
conn.delete_volume(volumes.keys()[0])
errors.append(err)
conn.close()
return render(request, 'create.html', locals())
def get_console_keymap(self):
return util.get_xml_path(self._XMLDesc(VIR_DOMAIN_XML_SECURE),
"/domain/devices/graphics/@keymap") or ''
def get_console_passwd(self):
return util.get_xml_path(self._XMLDesc(VIR_DOMAIN_XML_SECURE),
"/domain/devices/graphics/@passwd")
def get_console_websocket_port(self):
console_type = self.get_console_type()
websocket_port = util.get_xml_path(
self._XMLDesc(0),
"/domain/devices/graphics[@type='%s']/@websocket" % console_type)
return websocket_port
def get_console_type(self):
console_type = util.get_xml_path(self._XMLDesc(0),
"/domain/devices/graphics/@type")
return console_type
def get_console_socket(self):
socket = util.get_xml_path(self._XMLDesc(0),
"/domain/devices/graphics/@socket")
return socket
