diff --git a/osm_ro/vim_thread.py b/osm_ro/vim_thread.py
index 0074dfe..bbb81a5 100644
--- a/osm_ro/vim_thread.py
+++ b/osm_ro/vim_thread.py
@@ -22,8 +22,36 @@
 ##
 
 """"
-This is thread that interact with the host and the libvirt to manage VM
-One thread will be launched per host 
+This is thread that interacts with a VIM. It processes TASKs sequentially against a single VIM.
+The tasks are stored at database in table vim_actions
+The task content is:
+    MD  instance_action_id:  reference a global action over an instance-scenario: database instance_actions
+    MD  task_index:     index number of the task. This with the previous are a key
+    MD  datacenter_vim_id:  should contain the uuid of the VIM managed by this thread
+    MD  vim_id:     id of the vm,net,etc at VIM
+    MD  action:     CREATE, DELETE, LOOK, TODO: LOOK_CREATE
+    MD  item:       database table name, can be instance_vms, instance_nets, TODO: datacenter_flavors, datacenter_images
+    MD  item_id:    uuid of the referenced entry in the preious table
+    MD  status:     SCHEDULED,BUILD,DONE,FAILED,SUPERSEDED
+    MD  extra:      text with yaml format at database, dict at memory with:
+            params:     list with the params to be sent to the VIM for CREATE or LOOK. For DELETE the vim_id is taken from other related tasks
+            depends_on: list with the 'task_index'es of tasks that must be completed before. e.g. a vm depends on a net
+            sdn_net_id: used for net.
+            tries:
+            interfaces: used for VMs. Each key is the uuid of the instance_interfaces entry at database
+                iface_id: uuid of intance_interfaces
+                sdn_port_id:
+                sdn_net_id:
+            created:    False if the VIM element is not created by other actions, and it should not be deleted
+            vim_status: VIM status of the element. Stored also at database in the instance_XXX
+    M   depends:    dict with task_index(from depends_on) to task class
+    M   params:     same as extra[params] but with the resolved dependencies
+    M   vim_interfaces: similar to extra[interfaces] but with VIM information. Stored at database in the instance_XXX but not at vim_actions
+    M   vim_info:   Detailed information of a vm,net from the VIM. Stored at database in the instance_XXX but not at vim_actions
+    MD  error_msg:  descriptive text upon an error.Stored also at database instance_XXX
+    MD  created_at: task creation time
+    MD  modified_at: last task update time. On refresh it contains when this task need to be refreshed
+
 """
 
 import threading
@@ -31,18 +59,23 @@
 import Queue
 import logging
 import vimconn
+import yaml
 from db_base import db_base_Exception
 from lib_osm_openvim.ovim import ovimException
 
 __author__ = "Alfonso Tierno, Pablo Montes"
-__date__ = "$10-feb-2017 12:07:15$"
+__date__ = "$28-Sep-2017 12:07:15$"
 
 # from logging import Logger
 # import auxiliary_functions as af
 
 
 def is_task_id(task_id):
-    return True if task_id[:5] == "TASK." else False
+    return task_id.startswith("TASK-")
+
+
+class VimThreadException(Exception):
+    pass
 
 
 class vim_thread(threading.Thread):
