import time
import queue
import logging
-from osm_ro import vimconn
-from osm_ro.wim.sdnconn import SdnConnectorError
+from osm_ro_plugin import vimconn
+from osm_ro_plugin.sdnconn import SdnConnectorError
import yaml
from osm_ro.db_base import db_base_Exception
from http import HTTPStatus
raise SdnConnectorError(str(exc), http_code=HTTPStatus.INTERNAL_SERVER_ERROR.value) from exc
def _proccess_vim_exception(self, exc):
- if isinstance(exc, vimconn.vimconnException):
+ if isinstance(exc, vimconn.VimConnException):
raise
else:
self.logger.error("plugin={} throws a non vimconnException exception {}".format(self.plugin_name, exc),
exc_info=True)
- raise vimconn.vimconnException(str(exc), http_code=HTTPStatus.INTERNAL_SERVER_ERROR.value) from exc
+ raise vimconn.VimConnException(str(exc), http_code=HTTPStatus.INTERNAL_SERVER_ERROR.value) from exc
def get_vim_sdn_connector(self):
if self.datacenter_tenant_id:
# vim_config["wim_external_ports"] = [x for x in vim_port_mappings
# if x["service_mapping_info"].get("wim")]
self.plugin_name = "rovim_" + vim["type"]
- self.vim = self.plugins[self.plugin_name].vimconnector(
+ self.vim = self.plugins[self.plugin_name](
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'],
self.wim_account_id, self.plugin_name))
except Exception as e:
self.logger.error("Cannot load sdn connector for wim_account={}, plugin={}: {}".format(
- self.wim_account_id, self.plugin_name, e))
+ self.wim_account_id, self.plugin_name, e), exc_info=True)
self.sdnconnector = None
- self.error_status = "Error loading sdn connector: {}".format(e)
+ self.error_status = self._format_vim_error_msg("Error loading sdn connector: {}".format(e))
def _get_db_task(self):
"""
try:
vim_dict = self.vim.refresh_vms_status(vm_to_refresh_list)
vim_info = vim_dict[vim_id]
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
# Mark all tasks at VIM_ERROR status
self.logger.error("task=several get-VM: vimconnException when trying to refresh vms " + str(e))
vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
try:
vim_dict = self.vim.refresh_nets_status(net_to_refresh_list)
vim_info = vim_dict[vim_id]
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
# Mark all tasks at VIM_ERROR status
self.logger.error("task=several get-net: vimconnException when trying to refresh nets " + str(e))
vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
elif task["action"] == "DELETE":
self.del_vm(task)
else:
- raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+ raise vimconn.VimConnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_nets':
if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
database_update = self._refres_net(task)
elif task["action"] == "FIND":
database_update = self.get_net(task)
else:
- raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+ raise vimconn.VimConnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_wim_nets':
if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
database_update = self.new_or_update_sdn_net(task)
elif task["action"] == "FIND":
database_update = self.get_sdn_net(task)
else:
- raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+ raise vimconn.VimConnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfis':
if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
database_update = self._refres_sfis(task)
elif task["action"] == "DELETE":
self.del_sfi(task)
else:
- raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+ raise vimconn.VimConnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfs':
if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
database_update = self._refres_sfs(task)
elif task["action"] == "DELETE":
self.del_sf(task)
else:
- raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+ raise vimconn.VimConnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_classifications':
if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
database_update = self._refres_classifications(task)
elif task["action"] == "DELETE":
self.del_classification(task)
else:
- raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+ raise vimconn.VimConnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfps':
if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
database_update = self._refres_sfps(task)
elif task["action"] == "DELETE":
self.del_sfp(task)
else:
- raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
+ raise vimconn.VimConnException(self.name + "unknown task action {}".format(task["action"]))
else:
- raise vimconn.vimconnException(self.name + "unknown task item {}".format(task["item"]))
+ raise vimconn.VimConnException(self.name + "unknown task item {}".format(task["item"]))
# TODO
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"]}
+ database_update = {"status": "VIM_ERROR" if task["item"] != "instance_wim_nets" else "WIM_ERROR",
+ "error_msg": task["error_msg"]}
# if task["item"] == 'instance_vms':
# database_update["vim_vm_id"] = None
# elif task["item"] == 'instance_nets':
self.task_queue.put(task, False)
return None
except queue.Full:
- raise vimconn.vimconnException(self.name + ": timeout inserting a task")
+ raise vimconn.VimConnException(self.name + ": timeout inserting a task")
def del_task(self, task):
with self.task_lock:
return False
def run(self):
- self.logger.debug("Starting")
+ self.logger.info("Starting")
while True:
self.get_vim_sdn_connector()
- self.logger.debug("Vimconnector loaded")
reload_thread = False
while True:
instance_element_update = {"status": "BUILD", "vim_vm_id": vim_vm_id, "error_msg": None}
return instance_element_update
- except (vimconn.vimconnException, VimThreadException) as e:
+ except (vimconn.VimConnException, VimThreadException) as e:
self.logger.error("task={} new-VM: {}".format(task_id, e))
error_text = self._format_vim_error_msg(str(e))
task["error_msg"] = error_text
task["error_msg"] = None
return None
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
task["error_msg"] = self._format_vim_error_msg(str(e))
- if isinstance(e, vimconn.vimconnNotFoundException):
+ if isinstance(e, vimconn.VimConnNotFoundException):
# If not found mark as Done and fill error_msg
task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
return None
instance_element_update = self._get_net_internal(task, filter_param)
return instance_element_update
- except (vimconn.vimconnException, VimThreadException) as e:
+ except (vimconn.VimConnException, VimThreadException) as e:
self.logger.error("task={} get-net: {}".format(task_id, e))
task["status"] = "FAILED"
task["vim_id"] = None
instance_element_update = {"vim_net_id": vim_net_id, "status": "BUILD",
"created": True, "error_msg": None}
return instance_element_update
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
self.logger.error("task={} new-net: Error {}: {}".format(task_id, action_text, e))
task["status"] = "FAILED"
task["vim_id"] = vim_net_id
task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
task["error_msg"] = None
return None
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
task["error_msg"] = self._format_vim_error_msg(str(e))
- if isinstance(e, vimconn.vimconnNotFoundException):
+ if isinstance(e, vimconn.VimConnNotFoundException):
# If not found mark as Done and fill error_msg
task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
return None
connected_ports = task["extra"].get("connected_ports", [])
new_connected_ports = []
last_update = task["extra"].get("last_update", 0)
- sdn_status = "BUILD"
+ sdn_status = task["extra"].get("vim_status", "BUILD")
sdn_info = None
task_id = task["instance_action_id"] + "." + str(task["task_index"])
new_connected_ports.append(external_port_id)
# if there are more ports to connect or they have been modified, call create/update
- 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"
+ try:
+ if set(connected_ports) != set(new_connected_ports) or sdn_need_update:
+ last_update = time.time()
+ if not wimconn_net_id:
+ if len(sdn_ports) < 2:
+ if not pending_ports:
+ sdn_status = "ACTIVE"
+ else:
+ 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:
- 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)
- connected_ports = new_connected_ports
- elif wimconn_net_id:
- try:
+ 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["vim_id"] = wimconn_net_id
instance_element_update = {"wim_internal_id": wimconn_net_id, "status": sdn_status,
"created": True, "error_msg": task["error_msg"] or None}
- except (vimconn.vimconnException, SdnConnectorError) as e:
+ except (vimconn.VimConnException, SdnConnectorError) as e:
self.logger.error("task={} new-sdn-net: Error: {}".format(task_id, e))
task["status"] = "FAILED"
task["vim_id"] = wimconn_net_id
# 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
instance_element_update = {"status": "ACTIVE", "vim_sfi_id": vim_sfi_id, "error_msg": None}
return instance_element_update
- except (vimconn.vimconnException, VimThreadException) as e:
+ 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["error_msg"] = None
return None
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
task["error_msg"] = self._format_vim_error_msg(str(e))
- if isinstance(e, vimconn.vimconnNotFoundException):
+ if isinstance(e, vimconn.VimConnNotFoundException):
# If not found mark as Done and fill error_msg
task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
return None
instance_element_update = {"status": "ACTIVE", "vim_sf_id": vim_sf_id, "error_msg": None}
return instance_element_update
- except (vimconn.vimconnException, VimThreadException) as e:
+ 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["error_msg"] = None
return None
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
task["error_msg"] = self._format_vim_error_msg(str(e))
- if isinstance(e, vimconn.vimconnNotFoundException):
+ if isinstance(e, vimconn.VimConnNotFoundException):
# If not found mark as Done and fill error_msg
task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
return None
"error_msg": None}
return instance_element_update
- except (vimconn.vimconnException, VimThreadException) as e:
+ 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["error_msg"] = None
return None
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
task["error_msg"] = self._format_vim_error_msg(str(e))
- if isinstance(e, vimconn.vimconnNotFoundException):
+ if isinstance(e, vimconn.VimConnNotFoundException):
# If not found mark as Done and fill error_msg
task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
return None
instance_element_update = {"status": "ACTIVE", "vim_sfp_id": vim_sfp_id, "error_msg": None}
return instance_element_update
- except (vimconn.vimconnException, VimThreadException) as e:
+ 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["error_msg"] = None
return None
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
task["error_msg"] = self._format_vim_error_msg(str(e))
- if isinstance(e, vimconn.vimconnNotFoundException):
+ if isinstance(e, vimconn.VimConnNotFoundException):
# If not found mark as Done and fill error_msg
task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
return None
try:
vim_dict = self.vim.refresh_sfps_status(sfp_to_refresh_list)
vim_info = vim_dict[vim_id]
- except vimconn.vimconnException as e:
+ 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)}
try:
vim_dict = self.vim.refresh_sfis_status(sfi_to_refresh_list)
vim_info = vim_dict[vim_id]
- except vimconn.vimconnException as e:
+ 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)}
try:
vim_dict = self.vim.refresh_sfs_status(sf_to_refresh_list)
vim_info = vim_dict[vim_id]
- except vimconn.vimconnException as e:
+ 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)}
try:
vim_dict = self.vim.refresh_classifications_status(classification_to_refresh_list)
vim_info = vim_dict[vim_id]
- except vimconn.vimconnException as e:
+ 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))
projects / osm / RO.git / blobdiff