Add images as configuration

opennebula_api/models.py

@@ -102,23 +102,43 @@ class OpenNebulaManager():
             return []
    
     def get_vm(self, vm_id):
+        vm_id = int(vm_id)
         try:
             vm_pool = self._get_vm_pool()
-            return vm_pool.get_by_id(int(vm_id))
+            return vm_pool.get_by_id(vm_id)
         except:
             return None
 
-    #TODO: get app with id 
-    def create_vm(self, template_id, app_id=None, ssh_key=None):
-        extra_template = "<CONTEXT><SSH_PUBLIC_KEY>{ssh_key}</SSH_PUBLIC_KEY></CONTEXT>".format(
-            ssh_key=ssh_key
-        )
-        vm_id = self.oneadmin_client.call(
-            oca.VmTemplate.METHODS['instantiate'],
-            template_id,
-            '',
-            False,
-            extra_template
+    def create_vm(self, template_id, image_id=None, ssh_key=None):
+        extra_template_formater = """<CONTEXT>
+                                      <SSH_PUBLIC_KEY>{ssh_key}</SSH_PUBLIC_KEY>
+                                     </CONTEXT>
+                                     <DISK>
+                                      <IMAGE_ID>{image_id}</IMAGE_ID>
+                                     </DISK>
+                                  """
+
+        template = self.get_template(template_id)
+        vm_id = template.instantiate(name ='', pending=False, extra_template='')
+        image = self.get_image(image_id)
+
+        image_name = "{image_name}{template_name}{vm_id}".format(
+                image_name=image.name,
+                template_name=template.name,
+                vm_id = vm_id,
+                )
+
+        image_id = image.clone(name=image_name)
+
+        self.oneadmin_client.call(
+            oca.VmTemplate.METHODS['update'],
+            vm_id, 
+            extra_template_formater.format(
+                ssh_key=ssh_key,
+                image_id=image_id
+                ),
+            # 0 = Replace / 1 = Merge
+            1,
         )
         try:
             self.oneadmin_client.call(
@@ -177,8 +197,12 @@ class OpenNebulaManager():
             return []
 
     def get_template(self, template_id):
-        template_pool = self._get_template_pool()
-        return template_pool.get_by_id(template_id)
+        template_id = int(template_id)
+        try:
+            template_pool = self._get_template_pool()
+            return template_pool.get_by_id(template_id)
+        except:
+            return None
 
     
     
@@ -238,3 +262,38 @@ class OpenNebulaManager():
             self.opennebula_user.id,
             new_password
         ) 
+
+
+    def _get_image_pool(self):
+        try:
+           image_pool = oca.ImagePool(self.oneadmin_client)
+           image_pool.info()
+        #TODO: Replace with logger
+        except ConnectionRefusedError:
+            logger.info('Could not connect to host: {host} via protocol {protocol}'.format(
+                    host=settings.OPENNEBULA_DOMAIN,
+                    protocol=settings.OPENNEBULA_PROTOCOL)
+                )
+            raise ConnectionRefusedError
+        return image_pool
+
+    def get_images(self):
+        try:
+            public_images = [
+                    image
+                    for image in self._get_image_pool()
+                    if 'public-' in image.name 
+                    ]
+            return public_images
+        except ConnectionRefusedError:
+            return []
+        pass
+
+    def get_image(self, image_id):
+        image_id = int(image_id)
+        try:
+            image_pool = self._get_image_pool()
+            return image_pool.get_by_id(image_id)
+        except:
+            return None
+

opennebula_api/serializers.py

@@ -31,7 +31,7 @@ class VirtualMachineTemplateSerializer(serializers.Serializer):
         core_price = template.pop('cpu_cost') 
         memory_price = template.pop('memory_cost') 
         disk_size_price = template.pop('disk_cost')
-        manager = OpenNebulaManager(create_user = False)
+        manager = OpenNebulaManager()
         
         try:
             opennebula_id = manager.create_template(name=name, cores=cores,
@@ -92,7 +92,7 @@ class VirtualMachineSerializer(serializers.Serializer):
         try:
             manager = OpenNebulaManager(email=owner.email,
                                         password=owner.password,
-                                        create_user = True)
+                                        )
             opennebula_id = manager.create_vm(template_id)
         except OpenNebulaException as err:
             raise serializers.ValidationError("OpenNebulaException occured. {0}".format(err))
@@ -117,3 +117,8 @@ class VirtualMachineSerializer(serializers.Serializer):
             price += int(disk.size)/1024 * float(template.disk_cost)
         return price
 
+class ImageSerializer(serializers.Serializer):
+    """Serializer to map the image instance into JSON format."""
+    id          = serializers.IntegerField(read_only=True)
+    name        = serializers.CharField()
+

opennebula_api/views.py

@@ -47,8 +47,7 @@ class VmCreateView(generics.ListCreateAPIView):
     def get_queryset(self):
         owner = self.request.user
         manager = OpenNebulaManager(email=owner.email,
-                                    password=owner.password,
-                                    create_user=True)
+                                    password=owner.password)
         return manager.get_vms()
 
     def perform_create(self, serializer):
@@ -64,21 +63,18 @@ class VmDetailsView(generics.RetrieveUpdateDestroyAPIView):
     def get_queryset(self):
         owner = self.request.user
         manager = OpenNebulaManager(email=owner.email,
-                                    password=owner.password,
-                                    create_user=True)
+                                    password=owner.password)
         return manager.get_vms()
 
     def get_object(self):
         owner = self.request.user
         manager = OpenNebulaManager(email=owner.email,
-                                    password=owner.password,
-                                    create_user=True)
+                                    password=owner.password)
         return manager.get_vm(self.kwargs.get('pk'))
 
     def perform_destroy(self, instance):
         owner = self.request.user
         manager = OpenNebulaManager(email=owner.email,
-                                    password=owner.password,
-                                    create_user = True)
+                                    password=owner.password)
         manager.delete_vm(instance.id)