self.error_status = None
self.wim_account_id = wim_account_id
self.datacenter_tenant_id = datacenter_tenant_id
- self.port_mapping = None
+ self.port_mappings = None
if self.wim_account_id:
self.target_k = "wim_account_id"
self.target_v = self.wim_account_id
})
continue
- # task of creation must be the first in the list of related_task
- assert(related_tasks[0]["action"] in ("CREATE", "FIND"))
-
task["params"] = None
if task["extra"]:
extra = yaml.load(task["extra"], Loader=yaml.Loader)
copy_to["sdn_net_id"] = copy_from["sdn_net_id"]
if copy_from.get("interfaces"):
copy_to["interfaces"] = copy_from["interfaces"]
+ if copy_from.get("sdn-ports"):
+ copy_to["sdn-ports"] = copy_from["sdn-ports"]
if copy_from.get("created_items"):
if not copy_to.get("created_items"):
copy_to["created_items"] = {}
task_create = None
dependency_task = None
- deletion_needed = False
+ deletion_needed = task["extra"].get("created", False)
if task["status"] == "FAILED":
return # TODO need to be retry??
try:
- # get all related tasks
+ # get all related tasks. task of creation must be the first in the list of related_task,
+ # unless the deletion fails and it is pendingit fails
+ # TODO this should be removed, passing related_tasks
related_tasks = self.db.get_rows(FROM="vim_wim_actions",
WHERE={self.target_k: self.target_v,
"status": ['SCHEDULED', 'BUILD', 'DONE', 'FAILED'],
break
# mark task_create as FINISHED
- self.db.update_rows("vim_wim_actions", UPDATE={"status": "FINISHED"},
- WHERE={self.target_k: self.target_v,
- "instance_action_id": task_create["instance_action_id"],
- "task_index": task_create["task_index"]
- })
+ if task_create:
+ self.db.update_rows("vim_wim_actions", UPDATE={"status": "FINISHED"},
+ WHERE={self.target_k: self.target_v,
+ "instance_action_id": task_create["instance_action_id"],
+ "task_index": task_create["task_index"]
+ })
if not deletion_needed:
- return
+ return False
elif dependency_task:
# move create information from task_create to relate_task
extra_new_created = yaml.load(dependency_task["extra"], Loader=yaml.Loader) or {}
"task_index": dependency_task["task_index"]
})
return False
- else:
+ elif task_create:
task["vim_id"] = task_create["vim_id"]
copy_extra_created(copy_to=task["extra"], copy_from=task_create["extra"])
+ # Ensure this task extra information is stored at database
+ self.db.update_rows("vim_wim_actions",
+ UPDATE={"extra": yaml.safe_dump(task["extra"], default_flow_style=True,
+ width=256)},
+ WHERE={self.target_k: self.target_v,
+ "instance_action_id": task["instance_action_id"],
+ "task_index": task["task_index"],
+ })
return True
+ return deletion_needed
except Exception as e:
self.logger.critical("Unexpected exception at _delete_task: " + str(e), exc_info=True)
old_task_status = task["status"]
create_or_find = False # if as result of processing this task something is created or found
next_refresh = 0
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
try:
if task["status"] == "SCHEDULED":
elif not self.vim and not self.sdnconnector:
task["status"] = "FAILED"
task["error_msg"] = self.error_status
- database_update = {"status": "VIM_ERROR", "error_msg": task["error_msg"]}
+ database_update = {"status": "VIM_ERROR" if self.datacenter_tenant_id else "WIM_ERROR",
+ "error_msg": task["error_msg"]}
elif task["item_id"] != related_tasks[0]["item_id"] and task["action"] in ("FIND", "CREATE"):
- # Do nothing, just copy values from one to another and updata database
+ # Do nothing, just copy values from one to another and update database
task["status"] = related_tasks[0]["status"]
task["error_msg"] = related_tasks[0]["error_msg"]
task["vim_id"] = related_tasks[0]["vim_id"]
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfis':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_sfis(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_sfi(task)
elif task["action"] == "DELETE":
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfs':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_sfs(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_sf(task)
elif task["action"] == "DELETE":
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_classifications':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_classifications(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_classification(task)
elif task["action"] == "DELETE":
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfps':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_sfps(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_sfp(task)
elif task["action"] == "DELETE":
else:
raise vimconn.vimconnException(self.name + "unknown task item {}".format(task["item"]))
# TODO
- except VimThreadException as e:
+ except Exception as e:
+ if not isinstance(e, VimThreadException):
+ self.logger.error("Error executing task={}: {}".format(task_id, e), exc_info=True)
task["error_msg"] = str(e)
task["status"] = "FAILED"
database_update = {"status": "VIM_ERROR", "error_msg": task["error_msg"]}
- if task["item"] == 'instance_vms':
- database_update["vim_vm_id"] = None
- elif task["item"] == 'instance_nets':
- database_update["vim_net_id"] = None
+ # if task["item"] == 'instance_vms':
+ # database_update["vim_vm_id"] = None
+ # elif task["item"] == 'instance_nets':
+ # database_update["vim_net_id"] = None
- task_id = task["instance_action_id"] + "." + str(task["task_index"])
self.logger.debug("task={} item={} action={} result={}:'{}' params={}".format(
task_id, task["item"], task["action"], task["status"],
task["vim_id"] if task["status"] == "DONE" else task.get("error_msg"), task["params"]))
next_refresh = time.time()
if task["extra"].get("vim_status") == "BUILD":
next_refresh += self.REFRESH_BUILD
- elif task["extra"].get("vim_status") in ("ERROR", "VIM_ERROR"):
+ elif task["extra"].get("vim_status") in ("ERROR", "VIM_ERROR", "WIM_ERROR"):
next_refresh += self.REFRESH_ERROR
elif task["extra"].get("vim_status") == "DELETED":
next_refresh += self.REFRESH_DELETE
if database_update:
where_filter = {"related": task["related"]}
if task["item"] == "instance_nets" and task["datacenter_vim_id"]:
- where_filter["datacenter_tenant_id"] = task["datacenter_vim_id"]
+ where_filter["datacenter_tenant_id"] = task["datacenter_vim_id"]
self.db.update_rows(table=task["item"],
UPDATE=database_update,
WHERE=where_filter)
except Exception as e:
if isinstance(e, SdnConnectorError) and e.http_error == HTTPStatus.NOT_FOUND.value:
pass
- else:
+ else:
self._proccess_sdn_exception(e)
params = task["params"]
# look for ports
sdn_ports = []
pending_ports = 0
+ vlan_used = None
ports = self.db.get_rows(FROM='instance_interfaces', WHERE={'instance_wim_net_id': task["item_id"]})
sdn_need_update = False
for port in ports:
+ vlan_used = port.get("vlan") or vlan_used
# TODO. Do not connect if already done
if port.get("compute_node") and port.get("pci"):
- for map in self.port_mappings:
- if map.get("device_id") == port["compute_node"] and \
- map.get("device_interface_id") == port["pci"]:
+ for pmap in self.port_mappings:
+ if pmap.get("device_id") == port["compute_node"] and \
+ pmap.get("device_interface_id") == port["pci"]:
break
else:
if self.sdnconn_config.get("mapping_not_needed"):
- map = {
+ pmap = {
"service_endpoint_id": "{}:{}".format(port["compute_node"], port["pci"]),
"service_endpoint_encapsulation_info": {
"vlan": port["vlan"],
}
}
else:
- map = None
+ pmap = None
error_list.append("Port mapping not found for compute_node={} pci={}".format(
port["compute_node"], port["pci"]))
- if map:
- if port["uuid"] not in connected_ports or port["modified_at"] > last_update:
+ if pmap:
+ if port["modified_at"] > last_update:
sdn_need_update = True
new_connected_ports.append(port["uuid"])
sdn_ports.append({
- "service_endpoint_id": map["service_endpoint_id"],
+ "service_endpoint_id": pmap["service_endpoint_id"],
"service_endpoint_encapsulation_type": "dot1q" if port["model"] == "SR-IOV" else None,
"service_endpoint_encapsulation_info": {
"vlan": port["vlan"],
"mac": port["mac_address"],
- "device_id": map.get("device_id"),
- "device_interface_id": map.get("device_interface_id"),
- "switch_dpid": map.get("switch_dpid"),
- "switch_port": map.get("switch_port"),
- "service_mapping_info": map.get("service_mapping_info"),
+ "device_id": pmap.get("device_id"),
+ "device_interface_id": pmap.get("device_interface_id"),
+ "switch_dpid": pmap.get("switch_dpid"),
+ "switch_port": pmap.get("switch_port"),
+ "service_mapping_info": pmap.get("service_mapping_info"),
}
})
if pending_ports:
error_list.append("Waiting for getting interfaces location from VIM. Obtained '{}' of {}"
.format(len(ports)-pending_ports, len(ports)))
+
+ # connect external ports
+ for index, external_port in enumerate(task["extra"].get("sdn-ports") or ()):
+ external_port_id = external_port.get("service_endpoint_id") or str(index)
+ sdn_ports.append({
+ "service_endpoint_id": external_port_id,
+ "service_endpoint_encapsulation_type": external_port.get("service_endpoint_encapsulation_type",
+ "dot1q"),
+ "service_endpoint_encapsulation_info": {
+ "vlan": external_port.get("vlan") or vlan_used,
+ "mac": external_port.get("mac_address"),
+ "device_id": external_port.get("device_id"),
+ "device_interface_id": external_port.get("device_interface_id"),
+ "switch_dpid": external_port.get("switch_dpid") or external_port.get("switch_id"),
+ "switch_port": external_port.get("switch_port"),
+ "service_mapping_info": external_port.get("service_mapping_info"),
+ }})
+ new_connected_ports.append(external_port_id)
+
# if there are more ports to connect or they have been modified, call create/update
- if sdn_need_update and len(sdn_ports) >= 2:
- if not wimconn_net_id:
- if params[0] == "data":
- net_type = "ELAN"
- elif params[0] == "ptp":
- net_type = "ELINE"
- else:
- net_type = "L3"
+ try:
+ if (set(connected_ports) != set(new_connected_ports) or sdn_need_update) and len(sdn_ports) >= 2:
+ last_update = time.time()
+ if not wimconn_net_id:
+ if params[0] == "data":
+ net_type = "ELAN"
+ elif params[0] == "ptp":
+ net_type = "ELINE"
+ else:
+ net_type = "L3"
- wimconn_net_id, created_items = self.sdnconnector.create_connectivity_service(net_type, sdn_ports)
- else:
- created_items = self.sdnconnector.edit_connectivity_service(wimconn_net_id, conn_info=created_items,
- connection_points=sdn_ports)
- last_update = time.time()
- connected_ports = new_connected_ports
- elif wimconn_net_id:
- try:
+ wimconn_net_id, created_items = self.sdnconnector.create_connectivity_service(
+ net_type, sdn_ports)
+ else:
+ created_items = self.sdnconnector.edit_connectivity_service(
+ wimconn_net_id, conn_info=created_items, connection_points=sdn_ports)
+ connected_ports = new_connected_ports
+ elif wimconn_net_id:
wim_status_dict = self.sdnconnector.get_connectivity_service_status(wimconn_net_id,
conn_info=created_items)
sdn_status = wim_status_dict["sdn_status"]
error_list.append(wim_status_dict.get("error_msg"))
if wim_status_dict.get("sdn_info"):
sdn_info = str(wim_status_dict.get("sdn_info"))
- except Exception as e:
- self._proccess_sdn_exception(e)
+ except Exception as e:
+ self._proccess_sdn_exception(e)
task["status"] = "DONE"
task["extra"]["vim_info"] = {}
# task["extra"]["sdn_net_id"] = sdn_net_id
- task["extra"]["vim_status"] = "BUILD"
+ task["extra"]["vim_status"] = sdn_status
task["extra"]["created"] = True
task["extra"]["created_items"] = created_items
task["extra"]["connected_ports"] = connected_ports
# task["extra"]["sdn_net_id"] = sdn_net_id
instance_element_update = {"wim_internal_id": wimconn_net_id, "status": "WIM_ERROR",
"error_msg": task["error_msg"]}
+
if sdn_info:
instance_element_update["wim_info"] = sdn_info
return instance_element_update
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_sfi_id
instance_element_update = {"status": "ACTIVE", "vim_sfi_id": vim_sfi_id, "error_msg": None}
return instance_element_update
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_sf_id
instance_element_update = {"status": "ACTIVE", "vim_sf_id": vim_sf_id, "error_msg": None}
return instance_element_update
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_classification_id
instance_element_update = {"status": "ACTIVE", "vim_classification_id": vim_classification_id,
"error_msg": None}
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_sfp_id
instance_element_update = {"status": "ACTIVE", "vim_sfp_id": vim_sfp_id, "error_msg": None}
return instance_element_update
return None
task["status"] = "FAILED"
return None
+
+ def _refres_sfps(self, task):
+ """Call VIM to get SFPs status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ sfp_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_sfps_status(sfp_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-sfp: vimconnException when trying to refresh sfps {}".format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-sfp: vim_sfp_id={} result={}".format(task_id, task["vim_id"], vim_info))
+ #TODO: Revise this part
+ 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_vim_info = task["extra"].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"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["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["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
+
+ def _refres_sfis(self, task):
+ """Call VIM to get sfis status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ sfi_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_sfis_status(sfi_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-sfi: vimconnException when trying to refresh sfis {}".format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-sfi: vim_sfi_id={} result={}".format(task_id, task["vim_id"], vim_info))
+ #TODO: Revise this part
+ 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_vim_info = task["extra"].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"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["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["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
+
+ def _refres_sfs(self, task):
+ """Call VIM to get sfs status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ sf_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_sfs_status(sf_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-sf: vimconnException when trying to refresh sfs {}".format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-sf: vim_sf_id={} result={}".format(task_id, task["vim_id"], vim_info))
+ #TODO: Revise this part
+ 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_vim_info = task["extra"].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"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["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["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
+
+ def _refres_classifications(self, task):
+ """Call VIM to get classifications status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ classification_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_classifications_status(classification_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-classification: vimconnException when trying to refresh classifications {}"
+ .format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-classification: vim_classification_id={} result={}".format(task_id,
+ task["vim_id"], vim_info))
+ #TODO: Revise this part
+ 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_vim_info = task["extra"].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"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["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["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
projects / osm / RO.git / blobdiff