From b052507134ccd6e62c71a00ef434e1e2ba834e95 Mon Sep 17 00:00:00 2001
From: Modulos <modulos@protonmail.com>
Date: Wed, 10 May 2017 01:11:49 +0200
Subject: [PATCH 1/7] Add create template function

---
 opennebula_api/models.py | 25 +++++++++++++++++++++++++
 opennebula_api/tests.py  | 12 +++++++++---
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/opennebula_api/models.py b/opennebula_api/models.py
index 21151dc8..c4943c3e 100644
--- a/opennebula_api/models.py
+++ b/opennebula_api/models.py
@@ -83,3 +83,28 @@ class OpenNebulaManager():
                     protocol=settings.OPENNEBULA_PROTOCOL)
                 )
         return user_pool
+    def create_template(self, name, cores, memory, disk_size):
+        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
diff --git a/opennebula_api/tests.py b/opennebula_api/tests.py
index 95d9d08d..b0c41429 100644
--- a/opennebula_api/tests.py
+++ b/opennebula_api/tests.py
@@ -18,7 +18,11 @@ class OpenNebulaManagerTestCases(TestCase):
 
     def test_model_can_connect_to_server(self):
         """Test the opennebula manager model can connect to a server."""
-        self.assertFalse(self.manager is None)
+        try:
+            version = self.manager.version()
+        except:
+            version = None
+        self.assertFalse(version is None)
 
     def test_model_can_create_user(self):
         """Test the opennebula manager model can create a new user."""
@@ -46,8 +50,10 @@ class VirtualMachineTemplateTestCase(TestCase):
         self.disk_size = 10.0
 
         self.manager = OpenNebulaManager(email=None, password=None, create_user=False)
-        self.opennebula_id = self.manager.create_template(self.cores, self.memory,
-                                                          self.disk_size)
+        self.opennebula_id = self.manager.create_template(name=self.template_name,
+                                                          cores=self.cores,
+                                                          memory=self.memory,
+                                                          disk_size=self.disk_size)
 
         self.template = VirtualMachineTemplate(opennebula_id=self.opennebula_id,
                                                base_price=self.base_price,

From c1a3f7281fe432a7b6ac8f20e3ef00c0a86de9b9 Mon Sep 17 00:00:00 2001
From: Modulos <modulos@protonmail.com>
Date: Wed, 10 May 2017 02:36:11 +0200
Subject: [PATCH 2/7] Add calculate price function to template

---
 opennebula_api/models.py | 12 ++++++++++++
 opennebula_api/tests.py  |  7 +++++++
 2 files changed, 19 insertions(+)

diff --git a/opennebula_api/models.py b/opennebula_api/models.py
index 21151dc8..1f66d5b3 100644
--- a/opennebula_api/models.py
+++ b/opennebula_api/models.py
@@ -14,6 +14,18 @@ class VirtualMachineTemplate(models.Model):
     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
 
 class VirtualMachine(models.Model):
     """This class represents an opennebula virtual machine."""
diff --git a/opennebula_api/tests.py b/opennebula_api/tests.py
index 95d9d08d..794e4435 100644
--- a/opennebula_api/tests.py
+++ b/opennebula_api/tests.py
@@ -63,6 +63,13 @@ class VirtualMachineTemplateTestCase(TestCase):
         new_count = VirtualMachineTemplate.objects.count()
         self.assertNotEqual(old_count, new_count)
 
+    def test_model_can_calculate_price(self):
+        price = self.cores * self.core_price
+        price += self.memory * self.memory_price
+        price += self.disk_size * self.disk_size_price 
+        self.assertEqual(price, self.template.calculate_price())
+
+
 
 class VirtualMachineTestCase(TestCase):
     def setUp(self):

From f2a7ac258d020fdc0caad419251d694a4ad6f070 Mon Sep 17 00:00:00 2001
From: Modulos <modulos@protonmail.com>
Date: Wed, 10 May 2017 02:49:03 +0200
Subject: [PATCH 3/7] Fix typo and add function description

---
 opennebula_api/models.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/opennebula_api/models.py b/opennebula_api/models.py
index c4943c3e..447a7f75 100644
--- a/opennebula_api/models.py
+++ b/opennebula_api/models.py
@@ -67,12 +67,12 @@ class OpenNebulaManager():
         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)
                 )
