"vmware": vimconn_vmware,
}
+
def is_task_id(task_id):
return task_id.startswith("TASK-")
class vim_thread(threading.Thread):
- REFRESH_BUILD = 5 # 5 seconds
- REFRESH_ACTIVE = 60 # 1 minute
+ REFRESH_BUILD = 5 # 5 seconds
+ REFRESH_ACTIVE = 60 # 1 minute
def __init__(self, task_lock, name=None, datacenter_name=None, datacenter_tenant_id=None,
db=None, db_lock=None, ovim=None):
self.name = name
self.vim_persistent_info = {}
- self.logger = logging.getLogger('openmano.vim.'+self.name)
+ self.logger = logging.getLogger('openmano.vim.' + self.name)
self.db = db
self.db_lock = db_lock
def get_vimconnector(self):
try:
- from_= "datacenter_tenants as dt join datacenters as d on dt.datacenter_id=d.uuid"
+ 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_)
+ vims = self.db.get_rows(FROM=from_, SELECT=select_, WHERE=where_)
vim = vims[0]
vim_config = {}
if vim["config"]:
vim_config['datacenter_tenant_id'] = vim.get('datacenter_tenant_id')
vim_config['datacenter_id'] = vim.get('datacenter_id')
+ # get port_mapping
+ with self.db_lock:
+ vim_config["wim_external_ports"] = self.ovim.get_of_port_mappings(
+ db_filter={"region": vim_config['datacenter_id'], "pci": None})
+
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'],
database_limit = 200
while True:
# get 200 (database_limit) entries each time
- with self.db_lock:
- vim_actions = self.db.get_rows(FROM="vim_wim_actions",
- WHERE={"datacenter_vim_id": self.datacenter_tenant_id,
- "item_id>=": old_item_id},
- ORDER_BY=("item_id", "item", "created_at",),
- LIMIT=database_limit)
+ vim_actions = self.db.get_rows(FROM="vim_wim_actions",
+ WHERE={"datacenter_vim_id": self.datacenter_tenant_id,
+ "item_id>=": old_item_id},
+ ORDER_BY=("item_id", "item", "created_at",),
+ LIMIT=database_limit)
for task in vim_actions:
item = task["item"]
item_id = task["item_id"]
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")})
+ "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={}"\
+ error_text = "ovimException creating new_external_port compute_node={}" \
" pci={} vlan={} {}".format(
- interface["compute_node"],
- interface["pci"],
- interface.get("vlan"), e)
+ 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"]})
+ self.db.update_rows(
+ 'instance_interfaces',
+ UPDATE={"mac_address": interface.get("mac_address"),
+ "ip_address": interface.get("ip_address"),
+ "vim_interface_id": interface.get("vim_interface_id"),
+ "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
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"]})
+ 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_need_update = True
if task_need_update:
- with self.db_lock:
- self.db.update_rows(
- 'vim_wim_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']})
+ self.db.update_rows(
+ 'vim_wim_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:
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))
+ 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":
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_nets', UPDATE=temp_dict, WHERE={"uuid": task["item_id"]})
- self.db.update_rows(
- 'vim_wim_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']})
+ self.db.update_rows('instance_nets', UPDATE=temp_dict, WHERE={"uuid": task["item_id"]})
+ self.db.update_rows(
+ 'vim_wim_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:
database_update["vim_net_id"] = None
no_refresh_tasks = ['instance_sfis', 'instance_sfs',
- 'instance_classifications', 'instance_sfps']
+ 'instance_classifications', 'instance_sfps']
if task["action"] == "DELETE":
action_key = task["item"] + task["item_id"]
del self.grouped_tasks[action_key]
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_wim_actions",
+ UPDATE={"status": task["status"], "vim_id": task.get("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="vim_wim_actions",
- UPDATE={"status": task["status"], "vim_id": task.get("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"]})
+ 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("task={} Error updating database {}".format(task_id, e), exc_info=True)
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-{}.{}".format(task["instance_action_id"], index)] = vim_actions_list[index]
+ 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-{}.{}".format(task["instance_action_id"], index)] = vim_actions_list[index]
if extra.get("interfaces"):
task["vim_interfaces"] = {}
else:
if task["status"] == "SCHEDULED":
task["status"] = "SUPERSEDED"
return True
- else: # task["status"] == "processing"
+ else: # task["status"] == "processing"
self.task_lock.release()
return False
if ins_action_id:
instance_action_id = ins_action_id
- with self.db_lock:
- tasks = self.db.get_rows(FROM="vim_wim_actions", WHERE={"instance_action_id": instance_action_id,
- "task_index": task_index})
+ tasks = self.db.get_rows(FROM="vim_wim_actions", WHERE={"instance_action_id": instance_action_id,
+ "task_index": task_index})
if not tasks:
return None
task = tasks[0]
@staticmethod
def _format_vim_error_msg(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[:max_length // 2 - 3] + " ... " + error_text[-max_length // 2 + 3:]
return error_text
def new_vm(self, task):
task_interfaces = {}
for iface in params_copy[5]:
task_interfaces[iface["vim_id"]] = {"iface_id": iface["uuid"]}
- with self.db_lock:
- 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"]})
+ result = self.db.get_rows(
+ SELECT=('sdn_net_id', 'interface_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']
+ task_interfaces[iface["vim_id"]]["interface_id"] = result[0]['interface_id']
else:
self.logger.critical("task={} new-VM: instance_nets uuid={} not found at DB".format(task_id,
- iface["uuid"]), exc_info=True)
+ iface["uuid"]), exc_info=True)
task["vim_info"] = {}
task["vim_interfaces"] = {}
# 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,
- 'datacenter_tenant_id': self.datacenter_tenant_id},
- ORDER="instance_scenario_id")
+ result = self.db.get_rows(SELECT=('sdn_net_id',), FROM='instance_nets',
+ 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']
# CREATE
params = task["params"]
action_text = "creating VIM"
- vim_net_id = self.vim.new_network(*params)
+ vim_net_id, created_items = self.vim.new_network(*params[0:3])
net_name = params[0]
net_type = params[1]
+ wim_account_name = None
+ if len(params) >= 4:
+ wim_account_name = params[3]
sdn_controller = self.vim.config.get('sdn-controller')
if sdn_controller and (net_type == "data" or net_type == "ptp"):
action_text = "creating SDN"
with self.db_lock:
sdn_net_id = self.ovim.new_network(network)
+
+ if wim_account_name and self.vim.config["wim_external_ports"]:
+ # add external port to connect WIM. Try with compute node __WIM:wim_name and __WIM
+ action_text = "attaching external port to ovim network"
+ sdn_port_name = sdn_net_id + "." + task["vim_id"]
+ sdn_port_name = sdn_port_name[:63]
+ sdn_port_data = {
+ "compute_node": "__WIM:" + wim_account_name[0:58],
+ "pci": None,
+ "vlan": network["vlan"],
+ "net_id": sdn_net_id,
+ "region": self.vim["config"]["datacenter_id"],
+ "name": sdn_port_name,
+ }
+ try:
+ with self.db_lock:
+ sdn_external_port_id = self.ovim.new_external_port(sdn_port_data)
+ except ovimException:
+ sdn_port_data["compute_node"] = "__WIM"
+ with self.db_lock:
+ sdn_external_port_id = self.ovim.new_external_port(sdn_port_data)
+ self.logger.debug("Added sdn_external_port {} to sdn_network {}".format(sdn_external_port_id,
+ sdn_net_id))
+
task["status"] = "DONE"
task["extra"]["vim_info"] = {}
task["extra"]["sdn_net_id"] = sdn_net_id
task["extra"]["created"] = True
+ task["extra"]["created_items"] = created_items
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",
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)
+ self.vim.delete_network(net_vim_id, task["extra"].get("created_items"))
task["status"] = "DONE"
task["error_msg"] = None
return True, None
def new_sfi(self, task):
vim_sfi_id = None
try:
+ # Waits for interfaces to be ready (avoids failure)
+ time.sleep(1)
dep_id = "TASK-" + str(task["extra"]["depends_on"][0])
task_id = task["instance_action_id"] + "." + str(task["task_index"])
error_text = ""
- interfaces = task.get("depends").get(dep_id).get("extra").get("interfaces").keys()
+ interfaces = task.get("depends").get(dep_id).get("extra").get("interfaces")
+ ingress_interface_id = task.get("extra").get("params").get("ingress_interface_id")
+ egress_interface_id = task.get("extra").get("params").get("egress_interface_id")
+ ingress_vim_interface_id = None
+ egress_vim_interface_id = None
+ for vim_interface, interface_data in interfaces.iteritems():
+ if interface_data.get("interface_id") == ingress_interface_id:
+ ingress_vim_interface_id = vim_interface
+ break
+ if ingress_interface_id != egress_interface_id:
+ for vim_interface, interface_data in interfaces.iteritems():
+ if interface_data.get("interface_id") == egress_interface_id:
+ egress_vim_interface_id = vim_interface
+ break
+ else:
+ egress_vim_interface_id = ingress_vim_interface_id
+ if not ingress_vim_interface_id or not egress_vim_interface_id:
+ self.logger.error("Error creating Service Function Instance, Ingress: %s, Egress: %s",
+ ingress_vim_interface_id, egress_vim_interface_id)
+ return False, None
# 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]]
+ ingress_port_id_list = [ingress_vim_interface_id]
+ egress_port_id_list = [egress_vim_interface_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)
+ vim_sfi_id = self.vim.new_sfi(name, ingress_port_id_list, egress_port_id_list, sfc_encap=False)
task["extra"]["created"] = True
task["error_msg"] = None
try:
task_id = task["instance_action_id"] + "." + str(task["task_index"])
error_text = ""
- depending_tasks = [ "TASK-" + str(dep_id) for dep_id in task["extra"]["depends_on"]]
- #sfis = task.get("depends").values()[0].get("extra").get("params")[5]
+ depending_tasks = ["TASK-" + str(dep_id) for dep_id in task["extra"]["depends_on"]]
+ # sfis = task.get("depends").values()[0].get("extra").get("params")[5]
sfis = [task.get("depends").get(dep_task) for dep_task in depending_tasks]
sfi_id_list = []
for sfi in sfis:
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],
- "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"),
- }
+ source_port = params.get("source_port")
+ destination_port = params.get("destination_port")
+ definition = {"logical_source_port": interfaces[0]}
+ if ip_proto:
+ if ip_proto == 1:
+ ip_proto = 'icmp'
+ elif ip_proto == 6:
+ ip_proto = 'tcp'
+ elif ip_proto == 17:
+ ip_proto = 'udp'
+ definition["protocol"] = ip_proto
+ if source_ip:
+ if '/' not in source_ip:
+ source_ip += '/32'
+ definition["source_ip_prefix"] = source_ip
+ if source_port:
+ definition["source_port_range_min"] = source_port
+ definition["source_port_range_max"] = source_port
+ if destination_port:
+ definition["destination_port_range_min"] = destination_port
+ definition["destination_port_range_max"] = destination_port
+ if destination_ip:
+ if '/' not in destination_ip:
+ destination_ip += '/32'
+ definition["destination_ip_prefix"] = destination_ip
vim_classification_id = self.vim.new_classification(
name, 'legacy_flow_classifier', definition)