@@ -58,12 +91,6 @@
             'host','user':  host ip or name to manage and user
             'db', 'db_lock': database class and lock to use it in exclusion
         """
-        self.tasksResult = {}
-        """ It will contain a dictionary with
-            task_id:
-                status: enqueued,done,error,deleted,processing
-                result: VIM result,
-        """
         threading.Thread.__init__(self)
         self.vim = vimconn
         self.datacenter_name = datacenter_name
@@ -80,35 +107,86 @@
 
         self.task_lock = task_lock
         self.task_queue = Queue.Queue(2000)
-        self.refresh_list = []
+
+        self.refresh_tasks = []
         """Contains time ordered task list for refreshing the status of VIM VMs and nets"""
 
+        self.pending_tasks = []
+        """Contains time ordered task list for creation, deletion of VIM VMs and nets"""
+
+        self.grouped_tasks = {}
+        """ It contains all the creation/deletion pending tasks grouped by its concrete vm, net, etc
+            <item><item_id>:
+                -   <task1>  # e.g. CREATE task
+                    <task2>  # e.g. DELETE task
+        """
+
+    def _reload_vim_actions(self):
+        """
+        Read actions from database and reload them at memory. Fill self.refresh_list, pending_list, vim_actions
+        :return: None
+        """
+        action_completed = False
+        task_list = []
+        old_action_key = None
+
+        with self.db_lock:
+            vim_actions = self.db.get_rows(FROM="vim_actions",
+                                           WHERE={"datacenter_vim_id":  self.datacenter_tenant_id },
+                                           ORDER_BY=("item", "item_id", "created_at",))
+        for task in vim_actions:
+            item = task["item"]
+            item_id = task["item_id"]
+            action_key = item + item_id
+            if old_action_key != action_key:
+                if not action_completed and task_list:
+                    # This will fill needed task parameters into memory, and insert the task if needed in
+                    # self.pending_tasks or self.refresh_tasks
+                    self._insert_pending_tasks(task_list)
+                task_list = []
+                old_action_key = action_key
+                action_completed = False
+            elif action_completed:
+                continue
+
+            if task["status"] == "SCHEDULED" or task["action"] == "CREATE" or task["action"] == "FIND":
+                task_list.append(task)
+            elif task["action"] == "DELETE":
+                # action completed because deleted and status is not SCHEDULED. Not needed anything
+                action_completed = True
+
+        # Last actions group need to be inserted too
+        if not action_completed and task_list:
+            self._insert_pending_tasks(task_list)
+
     def _refres_elements(self):
         """Call VIM to get VMs and networks status until 10 elements"""
         now = time.time()
+        nb_processed = 0
         vm_to_refresh_list = []
         net_to_refresh_list = []
         vm_to_refresh_dict = {}
         net_to_refresh_dict = {}
         items_to_refresh = 0
-        while self.refresh_list:
-            task = self.refresh_list[0]
+        while self.refresh_tasks:
+            task = self.refresh_tasks[0]
             with self.task_lock:
-                if task['status'] == 'deleted':
-                    self.refresh_list.pop(0)
+                if task['status'] == 'SUPERSEDED':
+                    self.refresh_tasks.pop(0)
                     continue
-                if task['time'] > now:
+                if task['modified_at'] > now:
                     break
-                task["status"] = "processing"
-            self.refresh_list.pop(0)
-            if task["name"] == 'get-vm':
+                # task["status"] = "processing"
+                nb_processed += 1
+            self.refresh_tasks.pop(0)
+            if task["item"] == 'instance_vms':
                 vm_to_refresh_list.append(task["vim_id"])
                 vm_to_refresh_dict[task["vim_id"]] = task
-            elif task["name"] == 'get-net':
+            elif task["item"] == 'instance_nets':
                 net_to_refresh_list.append(task["vim_id"])
                 net_to_refresh_dict[task["vim_id"]] = task
             else:
-                error_text = "unknown task {}".format(task["name"])
+                error_text = "unknown task {}".format(task["item"])
                 self.logger.error(error_text)
             items_to_refresh += 1
             if items_to_refresh == 10:
@@ -116,110 +194,100 @@
 
         if vm_to_refresh_list:
             try:
+                now = time.time()
                 vim_dict = self.vim.refresh_vms_status(vm_to_refresh_list)
                 for vim_id, vim_info in vim_dict.items():
-                    #look for task
+                    # look for task
+                    task_need_update = False
                     task = vm_to_refresh_dict[vim_id]
                     self.logger.debug("get-vm vm_id=%s result=%s", task["vim_id"], str(vim_info))
 
                     # update database
+                    task_vim_info = task.get("vim_info")
+                    task_error_msg = task.get("error_msg")
+                    task_vim_status = task["extra"].get("vim_status")
                     if vim_info.get("error_msg"):
                         vim_info["error_msg"] = self._format_vim_error_msg(vim_info["error_msg"])
-                    if task["vim_info"].get("status") != vim_info["status"] or \
-                        task["vim_info"].get("error_msg") != vim_info.get("error_msg") or \
-                        task["vim_info"].get("vim_info") != vim_info["vim_info"]:
+                    if task_vim_status != vim_info["status"] or task_error_msg != vim_info.get("error_msg") or \
+                                    task_vim_info != vim_info.get("vim_info"):
                         with self.db_lock:
                             temp_dict = {"status": vim_info["status"],
                                          "error_msg": vim_info.get("error_msg"),
-                                         "vim_info": vim_info["vim_info"]}
-                            self.db.update_rows('instance_vms', UPDATE=temp_dict, WHERE={"vim_vm_id": vim_id})
-                    for interface in vim_info["interfaces"]:
-                        for task_interface in task["vim_info"]["interfaces"]:
-                            if task_interface["vim_net_id"] == interface["vim_net_id"]:
-                                break
-                        else:
-                            task_interface = {"vim_net_id": interface["vim_net_id"]}
-                            task["vim_info"]["interfaces"].append(task_interface)
-                        if task_interface != interface:
-                            #delete old port
+                                         "vim_info": vim_info.get("vim_info")}
+                            self.db.update_rows('instance_vms', UPDATE=temp_dict, WHERE={"uuid": task["item_id"]})
+                        task["extra"]["vim_status"] = vim_info["status"]
+                        task["error_msg"] = vim_info.get("error_msg")
+                        task["vim_info"] = vim_info.get("vim_info")
+                        task_need_update = True
+                    for interface in vim_info.get("interfaces", ()):
+                        vim_interface_id = interface["vim_interface_id"]
+                        if vim_interface_id not in task["extra"]["interfaces"]:
+                            self.logger.critical("Interface not found {} on task info {}".format(
+                                vim_interface_id, task["extra"]["interfaces"]), exc_info=True)
+                            continue
+                        task_interface = task["extra"]["interfaces"][vim_interface_id]
+                        task_vim_interface = task["vim_interfaces"].get(vim_interface_id)
+                        if task_vim_interface != interface:
+                            # delete old port
                             if task_interface.get("sdn_port_id"):
                                 try:
                                     with self.db_lock:
                                         self.ovim.delete_port(task_interface["sdn_port_id"])
                                         task_interface["sdn_port_id"] = None
+                                        task_need_update = True
                                 except ovimException as e:
                                     self.logger.error("ovimException deleting external_port={} ".format(
                                         task_interface["sdn_port_id"]) + str(e), exc_info=True)
                                     # TODO Set error_msg at instance_nets
-                            vim_net_id = interface["vim_net_id"]
-                            sdn_net_id = None
-                            sdn_port_name = None
-                            with self.db_lock:
-                                where_= {'iv.vim_vm_id': vim_id, "ine.vim_net_id": vim_net_id,
-                                            'ine.datacenter_tenant_id': self.datacenter_tenant_id}
-                                # TODO check why vim_interface_id is not present at database
-                                # if interface.get("vim_interface_id"):
-                                #     where_["vim_interface_id"] = interface["vim_interface_id"]
-                                db_ifaces = self.db.get_rows(
-                                    FROM="instance_interfaces as ii left join instance_nets as ine on "
-                                         "ii.instance_net_id=ine.uuid left join instance_vms as iv on "
-                                         "ii.instance_vm_id=iv.uuid",
-                                    SELECT=("ii.uuid as iface_id", "ine.uuid as net_id", "iv.uuid as vm_id", "sdn_net_id", "vim_net_id"),
-                                    WHERE=where_)
-                            if len(db_ifaces)>1:
-                                self.logger.critical("Refresing interfaces. "
-                                                  "Found more than one interface at database for '{}'".format(where_))
-                            elif len(db_ifaces)==0:
-                                self.logger.critical("Refresing interfaces. "
-                                                  "Not found any interface at database for '{}'".format(where_))
-                                continue
-                            else:
-                                db_iface = db_ifaces[0]
-                                # If there is no sdn_net_id, check if it is because an already created vim network is being used
-                                # in that case, the sdn_net_id will be in that entry of the instance_nets table
-                                if not db_iface.get("sdn_net_id"):
+
+                            # Create SDN port
+                            sdn_net_id = task_interface.get("sdn_net_id")
+                            if sdn_net_id and interface.get("compute_node") and interface.get("pci"):
+                                sdn_port_name = sdn_net_id + "." + task["vim_id"]
+                                sdn_port_name = sdn_port_name[:63]
+                                try:
                                     with self.db_lock:
-                                        result = self.db.get_rows(
-                                            SELECT=('sdn_net_id',), FROM='instance_nets',
-                                            WHERE={'vim_net_id': db_iface.get("vim_net_id"),
-                                                   'instance_scenario_id': None,
-                                                   'datacenter_tenant_id':  self.datacenter_tenant_id})
-                                    if len(result) == 1:
-                                        db_iface["sdn_net_id"] = result[0]['sdn_net_id']
-
-                                if db_iface.get("sdn_net_id") and interface.get("compute_node") and interface.get("pci"):
-                                    sdn_net_id = db_iface["sdn_net_id"]
-                                    sdn_port_name = sdn_net_id + "." + db_iface["vm_id"]
-                                    sdn_port_name = sdn_port_name[:63]
-                                    try:
-                                        with self.db_lock:
-                                            sdn_port_id = self.ovim.new_external_port(
-                                                {"compute_node": interface["compute_node"],
-                                                 "pci": interface["pci"],
-                                                 "vlan": interface.get("vlan"),
-                                                 "net_id": sdn_net_id,
-                                                 "region": self.vim["config"]["datacenter_id"],
-                                                 "name": sdn_port_name,
-                                                 "mac": interface.get("mac_address")})
-                                            interface["sdn_port_id"] = sdn_port_id
-                                    except (ovimException, Exception) as e:
-                                        self.logger.error(
-                                            "ovimException creating new_external_port compute_node={} " \
-                                            "pci={} vlan={} ".format(
-                                                interface["compute_node"],
-                                                interface["pci"],
-                                                interface.get("vlan")) + str(e),
-                                            exc_info=True)
-                                        # TODO Set error_msg at instance_nets
-                                with self.db_lock:
-                                    vim_net_id = interface.pop("vim_net_id")
-                                    self.db.update_rows('instance_interfaces', UPDATE=interface,
-                                                    WHERE={'uuid': db_iface["iface_id"]})
-                                    interface["vim_net_id"] = vim_net_id
-                                # TODO insert instance_id
-
-                    task["vim_info"] = vim_info
-                    if task["vim_info"]["status"] == "BUILD":
+                                        sdn_port_id = self.ovim.new_external_port(
+                                            {"compute_node": interface["compute_node"],
+                                             "pci": interface["pci"],
+                                             "vlan": interface.get("vlan"),
+                                             "net_id": sdn_net_id,
+                                             "region": self.vim["config"]["datacenter_id"],
+                                             "name": sdn_port_name,
+                                             "mac": interface.get("mac_address")})
+                                        task_interface["sdn_port_id"] = sdn_port_id
+                                        task_need_update = True
+                                except (ovimException, Exception) as e:
+                                    self.logger.error(
+                                        "ovimException creating new_external_port compute_node={} "
+                                        "pci={} vlan={} ".format(
+                                            interface["compute_node"],
+                                            interface["pci"],
+                                            interface.get("vlan")) + str(e),
+                                        exc_info=True)
+                                    # TODO Set error_msg at instance_nets
+                            with self.db_lock:
+                                self.db.update_rows(
+                                    'instance_interfaces',
+                                    UPDATE={"mac_address": interface.get("mac_address"),
+                                            "ip_address": interface.get("ip_address"),
+                                            "vim_info": interface.get("vim_info"),
+                                            "sdn_port_id": task_interface.get("sdn_port_id"),
+                                            "compute_node": interface.get("compute_node"),
+                                            "pci": interface.get("pci"),
+                                            "vlan": interface.get("vlan"),
+                                    },
+                                    WHERE={'uuid': task_interface["iface_id"]})
+                            task["vim_interfaces"][vim_interface_id] = interface
+                    if task_need_update:
+                        with self.db_lock:
+                            self.db.update_rows(
+                                'vim_actions',
+                                UPDATE={"extra": yaml.safe_dump(task["extra"], default_flow_style=True, width=256),
+                                        "error_msg": task.get("error_msg"), "modified_at": now},
+                                WHERE={'instance_action_id': task['instance_action_id'],
+                                       'task_index': task['task_index']})
+                    if task["extra"].get("vim_status") == "BUILD":
                         self._insert_refresh(task, now + self.REFRESH_BUILD)
                     else:
                         self._insert_refresh(task, now + self.REFRESH_ACTIVE)
@@ -229,65 +297,61 @@
 
         if net_to_refresh_list:
             try:
+                now = time.time()
                 vim_dict = self.vim.refresh_nets_status(net_to_refresh_list)
                 for vim_id, vim_info in vim_dict.items():
-                    #look for task
+                    # look for task
                     task = net_to_refresh_dict[vim_id]
                     self.logger.debug("get-net net_id=%s result=%s", task["vim_id"], str(vim_info))
 
-                    #get database info
-                    where_ = {"vim_net_id": vim_id, 'datacenter_tenant_id': self.datacenter_tenant_id}
-                    with self.db_lock:
-                        db_nets = self.db.get_rows(
-                            FROM="instance_nets",
-                            SELECT=("uuid as net_id", "sdn_net_id"),
-                            WHERE=where_)
-                    if len(db_nets) > 1:
-                        self.logger.critical("Refresing networks. "
-                                          "Found more than one instance-networks at database for '{}'".format(where_))
-                    elif len(db_nets) == 0:
-                        self.logger.critical("Refresing networks. "
-                                          "Not found any instance-network at database for '{}'".format(where_))
-                        continue
-                    else:
-                        db_net = db_nets[0]
-                        if db_net.get("sdn_net_id"):
-                            # get ovim status
-                            try:
-                                with self.db_lock:
-                                    sdn_net = self.ovim.show_network(db_net["sdn_net_id"])
-                                if sdn_net["status"] == "ERROR":
-                                    if not vim_info.get("error_msg"):
-                                        vim_info["error_msg"] = sdn_net["error_msg"]
-                                    else:
-                                        vim_info["error_msg"] = "VIM_ERROR: {} && SDN_ERROR: {}".format(
-                                            self._format_vim_error_msg(vim_info["error_msg"], 1024//2-14),
-                                            self._format_vim_error_msg(sdn_net["error_msg"], 1024//2-14))
-                                    if vim_info["status"] == "VIM_ERROR":
-                                        vim_info["status"] = "VIM_SDN_ERROR"
-                                    else:
-                                        vim_info["status"] = "SDN_ERROR"
+                    task_vim_info = task.get("vim_info")
+                    task_vim_status = task["extra"].get("vim_status")
+                    task_error_msg = task.get("error_msg")
+                    task_sdn_net_id = task["extra"].get("sdn_net_id")
 
-                            except (ovimException, Exception) as e:
-                                self.logger.error(
-                                    "ovimException getting network infor snd_net_id={}".format(db_net["sdn_net_id"]),
-                                    exc_info=True)
-                                # TODO Set error_msg at instance_nets
+                    # get ovim status
+                    if task_sdn_net_id:
+                        try:
+                            with self.db_lock:
+                                sdn_net = self.ovim.show_network(task_sdn_net_id)
+                            if sdn_net["status"] == "ERROR":
+                                if not vim_info.get("error_msg"):
+                                    vim_info["error_msg"] = sdn_net["error_msg"]
+                                else:
+                                    vim_info["error_msg"] = "VIM_ERROR: {} && SDN_ERROR: {}".format(
+                                        self._format_vim_error_msg(vim_info["error_msg"], 1024//2-14),
+                                        self._format_vim_error_msg(sdn_net["error_msg"], 1024//2-14))
+                                if vim_info["status"] == "VIM_ERROR":
+                                    vim_info["status"] = "VIM_SDN_ERROR"
+                                else:
+                                    vim_info["status"] = "SDN_ERROR"
+
+                        except (ovimException, Exception) as e:
+                            self.logger.error(
+                                "ovimException getting network infor snd_net_id={}".format(task_sdn_net_id),
+                                exc_info=True)
+                            # TODO Set error_msg at instance_nets
 
                     # update database
                     if vim_info.get("error_msg"):
                         vim_info["error_msg"] = self._format_vim_error_msg(vim_info["error_msg"])
-                    if task["vim_info"].get("status") != vim_info["status"] or \
-                                    task["vim_info"].get("error_msg") != vim_info.get("error_msg") or \
-                                    task["vim_info"].get("vim_info") != vim_info["vim_info"]:
-                        with self.db_lock:
-                            temp_dict = {"status": vim_info["status"],
+                    if task_vim_status != vim_info["status"] or task_error_msg != vim_info.get("error_msg") or \
+                            task_vim_info != vim_info["vim_info"]:
+                        task["extra"]["vim_status"] = vim_info["status"]
+                        task["error_msg"] = vim_info.get("error_msg")
+                        task["vim_info"] = vim_info["vim_info"]
+                        temp_dict = {"status": vim_info["status"],
                                          "error_msg": vim_info.get("error_msg"),
                                          "vim_info": vim_info["vim_info"]}
-                            self.db.update_rows('instance_nets', UPDATE=temp_dict, WHERE={"vim_net_id": vim_id})
-
-                    task["vim_info"] = vim_info
-                    if task["vim_info"]["status"] == "BUILD":
+                        with self.db_lock:
+                            self.db.update_rows('instance_nets', UPDATE=temp_dict, WHERE={"uuid": task["item_id"]})
+                            self.db.update_rows(
+                                'vim_actions',
+                                UPDATE={"extra": yaml.safe_dump(task["extra"], default_flow_style=True, width=256),
+                                        "error_msg": task.get("error_msg"), "modified_at": now},
+                                WHERE={'instance_action_id': task['instance_action_id'],
+                                        'task_index': task['task_index']})
+                    if task["extra"].get("vim_status") == "BUILD":
                         self._insert_refresh(task, now + self.REFRESH_BUILD)
                     else:
                         self._insert_refresh(task, now + self.REFRESH_ACTIVE)
@@ -295,23 +359,26 @@
                 self.logger.error("vimconnException Exception when trying to refresh nets " + str(e))
                 self._insert_refresh(task, now + self.REFRESH_ACTIVE)
 
-        if not items_to_refresh:
-            time.sleep(1)
+        return nb_processed
 
-    def _insert_refresh(self, task, threshold_time):
-        """Insert a task at list of refreshing elements. The refreshing list is ordered by threshold_time (task['time']
+    def _insert_refresh(self, task, threshold_time=None):
+        """Insert a task at list of refreshing elements. The refreshing list is ordered by threshold_time (task['modified_at']
         It is assumed that this is called inside this thread
         """
-        task["time"] = threshold_time
-        for index in range(0, len(self.refresh_list)):
-            if self.refresh_list[index]["time"] > threshold_time:
-                self.refresh_list.insert(index, task)
+        if not threshold_time:
+            threshold_time = time.time()
+        task["modified_at"] = threshold_time
+        task_name = task["item"][9:] + "-" + task["action"]
+        task_id = task["instance_action_id"] + "." + str(task["task_index"])
+        for index in range(0, len(self.refresh_tasks)):
+            if self.refresh_tasks[index]["modified_at"] > threshold_time:
+                self.refresh_tasks.insert(index, task)
                 break
         else:
-            index = len(self.refresh_list)
-            self.refresh_list.append(task)
-        self.logger.debug("new refresh task={} name={}, time={} index={}".format(
-            task["id"], task["name"], task["time"], index))
+            index = len(self.refresh_tasks)
+            self.refresh_tasks.append(task)
+        self.logger.debug("new refresh task={} name={}, modified_at={} index={}".format(
+            task_id, task_name, task["modified_at"], index))
 
     def _remove_refresh(self, task_name, vim_id):
         """Remove a task with this name and vim_id from the list of refreshing elements.
@@ -320,27 +387,165 @@
         Return False if not found
         """
         index_to_delete = None
-        for index in range(0, len(self.refresh_list)):
-            if self.refresh_list[index]["name"] == task_name and self.refresh_list[index]["vim_id"] == vim_id:
+        for index in range(0, len(self.refresh_tasks)):
+            if self.refresh_tasks[index]["name"] == task_name and self.refresh_tasks[index]["vim_id"] == vim_id:
                 index_to_delete = index
                 break
         else:
             return False
         if index_to_delete != None:
-            del self.refresh_list[index_to_delete]
+            del self.refresh_tasks[index_to_delete]
         return True
 
+    def _proccess_pending_tasks(self):
+        nb_created = 0
+        nb_processed = 0
+        while self.pending_tasks:
+            task = self.pending_tasks.pop(0)
+            nb_processed += 1
+            if task["status"] == "SUPERSEDED":
+                # not needed to do anything but update database with the new status
+                result = True
+                database_update = None
+            elif task["item"] == 'instance_vms':
+                if task["action"] == "CREATE":
+                    result, database_update = self.new_vm(task)
+                    nb_created += 1
+                elif task["action"] == "DELETE":
+                    result, database_update = self.del_vm(task)
+                else:
+                    raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+            elif task["item"] == 'instance_nets':
+                if task["action"] == "CREATE":
+                    result, database_update = self.new_net(task)
+                    nb_created += 1
+                elif task["action"] == "DELETE":
+                    result, database_update = self.del_net(task)
+                elif task["action"] == "FIND":
+                    result, database_update = self.get_net(task)
+                else:
+                    raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+            else:
+                raise vimconn.vimconnException(self.name + "unknown task item {}".format(task["item"]))
+                # TODO
+
+            if task["status"] == "SCHEDULED":
+                # This is because a depend task is not completed. Moved to the end. NOT USED YET
+                if task["extra"].get("tries", 0) > 3:
+                    task["status"] == "FAILED"
+                else:
+                    task["extra"]["tries"] = task["extra"].get("tries", 0) + 1
+                    self.pending_tasks.append(task)
+            elif task["action"] == "DELETE":
+                action_key = task["item"] + task["item_id"]
+                del self.grouped_tasks[action_key]
+            elif task["action"] in ("CREATE", "FIND") and task["status"] in ("DONE", "BUILD"):
+                self._insert_refresh(task)
+
+            self.logger.debug("vim_action id={}.{} item={} action={} result={}:{} params={}".format(
+                task["instance_action_id"], task["task_index"], task["item"], task["action"],
+                task["status"], task["vim_id"] if task["status"] == "DONE" else task.get("error_msg"),
+                task["params"]))
+            try:
+                now = time.time()
+                with self.db_lock:
+                    self.db.update_rows(
+                        table="vim_actions",
+                        UPDATE={"status": task["status"], "vim_id": task["vim_id"], "modified_at": now,
+                                "error_msg": task["error_msg"],
+                                "extra": yaml.safe_dump(task["extra"], default_flow_style=True, width=256)},
+                        WHERE={"instance_action_id": task["instance_action_id"], "task_index": task["task_index"]})
+                    if result is not None:
+                        self.db.update_rows(
+                            table="instance_actions",
+                            UPDATE={("number_done" if result else "number_failed"): {"INCREMENT": 1},
+                                    "modified_at": now},
+                            WHERE={"uuid": task["instance_action_id"]})
+                    if database_update:
+                        self.db.update_rows(table=task["item"],
+                                            UPDATE=database_update,
+                                            WHERE={"uuid": task["item_id"]})
+            except db_base_Exception as e:
+                self.logger.error("Error updating database %s", str(e), exc_info=True)
+
+            if nb_created == 10:
+                break
+        return nb_processed
+
+    def _insert_pending_tasks(self, vim_actions_list):
+        now = time.time()
+        for task in vim_actions_list:
+            if task["datacenter_vim_id"] != self.datacenter_tenant_id:
+                continue
+            item = task["item"]
+            item_id = task["item_id"]
+            action_key = item + item_id
+            if action_key not in self.grouped_tasks:
+                self.grouped_tasks[action_key] = []
+            task["params"] = None
+            task["depends"] = {}
+            if task["extra"]:
+                extra = yaml.load(task["extra"])
+                task["extra"] = extra
+                task["params"] = extra.get("params")
+                depends_on_list = extra.get("depends_on")
+                if depends_on_list:
+                    for index in depends_on_list:
+                        if index < len(vim_actions_list) and vim_actions_list[index]["task_index"] == index and\
+                                    vim_actions_list[index]["instance_action_id"] == task["instance_action_id"]:
+                            task["depends"]["TASK-" + str(index)] = vim_actions_list[index]
+                if extra.get("interfaces"):
+                    task["vim_interfaces"] = {}
+            else:
+                task["extra"] = {}
+            if "error_msg" not in task:
+                task["error_msg"] = None
+            if "vim_id" not in task:
+                task["vim_id"] = None
+
+            if task["action"] == "DELETE":
+                need_delete_action = False
+                for to_supersede in self.grouped_tasks.get(action_key, ()):
+                    if to_supersede["action"] == "FIND" and to_supersede.get("vim_id"):
+                        task["vim_id"] = to_supersede["vim_id"]
+                    if to_supersede["action"] == "CREATE" and to_supersede.get("vim_id"):
+                        need_delete_action = True
+                        task["vim_id"] = to_supersede["vim_id"]
+                        if to_supersede["extra"].get("sdn_vim_id"):
+                            task["extra"]["sdn_vim_id"] = to_supersede["extra"]["sdn_vim_id"]
+                        if to_supersede["extra"].get("interfaces"):
+                            task["extra"]["interfaces"] = to_supersede["extra"]["interfaces"]
+                    # Mark task as SUPERSEDED.
+                    #   If task is in self.pending_tasks, it will be removed and database will be update
+                    #   If task is in self.refresh_tasks, it will be removed
+                    to_supersede["status"] = "SUPERSEDED"
+                if not need_delete_action:
+                    task["status"] = "SUPERSEDED"
+
+                self.grouped_tasks[action_key].append(task)
+                self.pending_tasks.append(task)
+            elif task["status"] == "SCHEDULED":
+                self.grouped_tasks[action_key].append(task)
+                self.pending_tasks.append(task)
+            elif task["action"] in ("CREATE", "FIND"):
+                self.grouped_tasks[action_key].append(task)
+                if task["status"] in ("DONE", "BUILD"):
+                    self._insert_refresh(task)
+            # TODO add VM reset, get console, etc...
+            else:
+                raise vimconn.vimconnException(self.name + "unknown vim_action action {}".format(task["action"]))
+
     def insert_task(self, task):
         try:
             self.task_queue.put(task, False)
-            return task["id"]
+            return None
         except Queue.Full:
             raise vimconn.vimconnException(self.name + ": timeout inserting a task")
 
     def del_task(self, task):
         with self.task_lock:
-            if task["status"] == "enqueued":
-                task["status"] == "deleted"
+            if task["status"] == "SCHEDULED":
+                task["status"] == "SUPERSEDED"
                 return True
             else:   # task["status"] == "processing"
                 self.task_lock.release()
@@ -349,50 +554,28 @@
     def run(self):
         self.logger.debug("Starting")
         while True:
-            #TODO reload service
+            self._reload_vim_actions()
+            reload_thread = False
             while True:
                 try:
-                    if not self.task_queue.empty():
+                    while not self.task_queue.empty():
                         task = self.task_queue.get()
-                        self.task_lock.acquire()
-                        if task["status"] == "deleted":
-                            self.task_lock.release()
-                            continue
-                        task["status"] = "processing"
-                        self.task_lock.release()
-                    else:
-                        self._refres_elements()
-                        continue
-                    self.logger.debug("processing task id={} name={} params={}".format(task["id"], task["name"],
-                                                                                       str(task["params"])))
-                    if task["name"] == 'exit' or task["name"] == 'reload':
-                        result, content = self.terminate(task)
-                    elif task["name"] == 'new-vm':
-                        result, content = self.new_vm(task)
-                    elif task["name"] == 'del-vm':
-                        result, content = self.del_vm(task)
-                    elif task["name"] == 'new-net':
-                        result, content = self.new_net(task)
-                    elif task["name"] == 'del-net':
-                        result, content = self.del_net(task)
-                    else:
-                        error_text = "unknown task {}".format(task["name"])
-                        self.logger.error(error_text)
-                        result = False
-                        content = error_text
-                    self.logger.debug("task id={} name={} result={}:{} params={}".format(task["id"], task["name"],
-                                                                                        result, content,
-                                                                                        str(task["params"])))
-
-                    with self.task_lock:
-                        task["status"] = "done" if result else "error"
-                        task["result"] = content
-                    self.task_queue.task_done()
-
-                    if task["name"] == 'exit':
-                        return 0
-                    elif task["name"] == 'reload':
+                        if isinstance(task, list):
+                            self._insert_pending_tasks(task)
+                        elif isinstance(task, str):
+                            if task == 'exit':
+                                return 0
+                            elif task == 'reload':
+                                reload_thread = True
+                                break
+                        self.task_queue.task_done()
+                    if reload_thread:
                         break
+                    nb_processed = self._proccess_pending_tasks()
+                    nb_processed += self._refres_elements()
+                    if not nb_processed:
+                        time.sleep(1)
+
                 except Exception as e:
                     self.logger.critical("Unexpected exception at run: " + str(e), exc_info=True)
 
@@ -401,6 +584,26 @@
     def terminate(self, task):
         return True, None
 
+    def _look_for_task(self, instance_action_id, task_id):
+        task_index = task_id.split("-")[-1]
+        with self.db_lock:
+            tasks = self.db.get_rows(FROM="vim_actions", WHERE={"instance_action_id": instance_action_id,
+                                                                 "task_index": task_index})
+        if not tasks:
+            return None
+        task = tasks[0]
+        task["params"] = None
+        task["depends"] = {}
+        if task["extra"]:
+            extra = yaml.load(task["extra"])
+            task["extra"] = extra
+            task["params"] = extra.get("params")
+            if extra.get("interfaces"):
+                task["vim_interfaces"] = {}
+        else:
+            task["extra"] = {}
+        return task
+
     def _format_vim_error_msg(self, error_text, max_length=1024):
         if error_text and len(error_text) >= max_length:
             return error_text[:max_length//2-3] + " ... " + error_text[-max_length//2+3:]
@@ -408,9 +611,9 @@
 
     def new_net(self, task):
         try:
-            task_id = task["id"]
+            task_id = task["instance_action_id"] + "." + str(task["task_index"])
             params = task["params"]
-            net_id = self.vim.new_network(*params)
+            vim_net_id = self.vim.new_network(*params)
 
             net_name = params[0]
             net_type = params[1]
@@ -421,7 +624,7 @@
             if sdn_controller and (net_type == "data" or net_type == "ptp"):
                 network = {"name": net_name, "type": net_type, "region": self.vim["config"]["datacenter_id"]}
 
-                vim_net = self.vim.get_network(net_id)
+                vim_net = self.vim.get_network(vim_net_id)
                 if vim_net.get('encapsulation') != 'vlan':
                     raise vimconn.vimconnException(
                         "net '{}' defined as type '{}' has not vlan encapsulation '{}'".format(
@@ -432,165 +635,170 @@
                         sdn_net_id = self.ovim.new_network(network)
                 except (ovimException, Exception) as e:
                     self.logger.error("task=%s cannot create SDN network vim_net_id=%s input='%s' ovimException='%s'",
-                                      str(task_id), net_id, str(network), str(e))
-            with self.db_lock:
-                self.db.update_rows("instance_nets", UPDATE={"vim_net_id": net_id, "sdn_net_id": sdn_net_id},
-                                    WHERE={"vim_net_id": task_id})
-            new_refresh_task = {"status": "enqueued",
-                                "id": task_id,
-                                "name": "get-net",
-                                "vim_id": net_id,
-                                "vim_info": {} }
-            self._insert_refresh(new_refresh_task, time.time())
-            return True, net_id
-        except db_base_Exception as e:
-            self.logger.error("Error updating database %s", str(e))
-            return True, net_id
+                                      str(task_id), vim_net_id, str(network), str(e))
+            task["status"] = "DONE"
+            task["extra"]["vim_info"] = {}
+            task["extra"]["sdn_net_id"] = sdn_net_id
+            task["error_msg"] = None
+            task["vim_id"] = vim_net_id
+            instance_element_update = {"vim_net_id": vim_net_id, "sdn_net_id": sdn_net_id, "status": "BUILD", "error_msg": None}
+            return True, instance_element_update
         except vimconn.vimconnException as e:
             self.logger.error("Error creating NET, task=%s: %s", str(task_id), str(e))
-            try:
-                with self.db_lock:
-                    self.db.update_rows("instance_nets",
-                                        UPDATE={"error_msg": self._format_vim_error_msg(str(e)), "status": "VIM_ERROR"},
-                                        WHERE={"vim_net_id": task_id})
-            except db_base_Exception as e:
-                self.logger.error("Error updating database %s", str(e))
-            return False, str(e)
-        #except ovimException as e:
-        #    self.logger.error("Error creating NET in ovim, task=%s: %s", str(task_id), str(e))
-        #    return False, str(e)
+            task["status"] = "FAILED"
+            task["vim_id"] = None
+            task["error_msg"] = self._format_vim_error_msg(str(e))
+            instance_element_update = {"vim_net_id": None, "sdn_net_id": None, "status": "VIM_ERROR", "error_msg": task["error_msg"]}
+            return False, instance_element_update
 
     def new_vm(self, task):
         try:
             params = task["params"]
-            task_id = task["id"]
+            task_id = task["instance_action_id"] + "." + str(task["task_index"])
             depends = task.get("depends")
             net_list = params[5]
             error_text = ""
             for net in net_list:
                 if "net_id" in net and is_task_id(net["net_id"]):  # change task_id into network_id
-                    try:
+                    if net["net_id"] in depends:
                         task_net = depends[net["net_id"]]
-                        with self.task_lock:
-                            if task_net["status"] == "error":
-                                error_text = "Cannot create VM because depends on a network that cannot be created: " +\
-                                       str(task_net["result"])
-                                break
-                            elif task_net["status"] == "enqueued" or task_net["status"] == "processing":
-                                error_text = "Cannot create VM because depends on a network still not created"
-                                break
-                            network_id = task_net["result"]
-                        net["net_id"] = network_id
-                    except Exception as e:
-                        error_text = "Error trying to map from task_id={} to task result: {}".format(
-                            net["net_id"],str(e))
-                        break
-            if not error_text:
-                vm_id = self.vim.new_vminstance(*params)
-            try:
-                with self.db_lock:
-                    if error_text:
-                        update = self.db.update_rows("instance_vms",
-                                                     UPDATE={"status": "VIM_ERROR", "error_msg": error_text},
-                                                     WHERE={"vim_vm_id": task_id})
                     else:
-                        update = self.db.update_rows("instance_vms", UPDATE={"vim_vm_id": vm_id}, WHERE={"vim_vm_id": task_id})
-                    if not update:
-                        self.logger.error("task id={} name={} database not updated vim_vm_id={}".format(
-                            task["id"], task["name"], vm_id))
-            except db_base_Exception as e:
-                self.logger.error("Error updating database %s", str(e))
-            if error_text:
-                return False, error_text
-            new_refresh_task = {"status": "enqueued",
-                                "id": task_id,
-                                "name": "get-vm",
-                                "vim_id": vm_id,
-                                "vim_info": {"interfaces":[]} }
-            self._insert_refresh(new_refresh_task, time.time())
-            return True, vm_id
-        except vimconn.vimconnException as e:
-            self.logger.error("Error creating VM, task=%s: %s", str(task_id), str(e))
-            try:
+                        task_net = self._look_for_task(task["instance_action_id"], net["net_id"])
+                    if not task_net:
+                        raise VimThreadException(
+                            "Error trying to get depending task from task_index={}".format(net["net_id"]))
+                    network_id = task_net.get("vim_id")
+                    if not network_id:
+                        raise VimThreadException(
+                            "Cannot create VM because depends on a network not created or found: " +
+                            str(task_net["error_msg"]))
+                    net["net_id"] = network_id
+            vim_vm_id = self.vim.new_vminstance(*params)
+
+            # fill task_interfaces. Look for snd_net_id at database for each interface
+            task_interfaces = {}
+            for iface in net_list:
+                task_interfaces[iface["vim_id"]] = {"iface_id": iface["uuid"]}
                 with self.db_lock:
-                    self.db.update_rows("instance_vms",
-                                        UPDATE={"error_msg": self._format_vim_error_msg(str(e)), "status": "VIM_ERROR"},
-                                        WHERE={"vim_vm_id": task_id})
-            except db_base_Exception as edb:
-                self.logger.error("Error updating database %s", str(edb))
-            return False, str(e)
+                    result = self.db.get_rows(SELECT=('sdn_net_id',),
+                        FROM='instance_nets as ine join instance_interfaces as ii on ii.instance_net_id=ine.uuid',
+                        WHERE={'ii.uuid': iface["uuid"]})
+                if result:
+                    task_interfaces[iface["vim_id"]]["sdn_net_id"] = result[0]['sdn_net_id']
+                else:
+                    self.logger.critical("Error creating VM, task=%s Network {} not found at DB", task_id,
+                                         iface["uuid"], exc_info=True)
+
+            task["vim_info"] = {}
+            task["vim_interfaces"] = {}
+            task["extra"]["interfaces"] = task_interfaces
+            task["error_msg"] = None
+            task["status"] = "DONE"
+            task["vim_id"] = vim_vm_id
+            instance_element_update = {"status": "BUILD", "vim_vm_id": vim_vm_id, "error_msg": None}
+            return True, instance_element_update
+
+        except (vimconn.vimconnException, VimThreadException) as e:
+            self.logger.error("Error creating VM, task=%s: %s", task_id, str(e))
+            error_text = self._format_vim_error_msg(str(e))
+            task["error_msg"] = error_text
+            task["status"] = "FAILED"
+            task["vim_id"] = None
+            instance_element_update = {"status": "VIM_ERROR", "vim_vm_id": None, "error_msg": error_text}
+            return False, instance_element_update
 
     def del_vm(self, task):
-        vm_id = task["params"][0]
-        interfaces = task["params"][1]
-        if is_task_id(vm_id):
-            try:
-                task_create = task["depends"][vm_id]
-                with self.task_lock:
-                    if task_create["status"] == "error":
-                        return True, "VM was not created. It has error: " + str(task_create["result"])
-                    elif task_create["status"] == "enqueued" or task_create["status"] == "processing":
-                        return False, "Cannot delete VM vim_id={} because still creating".format(vm_id)
-                    vm_id = task_create["result"]
-            except Exception as e:
-                return False, "Error trying to get task_id='{}':".format(vm_id, str(e))
+        vm_vim_id = task["vim_id"]
+        interfaces = task["extra"].get("interfaces", ())
         try:
-            self._remove_refresh("get-vm", vm_id)
-            for iface in interfaces:
+            for iface in interfaces.values():
                 if iface.get("sdn_port_id"):
                     try:
                         with self.db_lock:
                             self.ovim.delete_port(iface["sdn_port_id"])
                     except ovimException as e:
                         self.logger.error("ovimException deleting external_port={} at VM vim_id={} deletion ".format(
-                            iface["sdn_port_id"], vm_id) + str(e), exc_info=True)
+                            iface["sdn_port_id"], vm_vim_id) + str(e), exc_info=True)
                         # TODO Set error_msg at instance_nets
 
-            return True, self.vim.delete_vminstance(vm_id)
+            self.vim.delete_vminstance(vm_vim_id)
+            task["status"] = "DONE"
+            task["error_msg"] = None
+            return True, None
+
         except vimconn.vimconnException as e:
-            return False, str(e)
+            task["error_msg"] = self._format_vim_error_msg(str(e))
+            if isinstance(e, vimconn.vimconnNotFoundException):
+                # If not found mark as Done and fill error_msg
+                task["status"] = "DONE"
+                return True, None
+            task["status"] = "FAILED"
+            return False, None
 
     def del_net(self, task):
-        net_id = task["params"][0]
-        sdn_net_id = task["params"][1]
-        if is_task_id(net_id):
-            try:
-                task_create = task["depends"][net_id]
-                with self.task_lock:
-                    if task_create["status"] == "error":
-                        return True, "net was not created. It has error: " + str(task_create["result"])
-                    elif task_create["status"] == "enqueued" or task_create["status"] == "processing":
-                        return False, "Cannot delete net because still creating"
-                    net_id = task_create["result"]
-            except Exception as e:
-                return False, "Error trying to get task_id='{}':".format(net_id, str(e))
+        net_vim_id = task["vim_id"]
+        sdn_net_id = task["extra"].get("sdn_net_id")
         try:
-            self._remove_refresh("get-net", net_id)
-            result = self.vim.delete_network(net_id)
             if sdn_net_id:
-                # Delete any attached port to this sdn network
-                # At this point, there will be ports associated to this network in case it was manually done using 'openmano vim-net-sdn-attach'
-                try:
-                    with self.db_lock:
-                        port_list = self.ovim.get_ports(columns={'uuid'}, filter={'name': 'external_port', 'net_id': sdn_net_id})
-                except ovimException as e:
-                    raise vimconn.vimconnException(
-                        "ovimException obtaining external ports for net {}. ".format(sdn_net_id) + str(e))
-
-                for port in port_list:
-                    try:
-                        with self.db_lock:
-                            self.ovim.delete_port(port['uuid'])
-                    except ovimException as e:
-                        raise vimconn.vimconnException(
-                            "ovimException deleting port {} for net {}. ".format(port['uuid'], sdn_net_id) + str(e))
+                # Delete any attached port to this sdn network. There can be ports associated to this network in case
+                # it was manually done using 'openmano vim-net-sdn-attach'
                 with self.db_lock:
+                    port_list = self.ovim.get_ports(columns={'uuid'},
+                                                    filter={'name': 'external_port', 'net_id': sdn_net_id})
+                    for port in port_list:
+                        self.ovim.delete_port(port['uuid'])
                     self.ovim.delete_network(sdn_net_id)
-            return True, result
-        except vimconn.vimconnException as e:
-            return False, str(e)
+            self.vim.delete_network(net_vim_id)
+            task["status"] = "DONE"
+            task["error_msg"] = None
+            return True, None
         except ovimException as e:
-            logging.error("Error deleting network from ovim. net_id: {}, sdn_net_id: {}".format(net_id, sdn_net_id))
-            return False, str(e)
+            task["error_msg"] = self._format_vim_error_msg("ovimException obtaining and deleting external "
+                                                           "ports for net {}: {}".format(sdn_net_id, str(e)))
+        except vimconn.vimconnException as e:
+            task["error_msg"] = self._format_vim_error_msg(str(e))
+            if isinstance(e, vimconn.vimconnNotFoundException):
+                # If not found mark as Done and fill error_msg
+                task["status"] = "DONE"
+                return True, None
+        task["status"] = "FAILED"
+        return False, None
 
+    def get_net(self, task):
+        try:
+            task_id = task["instance_action_id"] + "." + str(task["task_index"])
+            params = task["params"]
+            filter = params[0]
+            vim_nets = self.vim.get_network_list(filter)
+            if not vim_nets:
+                raise VimThreadException("Network not found with this criteria: '{}'".format(filter))
+            elif len(vim_nets) > 1:
+                raise VimThreadException("More than one network found with this criteria: '{}'".format(filter))
+            vim_net_id = vim_nets[0]["id"]
 
+            # Discover if this network is managed by a sdn controller
+            sdn_net_id = None
+            with self.db_lock:
+                result = self.db.get_rows(SELECT=('sdn_net_id',), FROM='instance_nets',
+                    WHERE={'vim_net_id': vim_net_id, 'instance_scenario_id': None,
+                           'datacenter_tenant_id': self.datacenter_tenant_id})
+            if result:
+                sdn_net_id = result[0]['sdn_net_id']
+
+            task["status"] = "DONE"
+            task["extra"]["vim_info"] = {}
+            task["extra"]["created"] = False
+            task["extra"]["sdn_net_id"] = sdn_net_id
+            task["error_msg"] = None
+            task["vim_id"] = vim_net_id
+            instance_element_update = {"vim_net_id": vim_net_id, "created": False, "status": "BUILD",
+                                       "error_msg": None}
+            return True, instance_element_update
+        except (vimconn.vimconnException, VimThreadException) as e:
+            self.logger.error("Error looking for  NET, task=%s: %s", str(task_id), str(e))
+            task["status"] = "FAILED"
+            task["vim_id"] = None
+            task["error_msg"] = self._format_vim_error_msg(str(e))
+            instance_element_update = {"vim_net_id": None, "status": "VIM_ERROR",
+                                       "error_msg": task["error_msg"]}
+            return False, instance_element_update