-            return opennebula_user
     def _get_user_pool(self):
         try:
             user_pool = oca.UserPool(self.oneadmin_client)
@@ -84,6 +84,13 @@ class OpenNebulaManager():
                 )
         return user_pool
     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>

From ba0cc137bc64f8e5b011c63cf0a9cdcefefd95f5 Mon Sep 17 00:00:00 2001
From: Modulos <modulos@protonmail.com>
Date: Wed, 10 May 2017 04:06:12 +0200
Subject: [PATCH 4/7] Start serialization

---
 opennebula_api/models.py     | 103 +++++++++++++++++++++++++++++++++++
 opennebula_api/serializer.py |  32 +++++++++++
 2 files changed, 135 insertions(+)
 create mode 100644 opennebula_api/serializer.py

diff --git a/opennebula_api/models.py b/opennebula_api/models.py
index 21151dc8..31ed7e45 100644
--- a/opennebula_api/models.py
+++ b/opennebula_api/models.py
@@ -14,12 +14,115 @@ class VirtualMachineTemplate(models.Model):
     core_price = models.FloatField()
     disk_size_price = models.FloatField()
 
+    def get_name(self):
+        if self.manager is None:
+            self.manager = OpenNebulaManager()
+
+        template = self.manager._get_template(template_id=self.opennebula_id)
+        return template.name
+
+    def get_cores(self):
+        if self.manager is None:
+            self.manager = OpenNebulaManager()
+
+        template = self.manager._get_template(template_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_template(template_id=self.opennebula_id).template
+        return int(template.disk.size) / 1024
+
+    def get_memory(self):
+        if self.manager is None:
+            self.manager = OpenNebulaManager()
+
+        template = self.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_pirce(self)
+        return 0.0
+
 class OpenNebulaManager():
     """This class represents an opennebula manager."""
 
diff --git a/opennebula_api/serializer.py b/opennebula_api/serializer.py
new file mode 100644
index 00000000..98db0daa
--- /dev/null
+++ b/opennebula_api/serializer.py
@@ -0,0 +1,32 @@
+from res_framework import serializers
+from .models import VirtualMachine, VirtualMachineTemplate
+
+class VirtualMachineSerializer(serializers.ModelSerializer):
+    """Serializer to map the virtual machine instance into JSON format."""
+
+    cores       = serializers.IntegerField(read_only=True, source='get_cores') 
+    name        = serializers.CharField(read_only=True, source='get_name')
+    disk_size   = serializers.IntegerField(read_only=True, source='get_disk_size')
+    memory      = serializers.IntegerField(read_only=True, source='get_memory')
+    #TODO: See if we can change to IPAddressField
+    ip          = serializers.CharField(read_only=True, source='get_ip')
+    deploy_id   = serializers.IntegerField(read_only=True, source='get_deploy_id')
+    id          = serializers.IntegerField(read_only=True, source='get_id')
+    state       = serializers.CharField(read_only=True, source='get_state')
+    price       = serializers.FloatField(read_only=True, source='get_price')
+
+    class Meta:
+        model = VirtualMachine
+
+
+class VirtualMachineTemplateSerializer(serializers.ModelSerializer):
+    """Serializer to map the virtual machine template instance into JSON format."""
+    cores       = serializers.IntegerField(read_only=True, source='get_cores') 
+    name        = serializers.CharField(read_only=True, source='get_name')
+    disk_size   = serializers.IntegerField(read_only=True, source='get_disk_size')
+    memory      = serializers.IntegerField(read_only=True, source='get_memory')
+
+    class Meta:
+        model = VirtualMachineTemplate
+        fields = ()
+

From 5ed72bf4bf3a607b64cf2032c67edce3bfb20df8 Mon Sep 17 00:00:00 2001
From: Modulos <modulos@protonmail.com>
Date: Thu, 11 May 2017 04:03:31 +0200
Subject: [PATCH 5/7] Change to ungleich/python-oca

The offical python-oca repo does not (yet) support all the funcions we
need.
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index cec95282..de1b1500 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -82,7 +82,7 @@ stripe==1.33.0
 wheel==0.29.0
 django-admin-honeypot==1.0.0
 coverage==4.3.4
-git+https://github.com/python-oca/python-oca.git#egg=python-oca
+git+https://github.com/ungleich/python-oca.git#egg=python-oca
 djangorestframework
 
 

From cbc13de34f470c6510fcd57fc9bcf7cf6da0403a Mon Sep 17 00:00:00 2001
From: Modulos <modulos@protonmail.com>
Date: Thu, 11 May 2017 04:05:58 +0200
Subject: [PATCH 6/7] Access VirtualMachineTemplates via api!

Serialization of VirtualMachineTemplates now fully works
---
 opennebula_api/models.py      | 84 +++++++++++++++++++++++++++--------
 opennebula_api/serializer.py  | 32 -------------
 opennebula_api/serializers.py | 63 ++++++++++++++++++++++++++
 opennebula_api/tests.py       | 41 ++++++++++++++---
 opennebula_api/views.py       | 19 +++++++-
 5 files changed, 180 insertions(+), 59 deletions(-)
 delete mode 100644 opennebula_api/serializer.py
 create mode 100644 opennebula_api/serializers.py

diff --git a/opennebula_api/models.py b/opennebula_api/models.py
index 99c486fe..2d4a9f97 100644
--- a/opennebula_api/models.py
+++ b/opennebula_api/models.py
@@ -28,31 +28,30 @@ class VirtualMachineTemplate(models.Model):
         return price
 
     def get_name(self):
-        if self.manager is None:
-            self.manager = OpenNebulaManager()
 
-        template = self.manager._get_template(template_id=self.opennebula_id)
+        manager = OpenNebulaManager(create_user=False)
+        template = manager._get_template(template_id=self.opennebula_id)
         return template.name
 
     def get_cores(self):
-        if self.manager is None:
-            self.manager = OpenNebulaManager()
 
-        template = self.manager._get_template(template_id=self.opennebula_id).template
+        manager = OpenNebulaManager(create_user=False)
+        template = manager._get_template(template_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_template(template_id=self.opennebula_id).template
-        return int(template.disk.size) / 1024
+        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):
-        if self.manager is None:
-            self.manager = OpenNebulaManager()
 
-        template = self.manager._get_template(template_id=self.opennebula_id).template
+        manager = OpenNebulaManager(create_user=False)
+        template = manager._get_template(template_id=self.opennebula_id).template
         return int(template.memory) / 1024
 
 class VirtualMachine(models.Model):
@@ -133,7 +132,7 @@ class VirtualMachine(models.Model):
         vm = self.manager._get_vm(vm_id=self.opennebula_id)
         return self.VM_STATE.get(str(vm.state))
 
-    def get_pirce(self)
+    def get_price(self):
         return 0.0
 
 class OpenNebulaManager():
@@ -147,8 +146,7 @@ class OpenNebulaManager():
             settings.OPENNEBULA_PASSWORD
         )
         
