import osm_im.vnfd as vnfd_catalog
import osm_im.nsd as nsd_catalog
from pyangbind.lib.serialise import pybindJSONDecoder
-from itertools import chain
+from copy import deepcopy
+
global global_config
global vimconn_imported
def get_imagelist(mydb, vnf_id, nfvo_tenant=None):
- '''Obtain imageList
- return result, content:
- <0, error_text upon error
- nb_records, flavor_list on success
- '''
- WHERE_dict={}
- WHERE_dict['vnf_id'] = vnf_id
- if nfvo_tenant is not None:
- WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
-
- #result, content = mydb.get_table(FROM='vms join vnfs on vms-vnf_id = vnfs.uuid',SELECT=('uuid'),WHERE=WHERE_dict )
- images = mydb.get_rows(FROM='vms join images on vms.image_id=images.uuid',SELECT=('image_id',),WHERE=WHERE_dict )
- imageList=[]
- for image in images:
- imageList.append(image['image_id'])
- return imageList
+ """
+ Get used images of all vms belonging to this VNFD
+ :param mydb: database conector
+ :param vnf_id: vnfd uuid
+ :param nfvo_tenant: tenant, not used
+ :return: The list of image uuid used
+ """
+ image_list = []
+ vms = mydb.get_rows(SELECT=('image_id','image_list'), FROM='vms', WHERE={'vnf_id': vnf_id})
+ for vm in vms:
+ if vm["image_id"] not in image_list:
+ image_list.append(vm["image_id"])
+ if vm["image_list"]:
+ vm_image_list = yaml.load(vm["image_list"])
+ for image_dict in vm_image_list:
+ if image_dict["image_id"] not in image_list:
+ image_list.append(image_dict["image_id"])
+ return image_list
def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, datacenter_tenant_id=None,
- vim_tenant=None, vim_tenant_name=None, vim_user=None, vim_passwd=None):
+ vim_tenant=None, vim_tenant_name=None, vim_user=None, vim_passwd=None, ignore_errors=False):
'''Obtain a dictionary of VIM (datacenter) classes with some of the input parameters
return dictionary with {datacenter_id: vim_class, ... }. vim_class contain:
'nfvo_tenant_id','datacenter_id','vim_tenant_id','vim_url','vim_url_admin','datacenter_name','type','user','passwd'
vim_dict={}
for vim in vims:
extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'),
- 'datacenter_id': vim.get('datacenter_id')}
+ 'datacenter_id': vim.get('datacenter_id'),
+ '_vim_type_internal': vim.get('type')}
if vim["config"]:
extra.update(yaml.load(vim["config"]))
if vim.get('dt_config'):
except (IOError, ImportError) as e:
# if module_info and module_info[0]:
# file.close(module_info[0])
+ if ignore_errors:
+ logger.error("Unknown vim type '{}'. Can not open file '{}.py'; {}: {}".format(
+ vim["type"], module, type(e).__name__, str(e)))
+ continue
raise NfvoException("Unknown vim type '{}'. Can not open file '{}.py'; {}: {}".format(
vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request)
config=extra, persistent_info=persistent_info
)
except Exception as e:
- raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), HTTP_Internal_Server_Error)
+ if ignore_errors:
+ logger.error("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)))
+ continue
+ http_code = HTTP_Internal_Server_Error
+ if isinstance(e, vimconn.vimconnException):
+ http_code = e.http_code
+ raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), http_code)
return vim_dict
except db_base_Exception as e:
raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code)
device=devices_original[index]
if "image" not in device and "image name" not in device:
if 'size' in device:
- disk_list.append({'size': device.get('size', default_volume_size)})
+ disk_list.append({'size': device.get('size', default_volume_size), 'name': device.get('name')})
continue
image_dict={}
image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img")
db_interfaces = []
db_images = []
db_flavors = []
+ db_ip_profiles_index = 0
+ db_ip_profiles = []
uuid_list = []
vnfd_uuid_list = []
vnfd_catalog_descriptor = vnf_descriptor.get("vnfd:vnfd-catalog")
if vnfd_descriptor["id"] == str(vnfd["id"]):
break
+ # table ip_profiles (ip-profiles)
+ ip_profile_name2db_table_index = {}
+ for ip_profile in vnfd.get("ip-profiles").itervalues():
+ db_ip_profile = {
+ "ip_version": str(ip_profile["ip-profile-params"].get("ip-version", "ipv4")),
+ "subnet_address": str(ip_profile["ip-profile-params"].get("subnet-address")),
+ "gateway_address": str(ip_profile["ip-profile-params"].get("gateway-address")),
+ "dhcp_enabled": str(ip_profile["ip-profile-params"]["dhcp-params"].get("enabled", True)),
+ "dhcp_start_address": str(ip_profile["ip-profile-params"]["dhcp-params"].get("start-address")),
+ "dhcp_count": str(ip_profile["ip-profile-params"]["dhcp-params"].get("count")),
+ }
+ dns_list = []
+ for dns in ip_profile["ip-profile-params"]["dns-server"].itervalues():
+ dns_list.append(str(dns.get("address")))
+ db_ip_profile["dns_address"] = ";".join(dns_list)
+ if ip_profile["ip-profile-params"].get('security-group'):
+ db_ip_profile["security_group"] = ip_profile["ip-profile-params"]['security-group']
+ ip_profile_name2db_table_index[str(ip_profile["name"])] = db_ip_profiles_index
+ db_ip_profiles_index += 1
+ db_ip_profiles.append(db_ip_profile)
+
# table nets (internal-vld)
net_id2uuid = {} # for mapping interface with network
for vld in vnfd.get("internal-vld").itervalues():
"vnf_id": vnf_uuid,
"uuid": net_uuid,
"description": get_str(vld, "description", 255),
+ "osm_id": get_str(vld, "id", 255),
"type": "bridge", # TODO adjust depending on connection point type
}
net_id2uuid[vld.get("id")] = net_uuid
db_nets.append(db_net)
+ # ip-profile, link db_ip_profile with db_sce_net
+ if vld.get("ip-profile-ref"):
+ ip_profile_name = vld.get("ip-profile-ref")
+ if ip_profile_name not in ip_profile_name2db_table_index:
+ raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{}]':'vld[{}]':'ip-profile-ref':"
+ "'{}'. Reference to a non-existing 'ip_profiles'".format(
+ str(vnfd["id"]), str(vld["id"]), str(vld["ip-profile-ref"])),
+ HTTP_Bad_Request)
+ db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["net_id"] = net_uuid
+ else: #check no ip-address has been defined
+ for icp in vld.get("internal-connection-point").itervalues():
+ if icp.get("ip-address"):
+ raise NfvoException("Error at 'vnfd[{}]':'vld[{}]':'internal-connection-point[{}]' "
+ "contains an ip-address but no ip-profile has been defined at VLD".format(
+ str(vnfd["id"]), str(vld["id"]), str(icp["id"])),
+ HTTP_Bad_Request)
# connection points vaiable declaration
cp_name2iface_uuid = {}
vdu_id2uuid = {}
vdu_id2db_table_index = {}
for vdu in vnfd.get("vdu").itervalues():
+
+ for vdu_descriptor in vnfd_descriptor["vdu"]:
+ if vdu_descriptor["id"] == str(vdu["id"]):
+ break
vm_uuid = str(uuid4())
uuid_list.append(vm_uuid)
vdu_id = get_str(vdu, "id", 255)
image_uuid = db_image["uuid"]
db_images.append(db_image)
db_vm["image_id"] = image_uuid
+ if vdu.get("alternative-images"):
+ vm_alternative_images = []
+ for alt_image in vdu.get("alternative-images").itervalues():
+ db_image = {}
+ image_uuid = _lookfor_or_create_image(db_image, mydb, alt_image)
+ if not image_uuid:
+ image_uuid = db_image["uuid"]
+ db_images.append(db_image)
+ vm_alternative_images.append({
+ "image_id": image_uuid,
+ "vim_type": str(alt_image["vim-type"]),
+ # "universal_name": str(alt_image["image"]),
+ # "checksum": str(alt_image["image-checksum"]) if alt_image.get("image-checksum") else None
+ })
+
+ db_vm["image_list"] = yaml.safe_dump(vm_alternative_images, default_flow_style=True, width=256)
# volumes
devices = []
if vdu.get("volumes"):
- for volume_key in sorted(vdu["volumes"]):
+ for volume_key in vdu["volumes"]:
volume = vdu["volumes"][volume_key]
if not image_present:
# Convert the first volume to vnfc.image
db_vm["image_id"] = image_uuid
else:
# Add Openmano devices
- device = {}
+ device = {"name": str(volume.get("name"))}
device["type"] = str(volume.get("device-type"))
if volume.get("size"):
device["size"] = int(volume["size"])
device["image name"] = str(volume["image"])
if volume.get("image-checksum"):
device["image checksum"] = str(volume["image-checksum"])
+
devices.append(device)
# cloud-init
HTTP_Bad_Request)
elif iface.get("internal-connection-point-ref"):
try:
+ for icp_descriptor in vdu_descriptor["internal-connection-point"]:
+ if icp_descriptor["id"] == str(iface.get("internal-connection-point-ref")):
+ break
+ else:
+ raise KeyError("does not exist at vdu:internal-connection-point")
+ icp = None
+ icp_vld = None
for vld in vnfd.get("internal-vld").itervalues():
for cp in vld.get("internal-connection-point").itervalues():
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["internal_name"]:
- break
- 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":
- db_interface["port_security"] = 1
- break
- except KeyError:
+ if icp:
+ raise KeyError("is referenced by more than one 'internal-vld'")
+ icp = cp
+ icp_vld = vld
+ if not icp:
+ raise KeyError("is not referenced by any 'internal-vld'")
+
+ db_interface["net_id"] = net_id2uuid[icp_vld.get("id")]
+ if str(icp_descriptor.get("port-security-enabled")).lower() == "false":
+ db_interface["port_security"] = 0
+ elif str(icp_descriptor.get("port-security-enabled")).lower() == "true":
+ db_interface["port_security"] = 1
+ if icp.get("ip-address"):
+ if not icp_vld.get("ip-profile-ref"):
+ raise NfvoException
+ db_interface["ip_address"] = str(icp.get("ip-address"))
+ except KeyError as e:
raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'vdu[{vdu}]':"
- "'interface[{iface}]':'internal-connection-point-ref':'{cp}' is not"
- " referenced by any internal-vld".format(
+ "'interface[{iface}]':'internal-connection-point-ref':'{cp}'"
+ " {msg}".format(
vnf=vnfd_id, vdu=vdu_id, iface=iface["name"],
- cp=iface.get("internal-connection-point-ref")),
+ cp=iface.get("internal-connection-point-ref"), msg=str(e)),
HTTP_Bad_Request)
- if iface.get("position") is not None:
- db_interface["created_at"] = int(iface.get("position")) - 1000
+ if iface.get("position"):
+ db_interface["created_at"] = int(iface.get("position")) * 50
+ if iface.get("mac-address"):
+ db_interface["mac"] = str(iface.get("mac-address"))
db_interfaces.append(db_interface)
# table flavors
if mgmt_access:
db_vnf["mgmt_access"] = yaml.safe_dump(mgmt_access, default_flow_style=True, width=256)
-
-
db_vnfs.append(db_vnf)
db_tables=[
{"vnfs": db_vnfs},
{"nets": db_nets},
{"images": db_images},
{"flavors": db_flavors},
+ {"ip_profiles": db_ip_profiles},
{"vms": db_vms},
{"interfaces": db_interfaces},
]
vnf_descriptor['vnf']['tenant_id'] = tenant_id
# Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
if global_config["auto_push_VNF_to_VIMs"]:
- vims = get_vim(mydb, tenant_id)
+ vims = get_vim(mydb, tenant_id, ignore_errors=True)
# Step 4. Review the descriptor and add missing fields
#print vnf_descriptor
vnf_descriptor['vnf']['tenant_id'] = tenant_id
# Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
if global_config["auto_push_VNF_to_VIMs"]:
- vims = get_vim(mydb, tenant_id)
+ vims = get_vim(mydb, tenant_id, ignore_errors=True)
# Step 4. Review the descriptor and add missing fields
#print vnf_descriptor
if tenant_id != "any":
check_tenant(mydb, tenant_id)
# Get the URL of the VIM from the nfvo_tenant and the datacenter
- vims = get_vim(mydb, tenant_id)
+ vims = get_vim(mydb, tenant_id, ignore_errors=True)
else:
vims={}
for image in imageList:
try:
#check if image is used by other vnf
- c = mydb.get_rows(FROM='vms', WHERE={'image_id':image} )
+ c = mydb.get_rows(FROM='vms', WHERE=[{'image_id': image}, {'image_list LIKE ': '%' + image + '%'}])
if len(c) > 0:
logger.debug("Image '%s' not deleted because it is being used by another VNF", image)
continue
:param mydb:
:param tenant_id:
:param nsd_descriptor:
- :return: The list of cretated NSD ids
+ :return: The list of created NSD ids
"""
try:
mynsd = nsd_catalog.nsd()
db_sce_nets = []
db_sce_vnfs = []
db_sce_interfaces = []
+ db_sce_vnffgs = []
+ db_sce_rsps = []
+ db_sce_rsp_hops = []
+ db_sce_classifiers = []
+ db_sce_classifier_matches = []
db_ip_profiles = []
db_ip_profiles_index = 0
uuid_list = []
for nsd_yang in mynsd.nsd_catalog.nsd.itervalues():
nsd = nsd_yang.get()
- # table sceanrios
+ # table scenarios
scenario_uuid = str(uuid4())
uuid_list.append(scenario_uuid)
nsd_uuid_list.append(scenario_uuid)
db_sce_vnf = {
"uuid": sce_vnf_uuid,
"scenario_id": scenario_uuid,
- "name": existing_vnf[0]["name"][:200] + "." + get_str(vnf, "member-vnf-index", 5),
+ # "name": get_str(vnf, "member-vnf-index", 255),
+ "name": existing_vnf[0]["name"][:200] + "." + get_str(vnf, "member-vnf-index", 50),
"vnf_id": existing_vnf[0]["uuid"],
- "member_vnf_index": int(vnf["member-vnf-index"]),
+ "member_vnf_index": str(vnf["member-vnf-index"]),
# TODO 'start-by-default': True
}
- vnf_index2scevnf_uuid[int(vnf['member-vnf-index'])] = sce_vnf_uuid
- vnf_index2vnf_uuid[int(vnf['member-vnf-index'])] = existing_vnf[0]["uuid"]
+ vnf_index2scevnf_uuid[str(vnf['member-vnf-index'])] = sce_vnf_uuid
+ vnf_index2vnf_uuid[str(vnf['member-vnf-index'])] = existing_vnf[0]["uuid"]
db_sce_vnfs.append(db_sce_vnf)
# table ip_profiles (ip-profiles)
"scenario_id": scenario_uuid,
# "type": #TODO
"multipoint": not vld.get("type") == "ELINE",
+ "osm_id": get_str(vld, "id", 255),
# "external": #TODO
"description": get_str(vld, "description", 255),
}
str(nsd["id"]), str(vld["id"]), str(vld["ip-profile-ref"])),
HTTP_Bad_Request)
db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["sce_net_id"] = sce_net_uuid
+ elif vld.get("vim-network-name"):
+ db_sce_net["vim_network_name"] = get_str(vld, "vim-network-name", 255)
# table sce_interfaces (vld:vnfd-connection-point-ref)
for iface in vld.get("vnfd-connection-point-ref").itervalues():
- vnf_index = int(iface['member-vnf-index-ref'])
+ vnf_index = str(iface['member-vnf-index-ref'])
# check correct parameters
if vnf_index not in vnf_index2vnf_uuid:
raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'vld[{}]':'vnfd-connection-point"
db_sce_net["type"] = "data"
sce_interface_uuid = str(uuid4())
uuid_list.append(sce_net_uuid)
+ iface_ip_address = None
+ if iface.get("ip-address"):
+ iface_ip_address = str(iface.get("ip-address"))
db_sce_interface = {
"uuid": sce_interface_uuid,
"sce_vnf_id": vnf_index2scevnf_uuid[vnf_index],
"sce_net_id": sce_net_uuid,
"interface_id": interface_uuid,
- # "ip_address": #TODO
+ "ip_address": iface_ip_address,
}
db_sce_interfaces.append(db_sce_interface)
if not db_sce_net["type"]:
db_sce_net["type"] = "bridge"
+ # table sce_vnffgs (vnffgd)
+ for vnffg in nsd.get("vnffgd").itervalues():
+ sce_vnffg_uuid = str(uuid4())
+ uuid_list.append(sce_vnffg_uuid)
+ db_sce_vnffg = {
+ "uuid": sce_vnffg_uuid,
+ "name": get_str(vnffg, "name", 255),
+ "scenario_id": scenario_uuid,
+ "vendor": get_str(vnffg, "vendor", 255),
+ "description": get_str(vld, "description", 255),
+ }
+ db_sce_vnffgs.append(db_sce_vnffg)
+
+ # deal with rsps
+ db_sce_rsps = []
+ for rsp in vnffg.get("rsp").itervalues():
+ sce_rsp_uuid = str(uuid4())
+ uuid_list.append(sce_rsp_uuid)
+ db_sce_rsp = {
+ "uuid": sce_rsp_uuid,
+ "name": get_str(rsp, "name", 255),
+ "sce_vnffg_id": sce_vnffg_uuid,
+ "id": get_str(rsp, "id", 255), # only useful to link with classifiers; will be removed later in the code
+ }
+ db_sce_rsps.append(db_sce_rsp)
+ db_sce_rsp_hops = []
+ for iface in rsp.get("vnfd-connection-point-ref").itervalues():
+ vnf_index = str(iface['member-vnf-index-ref'])
+ if_order = int(iface['order'])
+ # check correct parameters
+ if vnf_index not in vnf_index2vnf_uuid:
+ raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
+ "-ref':'member-vnf-index-ref':'{}'. Reference to a non-existing index at "
+ "'nsd':'constituent-vnfd'".format(
+ str(nsd["id"]), str(rsp["id"]), str(iface["member-vnf-index-ref"])),
+ HTTP_Bad_Request)
+
+ existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',),
+ 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",
+ 255)})
+ if not existing_ifaces:
+ raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
+ "-ref':'vnfd-connection-point-ref':'{}'. Reference to a non-existing "
+ "connection-point name at VNFD '{}'".format(
+ str(nsd["id"]), str(rsp["id"]), str(iface["vnfd-connection-point-ref"]),
+ str(iface.get("vnfd-id-ref"))[:255]),
+ HTTP_Bad_Request)
+ interface_uuid = existing_ifaces[0]["uuid"]
+ sce_rsp_hop_uuid = str(uuid4())
+ uuid_list.append(sce_rsp_hop_uuid)
+ db_sce_rsp_hop = {
+ "uuid": sce_rsp_hop_uuid,
+ "if_order": if_order,
+ "interface_id": interface_uuid,
+ "sce_vnf_id": vnf_index2scevnf_uuid[vnf_index],
+ "sce_rsp_id": sce_rsp_uuid,
+ }
+ db_sce_rsp_hops.append(db_sce_rsp_hop)
+
+ # deal with classifiers
+ db_sce_classifiers = []
+ for classifier in vnffg.get("classifier").itervalues():
+ sce_classifier_uuid = str(uuid4())
+ uuid_list.append(sce_classifier_uuid)
+
+ # source VNF
+ vnf_index = str(classifier['member-vnf-index-ref'])
+ if vnf_index not in vnf_index2vnf_uuid:
+ raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'classifier[{}]':'vnfd-connection-point"
+ "-ref':'member-vnf-index-ref':'{}'. Reference to a non-existing index at "
+ "'nsd':'constituent-vnfd'".format(
+ str(nsd["id"]), str(classifier["id"]), str(classifier["member-vnf-index-ref"])),
+ HTTP_Bad_Request)
+ existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',),
+ FROM="interfaces as i join vms on i.vm_id=vms.uuid",
+ WHERE={'vnf_id': vnf_index2vnf_uuid[vnf_index],
+ 'external_name': get_str(classifier, "vnfd-connection-point-ref",
+ 255)})
+ if not existing_ifaces:
+ raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
+ "-ref':'vnfd-connection-point-ref':'{}'. Reference to a non-existing "
+ "connection-point name at VNFD '{}'".format(
+ str(nsd["id"]), str(rsp["id"]), str(iface["vnfd-connection-point-ref"]),
+ str(iface.get("vnfd-id-ref"))[:255]),
+ HTTP_Bad_Request)
+ interface_uuid = existing_ifaces[0]["uuid"]
+
+ db_sce_classifier = {
+ "uuid": sce_classifier_uuid,
+ "name": get_str(classifier, "name", 255),
+ "sce_vnffg_id": sce_vnffg_uuid,
+ "sce_vnf_id": vnf_index2scevnf_uuid[vnf_index],
+ "interface_id": interface_uuid,
+ }
+ rsp_id = get_str(classifier, "rsp-id-ref", 255)
+ rsp = next((item for item in db_sce_rsps if item["id"] == rsp_id), None)
+ db_sce_classifier["sce_rsp_id"] = rsp["uuid"]
+ db_sce_classifiers.append(db_sce_classifier)
+
+ db_sce_classifier_matches = []
+ for match in classifier.get("match-attributes").itervalues():
+ sce_classifier_match_uuid = str(uuid4())
+ uuid_list.append(sce_classifier_match_uuid)
+ db_sce_classifier_match = {
+ "uuid": sce_classifier_match_uuid,
+ "ip_proto": get_str(match, "ip-proto", 2),
+ "source_ip": get_str(match, "source-ip-address", 16),
+ "destination_ip": get_str(match, "destination-ip-address", 16),
+ "source_port": get_str(match, "source-port", 5),
+ "destination_port": get_str(match, "destination-port", 5),
+ "sce_classifier_id": sce_classifier_uuid,
+ }
+ db_sce_classifier_matches.append(db_sce_classifier_match)
+ # TODO: vnf/cp keys
+
+ # remove unneeded id's in sce_rsps
+ for rsp in db_sce_rsps:
+ rsp.pop('id')
+
db_tables = [
{"scenarios": db_scenarios},
{"sce_nets": db_sce_nets},
{"ip_profiles": db_ip_profiles},
{"sce_vnfs": db_sce_vnfs},
{"sce_interfaces": db_sce_interfaces},
+ {"sce_vnffgs": db_sce_vnffgs},
+ {"sce_rsps": db_sce_rsps},
+ {"sce_rsp_hops": db_sce_rsp_hops},
+ {"sce_classifiers": db_sce_classifiers},
+ {"sce_classifier_matches": db_sce_classifier_matches},
]
- logger.debug("create_vnf Deployment done vnfDict: %s",
+ logger.debug("new_nsd_v3 done: %s",
yaml.safe_dump(db_tables, indent=4, default_flow_style=False) )
mydb.new_rows(db_tables, uuid_list)
return nsd_uuid_list
d[k] = u[k]
return d
+
def create_instance(mydb, tenant_id, instance_dict):
# print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
# logger.debug("Creating instance...")
myvim_threads_id[default_datacenter_id], _ = get_vim_thread(mydb, tenant_id, default_datacenter_id)
tenant = mydb.get_rows_by_id('nfvo_tenants', tenant_id)
# myvim_tenant = myvim['tenant_id']
-
- rollbackList=[]
+ rollbackList = []
# print "Checking that the scenario exists and getting the scenario dictionary"
scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_vim_id=myvim_threads_id[default_datacenter_id],
db_instance_vnfs = []
db_instance_vms = []
db_instance_interfaces = []
+ db_instance_sfis = []
+ db_instance_sfs = []
+ db_instance_classifications = []
+ db_instance_sfps = []
db_ip_profiles = []
db_vim_actions = []
uuid_list = []
}
# Auxiliary dictionaries from x to y
- vnf_net2instance = {}
sce_net2instance = {}
net2task_id = {'scenario': {}}
+ def ip_profile_IM2RO(ip_profile_im):
+ # translate from input format to database format
+ ip_profile_ro = {}
+ if 'subnet-address' in ip_profile_im:
+ ip_profile_ro['subnet_address'] = ip_profile_im['subnet-address']
+ if 'ip-version' in ip_profile_im:
+ ip_profile_ro['ip_version'] = ip_profile_im['ip-version']
+ if 'gateway-address' in ip_profile_im:
+ ip_profile_ro['gateway_address'] = ip_profile_im['gateway-address']
+ if 'dns-address' in ip_profile_im:
+ ip_profile_ro['dns_address'] = ip_profile_im['dns-address']
+ if isinstance(ip_profile_ro['dns_address'], (list, tuple)):
+ ip_profile_ro['dns_address'] = ";".join(ip_profile_ro['dns_address'])
+ if 'dhcp' in ip_profile_im:
+ ip_profile_ro['dhcp_start_address'] = ip_profile_im['dhcp'].get('start-address')
+ ip_profile_ro['dhcp_enabled'] = ip_profile_im['dhcp'].get('enabled', True)
+ ip_profile_ro['dhcp_count'] = ip_profile_im['dhcp'].get('count')
+ return ip_profile_ro
+
# logger.debug("Creating instance from scenario-dict:\n%s",
# yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
try:
# 0 check correct parameters
for net_name, net_instance_desc in instance_dict.get("networks", {}).iteritems():
- found = False
for scenario_net in scenarioDict['nets']:
- if net_name == scenario_net["name"]:
- found = True
+ if net_name == scenario_net.get("name") or net_name == scenario_net.get("osm_id") or net_name == scenario_net.get("uuid"):
break
- if not found:
- raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(net_name),
+ else:
+ raise NfvoException("Invalid scenario network name or id '{}' at instance:networks".format(net_name),
HTTP_Bad_Request)
if "sites" not in net_instance_desc:
net_instance_desc["sites"] = [ {} ]
site["datacenter"] = default_datacenter_id # change name to id
for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).iteritems():
- found = False
for scenario_vnf in scenarioDict['vnfs']:
- if vnf_name == scenario_vnf['name']:
- found = True
+ if vnf_name == scenario_vnf['member_vnf_index'] or vnf_name == scenario_vnf['uuid'] or vnf_name == scenario_vnf['name']:
break
- if not found:
- raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_instance_desc), HTTP_Bad_Request)
+ else:
+ raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_name), HTTP_Bad_Request)
if "datacenter" in vnf_instance_desc:
# Add this datacenter to myvims
vnf_instance_desc["datacenter"] = get_datacenter_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"])
myvim_threads_id[d], _ = get_vim_thread(mydb, tenant_id, vnf_instance_desc["datacenter"])
scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"]
+ for net_id, net_instance_desc in vnf_instance_desc.get("networks", {}).iteritems():
+ for scenario_net in scenario_vnf['nets']:
+ if net_id == scenario_net['osm_id'] or net_id == scenario_net['uuid'] or net_id == scenario_net["name"]:
+ break
+ else:
+ raise NfvoException("Invalid net id or name '{}' at instance:vnfs:networks".format(net_id), HTTP_Bad_Request)
+ if net_instance_desc.get("vim-network-name"):
+ scenario_net["vim-network-name"] = net_instance_desc["vim-network-name"]
+ if net_instance_desc.get("name"):
+ scenario_net["name"] = net_instance_desc["name"]
+ if 'ip-profile' in net_instance_desc:
+ ipprofile_db = ip_profile_IM2RO(net_instance_desc['ip-profile'])
+ if 'ip_profile' not in scenario_net:
+ scenario_net['ip_profile'] = ipprofile_db
+ else:
+ update(scenario_net['ip_profile'], ipprofile_db)
+
+ for vdu_id, vdu_instance_desc in vnf_instance_desc.get("vdus", {}).iteritems():
+ for scenario_vm in scenario_vnf['vms']:
+ if vdu_id == scenario_vm['osm_id'] or vdu_id == scenario_vm["name"]:
+ break
+ else:
+ raise NfvoException("Invalid vdu id or name '{}' at instance:vnfs:vdus".format(vdu_id), HTTP_Bad_Request)
+ scenario_vm["instance_parameters"] = vdu_instance_desc
+ for iface_id, iface_instance_desc in vdu_instance_desc.get("interfaces", {}).iteritems():
+ for scenario_interface in scenario_vm['interfaces']:
+ if iface_id == scenario_interface['internal_name'] or iface_id == scenario_interface["external_name"]:
+ scenario_interface.update(iface_instance_desc)
+ break
+ else:
+ raise NfvoException("Invalid vdu id or name '{}' at instance:vnfs:vdus".format(vdu_id), HTTP_Bad_Request)
+
# 0.1 parse cloud-config parameters
cloud_config = unify_cloud_config(instance_dict.get("cloud-config"), scenarioDict.get("cloud-config"))
- # We add the RO key to cloud_config
- if tenant[0].get('RO_pub_key'):
- RO_key = {"key-pairs": [tenant[0]['RO_pub_key']]}
- cloud_config = unify_cloud_config(cloud_config, RO_key)
# 0.2 merge instance information into scenario
# Ideally, the operation should be as simple as: update(scenarioDict,instance_dict)
# However, this is not possible yet.
- for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems():
+ for net_name, net_instance_desc in instance_dict.get("networks", {}).iteritems():
for scenario_net in scenarioDict['nets']:
if net_name == scenario_net["name"]:
if 'ip-profile' in net_instance_desc:
- # translate from input format to database format
- ipprofile_in = net_instance_desc['ip-profile']
- ipprofile_db = {}
- ipprofile_db['subnet_address'] = ipprofile_in.get('subnet-address')
- ipprofile_db['ip_version'] = ipprofile_in.get('ip-version', 'IPv4')
- ipprofile_db['gateway_address'] = ipprofile_in.get('gateway-address')
- ipprofile_db['dns_address'] = ipprofile_in.get('dns-address')
- if isinstance(ipprofile_db['dns_address'], (list, tuple)):
- ipprofile_db['dns_address'] = ";".join(ipprofile_db['dns_address'])
- if 'dhcp' in ipprofile_in:
- ipprofile_db['dhcp_start_address'] = ipprofile_in['dhcp'].get('start-address')
- ipprofile_db['dhcp_enabled'] = ipprofile_in['dhcp'].get('enabled', True)
- ipprofile_db['dhcp_count'] = ipprofile_in['dhcp'].get('count' )
+ ipprofile_db = ip_profile_IM2RO(net_instance_desc['ip-profile'])
if 'ip_profile' not in scenario_net:
scenario_net['ip_profile'] = ipprofile_db
else:
update(scenario_net['ip_profile'], ipprofile_db)
- for interface in net_instance_desc.get('interfaces', () ):
+ for interface in net_instance_desc.get('interfaces', ()):
if 'ip_address' in interface:
for vnf in scenarioDict['vnfs']:
if interface['vnf'] == vnf['name']:
for vnf_interface in vnf['interfaces']:
if interface['vnf_interface'] == vnf_interface['external_name']:
- vnf_interface['ip_address']=interface['ip_address']
+ vnf_interface['ip_address'] = interface['ip_address']
# logger.debug(">>>>>>>> Merged dictionary")
# logger.debug("Creating instance scenario-dict MERGED:\n%s",
# yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False))
# 1. Creating new nets (sce_nets) in the VIM"
+ number_mgmt_networks = 0
db_instance_nets = []
for sce_net in scenarioDict['nets']:
- descriptor_net = instance_dict.get("networks", {}).get(sce_net["name"], {})
+ # get involved datacenters where this network need to be created
+ involved_datacenters = []
+ for sce_vnf in scenarioDict.get("vnfs"):
+ vnf_datacenter = sce_vnf.get("datacenter", default_datacenter_id)
+ if vnf_datacenter in involved_datacenters:
+ continue
+ if sce_vnf.get("interfaces"):
+ for sce_vnf_ifaces in sce_vnf["interfaces"]:
+ if sce_vnf_ifaces.get("sce_net_id") == sce_net["uuid"]:
+ involved_datacenters.append(vnf_datacenter)
+ break
+
+ descriptor_net = {}
+ if instance_dict.get("networks") and instance_dict["networks"].get(sce_net["name"]):
+ descriptor_net = instance_dict["networks"][sce_net["name"]]
net_name = descriptor_net.get("vim-network-name")
sce_net2instance[sce_net['uuid']] = {}
net2task_id['scenario'][sce_net['uuid']] = {}
- sites = descriptor_net.get("sites", [ {} ])
- for site in sites:
- if site.get("datacenter"):
- vim = myvims[ site["datacenter"] ]
- datacenter_id = site["datacenter"]
- myvim_thread_id = myvim_threads_id[ site["datacenter"] ]
- else:
- vim = myvims[ default_datacenter_id ]
- datacenter_id = default_datacenter_id
- myvim_thread_id = myvim_threads_id[default_datacenter_id]
+ if sce_net["external"]:
+ number_mgmt_networks += 1
+
+ for datacenter_id in involved_datacenters:
+ netmap_use = None
+ netmap_create = None
+ if descriptor_net.get("sites"):
+ for site in descriptor_net["sites"]:
+ if site.get("datacenter") == datacenter_id:
+ netmap_use = site.get("netmap-use")
+ netmap_create = site.get("netmap-create")
+ break
+
+ vim = myvims[datacenter_id]
+ myvim_thread_id = myvim_threads_id[datacenter_id]
+
net_type = sce_net['type']
lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} # 'shared': True
if sce_net["external"]:
net_name = sce_net["name"]
else:
- net_name = "{}.{}".format(instance_name, sce_net["name"])
+ net_name = "{}-{}".format(instance_name, sce_net["name"])
net_name = net_name[:255] # limit length
- if "netmap-use" in site or "netmap-create" in site:
+ if netmap_use or netmap_create:
create_network = False
lookfor_network = False
- if "netmap-use" in site:
+ if netmap_use:
lookfor_network = True
- if utils.check_valid_uuid(site["netmap-use"]):
- filter_text = "scenario id '%s'" % site["netmap-use"]
- lookfor_filter["id"] = site["netmap-use"]
+ if utils.check_valid_uuid(netmap_use):
+ lookfor_filter["id"] = netmap_use
else:
- filter_text = "scenario name '%s'" % site["netmap-use"]
- lookfor_filter["name"] = site["netmap-use"]
- if "netmap-create" in site:
+ lookfor_filter["name"] = netmap_use
+ if netmap_create:
create_network = True
net_vim_name = net_name
- if site["netmap-create"]:
- net_vim_name = site["netmap-create"]
+ if isinstance(netmap_create, str):
+ net_vim_name = netmap_create
+ elif sce_net.get("vim_network_name"):
+ create_network = False
+ lookfor_network = True
+ lookfor_filter["name"] = sce_net.get("vim_network_name")
elif sce_net["external"]:
- if sce_net['vim_id'] != None:
+ if sce_net['vim_id'] is not None:
# there is a netmap at datacenter_nets database # TODO REVISE!!!!
create_network = False
lookfor_network = True
lookfor_filter["id"] = sce_net['vim_id']
- filter_text = "vim_id '{}' datacenter_netmap name '{}'. Try to reload vims with "\
- "datacenter-net-update".format(sce_net['vim_id'], sce_net["name"])
- # look for network at datacenter and return error
+ elif vim["config"].get("management_network_id") or vim["config"].get("management_network_name"):
+ if number_mgmt_networks > 1:
+ raise NfvoException("Found several VLD of type mgmt. "
+ "You must concrete what vim-network must be use for each one",
+ HTTP_Bad_Request)
+ create_network = False
+ lookfor_network = True
+ if vim["config"].get("management_network_id"):
+ lookfor_filter["id"] = vim["config"]["management_network_id"]
+ else:
+ lookfor_filter["name"] = vim["config"]["management_network_name"]
else:
# There is not a netmap, look at datacenter for a net with this name and create if not found
create_network = True
lookfor_network = True
lookfor_filter["name"] = sce_net["name"]
net_vim_name = sce_net["name"]
- filter_text = "scenario name '%s'" % sce_net["name"]
else:
net_vim_name = net_name
create_network = True
"created": create_network,
'datacenter_id': datacenter_id,
'datacenter_tenant_id': myvim_thread_id,
- 'status': 'BUILD' if create_network else "ACTIVE"
+ 'status': 'BUILD' # if create_network else "ACTIVE"
}
db_instance_nets.append(db_net)
db_vim_action = {
}
db_ip_profiles.append(db_ip_profile)
- # 2. Creating new nets (vnf internal nets) in the VIM"
- # For each vnf net, we create it and we add it to instanceNetlist.
- for sce_vnf in scenarioDict['vnfs']:
- for net in sce_vnf['nets']:
- if sce_vnf.get("datacenter"):
- datacenter_id = sce_vnf["datacenter"]
- myvim_thread_id = myvim_threads_id[sce_vnf["datacenter"]]
- else:
- datacenter_id = default_datacenter_id
- myvim_thread_id = myvim_threads_id[default_datacenter_id]
- descriptor_net = instance_dict.get("vnfs", {}).get(sce_vnf["name"], {})
- net_name = descriptor_net.get("name")
- if not net_name:
- net_name = "{}.{}".format(instance_name, net["name"])
- net_name = net_name[:255] # limit length
- net_type = net['type']
-
- if sce_vnf['uuid'] not in vnf_net2instance:
- vnf_net2instance[sce_vnf['uuid']] = {}
- if sce_vnf['uuid'] not in net2task_id:
- net2task_id[sce_vnf['uuid']] = {}
- net2task_id[sce_vnf['uuid']][net['uuid']] = task_index
-
- # fill database content
- net_uuid = str(uuid4())
- uuid_list.append(net_uuid)
- vnf_net2instance[sce_vnf['uuid']][net['uuid']] = net_uuid
- db_net = {
- "uuid": net_uuid,
- 'vim_net_id': None,
+ # Create VNFs
+ vnf_params = {
+ "default_datacenter_id": default_datacenter_id,
+ "myvim_threads_id": myvim_threads_id,
+ "instance_uuid": instance_uuid,
+ "instance_name": instance_name,
+ "instance_action_id": instance_action_id,
+ "myvims": myvims,
+ "cloud_config": cloud_config,
+ "RO_pub_key": tenant[0].get('RO_pub_key'),
+ }
+ vnf_params_out = {
+ "task_index": task_index,
+ "uuid_list": uuid_list,
+ "db_instance_nets": db_instance_nets,
+ "db_vim_actions": db_vim_actions,
+ "db_ip_profiles": db_ip_profiles,
+ "db_instance_vnfs": db_instance_vnfs,
+ "db_instance_vms": db_instance_vms,
+ "db_instance_interfaces": db_instance_interfaces,
+ "net2task_id": net2task_id,
+ "sce_net2instance": sce_net2instance,
+ }
+ # sce_vnf_list = sorted(scenarioDict['vnfs'], key=lambda k: k['name'])
+ for sce_vnf in scenarioDict['vnfs']: # sce_vnf_list:
+ instantiate_vnf(mydb, sce_vnf, vnf_params, vnf_params_out, rollbackList)
+ task_index = vnf_params_out["task_index"]
+ uuid_list = vnf_params_out["uuid_list"]
+
+ # Create VNFFGs
+ # task_depends_on = []
+ for vnffg in scenarioDict['vnffgs']:
+ for rsp in vnffg['rsps']:
+ sfs_created = []
+ for cp in rsp['connection_points']:
+ count = mydb.get_rows(
+ SELECT=('vms.count'),
+ FROM="vms join interfaces on vms.uuid=interfaces.vm_id join sce_rsp_hops as h on interfaces.uuid=h.interface_id",
+ WHERE={'h.uuid': cp['uuid']})[0]['count']
+ instance_vnf = next((item for item in db_instance_vnfs if item['sce_vnf_id'] == cp['sce_vnf_id']), None)
+ instance_vms = [item for item in db_instance_vms if item['instance_vnf_id'] == instance_vnf['uuid']]
+ dependencies = []
+ for instance_vm in instance_vms:
+ action = next((item for item in db_vim_actions if item['item_id'] == instance_vm['uuid']), None)
+ if action:
+ dependencies.append(action['task_index'])
+ # TODO: throw exception if count != len(instance_vms)
+ # TODO: and action shouldn't ever be None
+ sfis_created = []
+ for i in range(count):
+ # create sfis
+ sfi_uuid = str(uuid4())
+ uuid_list.append(sfi_uuid)
+ db_sfi = {
+ "uuid": sfi_uuid,
+ "instance_scenario_id": instance_uuid,
+ 'sce_rsp_hop_id': cp['uuid'],
+ 'datacenter_id': datacenter_id,
+ 'datacenter_tenant_id': myvim_thread_id,
+ "vim_sfi_id": None, # vim thread will populate
+ }
+ db_instance_sfis.append(db_sfi)
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": myvim_thread_id,
+ "action": "CREATE",
+ "status": "SCHEDULED",
+ "item": "instance_sfis",
+ "item_id": sfi_uuid,
+ "extra": yaml.safe_dump({"params": "", "depends_on": [dependencies[i]]},
+ default_flow_style=True, width=256)
+ }
+ sfis_created.append(task_index)
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+ # create sfs
+ sf_uuid = str(uuid4())
+ uuid_list.append(sf_uuid)
+ db_sf = {
+ "uuid": sf_uuid,
+ "instance_scenario_id": instance_uuid,
+ 'sce_rsp_hop_id': cp['uuid'],
+ 'datacenter_id': datacenter_id,
+ 'datacenter_tenant_id': myvim_thread_id,
+ "vim_sf_id": None, # vim thread will populate
+ }
+ db_instance_sfs.append(db_sf)
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": myvim_thread_id,
+ "action": "CREATE",
+ "status": "SCHEDULED",
+ "item": "instance_sfs",
+ "item_id": sf_uuid,
+ "extra": yaml.safe_dump({"params": "", "depends_on": sfis_created},
+ default_flow_style=True, width=256)
+ }
+ sfs_created.append(task_index)
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+ classifier = rsp['classifier']
+
+ # TODO the following ~13 lines can be reused for the sfi case
+ count = mydb.get_rows(
+ SELECT=('vms.count'),
+ FROM="vms join interfaces on vms.uuid=interfaces.vm_id join sce_classifiers as c on interfaces.uuid=c.interface_id",
+ WHERE={'c.uuid': classifier['uuid']})[0]['count']
+ instance_vnf = next((item for item in db_instance_vnfs if item['sce_vnf_id'] == classifier['sce_vnf_id']), None)
+ instance_vms = [item for item in db_instance_vms if item['instance_vnf_id'] == instance_vnf['uuid']]
+ dependencies = []
+ for instance_vm in instance_vms:
+ action = next((item for item in db_vim_actions if item['item_id'] == instance_vm['uuid']), None)
+ if action:
+ dependencies.append(action['task_index'])
+ # TODO: throw exception if count != len(instance_vms)
+ # TODO: and action shouldn't ever be None
+ classifications_created = []
+ for i in range(count):
+ for match in classifier['matches']:
+ # create classifications
+ classification_uuid = str(uuid4())
+ uuid_list.append(classification_uuid)
+ db_classification = {
+ "uuid": classification_uuid,
+ "instance_scenario_id": instance_uuid,
+ 'sce_classifier_match_id': match['uuid'],
+ 'datacenter_id': datacenter_id,
+ 'datacenter_tenant_id': myvim_thread_id,
+ "vim_classification_id": None, # vim thread will populate
+ }
+ db_instance_classifications.append(db_classification)
+ classification_params = {
+ "ip_proto": match["ip_proto"],
+ "source_ip": match["source_ip"],
+ "destination_ip": match["destination_ip"],
+ "source_port": match["source_port"],
+ "destination_port": match["destination_port"]
+ }
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": myvim_thread_id,
+ "action": "CREATE",
+ "status": "SCHEDULED",
+ "item": "instance_classifications",
+ "item_id": classification_uuid,
+ "extra": yaml.safe_dump({"params": classification_params, "depends_on": [dependencies[i]]},
+ default_flow_style=True, width=256)
+ }
+ classifications_created.append(task_index)
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+
+ # create sfps
+ sfp_uuid = str(uuid4())
+ uuid_list.append(sfp_uuid)
+ db_sfp = {
+ "uuid": sfp_uuid,
"instance_scenario_id": instance_uuid,
- "net_id": net["uuid"],
- "created": True,
+ 'sce_rsp_id': rsp['uuid'],
'datacenter_id': datacenter_id,
'datacenter_tenant_id': myvim_thread_id,
+ "vim_sfp_id": None, # vim thread will populate
}
- db_instance_nets.append(db_net)
-
+ db_instance_sfps.append(db_sfp)
db_vim_action = {
"instance_action_id": instance_action_id,
"task_index": task_index,
"datacenter_vim_id": myvim_thread_id,
- "status": "SCHEDULED",
"action": "CREATE",
- "item": "instance_nets",
- "item_id": net_uuid,
- "extra": yaml.safe_dump({"params": (net_name, net_type, net.get('ip_profile',None))},
+ "status": "SCHEDULED",
+ "item": "instance_sfps",
+ "item_id": sfp_uuid,
+ "extra": yaml.safe_dump({"params": "", "depends_on": sfs_created + classifications_created},
default_flow_style=True, width=256)
}
task_index += 1
db_vim_actions.append(db_vim_action)
- if 'ip_profile' in net:
- db_ip_profile = {
- 'instance_net_id': net_uuid,
- 'ip_version': net['ip_profile']['ip_version'],
- 'subnet_address': net['ip_profile']['subnet_address'],
- 'gateway_address': net['ip_profile']['gateway_address'],
- 'dns_address': net['ip_profile']['dns_address'],
- 'dhcp_enabled': net['ip_profile']['dhcp_enabled'],
- 'dhcp_start_address': net['ip_profile']['dhcp_start_address'],
- 'dhcp_count': net['ip_profile']['dhcp_count'],
- }
- db_ip_profiles.append(db_ip_profile)
-
- # print "vnf_net2instance:"
- # print yaml.safe_dump(vnf_net2instance, indent=4, default_flow_style=False)
-
- # 3. Creating new vm instances in the VIM
- # myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
- sce_vnf_list = sorted(scenarioDict['vnfs'], key=lambda k: k['name'])
- for sce_vnf in sce_vnf_list:
- vnf_availability_zones = []
- for vm in sce_vnf['vms']:
- vm_av = vm.get('availability_zone')
- if vm_av and vm_av not in vnf_availability_zones:
- vnf_availability_zones.append(vm_av)
-
- # check if there is enough availability zones available at vim level.
- if myvims[datacenter_id].availability_zone and vnf_availability_zones:
- if len(vnf_availability_zones) > len(myvims[datacenter_id].availability_zone):
- raise NfvoException('No enough availability zones at VIM for this deployment', HTTP_Bad_Request)
-
- if sce_vnf.get("datacenter"):
- vim = myvims[ sce_vnf["datacenter"] ]
- myvim_thread_id = myvim_threads_id[ sce_vnf["datacenter"] ]
- datacenter_id = sce_vnf["datacenter"]
- else:
- vim = myvims[ default_datacenter_id ]
- myvim_thread_id = myvim_threads_id[ default_datacenter_id ]
- datacenter_id = default_datacenter_id
- sce_vnf["datacenter_id"] = datacenter_id
- i = 0
-
- vnf_uuid = str(uuid4())
- uuid_list.append(vnf_uuid)
- db_instance_vnf = {
- 'uuid': vnf_uuid,
- 'instance_scenario_id': instance_uuid,
- 'vnf_id': sce_vnf['vnf_id'],
- 'sce_vnf_id': sce_vnf['uuid'],
- 'datacenter_id': datacenter_id,
- 'datacenter_tenant_id': myvim_thread_id,
- }
- db_instance_vnfs.append(db_instance_vnf)
-
- for vm in sce_vnf['vms']:
- myVMDict = {}
- myVMDict['name'] = "{}.{}.{}".format(instance_name[:64], sce_vnf['name'][:64], vm["name"][:64])
- myVMDict['description'] = myVMDict['name'][0:99]
-# if not startvms:
-# myVMDict['start'] = "no"
- myVMDict['name'] = myVMDict['name'][0:255] # limit name length
- #create image at vim in case it not exist
- image_dict = mydb.get_table_by_uuid_name("images", vm['image_id'])
- image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True)
- vm['vim_image_id'] = image_id
-
- # create flavor at vim in case it not exist
- flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id'])
- if flavor_dict['extended']!=None:
- flavor_dict['extended'] = yaml.load(flavor_dict['extended'])
- flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True)
-
- # Obtain information for additional disks
- extended_flavor_dict = mydb.get_rows(FROM='datacenters_flavors', SELECT=('extended',), WHERE={'vim_id': flavor_id})
- if not extended_flavor_dict:
- raise NfvoException("flavor '{}' not found".format(flavor_id), HTTP_Not_Found)
- return
-
- # extended_flavor_dict_yaml = yaml.load(extended_flavor_dict[0])
- myVMDict['disks'] = None
- extended_info = extended_flavor_dict[0]['extended']
- if extended_info != None:
- extended_flavor_dict_yaml = yaml.load(extended_info)
- if 'disks' in extended_flavor_dict_yaml:
- myVMDict['disks'] = extended_flavor_dict_yaml['disks']
-
- vm['vim_flavor_id'] = flavor_id
- myVMDict['imageRef'] = vm['vim_image_id']
- myVMDict['flavorRef'] = vm['vim_flavor_id']
- myVMDict['availability_zone'] = vm.get('availability_zone')
- myVMDict['networks'] = []
- task_depends_on = []
- # TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
- db_vm_ifaces = []
- for iface in vm['interfaces']:
- netDict = {}
- if iface['type']=="data":
- netDict['type'] = iface['model']
- elif "model" in iface and iface["model"]!=None:
- netDict['model']=iface['model']
- # TODO in future, remove this because mac_address will not be set, and the type of PV,VF
- # is obtained from iterface table model
- # discover type of interface looking at flavor
- for numa in flavor_dict.get('extended',{}).get('numas',[]):
- for flavor_iface in numa.get('interfaces',[]):
- if flavor_iface.get('name') == iface['internal_name']:
- if flavor_iface['dedicated'] == 'yes':
- netDict['type']="PF" #passthrough
- elif flavor_iface['dedicated'] == 'no':
- netDict['type']="VF" #siov
- elif flavor_iface['dedicated'] == 'yes:sriov':
- netDict['type']="VFnotShared" #sriov but only one sriov on the PF
- netDict["mac_address"] = flavor_iface.get("mac_address")
- break;
- netDict["use"]=iface['type']
- if netDict["use"]=="data" and not netDict.get("type"):
- #print "netDict", netDict
- #print "iface", iface
- e_text = "Cannot determine the interface type PF or VF of VNF '%s' VM '%s' iface '%s'" %(sce_vnf['name'], vm['name'], iface['internal_name'])
- if flavor_dict.get('extended')==None:
- raise NfvoException(e_text + "After database migration some information is not available. \
- Try to delete and create the scenarios and VNFs again", HTTP_Conflict)
- else:
- raise NfvoException(e_text, HTTP_Internal_Server_Error)
- if netDict["use"]=="mgmt" or netDict["use"]=="bridge":
- netDict["type"]="virtual"
- if "vpci" in iface and iface["vpci"] is not None:
- netDict['vpci'] = iface['vpci']
- if "mac" in iface and iface["mac"] is not None:
- netDict['mac_address'] = iface['mac']
- if "port-security" in iface and iface["port-security"] is not None:
- netDict['port_security'] = iface['port-security']
- if "floating-ip" in iface and iface["floating-ip"] is not None:
- netDict['floating_ip'] = iface['floating-ip']
- netDict['name'] = iface['internal_name']
- if iface['net_id'] is None:
- for vnf_iface in sce_vnf["interfaces"]:
- # print iface
- # print vnf_iface
- if vnf_iface['interface_id']==iface['uuid']:
- netDict['net_id'] = "TASK-{}".format(net2task_id['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id])
- instance_net_id = sce_net2instance[ vnf_iface['sce_net_id'] ][datacenter_id]
- task_depends_on.append(net2task_id['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id])
- break
- else:
- netDict['net_id'] = "TASK-{}".format(net2task_id[ sce_vnf['uuid'] ][ iface['net_id'] ])
- instance_net_id = vnf_net2instance[ sce_vnf['uuid'] ][ iface['net_id'] ]
- task_depends_on.append(net2task_id[sce_vnf['uuid'] ][ iface['net_id']])
- # skip bridge ifaces not connected to any net
- if 'net_id' not in netDict or netDict['net_id']==None:
- continue
- myVMDict['networks'].append(netDict)
- db_vm_iface={
- # "uuid"
- # 'instance_vm_id': instance_vm_uuid,
- "instance_net_id": instance_net_id,
- 'interface_id': iface['uuid'],
- # 'vim_interface_id': ,
- 'type': 'external' if iface['external_name'] is not None else 'internal',
- 'ip_address': iface.get('ip_address'),
- 'floating_ip': int(iface.get('floating-ip', False)),
- 'port_security': int(iface.get('port-security', True))
- }
- db_vm_ifaces.append(db_vm_iface)
- # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
- # print myVMDict['name']
- # print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False)
- # print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
- # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
- if vm.get("boot_data"):
- cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config)
- else:
- cloud_config_vm = cloud_config
- if myVMDict.get('availability_zone'):
- av_index = vnf_availability_zones.index(myVMDict['availability_zone'])
- else:
- av_index = None
- for vm_index in range(0, vm.get('count', 1)):
- vm_index_name = ""
- if vm.get('count', 1) > 1:
- vm_index_name += "." + chr(97 + vm_index)
- task_params = (myVMDict['name']+vm_index_name, myVMDict['description'], myVMDict.get('start', None),
- myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'], cloud_config_vm,
- myVMDict['disks'], av_index, vnf_availability_zones)
- # put interface uuid back to scenario[vnfs][vms[[interfaces]
- for net in myVMDict['networks']:
- if "vim_id" in net:
- for iface in vm['interfaces']:
- if net["name"]==iface["internal_name"]:
- iface["vim_id"]=net["vim_id"]
- break
- vm_uuid = str(uuid4())
- uuid_list.append(vm_uuid)
- db_vm = {
- "uuid": vm_uuid,
- 'instance_vnf_id': vnf_uuid,
- #TODO delete "vim_vm_id": vm_id,
- "vm_id": vm["uuid"],
- # "status":
- }
- db_instance_vms.append(db_vm)
-
- iface_index = 0
- for db_vm_iface in db_vm_ifaces:
- iface_uuid = str(uuid4())
- uuid_list.append(iface_uuid)
- db_vm_iface_instance = {
- "uuid": iface_uuid,
- "instance_vm_id": vm_uuid
- }
- db_vm_iface_instance.update(db_vm_iface)
- if db_vm_iface_instance.get("ip_address"): # increment ip_address
- ip = db_vm_iface_instance.get("ip_address")
- i = ip.rfind(".")
- if i > 0:
- try:
- i += 1
- ip = ip[i:] + str(int(ip[:i]) +1)
- db_vm_iface_instance["ip_address"] = ip
- except:
- db_vm_iface_instance["ip_address"] = None
- db_instance_interfaces.append(db_vm_iface_instance)
- myVMDict['networks'][iface_index]["uuid"] = iface_uuid
- iface_index += 1
-
- db_vim_action = {
- "instance_action_id": instance_action_id,
- "task_index": task_index,
- "datacenter_vim_id": myvim_thread_id,
- "action": "CREATE",
- "status": "SCHEDULED",
- "item": "instance_vms",
- "item_id": vm_uuid,
- "extra": yaml.safe_dump({"params": task_params, "depends_on": task_depends_on},
- default_flow_style=True, width=256)
- }
- task_index += 1
- db_vim_actions.append(db_vim_action)
-
scenarioDict["datacenter2tenant"] = myvim_threads_id
db_instance_action["number_tasks"] = task_index
{"instance_vms": db_instance_vms},
{"instance_interfaces": db_instance_interfaces},
{"instance_actions": db_instance_action},
+ {"instance_sfis": db_instance_sfis},
+ {"instance_sfs": db_instance_sfs},
+ {"instance_classifications": db_instance_classifications},
+ {"instance_sfps": db_instance_sfps},
{"vim_actions": db_vim_actions}
]
raise NfvoException(error_text, e.http_code)
+def instantiate_vnf(mydb, sce_vnf, params, params_out, rollbackList):
+ default_datacenter_id = params["default_datacenter_id"]
+ myvim_threads_id = params["myvim_threads_id"]
+ instance_uuid = params["instance_uuid"]
+ instance_name = params["instance_name"]
+ instance_action_id = params["instance_action_id"]
+ myvims = params["myvims"]
+ cloud_config = params["cloud_config"]
+ RO_pub_key = params["RO_pub_key"]
+
+ task_index = params_out["task_index"]
+ uuid_list = params_out["uuid_list"]
+ db_instance_nets = params_out["db_instance_nets"]
+ db_vim_actions = params_out["db_vim_actions"]
+ db_ip_profiles = params_out["db_ip_profiles"]
+ db_instance_vnfs = params_out["db_instance_vnfs"]
+ db_instance_vms = params_out["db_instance_vms"]
+ db_instance_interfaces = params_out["db_instance_interfaces"]
+ net2task_id = params_out["net2task_id"]
+ sce_net2instance = params_out["sce_net2instance"]
+
+ vnf_net2instance = {}
+
+ # 2. Creating new nets (vnf internal nets) in the VIM"
+ # For each vnf net, we create it and we add it to instanceNetlist.
+ if sce_vnf.get("datacenter"):
+ datacenter_id = sce_vnf["datacenter"]
+ myvim_thread_id = myvim_threads_id[sce_vnf["datacenter"]]
+ else:
+ datacenter_id = default_datacenter_id
+ myvim_thread_id = myvim_threads_id[default_datacenter_id]
+ for net in sce_vnf['nets']:
+ # TODO revis
+ # descriptor_net = instance_dict.get("vnfs", {}).get(sce_vnf["name"], {})
+ # net_name = descriptor_net.get("name")
+ net_name = None
+ if not net_name:
+ net_name = "{}-{}".format(instance_name, net["name"])
+ net_name = net_name[:255] # limit length
+ net_type = net['type']
+
+ if sce_vnf['uuid'] not in vnf_net2instance:
+ vnf_net2instance[sce_vnf['uuid']] = {}
+ if sce_vnf['uuid'] not in net2task_id:
+ net2task_id[sce_vnf['uuid']] = {}
+ net2task_id[sce_vnf['uuid']][net['uuid']] = task_index
+
+ # fill database content
+ net_uuid = str(uuid4())
+ uuid_list.append(net_uuid)
+ vnf_net2instance[sce_vnf['uuid']][net['uuid']] = net_uuid
+ db_net = {
+ "uuid": net_uuid,
+ 'vim_net_id': None,
+ "instance_scenario_id": instance_uuid,
+ "net_id": net["uuid"],
+ "created": True,
+ 'datacenter_id': datacenter_id,
+ 'datacenter_tenant_id': myvim_thread_id,
+ }
+ db_instance_nets.append(db_net)
+
+ if net.get("vim-network-name"):
+ lookfor_filter = {"name": net["vim-network-name"]}
+ task_action = "FIND"
+ task_extra = {"params": (lookfor_filter,)}
+ else:
+ task_action = "CREATE"
+ task_extra = {"params": (net_name, net_type, net.get('ip_profile', None))}
+
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": myvim_thread_id,
+ "status": "SCHEDULED",
+ "action": task_action,
+ "item": "instance_nets",
+ "item_id": net_uuid,
+ "extra": yaml.safe_dump(task_extra, default_flow_style=True, width=256)
+ }
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+
+ if 'ip_profile' in net:
+ db_ip_profile = {
+ 'instance_net_id': net_uuid,
+ 'ip_version': net['ip_profile']['ip_version'],
+ 'subnet_address': net['ip_profile']['subnet_address'],
+ 'gateway_address': net['ip_profile']['gateway_address'],
+ 'dns_address': net['ip_profile']['dns_address'],
+ 'dhcp_enabled': net['ip_profile']['dhcp_enabled'],
+ 'dhcp_start_address': net['ip_profile']['dhcp_start_address'],
+ 'dhcp_count': net['ip_profile']['dhcp_count'],
+ }
+ db_ip_profiles.append(db_ip_profile)
+
+ # print "vnf_net2instance:"
+ # print yaml.safe_dump(vnf_net2instance, indent=4, default_flow_style=False)
+
+ # 3. Creating new vm instances in the VIM
+ # myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
+ ssh_access = None
+ if sce_vnf.get('mgmt_access'):
+ ssh_access = sce_vnf['mgmt_access'].get('config-access', {}).get('ssh-access')
+ vnf_availability_zones = []
+ for vm in sce_vnf['vms']:
+ vm_av = vm.get('availability_zone')
+ if vm_av and vm_av not in vnf_availability_zones:
+ vnf_availability_zones.append(vm_av)
+
+ # check if there is enough availability zones available at vim level.
+ if myvims[datacenter_id].availability_zone and vnf_availability_zones:
+ if len(vnf_availability_zones) > len(myvims[datacenter_id].availability_zone):
+ raise NfvoException('No enough availability zones at VIM for this deployment', HTTP_Bad_Request)
+
+ if sce_vnf.get("datacenter"):
+ vim = myvims[sce_vnf["datacenter"]]
+ myvim_thread_id = myvim_threads_id[sce_vnf["datacenter"]]
+ datacenter_id = sce_vnf["datacenter"]
+ else:
+ vim = myvims[default_datacenter_id]
+ myvim_thread_id = myvim_threads_id[default_datacenter_id]
+ datacenter_id = default_datacenter_id
+ sce_vnf["datacenter_id"] = datacenter_id
+ i = 0
+
+ vnf_uuid = str(uuid4())
+ uuid_list.append(vnf_uuid)
+ db_instance_vnf = {
+ 'uuid': vnf_uuid,
+ 'instance_scenario_id': instance_uuid,
+ 'vnf_id': sce_vnf['vnf_id'],
+ 'sce_vnf_id': sce_vnf['uuid'],
+ 'datacenter_id': datacenter_id,
+ 'datacenter_tenant_id': myvim_thread_id,
+ }
+ db_instance_vnfs.append(db_instance_vnf)
+
+ for vm in sce_vnf['vms']:
+ myVMDict = {}
+ sce_vnf_name = sce_vnf['member_vnf_index'] if sce_vnf['member_vnf_index'] else sce_vnf['name']
+ myVMDict['name'] = "{}-{}-{}".format(instance_name[:64], sce_vnf_name[:64], vm["name"][:64])
+ myVMDict['description'] = myVMDict['name'][0:99]
+ # if not startvms:
+ # myVMDict['start'] = "no"
+ if vm.get("instance_parameters") and vm["instance_parameters"].get("name"):
+ myVMDict['name'] = vm["instance_parameters"].get("name")
+ myVMDict['name'] = myVMDict['name'][0:255] # limit name length
+ # create image at vim in case it not exist
+ image_uuid = vm['image_id']
+ if vm.get("image_list"):
+ for alternative_image in vm["image_list"]:
+ if alternative_image["vim_type"] == vim["config"]["_vim_type_internal"]:
+ image_uuid = alternative_image['image_id']
+ break
+ image_dict = mydb.get_table_by_uuid_name("images", image_uuid)
+ image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True)
+ vm['vim_image_id'] = image_id
+
+ # create flavor at vim in case it not exist
+ flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id'])
+ if flavor_dict['extended'] != None:
+ flavor_dict['extended'] = yaml.load(flavor_dict['extended'])
+ flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True)
+
+ # Obtain information for additional disks
+ extended_flavor_dict = mydb.get_rows(FROM='datacenters_flavors', SELECT=('extended',),
+ WHERE={'vim_id': flavor_id})
+ if not extended_flavor_dict:
+ raise NfvoException("flavor '{}' not found".format(flavor_id), HTTP_Not_Found)
+
+ # extended_flavor_dict_yaml = yaml.load(extended_flavor_dict[0])
+ myVMDict['disks'] = None
+ extended_info = extended_flavor_dict[0]['extended']
+ if extended_info != None:
+ extended_flavor_dict_yaml = yaml.load(extended_info)
+ if 'disks' in extended_flavor_dict_yaml:
+ myVMDict['disks'] = extended_flavor_dict_yaml['disks']
+ if vm.get("instance_parameters") and vm["instance_parameters"].get("devices"):
+ for disk in myVMDict['disks']:
+ if disk.get("name") in vm["instance_parameters"]["devices"]:
+ disk.update(vm["instance_parameters"]["devices"][disk.get("name")])
+
+ vm['vim_flavor_id'] = flavor_id
+ myVMDict['imageRef'] = vm['vim_image_id']
+ myVMDict['flavorRef'] = vm['vim_flavor_id']
+ myVMDict['availability_zone'] = vm.get('availability_zone')
+ myVMDict['networks'] = []
+ task_depends_on = []
+ # TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
+ db_vm_ifaces = []
+ for iface in vm['interfaces']:
+ netDict = {}
+ if iface['type'] == "data":
+ netDict['type'] = iface['model']
+ elif "model" in iface and iface["model"] != None:
+ netDict['model'] = iface['model']
+ # TODO in future, remove this because mac_address will not be set, and the type of PV,VF
+ # is obtained from iterface table model
+ # discover type of interface looking at flavor
+ for numa in flavor_dict.get('extended', {}).get('numas', []):
+ for flavor_iface in numa.get('interfaces', []):
+ if flavor_iface.get('name') == iface['internal_name']:
+ if flavor_iface['dedicated'] == 'yes':
+ netDict['type'] = "PF" # passthrough
+ elif flavor_iface['dedicated'] == 'no':
+ netDict['type'] = "VF" # siov
+ elif flavor_iface['dedicated'] == 'yes:sriov':
+ netDict['type'] = "VFnotShared" # sriov but only one sriov on the PF
+ netDict["mac_address"] = flavor_iface.get("mac_address")
+ break
+ netDict["use"] = iface['type']
+ if netDict["use"] == "data" and not netDict.get("type"):
+ # print "netDict", netDict
+ # print "iface", iface
+ e_text = "Cannot determine the interface type PF or VF of VNF '{}' VM '{}' iface '{}'".fromat(
+ sce_vnf['name'], vm['name'], iface['internal_name'])
+ if flavor_dict.get('extended') == None:
+ raise NfvoException(e_text + "After database migration some information is not available. \
+ Try to delete and create the scenarios and VNFs again", HTTP_Conflict)
+ else:
+ raise NfvoException(e_text, HTTP_Internal_Server_Error)
+ if netDict["use"] == "mgmt" or netDict["use"] == "bridge":
+ netDict["type"] = "virtual"
+ if iface.get("vpci"):
+ netDict['vpci'] = iface['vpci']
+ if iface.get("mac"):
+ netDict['mac_address'] = iface['mac']
+ if iface.get("ip_address"):
+ netDict['ip_address'] = iface['ip_address']
+ if iface.get("port-security") is not None:
+ netDict['port_security'] = iface['port-security']
+ if iface.get("floating-ip") is not None:
+ netDict['floating_ip'] = iface['floating-ip']
+ netDict['name'] = iface['internal_name']
+ if iface['net_id'] is None:
+ for vnf_iface in sce_vnf["interfaces"]:
+ # print iface
+ # print vnf_iface
+ if vnf_iface['interface_id'] == iface['uuid']:
+ netDict['net_id'] = "TASK-{}".format(
+ net2task_id['scenario'][vnf_iface['sce_net_id']][datacenter_id])
+ instance_net_id = sce_net2instance[vnf_iface['sce_net_id']][datacenter_id]
+ task_depends_on.append(net2task_id['scenario'][vnf_iface['sce_net_id']][datacenter_id])
+ break
+ else:
+ netDict['net_id'] = "TASK-{}".format(net2task_id[sce_vnf['uuid']][iface['net_id']])
+ instance_net_id = vnf_net2instance[sce_vnf['uuid']][iface['net_id']]
+ task_depends_on.append(net2task_id[sce_vnf['uuid']][iface['net_id']])
+ # skip bridge ifaces not connected to any net
+ if 'net_id' not in netDict or netDict['net_id'] == None:
+ continue
+ myVMDict['networks'].append(netDict)
+ db_vm_iface = {
+ # "uuid"
+ # 'instance_vm_id': instance_vm_uuid,
+ "instance_net_id": instance_net_id,
+ 'interface_id': iface['uuid'],
+ # 'vim_interface_id': ,
+ 'type': 'external' if iface['external_name'] is not None else 'internal',
+ 'ip_address': iface.get('ip_address'),
+ 'mac_address': iface.get('mac'),
+ 'floating_ip': int(iface.get('floating-ip', False)),
+ 'port_security': int(iface.get('port-security', True))
+ }
+ db_vm_ifaces.append(db_vm_iface)
+ # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
+ # print myVMDict['name']
+ # print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False)
+ # print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
+ # print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
+
+ # We add the RO key to cloud_config if vnf will need ssh access
+ cloud_config_vm = cloud_config
+ if ssh_access and ssh_access['required'] and ssh_access['default-user'] and tenant[0].get('RO_pub_key'):
+ RO_key = {"key-pairs": [tenant[0]['RO_pub_key']]}
+ cloud_config_vm = unify_cloud_config(cloud_config_vm, RO_key)
+ if vm.get("boot_data"):
+ cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config_vm)
+
+ if myVMDict.get('availability_zone'):
+ av_index = vnf_availability_zones.index(myVMDict['availability_zone'])
+ else:
+ av_index = None
+ for vm_index in range(0, vm.get('count', 1)):
+ vm_name = myVMDict['name'] + "-" + str(vm_index+1)
+ task_params = (vm_name, myVMDict['description'], myVMDict.get('start', None),
+ myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'], cloud_config_vm,
+ myVMDict['disks'], av_index, vnf_availability_zones)
+ # put interface uuid back to scenario[vnfs][vms[[interfaces]
+ for net in myVMDict['networks']:
+ if "vim_id" in net:
+ for iface in vm['interfaces']:
+ if net["name"] == iface["internal_name"]:
+ iface["vim_id"] = net["vim_id"]
+ break
+ vm_uuid = str(uuid4())
+ uuid_list.append(vm_uuid)
+ db_vm = {
+ "uuid": vm_uuid,
+ 'instance_vnf_id': vnf_uuid,
+ # TODO delete "vim_vm_id": vm_id,
+ "vm_id": vm["uuid"],
+ "vim_name": vm_name,
+ # "status":
+ }
+ db_instance_vms.append(db_vm)
+
+ iface_index = 0
+ for db_vm_iface in db_vm_ifaces:
+ iface_uuid = str(uuid4())
+ uuid_list.append(iface_uuid)
+ db_vm_iface_instance = {
+ "uuid": iface_uuid,
+ "instance_vm_id": vm_uuid
+ }
+ db_vm_iface_instance.update(db_vm_iface)
+ if db_vm_iface_instance.get("ip_address"): # increment ip_address
+ ip = db_vm_iface_instance.get("ip_address")
+ i = ip.rfind(".")
+ if i > 0:
+ try:
+ i += 1
+ ip = ip[i:] + str(int(ip[:i]) + 1)
+ db_vm_iface_instance["ip_address"] = ip
+ except:
+ db_vm_iface_instance["ip_address"] = None
+ db_instance_interfaces.append(db_vm_iface_instance)
+ myVMDict['networks'][iface_index]["uuid"] = iface_uuid
+ iface_index += 1
+
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": myvim_thread_id,
+ "action": "CREATE",
+ "status": "SCHEDULED",
+ "item": "instance_vms",
+ "item_id": vm_uuid,
+ "extra": yaml.safe_dump({"params": task_params, "depends_on": task_depends_on},
+ default_flow_style=True, width=256)
+ }
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+ params_out["task_index"] = task_index
+ params_out["uuid_list"] = uuid_list
+
+
def delete_instance(mydb, tenant_id, instance_id):
# print "Checking that the instance_id exists and getting the instance dictionary"
instanceDict = mydb.get_instance_scenario(instance_id, tenant_id)
# print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False)
tenant_id = instanceDict["tenant_id"]
# print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
-
# 1. Delete from Database
message = mydb.delete_instance_scenario(instance_id, tenant_id)
task_index += 1
db_vim_actions.append(db_vim_action)
+ # 2.3 deleting VNFFGs
+
+ for sfp in instanceDict.get('sfps', ()):
+ vimthread_affected[sfp["datacenter_tenant_id"]] = None
+ datacenter_key = (sfp["datacenter_id"], sfp["datacenter_tenant_id"])
+ if datacenter_key not in myvims:
+ try:
+ _,myvim_thread = get_vim_thread(mydb, tenant_id, sfp["datacenter_id"], sfp["datacenter_tenant_id"])
+ except NfvoException as e:
+ logger.error(str(e))
+ myvim_thread = None
+ myvim_threads[datacenter_key] = myvim_thread
+ vims = get_vim(mydb, tenant_id, datacenter_id=sfp["datacenter_id"],
+ datacenter_tenant_id=sfp["datacenter_tenant_id"])
+ if len(vims) == 0:
+ logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sfp["datacenter_id"], sfp["datacenter_tenant_id"]))
+ myvims[datacenter_key] = None
+ else:
+ myvims[datacenter_key] = vims.values()[0]
+ myvim = myvims[datacenter_key]
+ myvim_thread = myvim_threads[datacenter_key]
+
+ if not myvim:
+ error_msg += "\n vim_sfp_id={} cannot be deleted because datacenter={} not found".format(sfp['vim_sfp_id'], sfp["datacenter_id"])
+ continue
+ extra = {"params": (sfp['vim_sfp_id'])}
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": sfp["datacenter_tenant_id"],
+ "action": "DELETE",
+ "status": "SCHEDULED",
+ "item": "instance_sfps",
+ "item_id": sfp["uuid"],
+ "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
+ }
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+
+ for sf in instanceDict.get('sfs', ()):
+ vimthread_affected[sf["datacenter_tenant_id"]] = None
+ datacenter_key = (sf["datacenter_id"], sf["datacenter_tenant_id"])
+ if datacenter_key not in myvims:
+ try:
+ _,myvim_thread = get_vim_thread(mydb, tenant_id, sf["datacenter_id"], sf["datacenter_tenant_id"])
+ except NfvoException as e:
+ logger.error(str(e))
+ myvim_thread = None
+ myvim_threads[datacenter_key] = myvim_thread
+ vims = get_vim(mydb, tenant_id, datacenter_id=sf["datacenter_id"],
+ datacenter_tenant_id=sf["datacenter_tenant_id"])
+ if len(vims) == 0:
+ logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sf["datacenter_id"], sf["datacenter_tenant_id"]))
+ myvims[datacenter_key] = None
+ else:
+ myvims[datacenter_key] = vims.values()[0]
+ myvim = myvims[datacenter_key]
+ myvim_thread = myvim_threads[datacenter_key]
+
+ if not myvim:
+ error_msg += "\n vim_sf_id={} cannot be deleted because datacenter={} not found".format(sf['vim_sf_id'], sf["datacenter_id"])
+ continue
+ extra = {"params": (sf['vim_sf_id'])}
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": sf["datacenter_tenant_id"],
+ "action": "DELETE",
+ "status": "SCHEDULED",
+ "item": "instance_sfs",
+ "item_id": sf["uuid"],
+ "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
+ }
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+
+ for sfi in instanceDict.get('sfis', ()):
+ vimthread_affected[sfi["datacenter_tenant_id"]] = None
+ datacenter_key = (sfi["datacenter_id"], sfi["datacenter_tenant_id"])
+ if datacenter_key not in myvims:
+ try:
+ _,myvim_thread = get_vim_thread(mydb, tenant_id, sfi["datacenter_id"], sfi["datacenter_tenant_id"])
+ except NfvoException as e:
+ logger.error(str(e))
+ myvim_thread = None
+ myvim_threads[datacenter_key] = myvim_thread
+ vims = get_vim(mydb, tenant_id, datacenter_id=sfi["datacenter_id"],
+ datacenter_tenant_id=sfi["datacenter_tenant_id"])
+ if len(vims) == 0:
+ logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sfi["datacenter_id"], sfi["datacenter_tenant_id"]))
+ myvims[datacenter_key] = None
+ else:
+ myvims[datacenter_key] = vims.values()[0]
+ myvim = myvims[datacenter_key]
+ myvim_thread = myvim_threads[datacenter_key]
+
+ if not myvim:
+ error_msg += "\n vim_sfi_id={} cannot be deleted because datacenter={} not found".format(sfi['vim_sfi_id'], sfi["datacenter_id"])
+ continue
+ extra = {"params": (sfi['vim_sfi_id'])}
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": sfi["datacenter_tenant_id"],
+ "action": "DELETE",
+ "status": "SCHEDULED",
+ "item": "instance_sfis",
+ "item_id": sfi["uuid"],
+ "extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
+ }
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+
+ for classification in instanceDict['classifications']:
+ vimthread_affected[classification["datacenter_tenant_id"]] = None
+ datacenter_key = (classification["datacenter_id"], classification["datacenter_tenant_id"])
+ if datacenter_key not in myvims:
+ try:
+ _,myvim_thread = get_vim_thread(mydb, tenant_id, classification["datacenter_id"], classification["datacenter_tenant_id"])
+ except NfvoException as e:
+ logger.error(str(e))
+ myvim_thread = None
+ myvim_threads[datacenter_key] = myvim_thread
+ vims = get_vim(mydb, tenant_id, datacenter_id=classification["datacenter_id"],
+ datacenter_tenant_id=classification["datacenter_tenant_id"])
+ if len(vims) == 0:
+ logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(classification["datacenter_id"], classification["datacenter_tenant_id"]))
+ myvims[datacenter_key] = None
+ else:
+ myvims[datacenter_key] = vims.values()[0]
+ myvim = myvims[datacenter_key]
+ myvim_thread = myvim_threads[datacenter_key]
+
+ if not myvim:
+ error_msg += "\n vim_classification_id={} cannot be deleted because datacenter={} not found".format(classification['vim_classification_id'], classification["datacenter_id"])
+ continue
+ extra = {"params": (classification['vim_classification_id'])}
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": classification["datacenter_tenant_id"],
+ "action": "DELETE",
+ "status": "SCHEDULED",
+ "item": "instance_classifications",
+ "item_id": classification["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 = [
{"instance_actions": db_instance_action},
else:
return "action_id={} instance {} deleted".format(instance_action_id, message)
+def get_instance_id(mydb, tenant_id, instance_id):
+ global ovim
+ #check valid tenant_id
+ check_tenant(mydb, tenant_id)
+ #obtain data
+
+ instance_dict = mydb.get_instance_scenario(instance_id, tenant_id, verbose=True)
+ for net in instance_dict["nets"]:
+ if net.get("sdn_net_id"):
+ net_sdn = ovim.show_network(net["sdn_net_id"])
+ net["sdn_info"] = {
+ "admin_state_up": net_sdn.get("admin_state_up"),
+ "flows": net_sdn.get("flows"),
+ "last_error": net_sdn.get("last_error"),
+ "ports": net_sdn.get("ports"),
+ "type": net_sdn.get("type"),
+ "status": net_sdn.get("status"),
+ "vlan": net_sdn.get("vlan"),
+ }
+ return instance_dict
def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None):
'''Refreshes a scenario instance. It modifies instanceDict'''
if len(vims) == 0:
raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), HTTP_Not_Found)
myvim = vims.values()[0]
+ vm_result = {}
+ vm_error = 0
+ vm_ok = 0
- if action_dict.get("create-vdu"):
- for vdu in action_dict["create-vdu"]:
+ myvim_threads_id = {}
+ if action_dict.get("vdu-scaling"):
+ db_instance_vms = []
+ db_vim_actions = []
+ db_instance_interfaces = []
+ instance_action_id = get_task_id()
+ db_instance_action = {
+ "uuid": instance_action_id, # same uuid for the instance and the action on create
+ "tenant_id": nfvo_tenant,
+ "instance_id": instance_id,
+ "description": "SCALE",
+ }
+ vm_result["instance_action_id"] = instance_action_id
+ task_index = 0
+ for vdu in action_dict["vdu-scaling"]:
vdu_id = vdu.get("vdu-id")
+ osm_vdu_id = vdu.get("osm_vdu_id")
+ member_vnf_index = vdu.get("member-vnf-index")
vdu_count = vdu.get("count", 1)
- # get from database TODO
- # insert tasks TODO
- pass
+ if vdu_id:
+ target_vm = mydb.get_rows(
+ FROM="instance_vms as vms join instance_vnfs as vnfs on vms.instance_vnf_id=vnfs.uuid",
+ WHERE={"vms.uuid": vdu_id},
+ ORDER_BY="vms.created_at"
+ )
+ if not target_vm:
+ raise NfvoException("Cannot find the vdu with id {}".format(vdu_id), HTTP_Not_Found)
+ else:
+ if not osm_vdu_id and not member_vnf_index:
+ raise NfvoException("Invalid imput vdu parameters. Must supply either 'vdu-id' of 'osm_vdu_id','member-vnf-index'")
+ target_vm = mydb.get_rows(
+ # SELECT=("ivms.uuid", "ivnfs.datacenter_id", "ivnfs.datacenter_tenant_id"),
+ FROM="instance_vms as ivms join instance_vnfs as ivnfs on ivms.instance_vnf_id=ivnfs.uuid"\
+ " join sce_vnfs as svnfs on ivnfs.sce_vnf_id=svnfs.uuid"\
+ " join vms on ivms.vm_id=vms.uuid",
+ WHERE={"vms.osm_id": osm_vdu_id, "svnfs.member_vnf_index": member_vnf_index},
+ ORDER_BY="ivms.created_at"
+ )
+ if not target_vm:
+ raise NfvoException("Cannot find the vdu with osm_vdu_id {} and member-vnf-index {}".format(osm_vdu_id, member_vnf_index), HTTP_Not_Found)
+ vdu_id = target_vm[-1]["uuid"]
+ vm_result[vdu_id] = {"created": [], "deleted": [], "description": "scheduled"}
+ target_vm = target_vm[-1]
+ datacenter = target_vm["datacenter_id"]
+ myvim_threads_id[datacenter], _ = get_vim_thread(mydb, nfvo_tenant, datacenter)
+ if vdu["type"] == "delete":
+ # look for nm
+ vm_interfaces = None
+ for sce_vnf in instanceDict['vnfs']:
+ for vm in sce_vnf['vms']:
+ if vm["uuid"] == vdu_id:
+ vm_interfaces = vm["interfaces"]
+ break
+
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": target_vm["datacenter_tenant_id"],
+ "action": "DELETE",
+ "status": "SCHEDULED",
+ "item": "instance_vms",
+ "item_id": target_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)
+ vm_result[vdu_id]["deleted"].append(vdu_id)
+ # delete from database
+ db_instance_vms.append({"TO-DELETE": vdu_id})
+
+ else: # vdu["type"] == "create":
+ iface2iface = {}
+ where = {"item": "instance_vms", "item_id": target_vm["uuid"], "action": "CREATE"}
+
+ vim_action_to_clone = mydb.get_rows(FROM="vim_actions", WHERE=where)
+ if not vim_action_to_clone:
+ raise NfvoException("Cannot find the vim_action at database with {}".format(where), HTTP_Internal_Server_Error)
+ vim_action_to_clone = vim_action_to_clone[0]
+ extra = yaml.safe_load(vim_action_to_clone["extra"])
+
+ # generate a new depends_on. Convert format TASK-Y into new format TASK-ACTION-XXXX.XXXX.Y
+ # TODO do the same for flavor and image when available
+ task_depends_on = []
+ task_params = extra["params"]
+ task_params_networks = deepcopy(task_params[5])
+ for iface in task_params[5]:
+ if iface["net_id"].startswith("TASK-"):
+ if "." not in iface["net_id"]:
+ task_depends_on.append("{}.{}".format(vim_action_to_clone["instance_action_id"],
+ iface["net_id"][5:]))
+ iface["net_id"] = "TASK-{}.{}".format(vim_action_to_clone["instance_action_id"],
+ iface["net_id"][5:])
+ else:
+ task_depends_on.append(iface["net_id"][5:])
+ if "mac_address" in iface:
+ del iface["mac_address"]
+
+ vm_ifaces_to_clone = mydb.get_rows(FROM="instance_interfaces", WHERE={"instance_vm_id": target_vm["uuid"]})
+ for index in range(0, vdu_count):
+ vm_uuid = str(uuid4())
+ vm_name = target_vm.get('vim_name')
+ try:
+ suffix = vm_name.rfind("-")
+ vm_name = vm_name[:suffix+1] + str(1 + int(vm_name[suffix+1:]))
+ except Exception:
+ pass
+ db_instance_vm = {
+ "uuid": vm_uuid,
+ 'instance_vnf_id': target_vm['instance_vnf_id'],
+ 'vm_id': target_vm['vm_id'],
+ 'vim_name': vm_name
+ }
+ db_instance_vms.append(db_instance_vm)
+
+ for vm_iface in vm_ifaces_to_clone:
+ iface_uuid = str(uuid4())
+ iface2iface[vm_iface["uuid"]] = iface_uuid
+ db_vm_iface = {
+ "uuid": iface_uuid,
+ 'instance_vm_id': vm_uuid,
+ "instance_net_id": vm_iface["instance_net_id"],
+ 'interface_id': vm_iface['interface_id'],
+ 'type': vm_iface['type'],
+ 'floating_ip': vm_iface['floating_ip'],
+ 'port_security': vm_iface['port_security']
+ }
+ db_instance_interfaces.append(db_vm_iface)
+ task_params_copy = deepcopy(task_params)
+ for iface in task_params_copy[5]:
+ iface["uuid"] = iface2iface[iface["uuid"]]
+ # increment ip_address
+ if "ip_address" in iface:
+ ip = iface.get("ip_address")
+ i = ip.rfind(".")
+ if i > 0:
+ try:
+ i += 1
+ ip = ip[i:] + str(int(ip[:i]) + 1)
+ iface["ip_address"] = ip
+ except:
+ iface["ip_address"] = None
+ if vm_name:
+ task_params_copy[0] = vm_name
+ db_vim_action = {
+ "instance_action_id": instance_action_id,
+ "task_index": task_index,
+ "datacenter_vim_id": vim_action_to_clone["datacenter_vim_id"],
+ "action": "CREATE",
+ "status": "SCHEDULED",
+ "item": "instance_vms",
+ "item_id": vm_uuid,
+ # ALF
+ # ALF
+ # TODO examinar parametros, quitar MAC o incrementar. Incrementar IP y colocar las dependencias con ACTION-asdfasd.
+ # ALF
+ # ALF
+ "extra": yaml.safe_dump({"params": task_params_copy, "depends_on": task_depends_on}, default_flow_style=True, width=256)
+ }
+ task_index += 1
+ db_vim_actions.append(db_vim_action)
+ vm_result[vdu_id]["created"].append(vm_uuid)
+
+ db_instance_action["number_tasks"] = task_index
+ db_tables = [
+ {"instance_vms": db_instance_vms},
+ {"instance_interfaces": db_instance_interfaces},
+ {"instance_actions": db_instance_action},
+ # TODO revise sfps
+ # {"instance_sfis": db_instance_sfis},
+ # {"instance_sfs": db_instance_sfs},
+ # {"instance_classifications": db_instance_classifications},
+ # {"instance_sfps": db_instance_sfps},
+ {"vim_actions": db_vim_actions}
+ ]
+ logger.debug("create_vdu done DB tables: %s",
+ yaml.safe_dump(db_tables, indent=4, default_flow_style=False))
+ mydb.new_rows(db_tables, [])
+ for myvim_thread in myvim_threads_id.values():
+ vim_threads["running"][myvim_thread].insert_task(db_vim_actions)
+
+ return vm_result
input_vnfs = action_dict.pop("vnfs", [])
input_vms = action_dict.pop("vms", [])
- action_over_all = True if len(input_vnfs)==0 and len (input_vms)==0 else False
- vm_result = {}
- vm_error = 0
- vm_ok = 0
+ action_over_all = True if not input_vnfs and not input_vms else False
for sce_vnf in instanceDict['vnfs']:
for vm in sce_vnf['vms']:
- if not action_over_all:
- if sce_vnf['uuid'] not in input_vnfs and sce_vnf['vnf_name'] not in input_vnfs and \
- vm['uuid'] not in input_vms and vm['name'] not in input_vms:
- continue
+ if not action_over_all and sce_vnf['uuid'] not in input_vnfs and sce_vnf['vnf_name'] not in input_vnfs and \
+ sce_vnf['member_vnf_index'] not in input_vnfs and \
+ vm['uuid'] not in input_vms and vm['name'] not in input_vms:
+ continue
try:
if "add_public_key" in action_dict:
mgmt_access = {}
return vm_result
def instance_action_get(mydb, nfvo_tenant, instance_id, action_id):
- filter={}
+ filter = {}
if nfvo_tenant and nfvo_tenant != "any":
filter["tenant_id"] = nfvo_tenant
if instance_id and instance_id != "any":
if action_id:
filter["uuid"] = action_id
rows = mydb.get_rows(FROM="instance_actions", WHERE=filter)
- if not rows and action_id:
- raise NfvoException("Not found any action with this criteria", HTTP_Not_Found)
- return {"ations": rows}
+ if action_id:
+ if not rows:
+ raise NfvoException("Not found any action with this criteria", HTTP_Not_Found)
+ vim_actions = mydb.get_rows(FROM="vim_actions", WHERE={"instance_action_id": action_id})
+ rows[0]["vim_actions"] = vim_actions
+ return {"actions": rows}
def create_or_use_console_proxy_thread(console_server, console_port):
tenant_dict['encrypted_RO_priv_key'] = priv_key
mydb.new_row("nfvo_tenants", tenant_dict, confidential_data=True)
except db_base_Exception as e:
- raise NfvoException("Error creating the new tenant: {} ".format(tenant_dict['name']) + str(e), HTTP_Internal_Server_Error)
+ raise NfvoException("Error creating the new tenant: {} ".format(tenant_dict['name']) + str(e), e.http_code)
return tenant_uuid
def delete_tenant(mydb, tenant):
def new_datacenter(mydb, datacenter_descriptor):
+ sdn_port_mapping = None
if "config" in datacenter_descriptor:
- datacenter_descriptor["config"]=yaml.safe_dump(datacenter_descriptor["config"],default_flow_style=True,width=256)
- #Check that datacenter-type is correct
+ sdn_port_mapping = datacenter_descriptor["config"].pop("sdn-port-mapping", None)
+ datacenter_descriptor["config"] = yaml.safe_dump(datacenter_descriptor["config"], default_flow_style=True,
+ width=256)
+ # Check that datacenter-type is correct
datacenter_type = datacenter_descriptor.get("type", "openvim");
- module_info = None
+ # module_info = None
try:
module = "vimconn_" + datacenter_type
pkg = __import__("osm_ro." + module)
- vim_conn = getattr(pkg, module)
+ # vim_conn = getattr(pkg, module)
# module_info = imp.find_module(module, [__file__[:__file__.rfind("/")]])
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)
+ if sdn_port_mapping:
+ try:
+ datacenter_sdn_port_mapping_set(mydb, None, datacenter_id, sdn_port_mapping)
+ except Exception as e:
+ mydb.delete_row_by_id("datacenters", datacenter_id) # Rollback
+ raise e
return datacenter_id
datacenter_id = datacenter['uuid']
where={'uuid': datacenter['uuid']}
remove_port_mapping = False
+ new_sdn_port_mapping = None
if "config" in datacenter_descriptor:
if datacenter_descriptor['config'] != None:
try:
new_config_dict = datacenter_descriptor["config"]
+ if "sdn-port-mapping" in new_config_dict:
+ remove_port_mapping = True
+ new_sdn_port_mapping = new_config_dict.pop("sdn-port-mapping")
#delete null fields
to_delete=[]
for k in new_config_dict:
logger.error("Error deleting datacenter-port-mapping " + str(e))
mydb.update_rows('datacenters', datacenter_descriptor, where)
+ if new_sdn_port_mapping:
+ try:
+ datacenter_sdn_port_mapping_set(mydb, None, datacenter_id, new_sdn_port_mapping)
+ except ovimException as e:
+ logger.error("Error adding datacenter-port-mapping " + str(e))
return datacenter_id
logger.error("Cannot delete datacenter_tenants " + str(e))
pass # the error will be caused because dependencies, vim_tenant can not be deleted
thread_id = tenant_datacenter_item["datacenter_tenant_id"]
- thread = vim_threads["running"][thread_id]
- thread.insert_task("exit")
- vim_threads["deleting"][thread_id] = thread
+ thread = vim_threads["running"].get(thread_id)
+ if thread:
+ thread.insert_task("exit")
+ vim_threads["deleting"][thread_id] = thread
return "datacenter {} detached. {}".format(datacenter_id, warning)
result = mydb.get_rows(SELECT=('sdn_net_id',), FROM='instance_nets', WHERE=search_dict)
except db_base_Exception as e:
raise NfvoException("db_base_Exception obtaining SDN network to associated to vim network {}".format(
- network_id) + str(e), HTTP_Internal_Server_Error)
+ network_id) + str(e), e.http_code)
sdn_net_counter = 0
for net in result:
sdn_network_id, network_id) + str(e), HTTP_Internal_Server_Error)
except db_base_Exception as e:
raise NfvoException("db_base_Exception attaching SDN network to vim network {}".format(
- network_id) + str(e), HTTP_Internal_Server_Error)
+ network_id) + str(e), e.http_code)
return 'Port uuid: '+ result
mydb.delete_row(FROM='instance_nets', WHERE={'instance_scenario_id': None, 'sdn_net_id': sdn_network_id, 'vim_net_id': item_id})
except db_base_Exception as e:
raise NfvoException("Error deleting correspondence for VIM/SDN dataplane networks{}: ".format(correspondence) +
- str(e), HTTP_Internal_Server_Error)
+ str(e), e.http_code)
#Delete the SDN network
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, e), HTTP_Internal_Server_Error)
+ correspondence, e), e.http_code)
elif item=="tenants":
tenant = descriptor["tenant"]
content = myvim.new_tenant(tenant["name"], tenant.get("description"))
element = dict()
element["compute_node"] = compute_node["compute_node"]
for port in compute_node["ports"]:
- element["pci"] = port.get("pci")
+ pci = port.get("pci")
element["switch_port"] = port.get("switch_port")
element["switch_mac"] = port.get("switch_mac")
- if not element["pci"] or not (element["switch_port"] or element["switch_mac"]):
+ if not pci or not (element["switch_port"] or element["switch_mac"]):
raise NfvoException ("The mapping must contain the 'pci' and at least one of the elements 'switch_port'"
" or 'switch_mac'", HTTP_Bad_Request)
- maps.append(dict(element))
+ for pci_expanded in utils.expand_brackets(pci):
+ element["pci"] = pci_expanded
+ maps.append(dict(element))
return ovim.set_of_port_mapping(maps, ofc_id=sdn_controller_id, switch_dpid=switch_dpid, region=datacenter_id)
projects / osm / RO.git / blobdiff