import vimconn
import logging
import collections
+import math
from uuid import uuid4
from db_base import db_base_Exception
'log_level_of': 'DEBUG'
}
try:
+ # starts ovim library
ovim = ovim_module.ovim(ovim_configuration)
ovim.start_service()
+ #delete old unneeded vim_actions
+ clean_db(mydb)
+
+ # starts vim_threads
from_= 'tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join '\
'datacenter_tenants as dt on td.datacenter_tenant_id=dt.uuid'
select_ = ('type', 'd.config as config', 'd.uuid as datacenter_id', 'vim_url', 'vim_url_admin',
return ("openmanod version {} {}\n(c) Copyright Telefonica".format(global_config["version"],
global_config["version_date"] ))
+def clean_db(mydb):
+ """
+ Clean unused or old entries at database to avoid unlimited growing
+ :param mydb: database connector
+ :return: None
+ """
+ # get and delete unused vim_actions: all elements deleted, one week before, instance not present
+ now = t.time()-3600*24*7
+ instance_action_id = None
+ nb_deleted = 0
+ while True:
+ actions_to_delete = mydb.get_rows(
+ SELECT=("item", "item_id", "instance_action_id"),
+ FROM="vim_actions as va join instance_actions as ia on va.instance_action_id=ia.uuid "
+ "left join instance_scenarios as i on ia.instance_id=i.uuid",
+ WHERE={"va.action": "DELETE", "va.modified_at<": now, "i.uuid": None,
+ "va.status": ("DONE", "SUPERSEDED")},
+ LIMIT=100
+ )
+ for to_delete in actions_to_delete:
+ mydb.delete_row(FROM="vim_actions", WHERE=to_delete)
+ if instance_action_id != to_delete["instance_action_id"]:
+ instance_action_id = to_delete["instance_action_id"]
+ mydb.delete_row(FROM="instance_actions", WHERE={"uuid": instance_action_id})
+ nb_deleted += len(actions_to_delete)
+ if len(actions_to_delete) < 100:
+ break
+ if nb_deleted:
+ logger.debug("Removed {} unused vim_actions".format(nb_deleted))
+
+
def get_flavorlist(mydb, vnf_id, nfvo_tenant=None):
'''Obtain flavorList
mydb.delete_row(FROM="datacenters_images", WHERE={"datacenter_vim_id": vim["id"], "vim_id":item["uuid"]})
elif item["what"]=="flavor":
vim.delete_flavor(item["uuid"])
- mydb.delete_row(FROM="datacenters_flavors", WHERE={"datacenter_id": vim["id"], "vim_id":item["uuid"]})
+ mydb.delete_row(FROM="datacenters_flavors", WHERE={"datacenter_vim_id": vim["id"], "vim_id":item["uuid"]})
elif item["what"]=="network":
vim.delete_network(item["uuid"])
elif item["what"]=="vm":
def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_vim=False, return_on_error = None):
- temp_flavor_dict= {'disk':flavor_dict.get('disk',1),
+ temp_flavor_dict= {'disk':flavor_dict.get('disk',0),
'ram':flavor_dict.get('ram'),
'vcpus':flavor_dict.get('vcpus'),
}
try:
myvnfd = vnfd_catalog.vnfd()
try:
- pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd)
+ pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd, path_helper=True)
except Exception as e:
raise NfvoException("Error. Invalid VNF descriptor format " + str(e), HTTP_Bad_Request)
db_vnfs = []
vnf_uuid = str(uuid4())
uuid_list.append(vnf_uuid)
vnfd_uuid_list.append(vnf_uuid)
+ vnfd_id = get_str(vnfd, "id", 255)
db_vnf = {
"uuid": vnf_uuid,
- "osm_id": get_str(vnfd, "id", 255),
+ "osm_id": vnfd_id,
"name": get_str(vnfd, "name", 255),
"description": get_str(vnfd, "description", 255),
"tenant_id": tenant_id,
net_id2uuid[vld.get("id")] = net_uuid
db_nets.append(db_net)
+ # connection points vaiable declaration
+ cp_name2iface_uuid = {}
+ cp_name2vm_uuid = {}
+ cp_name2db_interface = {}
+
# table vms (vdus)
vdu_id2uuid = {}
vdu_id2db_table_index = {}
for vdu in vnfd.get("vdu").itervalues():
vm_uuid = str(uuid4())
uuid_list.append(vm_uuid)
+ vdu_id = get_str(vdu, "id", 255)
db_vm = {
"uuid": vm_uuid,
- "osm_id": get_str(vdu, "id", 255),
+ "osm_id": vdu_id,
"name": get_str(vdu, "name", 255),
"description": get_str(vdu, "description", 255),
"vnf_id": vnf_uuid,
device["image checksum"] = str(volume["image-checksum"])
devices.append(device)
- # table flavors
- db_flavor = {
- "name": get_str(vdu, "name", 250) + "-flv",
- "vcpus": int(vdu["vm-flavor"].get("vcpu-count", 1)),
- "ram": int(vdu["vm-flavor"].get("memory-mb", 1)),
- "disk": int(vdu["vm-flavor"].get("storage-gb", 1)),
- }
- # EPA TODO revise
- extended = {}
- numa = {}
- if devices:
- extended["devices"] = devices
- if vdu.get("guest-epa"): # TODO or dedicated_int:
- epa_vcpu_set = False
- if vdu["guest-epa"].get("numa-node-policy"): # TODO or dedicated_int:
- numa_node_policy = vdu["guest-epa"].get("numa-node-policy")
- if numa_node_policy.get("node"):
- numa_node = numa_node_policy["node"]['0']
- if numa_node.get("num-cores"):
- numa["cores"] = numa_node["num-cores"]
- epa_vcpu_set = True
- if numa_node.get("paired-threads"):
- if numa_node["paired-threads"].get("num-paired-threads"):
- numa["paired-threads"] = int(numa_node["paired-threads"]["num-paired-threads"])
- epa_vcpu_set = True
- if len(numa_node["paired-threads"].get("paired-thread-ids")):
- numa["paired-threads-id"] = []
- for pair in numa_node["paired-threads"]["paired-thread-ids"].itervalues():
- numa["paired-threads-id"].append(
- (str(pair["thread-a"]), str(pair["thread-b"]))
- )
- if numa_node.get("num-threads"):
- numa["threads"] = int(numa_node["num-threads"])
- epa_vcpu_set = True
- if numa_node.get("memory-mb"):
- numa["memory"] = max(int(numa_node["memory-mb"] / 1024), 1)
- if vdu["guest-epa"].get("mempage-size"):
- if vdu["guest-epa"]["mempage-size"] != "SMALL":
- numa["memory"] = max(int(db_flavor["ram"] / 1024), 1)
- if vdu["guest-epa"].get("cpu-pinning-policy") and not epa_vcpu_set:
- if vdu["guest-epa"]["cpu-pinning-policy"] == "DEDICATED":
- if vdu["guest-epa"].get("cpu-thread-pinning-policy") and \
- vdu["guest-epa"]["cpu-thread-pinning-policy"] != "PREFER":
- numa["cores"] = max(db_flavor["vcpus"], 1)
- else:
- numa["threads"] = max(db_flavor["vcpus"], 1)
- if numa:
- extended["numas"] = [numa]
- if extended:
- extended_text = yaml.safe_dump(extended, default_flow_style=True, width=256)
- db_flavor["extended"] = extended_text
- # look if flavor exist
-
- temp_flavor_dict = {'disk': db_flavor.get('disk', 1),
- 'ram': db_flavor.get('ram'),
- 'vcpus': db_flavor.get('vcpus'),
- 'extended': db_flavor.get('extended')
- }
- existing_flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict)
- if existing_flavors:
- flavor_uuid = existing_flavors[0]["uuid"]
- else:
- flavor_uuid = str(uuid4())
- uuid_list.append(flavor_uuid)
- db_flavor["uuid"] = flavor_uuid
- db_flavors.append(db_flavor)
- db_vm["flavor_id"] = flavor_uuid
-
# cloud-init
boot_data = {}
if vdu.get("cloud-init"):
db_vms_index += 1
# table interfaces (internal/external interfaces)
- cp_name2iface_uuid = {}
- cp_name2vm_uuid = {}
- cp_name2db_interface = {}
+ flavor_epa_interfaces = []
+ vdu_id2cp_name = {} # stored only when one external connection point is presented at this VDU
# for iface in chain(vdu.get("internal-interface").itervalues(), vdu.get("external-interface").itervalues()):
for iface in vdu.get("interface").itervalues():
+ flavor_epa_interface = {}
iface_uuid = str(uuid4())
uuid_list.append(iface_uuid)
db_interface = {
"internal_name": get_str(iface, "name", 255),
"vm_id": vm_uuid,
}
+ flavor_epa_interface["name"] = db_interface["internal_name"]
if iface.get("virtual-interface").get("vpci"):
db_interface["vpci"] = get_str(iface.get("virtual-interface"), "vpci", 12)
+ flavor_epa_interface["vpci"] = db_interface["vpci"]
if iface.get("virtual-interface").get("bandwidth"):
bps = int(iface.get("virtual-interface").get("bandwidth"))
- db_interface["bw"] = bps/1000
+ db_interface["bw"] = int(math.ceil(bps/1000000.0))
+ flavor_epa_interface["bandwidth"] = "{} Mbps".format(db_interface["bw"])
if iface.get("virtual-interface").get("type") == "OM-MGMT":
db_interface["type"] = "mgmt"
elif iface.get("virtual-interface").get("type") in ("SR-IOV", "PCI-PASSTHROUGH"):
db_interface["type"] = "data"
db_interface["model"] = get_str(iface.get("virtual-interface"), "type", 12)
+ flavor_epa_interface["dedicated"] = "no" if iface["virtual-interface"]["type"] == "SR-IOV" \
+ else "yes"
+ flavor_epa_interfaces.append(flavor_epa_interface)
else:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{}]':'vdu[{}]':'interface':'virtual"
"-interface':'type':'{}'. Interface type is not supported".format(
- str(vnfd["id"])[:255], str(vdu["id"])[:255],
- iface.get("virtual-interface").get("type")),
+ vnfd_id, vdu_id, iface.get("virtual-interface").get("type")),
HTTP_Bad_Request)
if iface.get("external-connection-point-ref"):
for cp_descriptor in vnfd_descriptor["connection-point"]:
if cp_descriptor["name"] == db_interface["external_name"]:
break
+ else:
+ raise KeyError()
+
+ if vdu_id in vdu_id2cp_name:
+ vdu_id2cp_name[vdu_id] = None # more than two connecdtion point for this VDU
+ else:
+ vdu_id2cp_name[vdu_id] = db_interface["external_name"]
+
+ # port security
if str(cp_descriptor.get("port-security-enabled")).lower() == "false":
db_interface["port_security"] = 0
elif str(cp_descriptor.get("port-security-enabled")).lower() == "true":
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'vdu[{vdu}]':"
"'interface[{iface}]':'vnfd-connection-point-ref':'{cp}' is not present"
" at connection-point".format(
- vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"],
+ vnf=vnfd_id, vdu=vdu_id, iface=iface["name"],
cp=iface.get("vnfd-connection-point-ref")),
HTTP_Bad_Request)
elif iface.get("internal-connection-point-ref"):
if cp.get("id-ref") == iface.get("internal-connection-point-ref"):
db_interface["net_id"] = net_id2uuid[vld.get("id")]
for cp_descriptor in vnfd_descriptor["connection-point"]:
- if cp_descriptor["name"] == db_interface["external_name"]:
+ if cp_descriptor["name"] == db_interface["internal_name"]:
break
if str(cp_descriptor.get("port-security-enabled")).lower() == "false":
db_interface["port_security"] = 0
break
except KeyError:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'vdu[{vdu}]':"
- "'interface[{iface}]':'vdu-internal-connection-point-ref':'{cp}' is not"
+ "'interface[{iface}]':'internal-connection-point-ref':'{cp}' is not"
" referenced by any internal-vld".format(
- vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"],
- cp=iface.get("vdu-internal-connection-point-ref")),
+ vnf=vnfd_id, vdu=vdu_id, iface=iface["name"],
+ cp=iface.get("internal-connection-point-ref")),
HTTP_Bad_Request)
if iface.get("position") is not None:
db_interface["created_at"] = int(iface.get("position")) - 1000
db_interfaces.append(db_interface)
+ # table flavors
+ db_flavor = {
+ "name": get_str(vdu, "name", 250) + "-flv",
+ "vcpus": int(vdu["vm-flavor"].get("vcpu-count", 1)),
+ "ram": int(vdu["vm-flavor"].get("memory-mb", 1)),
+ "disk": int(vdu["vm-flavor"].get("storage-gb", 0)),
+ }
+ # TODO revise the case of several numa-node-policy node
+ extended = {}
+ numa = {}
+ if devices:
+ extended["devices"] = devices
+ if flavor_epa_interfaces:
+ numa["interfaces"] = flavor_epa_interfaces
+ if vdu.get("guest-epa"): # TODO or dedicated_int:
+ epa_vcpu_set = False
+ if vdu["guest-epa"].get("numa-node-policy"): # TODO or dedicated_int:
+ numa_node_policy = vdu["guest-epa"].get("numa-node-policy")
+ if numa_node_policy.get("node"):
+ numa_node = numa_node_policy["node"].values()[0]
+ if numa_node.get("num-cores"):
+ numa["cores"] = numa_node["num-cores"]
+ epa_vcpu_set = True
+ if numa_node.get("paired-threads"):
+ if numa_node["paired-threads"].get("num-paired-threads"):
+ numa["paired-threads"] = int(numa_node["paired-threads"]["num-paired-threads"])
+ epa_vcpu_set = True
+ if len(numa_node["paired-threads"].get("paired-thread-ids")):
+ numa["paired-threads-id"] = []
+ for pair in numa_node["paired-threads"]["paired-thread-ids"].itervalues():
+ numa["paired-threads-id"].append(
+ (str(pair["thread-a"]), str(pair["thread-b"]))
+ )
+ if numa_node.get("num-threads"):
+ numa["threads"] = int(numa_node["num-threads"])
+ epa_vcpu_set = True
+ if numa_node.get("memory-mb"):
+ numa["memory"] = max(int(numa_node["memory-mb"] / 1024), 1)
+ if vdu["guest-epa"].get("mempage-size"):
+ if vdu["guest-epa"]["mempage-size"] != "SMALL":
+ numa["memory"] = max(int(db_flavor["ram"] / 1024), 1)
+ if vdu["guest-epa"].get("cpu-pinning-policy") and not epa_vcpu_set:
+ if vdu["guest-epa"]["cpu-pinning-policy"] == "DEDICATED":
+ if vdu["guest-epa"].get("cpu-thread-pinning-policy") and \
+ vdu["guest-epa"]["cpu-thread-pinning-policy"] != "PREFER":
+ numa["cores"] = max(db_flavor["vcpus"], 1)
+ else:
+ numa["threads"] = max(db_flavor["vcpus"], 1)
+ if numa:
+ extended["numas"] = [numa]
+ if extended:
+ extended_text = yaml.safe_dump(extended, default_flow_style=True, width=256)
+ db_flavor["extended"] = extended_text
+ # look if flavor exist
+ temp_flavor_dict = {'disk': db_flavor.get('disk', 0),
+ 'ram': db_flavor.get('ram'),
+ 'vcpus': db_flavor.get('vcpus'),
+ 'extended': db_flavor.get('extended')
+ }
+ existing_flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict)
+ if existing_flavors:
+ flavor_uuid = existing_flavors[0]["uuid"]
+ else:
+ flavor_uuid = str(uuid4())
+ uuid_list.append(flavor_uuid)
+ db_flavor["uuid"] = flavor_uuid
+ db_flavors.append(db_flavor)
+ db_vm["flavor_id"] = flavor_uuid
+
# VNF affinity and antiaffinity
for pg in vnfd.get("placement-groups").itervalues():
pg_name = get_str(pg, "name", 255)
if vdu_id not in vdu_id2db_table_index:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'placement-groups[{pg}]':"
"'member-vdus':'{vdu}'. Reference to a non-existing vdu".format(
- vnf=vnfd["id"], pg=pg_name, vdu=vdu_id),
+ vnf=vnfd_id, pg=pg_name, vdu=vdu_id),
HTTP_Bad_Request)
db_vms[vdu_id2db_table_index[vdu_id]]["availability_zone"] = pg_name
# TODO consider the case of isolation and not colocation
# VNF mgmt configuration
mgmt_access = {}
if vnfd["mgmt-interface"].get("vdu-id"):
- if vnfd["mgmt-interface"]["vdu-id"] not in vdu_id2uuid:
+ mgmt_vdu_id = get_str(vnfd["mgmt-interface"], "vdu-id", 255)
+ if mgmt_vdu_id not in vdu_id2uuid:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'mgmt-interface':'vdu-id':"
"'{vdu}'. Reference to a non-existing vdu".format(
- vnf=vnfd["id"], vdu=vnfd["mgmt-interface"]["vdu-id"]),
+ vnf=vnfd_id, vdu=mgmt_vdu_id),
HTTP_Bad_Request)
mgmt_access["vm_id"] = vdu_id2uuid[vnfd["mgmt-interface"]["vdu-id"]]
+ # if only one cp is defined by this VDU, mark this interface as of type "mgmt"
+ if vdu_id2cp_name.get(mgmt_vdu_id):
+ cp_name2db_interface[vdu_id2cp_name[mgmt_vdu_id]]["type"] = "mgmt"
+
if vnfd["mgmt-interface"].get("ip-address"):
mgmt_access["ip-address"] = str(vnfd["mgmt-interface"].get("ip-address"))
if vnfd["mgmt-interface"].get("cp"):
if vnfd["mgmt-interface"]["cp"] not in cp_name2iface_uuid:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'mgmt-interface':'cp':'{cp}'. "
"Reference to a non-existing connection-point".format(
- vnf=vnfd["id"], cp=vnfd["mgmt-interface"]["cp"]),
+ vnf=vnfd_id, cp=vnfd["mgmt-interface"]["cp"]),
HTTP_Bad_Request)
mgmt_access["vm_id"] = cp_name2vm_uuid[vnfd["mgmt-interface"]["cp"]]
mgmt_access["interface_id"] = cp_name2iface_uuid[vnfd["mgmt-interface"]["cp"]]
myflavorDict["description"] = VNFCitem["description"]
myflavorDict["ram"] = vnfc.get("ram", 0)
myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
- myflavorDict["disk"] = vnfc.get("disk", 1)
+ myflavorDict["disk"] = vnfc.get("disk", 0)
myflavorDict["extended"] = {}
devices = vnfc.get("devices")
myflavorDict["description"] = VNFCitem["description"]
myflavorDict["ram"] = vnfc.get("ram", 0)
myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
- myflavorDict["disk"] = vnfc.get("disk", 1)
+ myflavorDict["disk"] = vnfc.get("disk", 0)
myflavorDict["extended"] = {}
devices = vnfc.get("devices")
content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces on vms.uuid=interfaces.vm_id',\
SELECT=('interfaces.uuid as uuid','interfaces.external_name as external_name', 'vms.name as vm_name', 'interfaces.vm_id as vm_id', \
'interfaces.internal_name as internal_name', 'interfaces.type as type', 'interfaces.vpci as vpci','interfaces.bw as bw'),\
- WHERE={'vnfs.uuid': vnf_id},
- WHERE_NOT={'interfaces.external_name': None} )
+ WHERE={'vnfs.uuid': vnf_id, 'interfaces.external_name<>': None} )
#print content
data['vnf']['external-connections'] = content
continue
#flavor not used, must be deleted
#delelte at VIM
- c = mydb.get_rows(FROM='datacenters_flavors', WHERE={'flavor_id':flavor})
+ c = mydb.get_rows(FROM='datacenters_flavors', WHERE={'flavor_id': flavor})
for flavor_vim in c:
- if flavor_vim["datacenter_vim_id"] not in vims: # TODO change to datacenter_tenant_id
+ if not flavor_vim['created']: # skip this flavor because not created by openmano
continue
- if flavor_vim['created']=='false': #skip this flavor because not created by openmano
+ # look for vim
+ myvim = None
+ for vim in vims.values():
+ if vim["config"]["datacenter_tenant_id"] == flavor_vim["datacenter_vim_id"]:
+ myvim = vim
+ break
+ if not myvim:
continue
- myvim=vims[ flavor_vim["datacenter_id"] ]
try:
myvim.delete_flavor(flavor_vim["vim_id"])
- except vimconn.vimconnNotFoundException as e:
- logger.warn("VIM flavor %s not exist at datacenter %s", flavor_vim["vim_id"], flavor_vim["datacenter_id"] )
+ except vimconn.vimconnNotFoundException:
+ logger.warn("VIM flavor %s not exist at datacenter %s", flavor_vim["vim_id"],
+ flavor_vim["datacenter_vim_id"] )
except vimconn.vimconnException as e:
logger.error("Not possible to delete VIM flavor %s from datacenter %s: %s %s",
- flavor_vim["vim_id"], flavor_vim["datacenter_id"], type(e).__name__, str(e))
- undeletedItems.append("flavor {} from VIM {}".format(flavor_vim["vim_id"], flavor_vim["datacenter_id"] ))
- #delete flavor from Database, using table flavors and with cascade foreign key also at datacenters_flavors
+ flavor_vim["vim_id"], flavor_vim["datacenter_vim_id"], type(e).__name__, str(e))
+ undeletedItems.append("flavor {} from VIM {}".format(flavor_vim["vim_id"],
+ flavor_vim["datacenter_vim_id"]))
+ # delete flavor from Database, using table flavors and with cascade foreign key also at datacenters_flavors
mydb.delete_row_by_id('flavors', flavor)
except db_base_Exception as e:
logger.error("delete_vnf_error. Not possible to get flavor details and delete '%s'. %s", flavor, str(e))
- undeletedItems.append("flavor %s" % flavor)
+ undeletedItems.append("flavor {}".format(flavor))
for image in imageList:
#1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces
for name,vnf in vnfs.items():
- where={}
- where_or={"tenant_id": tenant_id, 'public': "true"}
+ where = {"OR": {"tenant_id": tenant_id, 'public': "true"}}
error_text = ""
error_pos = "'topology':'nodes':'" + name + "'"
if 'vnf_id' in vnf:
if 'VNF model' in vnf:
error_text += " 'VNF model' " + vnf['VNF model']
where['name'] = vnf['VNF model']
- if len(where) == 0:
+ if len(where) == 1:
raise NfvoException("Descriptor need a 'vnf_id' or 'VNF model' field at " + error_pos, HTTP_Bad_Request)
vnf_db = mydb.get_rows(SELECT=('uuid','name','description'),
FROM='vnfs',
- WHERE=where,
- WHERE_OR=where_or,
- WHERE_AND_OR="AND")
+ WHERE=where)
if len(vnf_db)==0:
raise NfvoException("unknown" + error_text + " at " + error_pos, HTTP_Not_Found)
elif len(vnf_db)>1:
#get external interfaces
ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'),
FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
- WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} )
+ WHERE={'vnfs.uuid':vnf['uuid'], 'external_name<>': None} )
for ext_iface in ext_ifaces:
vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']}
# 1: Check that VNF are present at database table vnfs and update content into scenario dict
for name,vnf in scenario["vnfs"].iteritems():
- where={}
- where_or={"tenant_id": tenant_id, 'public': "true"}
+ where = {"OR": {"tenant_id": tenant_id, 'public': "true"}}
error_text = ""
error_pos = "'scenario':'vnfs':'" + name + "'"
if 'vnf_id' in vnf:
if 'vnf_name' in vnf:
error_text += " 'vnf_name' " + vnf['vnf_name']
where['name'] = vnf['vnf_name']
- if len(where) == 0:
+ if len(where) == 1:
raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, HTTP_Bad_Request)
vnf_db = mydb.get_rows(SELECT=('uuid', 'name', 'description'),
FROM='vnfs',
- WHERE=where,
- WHERE_OR=where_or,
- WHERE_AND_OR="AND")
+ WHERE=where)
if len(vnf_db) == 0:
raise NfvoException("Unknown" + error_text + " at " + error_pos, HTTP_Not_Found)
elif len(vnf_db) > 1:
# get external interfaces
ext_ifaces = mydb.get_rows(SELECT=('external_name as name', 'i.uuid as iface_uuid', 'i.type as type'),
FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
- WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name': None} )
+ WHERE={'vnfs.uuid':vnf['uuid'], 'external_name<>': None} )
for ext_iface in ext_ifaces:
vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type': ext_iface['type']}
# TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly
elif vld.get("provider-network").get("overlay-type") == "VLAN":
db_sce_net["type"] = "data"
else:
- db_sce_net["type"] = "bridge"
+ # later on it will be fixed to bridge or data depending on the type of interfaces attached to it
+ db_sce_net["type"] = None
db_sce_nets.append(db_sce_net)
# ip-profile, link db_ip_profile with db_sce_net
str(nsd["id"]), str(vld["id"]), str(iface["member-vnf-index-ref"])),
HTTP_Bad_Request)
- existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',),
+ existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid', 'i.type as iface_type'),
FROM="interfaces as i join vms on i.vm_id=vms.uuid",
WHERE={'vnf_id': vnf_index2vnf_uuid[vnf_index],
'external_name': get_str(iface, "vnfd-connection-point-ref",
str(iface.get("vnfd-id-ref"))[:255]),
HTTP_Bad_Request)
interface_uuid = existing_ifaces[0]["uuid"]
+ if existing_ifaces[0]["iface_type"] == "data" and not db_sce_net["type"]:
+ db_sce_net["type"] = "data"
sce_interface_uuid = str(uuid4())
uuid_list.append(sce_net_uuid)
db_sce_interface = {
# "ip_address": #TODO
}
db_sce_interfaces.append(db_sce_interface)
+ if not db_sce_net["type"]:
+ db_sce_net["type"] = "bridge"
db_tables = [
{"scenarios": db_scenarios},
else:
av_index = None
- vm_id = myvim.new_vminstance(myVMDict['name'], myVMDict['description'], myVMDict.get('start', None),
+ vm_id, _ = myvim.new_vminstance(myVMDict['name'], myVMDict['description'], myVMDict.get('start', None),
myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'],
availability_zone_index=av_index,
availability_zone_list=vnf_availability_zones)
myvims = {}
myvim_threads = {}
vimthread_affected = {}
+ net2vm_dependencies = {}
task_index = 0
instance_action_id = get_task_id()
if not myvim:
error_msg += "\n VM id={} cannot be deleted because datacenter={} not found".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
continue
- try:
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": sce_vnf["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_vms",
- "item_id": vm["uuid"],
- "extra": yaml.safe_dump({"params": vm["interfaces"]},
- default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- except vimconn.vimconnNotFoundException as e:
- error_msg+="\n VM VIM_id={} not found at datacenter={}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
- logger.warn("VM instance '%s'uuid '%s', VIM id '%s', from VNF_id '%s' not found",
- vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id'])
- except vimconn.vimconnException as e:
- error_msg+="\n VM VIM_id={} at datacenter={} Error: {} {}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"], e.http_code, str(e))
- logger.error("Error %d deleting VM instance '%s'uuid '%s', VIM_id '%s', from VNF_id '%s': %s",
- e.http_code, vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id'], str(e))
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": sce_vnf["datacenter_tenant_id"],
+ "action": "DELETE",
+ "status": "SCHEDULED",
+ "item": "instance_vms",
+ "item_id": vm["uuid"],
+ "extra": yaml.safe_dump({"params": vm["interfaces"]},
+ default_flow_style=True, width=256)
+ }
+ db_vim_actions.append(db_vim_action)
+ for interface in vm["interfaces"]:
+ if not interface.get("instance_net_id"):
+ continue
+ if interface["instance_net_id"] not in net2vm_dependencies:
+ net2vm_dependencies[interface["instance_net_id"]] = []
+ net2vm_dependencies[interface["instance_net_id"]].append(task_index)
+ task_index += 1
# 2.2 deleting NETS
# net_fail_list=[]
for net in instanceDict['nets']:
- # TODO if not net['created']:
- # TODO continue #skip not created nets
-
vimthread_affected[net["datacenter_tenant_id"]] = None
datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
if datacenter_key not in myvims:
if not myvim:
error_msg += "\n Net VIM_id={} cannot be deleted because datacenter={} not found".format(net['vim_net_id'], net["datacenter_id"])
continue
- try:
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": net["datacenter_tenant_id"],
- "action": "DELETE",
- "status": "SCHEDULED",
- "item": "instance_nets",
- "item_id": net["uuid"],
- "extra": yaml.safe_dump({"params": (net['vim_net_id'], net['sdn_net_id'])},
- default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
- except vimconn.vimconnNotFoundException as e:
- error_msg += "\n NET VIM_id={} not found at datacenter={}".format(net['vim_net_id'], net["datacenter_id"])
- logger.warn("NET '%s', VIM_id '%s', from VNF_net_id '%s' not found",
- net['uuid'], net['vim_net_id'], str(net['vnf_net_id']))
- except vimconn.vimconnException as e:
- error_msg += "\n NET VIM_id={} at datacenter={} Error: {} {}".format(net['vim_net_id'],
- net["datacenter_id"],
- e.http_code, str(e))
- logger.error("Error %d deleting NET '%s', VIM_id '%s', from VNF_net_id '%s': %s",
- e.http_code, net['uuid'], net['vim_net_id'], str(net['vnf_net_id']), str(e))
+ extra = {"params": (net['vim_net_id'], net['sdn_net_id'])}
+ if net2vm_dependencies.get(net["uuid"]):
+ extra["depends_on"] = net2vm_dependencies[net["uuid"]]
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": net["datacenter_tenant_id"],
+ "action": "DELETE",
+ "status": "SCHEDULED",
+ "item": "instance_nets",
+ "item_id": net["uuid"],
+ "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
+ }
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
db_instance_action["number_tasks"] = task_index
db_tables = [
except (IOError, ImportError):
# if module_info and module_info[0]:
# file.close(module_info[0])
- raise NfvoException("Incorrect datacenter type '{}'. Plugin '{}'.py not installed".format(datacenter_type, module), HTTP_Bad_Request)
+ raise NfvoException("Incorrect datacenter type '{}'. Plugin '{}.py' not installed".format(datacenter_type, module), HTTP_Bad_Request)
datacenter_id = mydb.new_row("datacenters", datacenter_descriptor, add_uuid=True, confidential_data=True)
return datacenter_id
#If the datacenter has a SDN controller defined and the network is of dataplane type, then create the sdn network
if get_sdn_controller_id(mydb, datacenter) != None and (net_type == 'data' or net_type == 'ptp'):
+ #obtain datacenter_tenant_id
+ datacenter_tenant_id = mydb.get_rows(SELECT=('uuid',),
+ FROM='datacenter_tenants',
+ WHERE={'datacenter_id': datacenter})[0]['uuid']
try:
sdn_network = {}
sdn_network['vlan'] = net_vlan
sdn_network['type'] = net_type
sdn_network['name'] = net_name
+ sdn_network['region'] = datacenter_tenant_id
ovim_content = ovim.new_network(sdn_network)
except ovimException as e:
- self.logger.error("ovimException creating SDN network={} ".format(
+ logger.error("ovimException creating SDN network={} ".format(
sdn_network) + str(e), exc_info=True)
raise NfvoException("ovimException creating SDN network={} ".format(sdn_network) + str(e),
HTTP_Internal_Server_Error)
# Save entry in in dabase mano_db in table instance_nets to stablish a dictionary vim_net_id <->sdn_net_id
# use instance_scenario_id=None to distinguish from real instaces of nets
- correspondence = {'instance_scenario_id': None, 'sdn_net_id': ovim_content, 'vim_net_id': content}
- #obtain datacenter_tenant_id
- correspondence['datacenter_tenant_id'] = mydb.get_rows(SELECT=('uuid',), FROM='datacenter_tenants', WHERE={'datacenter_id': datacenter})[0]['uuid']
-
+ correspondence = {'instance_scenario_id': None,
+ 'sdn_net_id': ovim_content,
+ 'vim_net_id': content,
+ 'datacenter_tenant_id': datacenter_tenant_id
+ }
try:
mydb.new_row('instance_nets', correspondence, add_uuid=True)
except db_base_Exception as e:
- raise NfvoException("Error saving correspondence for VIM/SDN dataplane networks{}: ".format(correspondence) +
- str(e), HTTP_Internal_Server_Error)
+ raise NfvoException("Error saving correspondence for VIM/SDN dataplane networks{}: {}".format(
+ correspondence, e), HTTP_Internal_Server_Error)
elif item=="tenants":
tenant = descriptor["tenant"]
content = myvim.new_tenant(tenant["name"], tenant.get("description"))