-
-        if not create_user:
+        if not create_user or email is None:
             return
 
         # Get or create oppenebula user using given credentials
@@ -189,6 +187,7 @@ class OpenNebulaManager():
                     host=settings.OPENNEBULA_DOMAIN,
                     protocol=settings.OPENNEBULA_PROTOCOL)
                 )
+            raise ConnectionRefusedError
     def _get_user_pool(self):
         try:
             user_pool = oca.UserPool(self.oneadmin_client)
@@ -198,11 +197,30 @@ class OpenNebulaManager():
                     host=settings.OPENNEBULA_DOMAIN,
                     protocol=settings.OPENNEBULA_PROTOCOL)
                 )
+            raise ConnectionRefusedError
         return user_pool
 
-    def create_virtualmachine(self, template_id):
-        template_pool = oca.VmTemplatePool(self.oneadmin_client)
-        template_pool.info()
+    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)
 
@@ -215,6 +233,28 @@ class OpenNebulaManager():
         )
         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.
@@ -247,3 +287,9 @@ class OpenNebulaManager():
         )
 
         return template_id
+
+    def delete_template(self, template_id):
+        self.oneadmin_client.call(oca.VmTemplate.METHODS['delete'], template_id, False)
+
+
+   
diff --git a/opennebula_api/serializer.py b/opennebula_api/serializer.py
deleted file mode 100644
index 98db0daa..00000000
--- a/opennebula_api/serializer.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from res_framework import serializers
-from .models import VirtualMachine, VirtualMachineTemplate
-
-class VirtualMachineSerializer(serializers.ModelSerializer):
-    """Serializer to map the virtual machine instance into JSON format."""
-
-    cores       = serializers.IntegerField(read_only=True, source='get_cores') 
-    name        = serializers.CharField(read_only=True, source='get_name')
-    disk_size   = serializers.IntegerField(read_only=True, source='get_disk_size')
-    memory      = serializers.IntegerField(read_only=True, source='get_memory')
-    #TODO: See if we can change to IPAddressField
-    ip          = serializers.CharField(read_only=True, source='get_ip')
-    deploy_id   = serializers.IntegerField(read_only=True, source='get_deploy_id')
-    id          = serializers.IntegerField(read_only=True, source='get_id')
-    state       = serializers.CharField(read_only=True, source='get_state')
-    price       = serializers.FloatField(read_only=True, source='get_price')
-
-    class Meta:
-        model = VirtualMachine
-
-
-class VirtualMachineTemplateSerializer(serializers.ModelSerializer):
-    """Serializer to map the virtual machine template instance into JSON format."""
-    cores       = serializers.IntegerField(read_only=True, source='get_cores') 
-    name        = serializers.CharField(read_only=True, source='get_name')
-    disk_size   = serializers.IntegerField(read_only=True, source='get_disk_size')
-    memory      = serializers.IntegerField(read_only=True, source='get_memory')
-
-    class Meta:
-        model = VirtualMachineTemplate
-        fields = ()
-
diff --git a/opennebula_api/serializers.py b/opennebula_api/serializers.py
new file mode 100644
index 00000000..13f6d5ab
--- /dev/null
+++ b/opennebula_api/serializers.py
@@ -0,0 +1,63 @@
+import oca
+
+from rest_framework import serializers
+
+from oca import OpenNebulaException
+
+from .models import VirtualMachine, VirtualMachineTemplate, OpenNebulaManager
+
+class VirtualMachineSerializer(serializers.ModelSerializer):
+    """Serializer to map the virtual machine instance into JSON format."""
+
+    #TODO: Maybe we can change to template.get_cores
+    cores       = serializers.IntegerField(read_only=True, source='get_cores') 
+    name        = serializers.CharField(read_only=True, source='get_name')
+    disk_size   = serializers.IntegerField(read_only=True, source='get_disk_size')
+    memory      = serializers.IntegerField(read_only=True, source='get_memory')
+    #TODO: See if we can change to IPAddressField
+    ip          = serializers.CharField(read_only=True, source='get_ip')
+    deploy_id   = serializers.IntegerField(read_only=True, source='get_deploy_id')
+    vm_id          = serializers.IntegerField(read_only=True, source='get_vm_id')
+    state       = serializers.CharField(read_only=True, source='get_state')
+    price       = serializers.FloatField(read_only=True, source='get_price')
+
+    class Meta:
+        model = VirtualMachine
+        fields = ('id', 'opennebula_id', 'template', 'cores', 'name',
+                'disk_size', 'memory', 'ip', 'deploy_id', 'state', 'vm_id',
+                'price')
+
+class VirtualMachineTemplateSerializer(serializers.ModelSerializer):
+    """Serializer to map the virtual machine template instance into JSON format."""
+    cores       = serializers.IntegerField(source='get_cores') 
+    name        = serializers.CharField(source='get_name')
+    disk_size   = serializers.IntegerField(source='get_disk_size')
+    memory      = serializers.IntegerField(source='get_memory')
+
+    class Meta:
+        model = VirtualMachineTemplate
+        fields = ('id', 'name', 'cores', 'memory', 'disk_size', 'base_price', 
+                  'core_price', 'memory_price', 'disk_size_price', 'opennebula_id')
+        read_only_fields = ('opennebula_id', )
+
+    def validate(self, data):
+        # Create the opennebula model
+        cores   = data.pop('get_cores')
+        name    = data.pop('get_name')
+        disk_size = data.pop('get_disk_size')
+        memory  = data.pop('get_memory')
+
+        manager = OpenNebulaManager(create_user = False)
+        
+        try:
+            opennebula_id = manager.create_template(name=name, cores=cores,
+                                                    memory=memory,
+                                                    disk_size=disk_size)
+            data.update({'opennebula_id':opennebula_id})
+        except OpenNebulaException as err:
+            raise serializers.ValidationError("OpenNebulaException occured. {0}".format(err))
+        
+        return data
+
+    def create(self, validated_data):
+        return VirtualMachineTemplate.objects.create(**validated_data)
diff --git a/opennebula_api/tests.py b/opennebula_api/tests.py
index dbd78dc1..14694e6f 100644
--- a/opennebula_api/tests.py
+++ b/opennebula_api/tests.py
@@ -19,10 +19,10 @@ class OpenNebulaManagerTestCases(TestCase):
     def test_model_can_connect_to_server(self):
         """Test the opennebula manager model can connect to a server."""
         try:
