dynamicweb/opennebula_api/models.py

import oca
import socket

from django.db import models
from django.conf import settings

from oca.pool import WrongNameError

class VirtualMachineTemplate(models.Model):
    """This class represents an opennebula template."""
    opennebula_id = models.IntegerField()
    base_price = models.FloatField()
    memory_price = models.FloatField()
    core_price = models.FloatField()
    disk_size_price = models.FloatField()

    def calculate_price(self):
        manager = OpenNebulaManager()
        template = manger._get_template(self.opennebula_id).template

        price = int(template.vpcu) * self.core_price
        price += int(template.memory) / 1024 * self.memory_price
        try:
            price += int(template.disk.size) / 1024 * self.disk_size_price
        except AttributeError:
            for disk in template.disks:
                price += int(disk.size) / 1024 * self.disk_size_price
        return price

    def get_name(self):

        manager = OpenNebulaManager(create_user=False)
        template = manager._get_template(template_id=self.opennebula_id)
        return template.name

    def get_cores(self):

        manager = OpenNebulaManager(create_user=False)
        template = manager._get_template(template_id=self.opennebula_id).template
        return int(template.vcpu)
    
    def get_disk_size(self):

        manager = OpenNebulaManager(create_user=False)
        template = manager._get_template(template_id=self.opennebula_id).template
        disk_size = 0
        for disk in template.disks:
            disk_size += int(disk.size)
        return disk_size / 1024

    def get_memory(self):

        manager = OpenNebulaManager(create_user=False)
        template = manager._get_template(template_id=self.opennebula_id).template
        return int(template.memory) / 1024

class VirtualMachine(models.Model):
    """This class represents an opennebula virtual machine."""
    opennebula_id = models.IntegerField()
    template = models.ForeignKey(VirtualMachineTemplate)

    VM_STATE = {
        '0': 'INIT',
        '1': 'PENDING',
        '2': 'HOLD',
        '3': 'ACTIVE',
        '4': 'STOPPED',
        '5': 'SUSPENDED',
        '6': 'DONE',
        '8': 'POWEROFF',
        '9': 'UNDEPLOYED',
        '10': 'CLONING',
        '11': 'CLONING_FAILURE',
    }

    def get_name(self):
        if self.manager is None:
            self.manager = OpenNebulaManager()

        vm = self.manager._get_vm(vm_id=self.opennebula_id)
        return vm.name

    def get_cores(self):
        if self.manager is None:
            self.manager = OpenNebulaManager()

        template = self.manager._get_vm(vm_id=self.opennebula_id).template
        return int(template.vcpu)
    
    def get_disk_size(self):
        if self.manager is None:
            self.manager = OpenNebulaManager()

        template = self.manager._get_vm(vm_id=self.opennebula_id).template
        try: 
            return template.disk.size
        except AttributeError:
            disk_size = 0 
            for disk in template.disks:
                disk_size += disk.size
            return disk_size / 1024


    def get_memory(self):
        if self.manager is None:
            self.manager = OpenNebulaManager()

        template = self.manager._get_vm(vm_id=self.opennebula_id).template
        return int(template.memory)

    def get_id(self):
        if self.manager is None:
            self.manager = OpenNebulaManager()

        vm = self.manager._get_vm(vm_id=self.opennebula_id)
        return vm.id

    def get_ip(self):
        if self.manager is None:
            self.manager = OpenNebulaManager()

        vm = self.manager._get_vm(vm_id=self.opennebula_id)
        try:
            return vm.user_template.ungleich_public_ip
        except AttributeError:
            return '-'

    def get_state(self):
        if self.manager is None:
            self.manager = OpenNebulaManager()

        vm = self.manager._get_vm(vm_id=self.opennebula_id)
        return self.VM_STATE.get(str(vm.state))

    def get_price(self):
        return 0.0

