# -*- coding: utf-8 -*-
##
-# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
+# Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U.
# This file is part of openmano
# All Rights Reserved.
#
from .wim.engine import WimEngine
from .wim.persistence import WimPersistence
from copy import deepcopy
+from pprint import pformat
#
global global_config
if name not in vim_threads["names"]:
vim_threads["names"].append(name)
return name
- name = datacenter_name[:16] + "." + tenant_name[:16]
- if name not in vim_threads["names"]:
- vim_threads["names"].append(name)
- return name
- name = datacenter_id + "-" + tenant_id
+ if tenant_name:
+ name = datacenter_name[:16] + "." + tenant_name[:16]
+ if name not in vim_threads["names"]:
+ vim_threads["names"].append(name)
+ return name
+ name = datacenter_id
vim_threads["names"].append(name)
return name
def start_service(mydb, persistence=None, wim=None):
global db, global_config
- db = nfvo_db.nfvo_db()
+ db = nfvo_db.nfvo_db(lock=db_lock)
+ mydb.lock = db_lock
db.connect(global_config['db_host'], global_config['db_user'], global_config['db_passwd'], global_config['db_name'])
global ovim
- if persistence:
- persistence.lock = db_lock
- else:
- persistence = WimPersistence(db, lock=db_lock)
+ persistence = persistence or WimPersistence(db)
# Initialize openvim for SDN control
# TODO: Avoid static configuration by adding new parameters to openmanod.cfg
except Exception as e:
raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, e),
httperrors.Internal_Server_Error)
- thread_name = get_non_used_vim_name(vim['datacenter_name'], vim['vim_tenant_id'], vim['vim_tenant_name'],
+ thread_name = get_non_used_vim_name(vim['datacenter_name'], vim['datacenter_id'], vim['vim_tenant_name'],
vim['vim_tenant_id'])
new_thread = vim_thread.vim_thread(task_lock, thread_name, vim['datacenter_name'],
vim['datacenter_tenant_id'], db=db, db_lock=db_lock, ovim=ovim)
nb_deleted += len(actions_to_delete)
if len(actions_to_delete) < 100:
break
+ # clean locks
+ mydb.update_rows("vim_wim_actions", UPDATE={"worker": None}, WHERE={"worker<>": None})
+
if nb_deleted:
logger.debug("Removed {} unused vim_wim_actions".format(nb_deleted))
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:
+ if vm["image_id"] and 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"])
try:
flavor_vim_id = None
flavor_vim_id=vim.get_flavor_id_from_data(flavor_dict)
- flavor_create="false"
+ flavor_created="false"
except vimconn.vimconnException as e:
pass
try:
db_image["uuid"] = image_uuid
return None
+def get_resource_allocation_params(quota_descriptor):
+ """
+ read the quota_descriptor from vnfd and fetch the resource allocation properties from the descriptor object
+ :param quota_descriptor: cpu/mem/vif/disk-io quota descriptor
+ :return: quota params for limit, reserve, shares from the descriptor object
+ """
+ quota = {}
+ if quota_descriptor.get("limit"):
+ quota["limit"] = int(quota_descriptor["limit"])
+ if quota_descriptor.get("reserve"):
+ quota["reserve"] = int(quota_descriptor["reserve"])
+ if quota_descriptor.get("shares"):
+ quota["shares"] = int(quota_descriptor["shares"])
+ return quota
+
def new_vnfd_v3(mydb, tenant_id, vnf_descriptor):
"""
Parses an OSM IM vnfd_catalog and insert at DB
try:
myvnfd = vnfd_catalog.vnfd()
try:
- pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd, path_helper=True)
+ pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd, path_helper=True,
+ skip_unknown=True)
except Exception as e:
raise NfvoException("Error. Invalid VNF descriptor format " + str(e), httperrors.Bad_Request)
db_vnfs = []
cp_name2iface_uuid = {}
cp_name2vm_uuid = {}
cp_name2db_interface = {}
+ vdu_id2cp_name = {} # stored only when one external connection point is presented at this VDU
# table vms (vdus)
vdu_id2uuid = {}
"osm_id": vdu_id,
"name": get_str(vdu, "name", 255),
"description": get_str(vdu, "description", 255),
+ "pdu_type": get_str(vdu, "pdu-type", 255),
"vnf_id": vnf_uuid,
}
vdu_id2uuid[db_vm["osm_id"]] = vm_uuid
devices.append(device)
+ if not db_vm.get("image_id"):
+ if not db_vm["pdu_type"]:
+ raise NfvoException("Not defined image for VDU")
+ # create a fake image
+
# cloud-init
boot_data = {}
if vdu.get("cloud-init"):
# table interfaces (internal/external interfaces)
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 = {}
if iface.get("virtual-interface").get("type") == "OM-MGMT":
db_interface["type"] = "mgmt"
- elif iface.get("virtual-interface").get("type") in ("VIRTIO", "E1000"):
+ elif iface.get("virtual-interface").get("type") in ("VIRTIO", "E1000", "PARAVIRT"):
db_interface["type"] = "bridge"
db_interface["model"] = get_str(iface.get("virtual-interface"), "type", 12)
elif iface.get("virtual-interface").get("type") in ("SR-IOV", "PCI-PASSTHROUGH"):
numa["cores"] = max(db_flavor["vcpus"], 1)
else:
numa["threads"] = max(db_flavor["vcpus"], 1)
+ epa_vcpu_set = True
+ if vdu["guest-epa"].get("cpu-quota") and not epa_vcpu_set:
+ extended["cpu-quota"] = get_resource_allocation_params(vdu["guest-epa"].get("cpu-quota"))
+ if vdu["guest-epa"].get("mem-quota"):
+ extended["mem-quota"] = get_resource_allocation_params(vdu["guest-epa"].get("mem-quota"))
+ if vdu["guest-epa"].get("disk-io-quota"):
+ extended["disk-io-quota"] = get_resource_allocation_params(vdu["guest-epa"].get("disk-io-quota"))
+ if vdu["guest-epa"].get("vif-quota"):
+ extended["vif-quota"] = get_resource_allocation_params(vdu["guest-epa"].get("vif-quota"))
if numa:
extended["numas"] = [numa]
if extended:
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 cp_name2db_interface[vdu_id2cp_name[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}'. "
+ 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"]),
httperrors.Bad_Request)
mgmt_access["vm_id"] = cp_name2vm_uuid[vnfd["mgmt-interface"]["cp"]]
mgmt_access["interface_id"] = cp_name2iface_uuid[vnfd["mgmt-interface"]["cp"]]
# mark this interface as of type mgmt
- cp_name2db_interface[vnfd["mgmt-interface"]["cp"]]["type"] = "mgmt"
+ if cp_name2db_interface[vnfd["mgmt-interface"]["cp"]]:
+ cp_name2db_interface[vnfd["mgmt-interface"]["cp"]]["type"] = "mgmt"
default_user = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}).get("ssh-access", {}),
"default-user", 64)
SELECT=('vms.uuid as uuid', 'vms.osm_id as osm_id', 'vms.name as name', 'vms.description as description',
'boot_data'),
WHERE={'vnfs.uuid': vnf_id} )
- if len(content)==0:
- raise NfvoException("vnf '{}' not found".format(vnf_id), httperrors.Not_Found)
+ if len(content) != 0:
+ #raise NfvoException("vnf '{}' not found".format(vnf_id), httperrors.Not_Found)
# change boot_data into boot-data
- for vm in content:
- if vm.get("boot_data"):
- vm["boot-data"] = yaml.safe_load(vm["boot_data"])
- del vm["boot_data"]
+ for vm in content:
+ if vm.get("boot_data"):
+ vm["boot-data"] = yaml.safe_load(vm["boot_data"])
+ del vm["boot_data"]
- data['vnf']['VNFC'] = content
+ data['vnf']['VNFC'] = content
#TODO: GET all the information from a VNFC and include it in the output.
#GET NET
try:
mynsd = nsd_catalog.nsd()
try:
- pybindJSONDecoder.load_ietf_json(nsd_descriptor, None, None, obj=mynsd)
+ pybindJSONDecoder.load_ietf_json(nsd_descriptor, None, None, obj=mynsd, skip_unknown=True)
except Exception as e:
raise NfvoException("Error. Invalid NS descriptor format: " + str(e), httperrors.Bad_Request)
db_scenarios = []
str(iface.get("vnfd-id-ref"))[:255]),
httperrors.Bad_Request)
interface_uuid = existing_ifaces[0]["uuid"]
- if existing_ifaces[0]["iface_type"] == "data" and not db_sce_net["type"]:
+ if existing_ifaces[0]["iface_type"] == "data":
db_sce_net["type"] = "data"
sce_interface_uuid = str(uuid4())
uuid_list.append(sce_net_uuid)
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)
"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'])
str(nsd["id"]), str(rsp["id"]), str(iface["member-vnf-index-ref"])),
httperrors.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:
+ ingress_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-ingress-connection-point-ref",
+ 255)})
+ if not ingress_existing_ifaces:
raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
- "-ref':'vnfd-connection-point-ref':'{}'. Reference to a non-existing "
+ "-ref':'vnfd-ingress-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]),
- httperrors.Bad_Request)
- interface_uuid = existing_ifaces[0]["uuid"]
+ str(nsd["id"]), str(rsp["id"]), str(iface["vnfd-ingress-connection-point-ref"]),
+ str(iface.get("vnfd-id-ref"))[:255]), httperrors.Bad_Request)
+
+ egress_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-egress-connection-point-ref",
+ 255)})
+ if not egress_existing_ifaces:
+ raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'rsp[{}]':'vnfd-connection-point"
+ "-ref':'vnfd-egress-connection-point-ref':'{}'. Reference to a non-existing "
+ "connection-point name at VNFD '{}'".format(
+ str(nsd["id"]), str(rsp["id"]), str(iface["vnfd-egress-connection-point-ref"]),
+ str(iface.get("vnfd-id-ref"))[:255]), HTTP_Bad_Request)
+
+ ingress_interface_uuid = ingress_existing_ifaces[0]["uuid"]
+ egress_interface_uuid = egress_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,
+ "ingress_interface_id": ingress_interface_uuid,
+ "egress_interface_id": egress_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)
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)
#We should use the dictionary as input parameter for new_network
#print myNetDict
if not sce_net["external"]:
- network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile)
+ network_id, _ = myvim.new_network(myNetName, myNetType, myNetIPProfile)
#print "New VIM network created for scenario %s. Network id: %s" % (scenarioDict['name'],network_id)
sce_net['vim_id'] = network_id
auxNetDict['scenario'][sce_net['uuid']] = network_id
#print myNetDict
#TODO:
#We should use the dictionary as input parameter for new_network
- network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile)
+ network_id, _ = myvim.new_network(myNetName, myNetType, myNetIPProfile)
#print "VIM network id for scenario %s: %s" % (scenarioDict['name'],network_id)
net['vim_id'] = network_id
if sce_vnf['uuid'] not in auxNetDict:
def update(d, u):
- '''Takes dict d and updates it with the values in dict u.'''
- '''It merges all depth levels'''
+ """Takes dict d and updates it with the values in dict u.
+ It merges all depth levels"""
for k, v in u.iteritems():
if isinstance(v, collections.Mapping):
r = update(d.get(k, {}), v)
myvims = {}
myvim_threads_id = {}
datacenter = instance_dict.get("datacenter")
+ default_wim_account = instance_dict.get("wim_account")
default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
myvims[default_datacenter_id] = vim
myvim_threads_id[default_datacenter_id], _ = get_vim_thread(mydb, tenant_id, default_datacenter_id)
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],
- datacenter_id=default_datacenter_id)
+ if isinstance(scenario, str):
+ scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_vim_id=myvim_threads_id[default_datacenter_id],
+ datacenter_id=default_datacenter_id)
+ else:
+ scenarioDict = scenario
+ scenarioDict["uuid"] = None
# logger.debug(">>>>>> Dictionaries before merging")
# logger.debug(">>>>>> InstanceDict:\n{}".format(yaml.safe_dump(instance_dict,default_flow_style=False, width=256)))
# Auxiliary dictionaries from x to y
sce_net2instance = {}
net2task_id = {'scenario': {}}
+ # Mapping between local networks and WIMs
+ wim_usage = {}
def ip_profile_IM2RO(ip_profile_im):
# translate from input format to database format
raise NfvoException("Invalid net id or name '{}' at instance:vnfs:networks".format(net_id), httperrors.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("vim-network-id"):
+ scenario_net["vim-network-id"] = net_instance_desc["vim-network-id"]
if net_instance_desc.get("name"):
scenario_net["name"] = net_instance_desc["name"]
if 'ip-profile' in net_instance_desc:
# However, this is not possible yet.
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 net_name == scenario_net.get("name") or net_name == scenario_net.get("osm_id") or net_name == scenario_net.get("uuid"):
+ if "wim_account" in net_instance_desc and net_instance_desc["wim_account"] is not None:
+ scenario_net["wim_account"] = net_instance_desc["wim_account"]
if 'ip-profile' in net_instance_desc:
ipprofile_db = ip_profile_IM2RO(net_instance_desc['ip-profile'])
if 'ip_profile' not in scenario_net:
number_mgmt_networks = 0
db_instance_nets = []
for sce_net in scenarioDict['nets']:
+ sce_net_uuid = sce_net.get('uuid', sce_net["name"])
# get involved datacenters where this network need to be created
involved_datacenters = []
- for sce_vnf in scenarioDict.get("vnfs"):
+ 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_ifaces.get("sce_net_id") == sce_net["uuid"]:
involved_datacenters.append(vnf_datacenter)
break
+ if not involved_datacenters:
+ involved_datacenters.append(default_datacenter_id)
+ target_wim_account = sce_net.get("wim_account", default_wim_account)
+
+ # --> WIM
+ # TODO: use this information during network creation
+ wim_account_id = wim_account_name = None
+ if len(involved_datacenters) > 1 and 'uuid' in sce_net:
+ if target_wim_account is None or target_wim_account is True: # automatic selection of WIM
+ # OBS: sce_net without uuid are used internally to VNFs
+ # and the assumption is that VNFs will not be split among
+ # different datacenters
+ wim_account = wim_engine.find_suitable_wim_account(
+ involved_datacenters, tenant_id)
+ wim_account_id = wim_account['uuid']
+ wim_account_name = wim_account['name']
+ wim_usage[sce_net['uuid']] = wim_account_id
+ elif isinstance(target_wim_account, str): # manual selection of WIM
+ wim_account.persist.get_wim_account_by(target_wim_account, tenant_id)
+ wim_account_id = wim_account['uuid']
+ wim_account_name = wim_account['name']
+ wim_usage[sce_net['uuid']] = wim_account_id
+ else: # not WIM usage
+ wim_usage[sce_net['uuid']] = False
+ # <-- WIM
descriptor_net = {}
- if instance_dict.get("networks") and instance_dict["networks"].get(sce_net["name"]):
- descriptor_net = instance_dict["networks"][sce_net["name"]]
+ if instance_dict.get("networks"):
+ if sce_net.get("uuid") in instance_dict["networks"]:
+ descriptor_net = instance_dict["networks"][sce_net["uuid"]]
+ descriptor_net_name = sce_net["uuid"]
+ elif sce_net.get("osm_id") in instance_dict["networks"]:
+ descriptor_net = instance_dict["networks"][sce_net["osm_id"]]
+ descriptor_net_name = sce_net["osm_id"]
+ elif sce_net["name"] in instance_dict["networks"]:
+ descriptor_net = instance_dict["networks"][sce_net["name"]]
+ descriptor_net_name = sce_net["name"]
net_name = descriptor_net.get("vim-network-name")
- sce_net2instance[sce_net['uuid']] = {}
- net2task_id['scenario'][sce_net['uuid']] = {}
+ # add datacenters from instantiation parameters
+ if descriptor_net.get("sites"):
+ for site in descriptor_net["sites"]:
+ if site.get("datacenter") and site["datacenter"] not in involved_datacenters:
+ involved_datacenters.append(site["datacenter"])
+ sce_net2instance[sce_net_uuid] = {}
+ net2task_id['scenario'][sce_net_uuid] = {}
+
+ use_network = None
+ related_network = None
+ if descriptor_net.get("use-network"):
+ target_instance_nets = mydb.get_rows(
+ SELECT="related",
+ FROM="instance_nets",
+ WHERE={"instance_scenario_id": descriptor_net["use-network"]["instance_scenario_id"],
+ "osm_id": descriptor_net["use-network"]["osm_id"]},
+ )
+ if not target_instance_nets:
+ raise NfvoException(
+ "Cannot find the target network at instance:networks[{}]:use-network".format(descriptor_net_name),
+ httperrors.Bad_Request)
+ else:
+ use_network = target_instance_nets[0]["related"]
if sce_net["external"]:
number_mgmt_networks += 1
myvim_thread_id = myvim_threads_id[datacenter_id]
net_type = sce_net['type']
+ net_vim_name = None
lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} # 'shared': True
if not net_name:
lookfor_network = True
lookfor_filter["name"] = sce_net.get("vim_network_name")
elif sce_net["external"]:
- if sce_net['vim_id'] is not None:
+ if sce_net.get('vim_id'):
# there is a netmap at datacenter_nets database # TODO REVISE!!!!
create_network = False
lookfor_network = True
task_extra = {}
if create_network:
task_action = "CREATE"
- task_extra["params"] = (net_vim_name, net_type, sce_net.get('ip_profile', None))
+ task_extra["params"] = (net_vim_name, net_type, sce_net.get('ip_profile', None), wim_account_name)
if lookfor_network:
task_extra["find"] = (lookfor_filter,)
elif lookfor_network:
# fill database content
net_uuid = str(uuid4())
uuid_list.append(net_uuid)
- sce_net2instance[sce_net['uuid']][datacenter_id] = net_uuid
+ sce_net2instance[sce_net_uuid][datacenter_id] = net_uuid
+ if not related_network: # all db_instance_nets will have same related
+ related_network = use_network or net_uuid
db_net = {
"uuid": net_uuid,
+ "osm_id": sce_net.get("osm_id") or sce_net["name"],
+ "related": related_network,
'vim_net_id': None,
+ "vim_name": net_vim_name,
"instance_scenario_id": instance_uuid,
- "sce_net_id": sce_net["uuid"],
+ "sce_net_id": sce_net.get("uuid"),
"created": create_network,
'datacenter_id': datacenter_id,
'datacenter_tenant_id': myvim_thread_id,
"action": task_action,
"item": "instance_nets",
"item_id": net_uuid,
+ "related": related_network,
"extra": yaml.safe_dump(task_extra, default_flow_style=True, width=256)
}
- net2task_id['scenario'][sce_net['uuid']][datacenter_id] = task_index
+ net2task_id['scenario'][sce_net_uuid][datacenter_id] = task_index
task_index += 1
db_vim_actions.append(db_vim_action)
"myvims": myvims,
"cloud_config": cloud_config,
"RO_pub_key": tenant[0].get('RO_pub_key'),
+ "instance_parameters": instance_dict,
}
vnf_params_out = {
"task_index": task_index,
"sce_net2instance": sce_net2instance,
}
# sce_vnf_list = sorted(scenarioDict['vnfs'], key=lambda k: k['name'])
- for sce_vnf in scenarioDict['vnfs']: # sce_vnf_list:
+ for sce_vnf in scenarioDict.get('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 vnffg in scenarioDict.get('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",
+ SELECT='vms.count',
+ FROM="vms join interfaces on vms.uuid=interfaces.vm_id join sce_rsp_hops as h "
+ "on interfaces.uuid=h.ingress_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']]
for i in range(count):
# create sfis
sfi_uuid = str(uuid4())
+ extra_params = {
+ "ingress_interface_id": cp["ingress_interface_id"],
+ "egress_interface_id": cp["egress_interface_id"]
+ }
uuid_list.append(sfi_uuid)
db_sfi = {
"uuid": sfi_uuid,
+ "related": sfi_uuid,
"instance_scenario_id": instance_uuid,
'sce_rsp_hop_id': cp['uuid'],
'datacenter_id': datacenter_id,
"status": "SCHEDULED",
"item": "instance_sfis",
"item_id": sfi_uuid,
- "extra": yaml.safe_dump({"params": "", "depends_on": [dependencies[i]]},
+ "related": sfi_uuid,
+ "extra": yaml.safe_dump({"params": extra_params, "depends_on": [dependencies[i]]},
default_flow_style=True, width=256)
}
sfis_created.append(task_index)
uuid_list.append(sf_uuid)
db_sf = {
"uuid": sf_uuid,
+ "related": sf_uuid,
"instance_scenario_id": instance_uuid,
'sce_rsp_hop_id': cp['uuid'],
'datacenter_id': datacenter_id,
"status": "SCHEDULED",
"item": "instance_sfs",
"item_id": sf_uuid,
+ "related": sf_uuid,
"extra": yaml.safe_dump({"params": "", "depends_on": sfis_created},
default_flow_style=True, width=256)
}
uuid_list.append(classification_uuid)
db_classification = {
"uuid": classification_uuid,
+ "related": classification_uuid,
"instance_scenario_id": instance_uuid,
'sce_classifier_match_id': match['uuid'],
'datacenter_id': datacenter_id,
"status": "SCHEDULED",
"item": "instance_classifications",
"item_id": classification_uuid,
+ "related": classification_uuid,
"extra": yaml.safe_dump({"params": classification_params, "depends_on": [dependencies[i]]},
default_flow_style=True, width=256)
}
uuid_list.append(sfp_uuid)
db_sfp = {
"uuid": sfp_uuid,
+ "related": sfp_uuid,
"instance_scenario_id": instance_uuid,
'sce_rsp_id': rsp['uuid'],
'datacenter_id': datacenter_id,
"status": "SCHEDULED",
"item": "instance_sfps",
"item_id": sfp_uuid,
+ "related": sfp_uuid,
"extra": yaml.safe_dump({"params": "", "depends_on": sfs_created + classifications_created},
default_flow_style=True, width=256)
}
db_instance_action["number_tasks"] = task_index
# --> WIM
- wan_links = wim_engine.derive_wan_links(db_instance_nets, tenant_id)
+ logger.debug('wim_usage:\n%s\n\n', pformat(wim_usage))
+ wan_links = wim_engine.derive_wan_links(wim_usage, db_instance_nets, tenant_id)
wim_actions = wim_engine.create_actions(wan_links)
wim_actions, db_instance_action = (
wim_engine.incorporate_actions(wim_actions, db_instance_action))
returned_instance = mydb.get_instance_scenario(instance_uuid)
returned_instance["action_id"] = instance_action_id
return returned_instance
- except (NfvoException, vimconn.vimconnException, db_base_Exception) as e:
+ except (NfvoException, vimconn.vimconnException, wimconn.WimConnectorError, db_base_Exception) as e:
message = rollback(mydb, myvims, rollbackList)
if isinstance(e, db_base_Exception):
error_text = "database Exception"
elif isinstance(e, vimconn.vimconnException):
error_text = "VIM Exception"
+ elif isinstance(e, wimconn.WimConnectorError):
+ error_text = "WIM Exception"
else:
error_text = "Exception"
error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
vnf_net2instance[sce_vnf['uuid']][net['uuid']] = net_uuid
db_net = {
"uuid": net_uuid,
+ "related": net_uuid,
'vim_net_id': None,
+ "vim_name": net_name,
"instance_scenario_id": instance_uuid,
"net_id": net["uuid"],
"created": True,
}
db_instance_nets.append(db_net)
+ lookfor_filter = {}
if net.get("vim-network-name"):
- lookfor_filter = {"name": net["vim-network-name"]}
+ lookfor_filter["name"] = net["vim-network-name"]
+ if net.get("vim-network-id"):
+ lookfor_filter["id"] = net["vim-network-id"]
+ if lookfor_filter:
task_action = "FIND"
task_extra = {"params": (lookfor_filter,)}
else:
"action": task_action,
"item": "instance_nets",
"item_id": net_uuid,
+ "related": net_uuid,
"extra": yaml.safe_dump(task_extra, default_flow_style=True, width=256)
}
task_index += 1
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']:
+ for vm in sce_vnf.get('vms'):
vm_av = vm.get('availability_zone')
if vm_av and vm_av not in vnf_availability_zones:
vnf_availability_zones.append(vm_av)
db_instance_vnfs.append(db_instance_vnf)
for vm in sce_vnf['vms']:
+ # skip PDUs
+ if vm.get("pdu_type"):
+ continue
+
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['networks'] = []
task_depends_on = []
# TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
+ is_management_vm = False
db_vm_ifaces = []
for iface in vm['interfaces']:
netDict = {}
Try to delete and create the scenarios and VNFs again", httperrors.Conflict)
else:
raise NfvoException(e_text, httperrors.Internal_Server_Error)
- if netDict["use"] == "mgmt" or netDict["use"] == "bridge":
+ if netDict["use"] == "mgmt":
+ is_management_vm = True
+ netDict["type"] = "virtual"
+ if netDict["use"] == "bridge":
netDict["type"] = "virtual"
if iface.get("vpci"):
netDict['vpci'] = iface['vpci']
# 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 is_management_vm and params["instance_parameters"].get("mgmt_keys"):
+ cloud_config_vm = unify_cloud_config({"key-pairs": params["instance_parameters"]["mgmt_keys"]},
+ cloud_config_vm)
+
+ if vm.get("instance_parameters") and vm["instance_parameters"].get("mgmt_keys"):
+ cloud_config_vm = unify_cloud_config({"key-pairs": vm["instance_parameters"]["mgmt_keys"]},
+ cloud_config_vm)
+ # 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)
uuid_list.append(vm_uuid)
db_vm = {
"uuid": vm_uuid,
+ "related": vm_uuid,
'instance_vnf_id': vnf_uuid,
# TODO delete "vim_vm_id": vm_id,
"vm_id": vm["uuid"],
"status": "SCHEDULED",
"item": "instance_vms",
"item_id": vm_uuid,
+ "related": vm_uuid,
"extra": yaml.safe_dump({"params": task_params, "depends_on": task_depends_on},
default_flow_style=True, width=256)
}
# "number_tasks": 0 # filled bellow
}
- # 2.1 deleting VMs
- # vm_fail_list=[]
- for sce_vnf in instanceDict['vnfs']:
- datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
- vimthread_affected[sce_vnf["datacenter_tenant_id"]] = None
- if datacenter_key not in myvims:
- try:
- _,myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["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=sce_vnf["datacenter_id"],
- datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"],
- sce_vnf["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = vims.values()[0]
- myvim = myvims[datacenter_key]
- myvim_thread = myvim_threads[datacenter_key]
- for vm in sce_vnf['vms']:
- 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
- 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']:
- vimthread_affected[net["datacenter_tenant_id"]] = None
- datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
+ # 2.1 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, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
+ _, 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=net["datacenter_id"],
- datacenter_tenant_id=net["datacenter_tenant_id"])
+ 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(net["datacenter_id"], net["datacenter_tenant_id"]))
+ 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_thread = myvim_threads[datacenter_key]
if not myvim:
- error_msg += "\n Net VIM_id={} cannot be deleted because datacenter={} not found".format(net['vim_net_id'], net["datacenter_id"])
+ error_msg += "\n vim_sfp_id={} cannot be deleted because datacenter={} not found".format(sfp['vim_sfp_id'], sfp["datacenter_id"])
continue
- extra = {"params": (net['vim_net_id'], net['sdn_net_id'])}
- if net2vm_dependencies.get(net["uuid"]):
- extra["depends_on"] = net2vm_dependencies[net["uuid"]]
+ extra = {"params": (sfp['vim_sfp_id'])}
db_vim_action = {
"instance_action_id": instance_action_id,
"task_index": task_index,
- "datacenter_vim_id": net["datacenter_tenant_id"],
+ "datacenter_vim_id": sfp["datacenter_tenant_id"],
"action": "DELETE",
"status": "SCHEDULED",
- "item": "instance_nets",
- "item_id": net["uuid"],
+ "item": "instance_sfps",
+ "item_id": sfp["uuid"],
+ "related": sfp["related"],
"extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
}
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"])
+ 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, sfp["datacenter_id"], sfp["datacenter_tenant_id"])
+ _, 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=sfp["datacenter_id"],
- datacenter_tenant_id=sfp["datacenter_tenant_id"])
+ 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(sfp["datacenter_id"], sfp["datacenter_tenant_id"]))
+ 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_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"])
+ error_msg += "\n vim_classification_id={} cannot be deleted because datacenter={} not found".format(classification['vim_classification_id'],
+ classification["datacenter_id"])
continue
- extra = {"params": (sfp['vim_sfp_id'])}
+ depends_on = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfps"]
+ extra = {"params": (classification['vim_classification_id']), "depends_on": depends_on}
db_vim_action = {
"instance_action_id": instance_action_id,
"task_index": task_index,
- "datacenter_vim_id": sfp["datacenter_tenant_id"],
+ "datacenter_vim_id": classification["datacenter_tenant_id"],
"action": "DELETE",
"status": "SCHEDULED",
- "item": "instance_sfps",
- "item_id": sfp["uuid"],
+ "item": "instance_classifications",
+ "item_id": classification["uuid"],
+ "related": classification["related"],
"extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
}
task_index += 1
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"])
+ _, 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
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'])}
+ depends_on = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfps"]
+ extra = {"params": (sf['vim_sf_id']), "depends_on": depends_on}
db_vim_action = {
"instance_action_id": instance_action_id,
"task_index": task_index,
"status": "SCHEDULED",
"item": "instance_sfs",
"item_id": sf["uuid"],
+ "related": sf["related"],
"extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
}
task_index += 1
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"])
+ _, 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
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'])}
+ depends_on = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfs"]
+ extra = {"params": (sfi['vim_sfi_id']), "depends_on": depends_on}
db_vim_action = {
"instance_action_id": instance_action_id,
"task_index": task_index,
"status": "SCHEDULED",
"item": "instance_sfis",
"item_id": sfi["uuid"],
+ "related": sfi["related"],
"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"])
+ # 2.2 deleting VMs
+ # vm_fail_list=[]
+ for sce_vnf in instanceDict.get('vnfs', ()):
+ datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
+ vimthread_affected[sce_vnf["datacenter_tenant_id"]] = None
if datacenter_key not in myvims:
try:
- _,myvim_thread = get_vim_thread(mydb, tenant_id, classification["datacenter_id"], classification["datacenter_tenant_id"])
+ _, myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["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"])
+ vims = get_vim(mydb, tenant_id, datacenter_id=sce_vnf["datacenter_id"],
+ datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
+ if len(vims) == 0:
+ logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"],
+ sce_vnf["datacenter_tenant_id"]))
+ myvims[datacenter_key] = None
+ else:
+ myvims[datacenter_key] = vims.values()[0]
+ myvim = myvims[datacenter_key]
+ myvim_thread = myvim_threads[datacenter_key]
+
+ for vm in sce_vnf['vms']:
+ 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
+ sfi_dependencies = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfis"]
+ 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"],
+ "related": vm["related"],
+ "extra": yaml.safe_dump({"params": vm["interfaces"], "depends_on": sfi_dependencies},
+ 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.3 deleting NETS
+ # net_fail_list=[]
+ for net in instanceDict['nets']:
+ vimthread_affected[net["datacenter_tenant_id"]] = None
+ datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
+ if datacenter_key not in myvims:
+ try:
+ _,myvim_thread = get_vim_thread(mydb, tenant_id, net["datacenter_id"], net["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=net["datacenter_id"],
+ datacenter_tenant_id=net["datacenter_tenant_id"])
if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(classification["datacenter_id"], classification["datacenter_tenant_id"]))
+ logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
myvims[datacenter_key] = None
else:
myvims[datacenter_key] = vims.values()[0]
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"])
+ error_msg += "\n Net VIM_id={} cannot be deleted because datacenter={} not found".format(net['vim_net_id'], net["datacenter_id"])
continue
- extra = {"params": (classification['vim_classification_id'])}
+ extra = {"params": (net['vim_net_id'], net['sdn_net_id'])}
+ if net2vm_dependencies.get(net["uuid"]):
+ extra["depends_on"] = net2vm_dependencies[net["uuid"]]
+ sfi_dependencies = [action["task_index"] for action in db_vim_actions if action["item"] == "instance_sfis"]
+ if len(sfi_dependencies) > 0:
+ if "depends_on" in extra:
+ extra["depends_on"] += sfi_dependencies
+ else:
+ extra["depends_on"] = sfi_dependencies
db_vim_action = {
"instance_action_id": instance_action_id,
"task_index": task_index,
- "datacenter_vim_id": classification["datacenter_tenant_id"],
+ "datacenter_vim_id": net["datacenter_tenant_id"],
"action": "DELETE",
"status": "SCHEDULED",
- "item": "instance_classifications",
- "item_id": classification["uuid"],
+ "item": "instance_nets",
+ "item_id": net["uuid"],
+ "related": net["related"],
"extra": yaml.safe_dump(extra, default_flow_style=True, width=256)
}
task_index += 1
"description": "SCALE",
}
vm_result["instance_action_id"] = instance_action_id
+ vm_result["created"] = []
+ vm_result["deleted"] = []
task_index = 0
for vdu in action_dict["vdu-scaling"]:
vdu_id = vdu.get("vdu-id")
member_vnf_index = vdu.get("member-vnf-index")
vdu_count = vdu.get("count", 1)
if vdu_id:
- target_vm = mydb.get_rows(
+ target_vms = 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:
+ if not target_vms:
raise NfvoException("Cannot find the vdu with id {}".format(vdu_id), httperrors.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(
+ raise NfvoException("Invalid input vdu parameters. Must supply either 'vdu-id' of 'osm_vdu_id','member-vnf-index'")
+ target_vms = 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},
+ WHERE={"vms.osm_id": osm_vdu_id, "svnfs.member_vnf_index": member_vnf_index,
+ "ivnfs.instance_scenario_id": instance_id},
ORDER_BY="ivms.created_at"
)
- if not target_vm:
+ if not target_vms:
raise NfvoException("Cannot find the vdu with osm_vdu_id {} and member-vnf-index {}".format(osm_vdu_id, member_vnf_index), httperrors.Not_Found)
- vdu_id = target_vm[-1]["uuid"]
- vm_result[vdu_id] = {"created": [], "deleted": [], "description": "scheduled"}
- target_vm = target_vm[-1]
+ vdu_id = target_vms[-1]["uuid"]
+ target_vm = target_vms[-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
+ for index in range(0, vdu_count):
+ target_vm = target_vms[-1-index]
+ vdu_id = target_vm["uuid"]
+ # look for nm
+ vm_interfaces = None
+ for sce_vnf in instanceDict['vnfs']:
+ for vm in sce_vnf['vms']:
+ if vm["uuid"] == vdu_id:
+ # TODO revise this should not be vm["uuid"] instance_vms["vm_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})
+ 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": vdu_id,
+ "related": target_vm["related"],
+ "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["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)
+ vim_action_to_clone = mydb.get_rows(FROM="vim_wim_actions", WHERE=where)
if not vim_action_to_clone:
raise NfvoException("Cannot find the vim_action at database with {}".format(where), httperrors.Internal_Server_Error)
vim_action_to_clone = vim_action_to_clone[0]
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:]))
+ vm_name = vm_name[:suffix+1] + str(index + 1 + int(vm_name[suffix+1:]))
except Exception:
pass
db_instance_vm = {
"uuid": vm_uuid,
+ 'related': vm_uuid,
'instance_vnf_id': target_vm['instance_vnf_id'],
'vm_id': target_vm['vm_id'],
- 'vim_name': vm_name
+ 'vim_name': vm_name,
}
db_instance_vms.append(db_instance_vm)
"status": "SCHEDULED",
"item": "instance_vms",
"item_id": vm_uuid,
+ "related": vm_uuid,
# ALF
# ALF
# TODO examinar parametros, quitar MAC o incrementar. Incrementar IP y colocar las dependencias con ACTION-asdfasd.
}
task_index += 1
db_vim_actions.append(db_vim_action)
- vm_result[vdu_id]["created"].append(vm_uuid)
+ vm_result["created"].append(vm_uuid)
db_instance_action["number_tasks"] = task_index
db_tables = [
# {"instance_sfs": db_instance_sfs},
# {"instance_classifications": db_instance_classifications},
# {"instance_sfps": db_instance_sfps},
- {"vim_actions": db_vim_actions}
+ {"vim_wim_actions": db_vim_actions}
]
logger.debug("create_vdu done DB tables: %s",
yaml.safe_dump(db_tables, indent=4, default_flow_style=False))
raise NfvoException("Not found any action with this criteria", httperrors.Not_Found)
vim_wim_actions = mydb.get_rows(FROM="vim_wim_actions", WHERE={"instance_action_id": action_id})
rows[0]["vim_wim_actions"] = vim_wim_actions
+ # for backward compatibility set vim_actions = vim_wim_actions
+ rows[0]["vim_actions"] = vim_wim_actions
return {"actions": rows}
try:
datacenter_sdn_port_mapping_delete(mydb, None, datacenter_id)
except ovimException as e:
- raise NfvoException("Error deleting datacenter-port-mapping " + str(e), HTTP_Conflict)
+ raise NfvoException("Error deleting datacenter-port-mapping " + str(e), httperrors.Conflict)
mydb.update_rows('datacenters', datacenter_descriptor, where)
if new_sdn_port_mapping:
except ovimException as e:
# Rollback
mydb.update_rows('datacenters', datacenter, where)
- raise NfvoException("Error adding datacenter-port-mapping " + str(e), HTTP_Conflict)
+ raise NfvoException("Error adding datacenter-port-mapping " + str(e), httperrors.Conflict)
return datacenter_id
net_public = net.pop("shared", False)
net_ipprofile = net.pop("ip_profile", None)
net_vlan = net.pop("vlan", None)
- content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, vlan=net_vlan) #, **net)
+ content, _ = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, vlan=net_vlan) #, **net)
#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'):
sdn_network['type'] = net_type
sdn_network['name'] = net_name
sdn_network['region'] = datacenter_tenant_id
- ovim_content = ovim.new_network(sdn_network)
+ ovim_content = ovim.new_network(sdn_network)
except ovimException as e:
logger.error("ovimException creating SDN network={} ".format(
sdn_network) + str(e), exc_info=True)
pci = port.get("pci")
element["switch_port"] = port.get("switch_port")
element["switch_mac"] = port.get("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'", httperrors.Bad_Request)
+ if not element["switch_port"] and not element["switch_mac"]:
+ raise NfvoException ("The mapping must contain 'switch_port' or 'switch_mac'", httperrors.Bad_Request)
for pci_expanded in utils.expand_brackets(pci):
element["pci"] = pci_expanded
maps.append(dict(element))
projects / osm / RO.git / blobdiff