-            version = self.manager.version()
+            user_pool = self.manager._get_user_pool()
         except:
-            version = None
-        self.assertFalse(version is None)
+            user_pool = None
+        self.assertFalse(user_pool is None)
 
     def test_model_can_create_user(self):
         """Test the opennebula manager model can create a new user."""
@@ -30,7 +30,12 @@ class OpenNebulaManagerTestCases(TestCase):
         self.manager = OpenNebulaManager(email=self.email,
                                          password=self.password,
                                          create_user=True)
-        new_count = len(self.manager._get_user_pool())
+        user_pool = self.manager._get_user_pool()
+        new_count = len(user_pool)
+        # Remove the user afterwards
+        user = user_pool.get_by_name(self.email)
+        user.delete()
+        
         self.assertNotEqual(old_count, new_count)
 
 
@@ -67,6 +72,9 @@ class VirtualMachineTemplateTestCase(TestCase):
         old_count = VirtualMachineTemplate.objects.count()
         self.template.save()
         new_count = VirtualMachineTemplate.objects.count()
+        # Remove the template afterwards
+        template = self.manager._get_template(self.template.opennebula_id)
+        template.delete()
         self.assertNotEqual(old_count, new_count)
 
     def test_model_can_calculate_price(self):
@@ -80,8 +88,26 @@ class VirtualMachineTemplateTestCase(TestCase):
 class VirtualMachineTestCase(TestCase):
     def setUp(self):
         """Define the test client and other test variables."""
