dynamicweb/opennebula_api/serializers.py

205 lines
6.3 KiB
Python
Raw Normal View History

import ipaddress
from builtins import hasattr
from rest_framework import serializers
from oca import OpenNebulaException
from .models import OpenNebulaManager
class VirtualMachineTemplateSerializer(serializers.Serializer):
"""Serializer to map the virtual machine template instance into JSON format."""
id = serializers.IntegerField(read_only=True)
name = serializers.SerializerMethodField()
cores = serializers.SerializerMethodField()
disk_size = serializers.SerializerMethodField()
memory = serializers.SerializerMethodField()
def get_cores(self, obj):
if hasattr(obj.template, 'vcpu'):
return obj.template.vcpu
return ''
def get_disk_size(self, obj):
template = obj.template
disk_size = 0
try:
for disk in template.disks:
disk_size += int(disk.size)
return disk_size / 1024
except:
return 0
def get_memory(self, obj):
return int(obj.template.memory) / 1024
2017-05-13 11:47:53 +00:00
def get_name(self, obj):
2018-08-07 22:10:03 +00:00
if obj.name.startswith('public-'):
return obj.name.lstrip('public-')
else:
return obj.name
2017-05-13 11:47:53 +00:00
class VirtualMachineSerializer(serializers.Serializer):
"""Serializer to map the virtual machine instance into JSON format."""
2017-05-26 21:23:39 +00:00
name = serializers.SerializerMethodField()
cores = serializers.IntegerField(source='template.vcpu')
disk = serializers.IntegerField(write_only=True)
set_memory = serializers.IntegerField(write_only=True, label='Memory')
memory = serializers.SerializerMethodField()
disk_size = serializers.SerializerMethodField()
hdd_size = serializers.SerializerMethodField()
2018-02-23 14:35:24 +00:00
ssd_size = serializers.SerializerMethodField()
ipv4 = serializers.SerializerMethodField()
ipv6 = serializers.SerializerMethodField()
vm_id = serializers.IntegerField(read_only=True, source='id')
state = serializers.CharField(read_only=True, source='str_state')
price = serializers.SerializerMethodField()
ssh_key = serializers.CharField(write_only=True)
configuration = serializers.SerializerMethodField()
template_id = serializers.ChoiceField(
choices=[(key.id, key.name) for key in
OpenNebulaManager().try_get_templates()
],
source='template.template_id',
write_only=True,
default=[]
)
def create(self, validated_data):
owner = validated_data['owner']
ssh_key = validated_data['ssh_key']
cores = validated_data['template']['vcpu']
2017-05-13 15:32:55 +00:00
memory = validated_data['set_memory']
disk = validated_data['disk']
template_id = validated_data['template']['template_id']
specs = {
'cpu': cores,
'disk_size': disk,
'memory': memory,
}
try:
2017-05-11 10:45:09 +00:00
manager = OpenNebulaManager(email=owner.email,
2017-05-12 17:13:18 +00:00
password=owner.password,
2017-05-13 04:59:57 +00:00
)
opennebula_id = manager.create_vm(template_id=template_id,
ssh_key=ssh_key,
specs=specs)
except OpenNebulaException as err:
2018-02-23 14:35:24 +00:00
raise serializers.ValidationError(
"OpenNebulaException occured. {0}".format(err)
)
return manager.get_vm(opennebula_id)
def get_memory(self, obj):
return int(obj.template.memory) / 1024
def get_disk_size(self, obj):
template = obj.template
disk_size = 0
for disk in template.disks:
disk_size += int(disk.size)
return disk_size / 1024
2018-02-21 10:46:33 +00:00
def get_ssd_size(self, obj):
template = obj.template
disk_size = 0
for disk in template.disks:
if disk.datastore == 'cephds':
disk_size += int(disk.size)
return disk_size / 1024
def get_hdd_size(self, obj):
template = obj.template
disk_size = 0
for disk in template.disks:
if disk.datastore == 'ceph_hdd_ds':
disk_size += int(disk.size)
return disk_size / 1024
def get_price(self, obj):
template = obj.template
2017-05-14 00:17:48 +00:00
price = float(template.vcpu) * 5.0
price += (int(template.memory) / 1024 * 2.0)
for disk in template.disks:
price += int(disk.size) / 1024 * 0.6
return price
def get_configuration(self, obj):
template_id = obj.template.template_id
template = OpenNebulaManager().get_template(template_id)
2018-08-07 22:10:03 +00:00
if template.name.startswith('public-'):
return template.name.lstrip('public-')
else:
return template.name
2017-05-23 09:30:10 +00:00
def get_ipv4(self, obj):
"""
Get the IPv4s from the given VM
:param obj: The VM in contention
:return: Returns csv string of all IPv4s added to this VM otherwise returns "-" if no IPv4 is available
"""
ipv4 = []
for nic in obj.template.nics:
if hasattr(nic, 'ip'):
ipv4.append(nic.ip)
if len(ipv4) > 0:
return ', '.join(ipv4)
else:
return '-'
2017-05-23 09:30:10 +00:00
def get_ipv6(self, obj):
ipv6 = []
for nic in obj.template.nics:
if hasattr(nic, 'ip6_global'):
ipv6.append(nic.ip6_global)
if len(ipv6) > 0:
return ', '.join(ipv6)
else:
return '-'
2017-05-26 21:23:39 +00:00
def get_name(self, obj):
if obj.name.startswith('public-'):
return obj.name.lstrip('public-')
else:
return obj.name
2017-07-27 06:35:01 +00:00
class VMTemplateSerializer(serializers.Serializer):
"""Serializer to map the VMTemplate instance into JSON format."""
2018-02-23 14:35:24 +00:00
id = serializers.IntegerField(
read_only=True, source='opennebula_vm_template_id'
)
2017-07-27 06:35:01 +00:00
name = serializers.CharField(read_only=True)
def hexstr2int(string):
return int(string.replace(':', ''), 16)
FIRST_MAC = hexstr2int('02:00:b3:39:79:4d')
FIRST_V4 = ipaddress.ip_address('185.203.112.2')
COUNT = 1000
def v4_from_mac(mac):
"""Calculates the IPv4 address from a MAC address.
mac: string (the colon-separated representation)
returns: ipaddress.ip_address object with the v4 address
"""
return FIRST_V4 + (hexstr2int(mac) - FIRST_MAC)
def is_in_v4_range(mac):
return FIRST_MAC <= hexstr2int(mac) < FIRST_MAC + 1000