class OpenNebulaManager():
    """This class represents an opennebula manager."""

    def __init__(self, email=None, password=None, create_user=True):
        
        # Get oneadmin client
        self.oneadmin_client = self._get_opennebula_client(
            settings.OPENNEBULA_USERNAME,
            settings.OPENNEBULA_PASSWORD
        )
        
        if not create_user or email is None:
            return

        # Get or create oppenebula user using given credentials
        self.opennebula_user = self._get_or_create_user(
            email,
            password
        )

        # If opennebula user was created/obtained, get his client
        if self.opennebula_user:
            self.client = self._get_opennebula_client(
                email,
                password
            )

    def _get_opennebula_client(self, username, password):
        return oca.Client("{0}:{1}".format(
            username,
            password),
            "{protocol}://{domain}:{port}{endpoint}".format(
                protocol=settings.OPENNEBULA_PROTOCOL,
                domain=settings.OPENNEBULA_DOMAIN,
                port=settings.OPENNEBULA_PORT,
                endpoint=settings.OPENNEBULA_ENDPOINT
        ))

    def _get_or_create_user(self, email, password):
        try:
            user_pool = self._get_user_pool()
            opennebula_user = user_pool.get_by_name(email)
            return opennebula_user
        except WrongNameError as wrong_name_err:
            opennebula_user = self.oneadmin_client.call(oca.User.METHODS['allocate'], email,
                                                        password, 'core')
            return opennebula_user
        except ConnectionRefusedError:
            print('Could not connect to host: {host} via protocol {protocol}'.format(
                    host=settings.OPENNEBULA_DOMAIN,
                    protocol=settings.OPENNEBULA_PROTOCOL)
                )
            raise ConnectionRefusedError
    def _get_user_pool(self):
        try:
            user_pool = oca.UserPool(self.oneadmin_client)
            user_pool.info()
        except ConnectionRefusedError:
            print('Could not connect to host: {host} via protocol {protocol}'.format(
                    host=settings.OPENNEBULA_DOMAIN,
                    protocol=settings.OPENNEBULA_PROTOCOL)
                )
            raise ConnectionRefusedError
        return user_pool

    def _get_vm_pool(self):
        try:
           vm_pool = oca.VmPool(self.oneadmin_client)
           vm_pool.info()
        except ConnectionRefusedError:
            print('Could not connect to host: {host} via protocol {protocol}'.format(
                    host=settings.OPENNEBULA_DOMAIN,
                    protocol=settings.OPENNEBULA_PROTOCOL)
                )
            raise ConnectionRefusedError
        return vm_pool

   
    def _get_vm(self, vm_id):
        vm_pool = self._get_vm_pool()
        # Get virtual machines from all users 
        vm_pool.info(filter=-2)
        return vm_pool.get_by_id(vm_id)

    def create_vm(self, template_id):
        template_pool = self._get_template_pool()

        template = template_pool.get_by_id(template_id)

        vm_id = template.instantiate()
        self.oneadmin.call(
            oca.VirtualMachine.METHODS['chown'],
            vm_id,
            self.opennebula_user.id,
            self.opennebula_user.group_ids[0]
        )
        return vm_id

    def delete_vm(self, vm_id):
        vm = self._get_vm(vm_id)
        vm.delete()

    def _get_template_pool(self):
        try:
           template_pool = oca.VmTemplatePool(self.oneadmin_client)
           template_pool.info()
        except ConnectionRefusedError:
            print('Could not connect to host: {host} via protocol {protocol}'.format(
                    host=settings.OPENNEBULA_DOMAIN,
                    protocol=settings.OPENNEBULA_PROTOCOL)
                )
            raise ConnectionRefusedError
        return template_pool

    def _get_template(self, template_id):
        template_pool = self._get_template_pool()
        return template_pool.get_by_id(template_id)

    
    
    def create_template(self, name, cores, memory, disk_size):
        """Create and add a new template to opennebula.
        :param name:      A string representation describing the template.
                          Used as label in view.
        :param cores:     Amount of virtual cpu cores for the VM.
        :param memory:    Amount of RAM for the VM (MB)
        :param disk_size: Amount of disk space for VM (MB)
        """
        template_string_formatter = """<TEMPLATE>
                                        <NAME>{name}</NAME>
                                        <MEMORY>{memory}</MEMORY>
                                        <VCPU>{vcpu}</VCPU>
                                        <CPU>{cpu}</CPU>
                                        <DISK>
                                         <TYPE>fs</TYPE>
                                         <SIZE>{size}</SIZE>
                                         <DEV_PREFIX>vd</DEV_PREFIX>
                                        </DISK>
                                       </TEMPLATE>
                                       """
        template_id = oca.VmTemplate.allocate(
            self.oneadmin_client,
            template_string_formatter.format(
                name=name,
                vcpu=cores,
                cpu=0.1*cores,
                size=1024 * disk_size,
                memory=1024 * memory
            )
        )

        return template_id

    def delete_template(self, template_id):
        self.oneadmin_client.call(oca.VmTemplate.METHODS['delete'], template_id, False)