-        self.manager = OpenNebulaManager(email=None, password=None, create_user=False) 
-        self.template = VirtualMachineTemplate.objects.first()
+        self.template_name = "Standard"
+        self.base_price = 0.0
+        self.core_price = 5.0
+        self.memory_price = 2.0
+        self.disk_size_price = 0.6
+
+        self.cores = 1 
+        self.memory = 1
+        self.disk_size = 10.0
+        self.manager = OpenNebulaManager(email=None, password=None, create_user=False)
+        self.opennebula_id = self.manager.create_template(name=self.template_name,
+                                                          cores=self.cores,
+                                                          memory=self.memory,
+                                                          disk_size=self.disk_size)
+
+        self.template = VirtualMachineTemplate(opennebula_id=self.opennebula_id,
+                                               base_price=self.base_price,
+                                               memory_price=self.memory_price,
+                                               core_price=self.core_price,
+                                               disk_size_price=self.disk_size_price)
         self.template_id = self.template.opennebula_id()
         self.opennebula_id = self.manager.create_virtualmachine(template_id=self.template_id)
                                            
@@ -95,6 +121,9 @@ class VirtualMachineTestCase(TestCase):
         new_count = VirtualMachine.objects.count()
         self.assertNotEqual(old_count, new_count)
 
+    def test_model_can_create_a_virtualmachine_for_user(self):
+        pass
+
     def test_model_can_delete_a_virtualmachine(self):
         """Test the virtualmachine model can delete a virtualmachine."""
         self.virtualmachine.save()
