import logging
import vimconn
from db_base import db_base_Exception
-from openvim.ovim import ovimException
+from ovim import ovimException
# from logging import Logger
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"],
- "error_msg": vim_info.get("error_msg"),
- "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_vms', UPDATE=temp_dict, WHERE={"vim_vm_id": vim_id})
for interface in vim_info["interfaces"]:
for task_interface in task["vim_info"]["interfaces"]:
SELECT=("ii.uuid as iface_id", "ine.uuid as net_id", "iv.uuid as vm_id", "sdn_net_id"),
WHERE=where_)
if len(db_ifaces)>1:
- self.logger.error("Refresing interfaces. "
+ self.logger.critical("Refresing interfaces. "
"Found more than one interface at database for '{}'".format(where_))
elif len(db_ifaces)==0:
- self.logger.error("Refresing interfaces. "
+ self.logger.critical("Refresing interfaces. "
"Not found any interface at database for '{}'".format(where_))
+ continue
else:
db_iface = db_ifaces[0]
if db_iface.get("sdn_net_id") and interface.get("compute_node") and interface.get("pci"):
"vlan": interface.get("vlan"),
"net_id": sdn_net_id,
"region": self.vim["config"]["datacenter_id"],
- "name": sdn_port_name})
+ "name": sdn_port_name,
+ "mac": interface.get("mac_address")})
interface["sdn_port_id"] = sdn_port_id
except (ovimException, Exception) as e:
self.logger.error(
interface["vim_net_id"] = vim_net_id
task["vim_info"] = vim_info
- if "ACTIVE" in task["vim_info"]["status"]:
- self._insert_refresh(task, now+300) # 5minutes
- else:
+ if task["vim_info"]["status"] == "BUILD":
self._insert_refresh(task, now+5) # 5seconds
+ else:
+ self._insert_refresh(task, now+300) # 5minutes
except vimconn.vimconnException as e:
self.logger.error("vimconnException Exception when trying to refresh vms " + str(e))
self._insert_refresh(task, now + 300) # 5minutes
+ if net_to_refresh_list:
+ try:
+ vim_dict = self.vim.refresh_nets_status(net_to_refresh_list)
+ for vim_id, vim_info in vim_dict.items():
+ #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:
+ 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"
+
+ 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
+
+ # 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"],
+ "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":
+ self._insert_refresh(task, now+5) # 5seconds
+ else:
+ self._insert_refresh(task, now+300) # 5minutes
+ except vimconn.vimconnException as e:
+ self.logger.error("vimconnException Exception when trying to refresh nets " + str(e))
+ self._insert_refresh(task, now + 300) # 5minutes
+
if not items_to_refresh:
time.sleep(1)
while True:
#TODO reload service
while True:
- if not self.task_queue.empty():
- task = self.task_queue.get()
- self.task_lock.acquire()
- if task["status"] == "deleted":
+ try:
+ if 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
- 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':
- break
+ 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':
+ break
+ except Exception as e:
+ self.logger.critical("Unexpected exception at run: " + str(e), exc_info=True)
self.logger.debug("Finishing")
def terminate(self, task):
return True, None
- def _format_vim_error_msg(self, error_text):
- if error_text and len(error_text) >= 1024:
- return error_text[:516] + " ... " + error_text[-500:]
+ 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:]
return error_text
def new_net(self, task):
vim_net = self.vim.get_network(net_id)
if vim_net.get('encapsulation') != 'vlan':
- raise vimconn.vimconnException(net_name + "defined as type " + net_type + " but the created network in vim is " + vim_net['encapsulation'])
-
+ raise vimconn.vimconnException(
+ "net '{}' defined as type '{}' has not vlan encapsulation '{}'".format(
+ net_name, net_type, vim_net['encapsulation']))
network["vlan"] = vim_net.get('segmentation_id')
-
- sdn_net_id = None
- with self.db_lock:
- if network:
+ sdn_net_id = None
+ try:
sdn_net_id = self.ovim.new_network(network)
- self.db.update_rows("instance_nets", UPDATE={"vim_net_id": net_id, "sdn_net_id": sdn_net_id}, WHERE={"vim_net_id": task_id})
-
+ 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))
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)
+ #except ovimException as e:
+ # self.logger.error("Error creating NET in ovim, task=%s: %s", str(task_id), str(e))
+ # return False, str(e)
def new_vm(self, task):
try:
except Exception as e:
return False, "Error trying to get task_id='{}':".format(net_id, str(e))
try:
+ self._remove_refresh("get-net", net_id)
result = self.vim.delete_network(net_id)
if sdn_net_id:
with self.db_lock: