X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_ro%2Fvim_thread.py;h=7e31f09f066774875f5ef8ff8c789ba278e6b287;hb=20a608ce0d4a849f30d7125cf1dd63e81dc8cccc;hp=ce0fc7f585d70d283a954d00067d320dd919159f;hpb=56d877dad3d7ce6a36e233a77d1ee7dc8295e233;p=osm%2FRO.git diff --git a/osm_ro/vim_thread.py b/osm_ro/vim_thread.py index ce0fc7f5..7e31f09f 100644 --- a/osm_ro/vim_thread.py +++ b/osm_ro/vim_thread.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- ## -# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U. +# Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U. # This file is part of openvim # All Rights Reserved. # @@ -37,6 +37,7 @@ The task content is (M: stored at memory, D: stored at database): params: list with the params to be sent to the VIM for CREATE or FIND. For DELETE the vim_id is taken from other related tasks find: (only for CREATE tasks) if present it should FIND before creating and use if existing. Contains the FIND params depends_on: list with the 'task_index'es of tasks that must be completed before. e.g. a vm creation depends on a net creation + can contain an int (single index on the same instance-action) or str (compete action ID) sdn_net_id: used for net. tries: interfaces: used for VMs. Each key is the uuid of the instance_interfaces entry at database @@ -61,13 +62,26 @@ import time import Queue import logging import vimconn +import vimconn_openvim +import vimconn_aws +import vimconn_opennebula +import vimconn_openstack +import vimconn_vmware import yaml from db_base import db_base_Exception from lib_osm_openvim.ovim import ovimException +from copy import deepcopy __author__ = "Alfonso Tierno, Pablo Montes" __date__ = "$28-Sep-2017 12:07:15$" +vim_module = { + "openvim": vimconn_openvim, + "aws": vimconn_aws, + "opennebula": vimconn_opennebula, + "openstack": vimconn_openstack, + "vmware": vimconn_vmware, +} def is_task_id(task_id): return task_id.startswith("TASK-") @@ -85,7 +99,7 @@ class vim_thread(threading.Thread): REFRESH_BUILD = 5 # 5 seconds REFRESH_ACTIVE = 60 # 1 minute - def __init__(self, myvimconn, task_lock, name=None, datacenter_name=None, datacenter_tenant_id=None, + def __init__(self, task_lock, name=None, datacenter_name=None, datacenter_tenant_id=None, db=None, db_lock=None, ovim=None): """Init a thread. Arguments: @@ -95,12 +109,8 @@ class vim_thread(threading.Thread): 'db', 'db_lock': database class and lock to use it in exclusion """ threading.Thread.__init__(self) - if isinstance(myvimconn, vimconn.vimconnException): - self.vim = None - self.error_status = "Error accesing to VIM: {}".format(myvimconn) - else: - self.vim = myvimconn - self.error_status = None + self.vim = None + self.error_status = None self.datacenter_name = datacenter_name self.datacenter_tenant_id = datacenter_tenant_id self.ovim = ovim @@ -108,6 +118,7 @@ class vim_thread(threading.Thread): self.name = vimconn["id"] + "." + vimconn["config"]["datacenter_tenant_id"] else: self.name = name + self.vim_persistent_info = {} self.logger = logging.getLogger('openmano.vim.'+self.name) self.db = db @@ -129,6 +140,38 @@ class vim_thread(threading.Thread): # e.g. DELETE task """ + def get_vimconnector(self): + try: + from_= "datacenter_tenants as dt join datacenters as d on dt.datacenter_id=d.uuid" + select_ = ('type', 'd.config as config', 'd.uuid as datacenter_id', 'vim_url', 'vim_url_admin', + 'd.name as datacenter_name', 'dt.uuid as datacenter_tenant_id', + 'dt.vim_tenant_name as vim_tenant_name', 'dt.vim_tenant_id as vim_tenant_id', + 'user', 'passwd', 'dt.config as dt_config') + where_ = {"dt.uuid": self.datacenter_tenant_id} + with self.db_lock: + vims = self.db.get_rows(FROM=from_, SELECT=select_, WHERE=where_) + vim = vims[0] + vim_config = {} + if vim["config"]: + vim_config.update(yaml.load(vim["config"])) + if vim["dt_config"]: + vim_config.update(yaml.load(vim["dt_config"])) + vim_config['datacenter_tenant_id'] = vim.get('datacenter_tenant_id') + vim_config['datacenter_id'] = vim.get('datacenter_id') + + self.vim = vim_module[vim["type"]].vimconnector( + uuid=vim['datacenter_id'], name=vim['datacenter_name'], + tenant_id=vim['vim_tenant_id'], tenant_name=vim['vim_tenant_name'], + url=vim['vim_url'], url_admin=vim['vim_url_admin'], + user=vim['user'], passwd=vim['passwd'], + config=vim_config, persistent_info=self.vim_persistent_info + ) + self.error_status = None + except Exception as e: + self.logger.error("Cannot load vimconnector for vim_account {}: {}".format(self.datacenter_tenant_id, e)) + self.vim = None + self.error_status = "Error loading vimconnector: {}".format(e) + def _reload_vim_actions(self): """ Read actions from database and reload them at memory. Fill self.refresh_list, pending_list, vim_actions @@ -223,11 +266,17 @@ class vim_thread(threading.Thread): 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 + if task["vim_id"] not in vm_to_refresh_dict: + vm_to_refresh_dict[task["vim_id"]] = [task] + vm_to_refresh_list.append(task["vim_id"]) + else: + vm_to_refresh_dict[task["vim_id"]].append(task) elif task["item"] == 'instance_nets': - net_to_refresh_list.append(task["vim_id"]) - net_to_refresh_dict[task["vim_id"]] = task + if task["vim_id"] not in net_to_refresh_dict: + net_to_refresh_dict[task["vim_id"]] = [task] + net_to_refresh_list.append(task["vim_id"]) + else: + net_to_refresh_dict[task["vim_id"]].append(task) else: task_id = task["instance_action_id"] + "." + str(task["task_index"]) self.logger.critical("task={}: unknown task {}".format(task_id, task["item"]), exc_info=True) @@ -247,111 +296,112 @@ class vim_thread(threading.Thread): vim_dict[vim_id] = {"status": "VIM_ERROR", "error_msg": str(e)} for vim_id, vim_info in vim_dict.items(): - # look for task - task_need_update = False - task = vm_to_refresh_dict[vim_id] - task_id = task["instance_action_id"] + "." + str(task["task_index"]) - self.logger.debug("task={} get-VM: vim_vm_id={} result={}".format(task_id, task["vim_id"], vim_info)) - - # check and update interfaces - task_warning_msg = "" - 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("task={} get-VM: Interface not found {} on task info {}".format( - task_id, 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: - error_text = "ovimException deleting external_port={}: {}".format( - task_interface["sdn_port_id"], e) - self.logger.error("task={} get-VM: {}".format(task_id, error_text), exc_info=True) - task_warning_msg += error_text - # TODO Set error_msg at instance_nets instead of instance VMs - - # 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: - 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: - error_text = "ovimException creating new_external_port compute_node={}"\ - " pci={} vlan={} {}".format( - interface["compute_node"], - interface["pci"], - interface.get("vlan"), e) - self.logger.error("task={} get-VM: {}".format(task_id, error_text), exc_info=True) - task_warning_msg += error_text - # TODO Set error_msg at instance_nets instead of instance VMs + # look for task + for task in vm_to_refresh_dict[vim_id]: + task_need_update = False + task_id = task["instance_action_id"] + "." + str(task["task_index"]) + self.logger.debug("task={} get-VM: vim_vm_id={} result={}".format(task_id, task["vim_id"], vim_info)) + + # check and update interfaces + task_warning_msg = "" + 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("task={} get-VM: Interface not found {} on task info {}".format( + task_id, 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"], idempotent=True) + task_interface["sdn_port_id"] = None + task_need_update = True + except ovimException as e: + error_text = "ovimException deleting external_port={}: {}".format( + task_interface["sdn_port_id"], e) + self.logger.error("task={} get-VM: {}".format(task_id, error_text), exc_info=True) + task_warning_msg += error_text + # TODO Set error_msg at instance_nets instead of instance VMs + + # 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: + 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: + error_text = "ovimException creating new_external_port compute_node={}"\ + " pci={} vlan={} {}".format( + interface["compute_node"], + interface["pci"], + interface.get("vlan"), e) + self.logger.error("task={} get-VM: {}".format(task_id, error_text), exc_info=True) + task_warning_msg += error_text + # TODO Set error_msg at instance_nets instead of instance VMs + + 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 + + # check and update task and instance_vms database + vim_info_error_msg = None + if vim_info.get("error_msg"): + vim_info_error_msg = self._format_vim_error_msg(vim_info["error_msg"] + task_warning_msg) + elif task_warning_msg: + vim_info_error_msg = self._format_vim_error_msg(task_warning_msg) + task_vim_info = task.get("vim_info") + task_error_msg = task.get("error_msg") + task_vim_status = task["extra"].get("vim_status") + if task_vim_status != vim_info["status"] or task_error_msg != vim_info_error_msg or \ + (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]): + temp_dict = {"status": vim_info["status"], "error_msg": vim_info_error_msg} + if vim_info.get("vim_info"): + temp_dict["vim_info"] = vim_info["vim_info"] + with self.db_lock: + 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_error_msg + if vim_info.get("vim_info"): + task["vim_info"] = vim_info["vim_info"] + task_need_update = True + + if task_need_update: 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 - - # check and update task and instance_vms database - if vim_info.get("error_msg"): - vim_info["error_msg"] = self._format_vim_error_msg(vim_info["error_msg"] + task_warning_msg) - elif task_warning_msg: - vim_info["error_msg"] = self._format_vim_error_msg(task_warning_msg) - - task_vim_info = task.get("vim_info") - task_error_msg = task.get("error_msg") - task_vim_status = task["extra"].get("vim_status") - if task_vim_status != vim_info["status"] or task_error_msg != vim_info.get("error_msg") or \ - (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]): - temp_dict = {"status": vim_info["status"], "error_msg": vim_info.get("error_msg")} - if vim_info.get("vim_info"): - temp_dict["vim_info"] = vim_info["vim_info"] - with self.db_lock: - 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") - if vim_info.get("vim_info"): - task["vim_info"] = vim_info["vim_info"] - task_need_update = True - - 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) + '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) if net_to_refresh_list: now = time.time() @@ -366,60 +416,62 @@ class vim_thread(threading.Thread): for vim_id, vim_info in vim_dict.items(): # look for task - task = net_to_refresh_dict[vim_id] - task_id = task["instance_action_id"] + "." + str(task["task_index"]) - self.logger.debug("task={} get-net: vim_net_id={} result={}".format(task_id, task["vim_id"], vim_info)) - - 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") - - # get ovim status - if task_sdn_net_id: - try: + for task in net_to_refresh_dict[vim_id]: + task_id = task["instance_action_id"] + "." + str(task["task_index"]) + self.logger.debug("task={} get-net: vim_net_id={} result={}".format(task_id, task["vim_id"], vim_info)) + + 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") + + vim_info_status = vim_info["status"] + vim_info_error_msg = vim_info.get("error_msg") + # get ovim status + if task_sdn_net_id: + try: + with self.db_lock: + sdn_net = self.ovim.show_network(task_sdn_net_id) + except (ovimException, Exception) as e: + text_error = "ovimException getting network snd_net_id={}: {}".format(task_sdn_net_id, e) + self.logger.error("task={} get-net: {}".format(task_id, text_error), exc_info=True) + sdn_net = {"status": "ERROR", "last_error": text_error} + if sdn_net["status"] == "ERROR": + if not vim_info_error_msg: + vim_info_error_msg = str(sdn_net.get("last_error")) + 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["last_error"], 1024//2-14)) + vim_info_status = "ERROR" + elif sdn_net["status"] == "BUILD": + if vim_info_status == "ACTIVE": + vim_info_status = "BUILD" + + # update database + if vim_info_error_msg: + vim_info_error_msg = self._format_vim_error_msg(vim_info_error_msg) + if task_vim_status != vim_info_status or task_error_msg != vim_info_error_msg or \ + (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]): + task["extra"]["vim_status"] = vim_info_status + task["error_msg"] = vim_info_error_msg + if vim_info.get("vim_info"): + task["vim_info"] = vim_info["vim_info"] + temp_dict = {"status": vim_info_status, "error_msg": vim_info_error_msg} + if vim_info.get("vim_info"): + temp_dict["vim_info"] = vim_info["vim_info"] with self.db_lock: - sdn_net = self.ovim.show_network(task_sdn_net_id) - except (ovimException, Exception) as e: - text_error = "ovimException getting network snd_net_id={}: {}".format(task_sdn_net_id, e) - self.logger.error("task={} get-net: {}".format(task_id, text_error), exc_info=True) - sdn_net = {"status": "ERROR", "error_msg": text_error} - 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" - - # update database - if vim_info.get("error_msg"): - vim_info["error_msg"] = self._format_vim_error_msg(vim_info["error_msg"]) - if task_vim_status != vim_info["status"] or task_error_msg != vim_info.get("error_msg") or \ - (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]): - task["extra"]["vim_status"] = vim_info["status"] - task["error_msg"] = vim_info.get("error_msg") - if vim_info.get("vim_info"): - task["vim_info"] = vim_info["vim_info"] - temp_dict = {"status": vim_info["status"], "error_msg": vim_info.get("error_msg")} - if vim_info.get("vim_info"): - temp_dict["vim_info"] = vim_info["vim_info"] - 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) + 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) return nb_processed @@ -473,7 +525,7 @@ class vim_thread(threading.Thread): for task_index in task["extra"].get("depends_on", ()): task_dependency = task["depends"].get("TASK-" + str(task_index)) if not task_dependency: - task_dependency = self._look_for_task(task["instance_action_id"], "TASK-" + str(task_index)) + task_dependency = self._look_for_task(task["instance_action_id"], task_index) if not task_dependency: raise VimThreadException( "Cannot get depending net task trying to get depending task {}.{}".format( @@ -484,11 +536,11 @@ class vim_thread(threading.Thread): break elif task_dependency["status"] == "FAILED": raise VimThreadException( - "Cannot {} {}, (task {}.{}) because depends on failed {} {}, (task{}.{})".format( + "Cannot {} {}, (task {}.{}) because depends on failed {}.{}, (task{}.{}): {}".format( task["action"], task["item"], task["instance_action_id"], task["task_index"], task_dependency["instance_action_id"], task_dependency["task_index"], - task_dependency["action"], task_dependency["item"])) + task_dependency["action"], task_dependency["item"], task_dependency.get("error_msg"))) if dependency_not_completed: # Move this task to the end. task["extra"]["tries"] = task["extra"].get("tries", 0) + 1 @@ -530,6 +582,38 @@ class vim_thread(threading.Thread): result, database_update = self.get_net(task) else: raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"])) + elif task["item"] == 'instance_sfis': + if task["action"] == "CREATE": + result, database_update = self.new_sfi(task) + nb_created += 1 + elif task["action"] == "DELETE": + result, database_update = self.del_sfi(task) + else: + raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"])) + elif task["item"] == 'instance_sfs': + if task["action"] == "CREATE": + result, database_update = self.new_sf(task) + nb_created += 1 + elif task["action"] == "DELETE": + result, database_update = self.del_sf(task) + else: + raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"])) + elif task["item"] == 'instance_classifications': + if task["action"] == "CREATE": + result, database_update = self.new_classification(task) + nb_created += 1 + elif task["action"] == "DELETE": + result, database_update = self.del_classification(task) + else: + raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"])) + elif task["item"] == 'instance_sfps': + if task["action"] == "CREATE": + result, database_update = self.new_sfp(task) + nb_created += 1 + elif task["action"] == "DELETE": + result, database_update = self.del_sfp(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 @@ -543,11 +627,14 @@ class vim_thread(threading.Thread): elif task["item"] == 'instance_nets': database_update["vim_net_id"] = None + no_refresh_tasks = ['instance_sfis', 'instance_sfs', + 'instance_classifications', 'instance_sfps'] if 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) + if task["item"] not in no_refresh_tasks: + self._insert_refresh(task) task_id = task["instance_action_id"] + "." + str(task["task_index"]) self.logger.debug("task={} item={} action={} result={}:'{}' params={}".format( @@ -596,10 +683,19 @@ class vim_thread(threading.Thread): task["params"] = extra.get("params") depends_on_list = extra.get("depends_on") if depends_on_list: - for index in depends_on_list: + for dependency_task in depends_on_list: + if isinstance(dependency_task, int): + index = dependency_task + else: + instance_action_id, _, task_id = dependency_task.rpartition(".") + if instance_action_id != task["instance_action_id"]: + continue + index = int(task_id) + 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] + task["depends"]["TASK-" + str(index)] = vim_actions_list[index] + task["depends"]["TASK-{}.{}".format(task["instance_action_id"], index)] = vim_actions_list[index] if extra.get("interfaces"): task["vim_interfaces"] = {} else: @@ -665,6 +761,8 @@ class vim_thread(threading.Thread): def run(self): self.logger.debug("Starting") while True: + self.get_vimconnector() + self.logger.debug("Vimconnector loaded") self._reload_vim_actions() reload_thread = False @@ -694,7 +792,24 @@ class vim_thread(threading.Thread): self.logger.debug("Finishing") def _look_for_task(self, instance_action_id, task_id): - task_index = task_id.split("-")[-1] + """ + Look for a concrete task at vim_actions database table + :param instance_action_id: The instance_action_id + :param task_id: Can have several formats: + : integer + TASK- :backward compatibility, + [TASK-].: this instance_action_id overrides the one in the parameter + :return: Task dictionary or None if not found + """ + if isinstance(task_id, int): + task_index = task_id + else: + if task_id.startswith("TASK-"): + task_id = task_id[5:] + ins_action_id, _, task_index = task_id.rpartition(".") + if ins_action_id: + instance_action_id = ins_action_id + with self.db_lock: tasks = self.db.get_rows(FROM="vim_actions", WHERE={"instance_action_id": instance_action_id, "task_index": task_index}) @@ -740,11 +855,12 @@ class vim_thread(threading.Thread): "Cannot create VM because depends on a network not created or found: " + str(depends[net["net_id"]]["error_msg"])) net["net_id"] = network_id - vim_vm_id, created_items = self.vim.new_vminstance(*params) + params_copy = deepcopy(params) + vim_vm_id, created_items = self.vim.new_vminstance(*params_copy) # fill task_interfaces. Look for snd_net_id at database for each interface task_interfaces = {} - for iface in net_list: + for iface in params_copy[5]: task_interfaces[iface["vim_id"]] = {"iface_id": iface["uuid"]} with self.db_lock: result = self.db.get_rows( @@ -786,7 +902,7 @@ class vim_thread(threading.Thread): if iface.get("sdn_port_id"): try: with self.db_lock: - self.ovim.delete_port(iface["sdn_port_id"]) + self.ovim.delete_port(iface["sdn_port_id"], idempotent=True) except ovimException as e: self.logger.error("task={} del-VM: ovimException when deleting external_port={}: {} ".format( task_id, iface["sdn_port_id"], e), exc_info=True) @@ -825,8 +941,9 @@ class vim_thread(threading.Thread): 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}) + WHERE={'vim_net_id': vim_net_id, + 'datacenter_tenant_id': self.datacenter_tenant_id}, + ORDER="instance_scenario_id") if result: sdn_net_id = result[0]['sdn_net_id'] @@ -923,8 +1040,8 @@ class vim_thread(threading.Thread): 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) + self.ovim.delete_port(port['uuid'], idempotent=True) + self.ovim.delete_network(sdn_net_id, idempotent=True) if net_vim_id: self.vim.delete_network(net_vim_id) task["status"] = "DONE" @@ -941,3 +1058,234 @@ class vim_thread(threading.Thread): return True, None task["status"] = "FAILED" return False, None + + ## Service Function Instances + + def new_sfi(self, task): + vim_sfi_id = None + try: + params = task["params"] + task_id = task["instance_action_id"] + "." + str(task["task_index"]) + depends = task.get("depends") + error_text = "" + interfaces = task.get("depends").values()[0].get("extra").get("params")[5] + # At the moment, every port associated with the VM will be used both as ingress and egress ports. + # Bear in mind that different VIM connectors might support SFI differently. In the case of OpenStack, only the + # first ingress and first egress ports will be used to create the SFI (Port Pair). + port_id_list = [interfaces[0].get("vim_id")] + name = "sfi-%s" % task["item_id"][:8] + # By default no form of IETF SFC Encapsulation will be used + vim_sfi_id = self.vim.new_sfi(name, port_id_list, port_id_list, sfc_encap=False) + + task["extra"]["created"] = True + task["error_msg"] = None + task["status"] = "DONE" + task["vim_id"] = vim_sfi_id + instance_element_update = {"status": "ACTIVE", "vim_sfi_id": vim_sfi_id, "error_msg": None} + return True, instance_element_update + + except (vimconn.vimconnException, VimThreadException) as e: + self.logger.error("Error creating Service Function Instance, 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_sfi_id": None, "error_msg": error_text} + return False, instance_element_update + + def del_sfi(self, task): + sfi_vim_id = task["vim_id"] + try: + self.vim.delete_sfi(sfi_vim_id) + task["status"] = "DONE" + task["error_msg"] = None + return True, None + + 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 new_sf(self, task): + vim_sf_id = None + try: + params = task["params"] + task_id = task["instance_action_id"] + "." + str(task["task_index"]) + depends = task.get("depends") + error_text = "" + #sfis = task.get("depends").values()[0].get("extra").get("params")[5] + sfis = task.get("depends").values() + sfi_id_list = [] + for sfi in sfis: + sfi_id_list.append(sfi.get("vim_id")) + name = "sf-%s" % task["item_id"][:8] + # By default no form of IETF SFC Encapsulation will be used + vim_sf_id = self.vim.new_sf(name, sfi_id_list, sfc_encap=False) + + task["extra"]["created"] = True + task["error_msg"] = None + task["status"] = "DONE" + task["vim_id"] = vim_sf_id + instance_element_update = {"status": "ACTIVE", "vim_sf_id": vim_sf_id, "error_msg": None} + return True, instance_element_update + + except (vimconn.vimconnException, VimThreadException) as e: + self.logger.error("Error creating Service Function, 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_sf_id": None, "error_msg": error_text} + return False, instance_element_update + + def del_sf(self, task): + sf_vim_id = task["vim_id"] + try: + self.vim.delete_sf(sf_vim_id) + task["status"] = "DONE" + task["error_msg"] = None + return True, None + + 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 new_classification(self, task): + vim_classification_id = None + try: + params = task["params"] + task_id = task["instance_action_id"] + "." + str(task["task_index"]) + depends = task.get("depends") + error_text = "" + interfaces = task.get("depends").values()[0].get("extra").get("params")[5] + # Bear in mind that different VIM connectors might support Classifications differently. + # In the case of OpenStack, only the first VNF attached to the classifier will be used + # to create the Classification(s) (the "logical source port" of the "Flow Classifier"). + # Since the VNFFG classifier match lacks the ethertype, classification defaults to + # using the IPv4 flow classifier. + name = "c-%s" % task["item_id"][:8] + # if not CIDR is given for the IP addresses, add /32: + ip_proto = int(params.get("ip_proto")) + source_ip = params.get("source_ip") + destination_ip = params.get("destination_ip") + if ip_proto == 1: + ip_proto = 'icmp' + elif ip_proto == 6: + ip_proto = 'tcp' + elif ip_proto == 17: + ip_proto = 'udp' + if '/' not in source_ip: + source_ip += '/32' + if '/' not in destination_ip: + destination_ip += '/32' + definition = { + "logical_source_port": interfaces[0].get("vim_id"), + "protocol": ip_proto, + "source_ip_prefix": source_ip, + "destination_ip_prefix": destination_ip, + "source_port_range_min": params.get("source_port"), + "source_port_range_max": params.get("source_port"), + "destination_port_range_min": params.get("destination_port"), + "destination_port_range_max": params.get("destination_port"), + } + + vim_classification_id = self.vim.new_classification( + name, 'legacy_flow_classifier', definition) + + task["extra"]["created"] = True + task["error_msg"] = None + task["status"] = "DONE" + task["vim_id"] = vim_classification_id + instance_element_update = {"status": "ACTIVE", "vim_classification_id": vim_classification_id, "error_msg": None} + return True, instance_element_update + + except (vimconn.vimconnException, VimThreadException) as e: + self.logger.error("Error creating Classification, 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_classification_id": None, "error_msg": error_text} + return False, instance_element_update + + def del_classification(self, task): + classification_vim_id = task["vim_id"] + try: + self.vim.delete_classification(classification_vim_id) + task["status"] = "DONE" + task["error_msg"] = None + return True, None + + 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 new_sfp(self, task): + vim_sfp_id = None + try: + params = task["params"] + task_id = task["instance_action_id"] + "." + str(task["task_index"]) + depends = task.get("depends") + error_text = "" + deps = task.get("depends").values() + sf_id_list = [] + classification_id_list = [] + for dep in deps: + vim_id = dep.get("vim_id") + resource = dep.get("item") + if resource == "instance_sfs": + sf_id_list.append(vim_id) + elif resource == "instance_classifications": + classification_id_list.append(vim_id) + + name = "sfp-%s" % task["item_id"][:8] + # By default no form of IETF SFC Encapsulation will be used + vim_sfp_id = self.vim.new_sfp(name, classification_id_list, sf_id_list, sfc_encap=False) + + task["extra"]["created"] = True + task["error_msg"] = None + task["status"] = "DONE" + task["vim_id"] = vim_sfp_id + instance_element_update = {"status": "ACTIVE", "vim_sfp_id": vim_sfp_id, "error_msg": None} + return True, instance_element_update + + except (vimconn.vimconnException, VimThreadException) as e: + self.logger.error("Error creating Service Function, 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_sfp_id": None, "error_msg": error_text} + return False, instance_element_update + return + + def del_sfp(self, task): + sfp_vim_id = task["vim_id"] + try: + self.vim.delete_sfp(sfp_vim_id) + task["status"] = "DONE" + task["error_msg"] = None + return True, None + + 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