diff --git a/opennebula_api/views.py b/opennebula_api/views.py
index 91ea44a2..be0e1a24 100644
--- a/opennebula_api/views.py
+++ b/opennebula_api/views.py
@@ -1,3 +1,18 @@
-from django.shortcuts import render
+from rest_framework import generics
+from .serializers import VirtualMachineTemplateSerializer
+from .models import VirtualMachineTemplate, OpenNebulaManager
 
-# Create your views here.
+class TemplateCreateView(generics.ListCreateAPIView):
+    """This class defines the create behavior of our rest api."""
+    queryset = VirtualMachineTemplate.objects.all()
+    serializer_class = VirtualMachineTemplateSerializer
+
+    def perform_create(self, serializer):
+        """Save the post data when creating a new template."""
+        serializer.save()
+
+class TemplateDetailsView(generics.RetrieveUpdateDestroyAPIView):
+    """This class handles the http GET, PUT and DELETE requests."""
+
+    queryset = VirtualMachineTemplate.objects.all()
+    serializer_class = VirtualMachineTemplateSerializer

From ef00d676f56d115ff23c91a153c291b7c28766fc Mon Sep 17 00:00:00 2001
From: Modulos <modulos@protonmail.com>
Date: Thu, 11 May 2017 05:51:30 +0200
Subject: [PATCH 7/7] Access VirtualMachine via api!

Serialization of VirtualMachine objects now fully works
---
 opennebula_api/models.py      | 84 +++++++++++++----------------------
 opennebula_api/serializers.py | 72 +++++++++++++++++++++---------
 opennebula_api/views.py       | 21 ++++++++-
 3 files changed, 101 insertions(+), 76 deletions(-)

diff --git a/opennebula_api/models.py b/opennebula_api/models.py
index 2d4a9f97..6a7ba2fc 100644
--- a/opennebula_api/models.py
+++ b/opennebula_api/models.py
@@ -15,10 +15,9 @@ class VirtualMachineTemplate(models.Model):
     disk_size_price = models.FloatField()
 
     def calculate_price(self):
-        manager = OpenNebulaManager()
-        template = manger._get_template(self.opennebula_id).template
+        template = OpenNebulaManager()._get_template(self.opennebula_id).template
 
-        price = int(template.vpcu) * self.core_price
+        price = int(template.vcpu) * self.core_price
         price += int(template.memory) / 1024 * self.memory_price
         try:
             price += int(template.disk.size) / 1024 * self.disk_size_price
@@ -29,20 +28,17 @@ class VirtualMachineTemplate(models.Model):
 
     def get_name(self):
 
-        manager = OpenNebulaManager(create_user=False)
-        template = manager._get_template(template_id=self.opennebula_id)
+        template = OpenNebulaManager()._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
+        template = OpenNebulaManager()._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
+        template = OpenNebulaManager()._get_template(template_id=self.opennebula_id).template
         disk_size = 0
         for disk in template.disks:
             disk_size += int(disk.size)
@@ -50,14 +46,13 @@ class VirtualMachineTemplate(models.Model):
 
     def get_memory(self):
 
-        manager = OpenNebulaManager(create_user=False)
-        template = manager._get_template(template_id=self.opennebula_id).template
+        template = OpenNebulaManager()._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_template = models.ForeignKey(VirtualMachineTemplate)
 
     VM_STATE = {
         '0': 'INIT',
@@ -74,66 +69,42 @@ class VirtualMachine(models.Model):
     }
 
     def get_name(self):
-        if self.manager is None:
-            self.manager = OpenNebulaManager()
-
-        vm = self.manager._get_vm(vm_id=self.opennebula_id)
+            
+        vm = OpenNebulaManager()._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)
+        return self.vm_template.get_cores()
     
     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
-
+        
+        return self.vm_template.get_disk_size()
 
     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)
+        return self.vm_template.get_memory()
 
     def get_id(self):
-        if self.manager is None:
-            self.manager = OpenNebulaManager()
 
-        vm = self.manager._get_vm(vm_id=self.opennebula_id)
+        vm = OpenNebulaManager()._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)
+        vm = OpenNebulaManager()._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)
+        vm = OpenNebulaManager()._get_vm(vm_id=self.opennebula_id)
         return self.VM_STATE.get(str(vm.state))
 
     def get_price(self):
-        return 0.0
+        return self.vm_template.calculate_price()
 
 class OpenNebulaManager():
     """This class represents an opennebula manager."""
@@ -182,6 +153,7 @@ class OpenNebulaManager():
             opennebula_user = self.oneadmin_client.call(oca.User.METHODS['allocate'], email,
                                                         password, 'core')
             return opennebula_user
+        #TODO: Replace with logger
         except ConnectionRefusedError:
             print('Could not connect to host: {host} via protocol {protocol}'.format(
                     host=settings.OPENNEBULA_DOMAIN,
@@ -192,6 +164,7 @@ class OpenNebulaManager():
         try:
             user_pool = oca.UserPool(self.oneadmin_client)
             user_pool.info()
+        #TODO: Replace with logger
         except ConnectionRefusedError:
             print('Could not connect to host: {host} via protocol {protocol}'.format(
                     host=settings.OPENNEBULA_DOMAIN,
@@ -202,8 +175,9 @@ class OpenNebulaManager():
 
     def _get_vm_pool(self):
         try:
-           vm_pool = oca.VmPool(self.oneadmin_client)
+           vm_pool = oca.VirtualMachinePool(self.oneadmin_client)
            vm_pool.info()
+        #TODO: Replace with logger
         except ConnectionRefusedError:
             print('Could not connect to host: {host} via protocol {protocol}'.format(
                     host=settings.OPENNEBULA_DOMAIN,
@@ -225,12 +199,15 @@ class OpenNebulaManager():
         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]
-        )
+        try:
+            self.oneadmin_client.call(
+                oca.VirtualMachine.METHODS['chown'],
+                vm_id,
+                self.opennebula_user.id,
+                self.opennebula_user.group_ids[0]
+            )
+        except AttributeError:
+            pass
         return vm_id
 
     def delete_vm(self, vm_id):
@@ -241,6 +218,7 @@ class OpenNebulaManager():
         try:
            template_pool = oca.VmTemplatePool(self.oneadmin_client)
            template_pool.info()
+        #TODO: Replace with logger
         except ConnectionRefusedError:
             print('Could not connect to host: {host} via protocol {protocol}'.format(
                     host=settings.OPENNEBULA_DOMAIN,
diff --git a/opennebula_api/serializers.py b/opennebula_api/serializers.py
index 13f6d5ab..e8ff33bd 100644
--- a/opennebula_api/serializers.py
+++ b/opennebula_api/serializers.py
@@ -6,27 +6,6 @@ from oca import OpenNebulaException
 
 from .models import VirtualMachine, VirtualMachineTemplate, OpenNebulaManager
 
-class VirtualMachineSerializer(serializers.ModelSerializer):
-    """Serializer to map the virtual machine instance into JSON format."""
-
-    #TODO: Maybe we can change to template.get_cores
-    cores       = serializers.IntegerField(read_only=True, source='get_cores') 
-    name        = serializers.CharField(read_only=True, source='get_name')
-    disk_size   = serializers.IntegerField(read_only=True, source='get_disk_size')
-    memory      = serializers.IntegerField(read_only=True, source='get_memory')
-    #TODO: See if we can change to IPAddressField
-    ip          = serializers.CharField(read_only=True, source='get_ip')
-    deploy_id   = serializers.IntegerField(read_only=True, source='get_deploy_id')
-    vm_id          = serializers.IntegerField(read_only=True, source='get_vm_id')
-    state       = serializers.CharField(read_only=True, source='get_state')
-    price       = serializers.FloatField(read_only=True, source='get_price')
-
-    class Meta:
-        model = VirtualMachine
-        fields = ('id', 'opennebula_id', 'template', 'cores', 'name',
-                'disk_size', 'memory', 'ip', 'deploy_id', 'state', 'vm_id',
-                'price')
-
 class VirtualMachineTemplateSerializer(serializers.ModelSerializer):
     """Serializer to map the virtual machine template instance into JSON format."""
     cores       = serializers.IntegerField(source='get_cores') 
@@ -61,3 +40,54 @@ class VirtualMachineTemplateSerializer(serializers.ModelSerializer):
 
     def create(self, validated_data):
         return VirtualMachineTemplate.objects.create(**validated_data)
+
+class TemplatePrimaryKeyRelatedField(serializers.PrimaryKeyRelatedField):
+    def display_value(self, instance):
+        return 'Template: {}'.format(instance.get_name())
+
+class VirtualMachineSerializer(serializers.ModelSerializer):
+    """Serializer to map the virtual machine instance into JSON format."""
+
+    #TODO: Maybe we can change to template.get_cores
+    cores       = serializers.IntegerField(read_only=True, source='get_cores') 
+    name        = serializers.CharField(read_only=True, source='get_name')
+    disk_size   = serializers.IntegerField(read_only=True, source='get_disk_size')
+    memory      = serializers.IntegerField(read_only=True, source='get_memory')
+    #TODO: See if we can change to IPAddressField
+    ip          = serializers.CharField(read_only=True, source='get_ip')
+    deploy_id   = serializers.IntegerField(read_only=True, source='get_deploy_id')
+    vm_id          = serializers.IntegerField(read_only=True, source='get_vm_id')
+    state       = serializers.CharField(read_only=True, source='get_state')
+    price       = serializers.FloatField(read_only=True, source='get_price')
+
+    vm_template = VirtualMachineTemplateSerializer(read_only=True)
+
+    vm_template_id = TemplatePrimaryKeyRelatedField(
+                queryset=VirtualMachineTemplate.objects.all(),
+                source='vm_template'
+            )
+
+    class Meta:
+        model = VirtualMachine
+        fields = ('id', 'opennebula_id', 'vm_template', 'vm_template_id', 'cores', 'name',
+                'disk_size', 'memory', 'ip', 'deploy_id', 'state', 'vm_id',
+                'price')
+        read_only_fields = ('opennebula_id', )
+
+    def validate(self, data):
+        # Create the opennebula model
+        manager = OpenNebulaManager(create_user = False)
+        
+        try:
+            template_id = data['vm_template'].opennebula_id
+            opennebula_id = manager.create_vm(template_id)
+            data.update({'opennebula_id':opennebula_id})
+        except OpenNebulaException as err:
+            raise serializers.ValidationError("OpenNebulaException occured. {0}".format(err))
+        
+        return data
+
+    def create(self, validated_data):
+        return VirtualMachine.objects.create(**validated_data)
+
+
diff --git a/opennebula_api/views.py b/opennebula_api/views.py
index be0e1a24..4cd237ae 100644
--- a/opennebula_api/views.py
+++ b/opennebula_api/views.py
@@ -1,6 +1,8 @@
 from rest_framework import generics
-from .serializers import VirtualMachineTemplateSerializer
-from .models import VirtualMachineTemplate, OpenNebulaManager
+
+from .serializers import VirtualMachineTemplateSerializer, \
+                         VirtualMachineSerializer
+from .models import VirtualMachineTemplate, VirtualMachine, OpenNebulaManager
 
 class TemplateCreateView(generics.ListCreateAPIView):
     """This class defines the create behavior of our rest api."""
@@ -16,3 +18,18 @@ class TemplateDetailsView(generics.RetrieveUpdateDestroyAPIView):
 
     queryset = VirtualMachineTemplate.objects.all()
     serializer_class = VirtualMachineTemplateSerializer
+
+class VmCreateView(generics.ListCreateAPIView):
+    """This class defines the create behavior of our rest api."""
+    queryset = VirtualMachine.objects.all()
+    serializer_class = VirtualMachineSerializer
+
+    def perform_create(self, serializer):
+        """Save the post data when creating a new template."""
+        serializer.save()
+
+class VmDetailsView(generics.RetrieveUpdateDestroyAPIView):
+    """This class handles the http GET, PUT and DELETE requests."""
+
+    queryset = VirtualMachine.objects.all()
+    serializer_class = VirtualMachineSerializer