#import json
import yaml
import utils
+import vim_thread
from db_base import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Error, HTTP_Not_Found,\
HTTP_Conflict, HTTP_Method_Not_Allowed
import console_proxy_thread as cli
import logging
import collections
from db_base import db_base_Exception
+import nfvo_db
+from threading import Lock
+from time import time
global global_config
global vimconn_imported
global logger
+global default_volume_size
+default_volume_size = '5' #size in GB
-vimconn_imported={} #dictionary with VIM type as key, loaded module as value
+vimconn_imported = {} # dictionary with VIM type as key, loaded module as value
+vim_threads = {"running":{}, "deleting": {}, "names": []} # threads running for attached-VIMs
+vim_persistent_info = {}
logger = logging.getLogger('openmano.nfvo')
+task_lock = Lock()
+task_dict = {}
+last_task_id = 0.0
+db=None
+db_lock=Lock()
class NfvoException(Exception):
def __init__(self, message, http_code):
Exception.__init__(self, message)
+def get_task_id():
+ global last_task_id
+ task_id = time()
+ if task_id <= last_task_id:
+ task_id = last_task_id + 0.000001
+ last_task_id = task_id
+ return "TASK.{:.6f}".format(task_id)
+
+
+def new_task(name, params, store=True, depends=None):
+ task_id = get_task_id()
+ task = {"status": "enqueued", "id": task_id, "name": name, "params": params}
+ if depends:
+ task["depends"] = depends
+ if store:
+ task_dict[task_id] = task
+ return task
+
+
+def is_task_id(id):
+ return True if id[:5] == "TASK." else False
+
+
+def get_non_used_vim_name(datacenter_name, datacenter_id, tenant_name, tenant_id):
+ name = datacenter_name[:16]
+ 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
+ vim_threads["names"].append(name)
+ return name
+
+
+def start_service(mydb):
+ global db, global_config
+ db = nfvo_db.nfvo_db()
+ db.connect(global_config['db_host'], global_config['db_user'], global_config['db_passwd'], global_config['db_name'])
+ from_= 'tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join datacenter_tenants as dt on td.datacenter_tenant_id=dt.uuid'
+ select_ = ('type','d.config as config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name',
+ 'dt.uuid as datacenter_tenant_id','dt.vim_tenant_name as vim_tenant_name','dt.vim_tenant_id as vim_tenant_id',
+ 'user','passwd', 'dt.config as dt_config', 'nfvo_tenant_id')
+ try:
+ vims = mydb.get_rows(FROM=from_, SELECT=select_)
+ for vim in vims:
+ extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')}
+ if vim["config"]:
+ extra.update(yaml.load(vim["config"]))
+ if vim.get('dt_config'):
+ extra.update(yaml.load(vim["dt_config"]))
+ if vim["type"] not in vimconn_imported:
+ module_info=None
+ try:
+ module = "vimconn_" + vim["type"]
+ module_info = imp.find_module(module)
+ vim_conn = imp.load_module(vim["type"], *module_info)
+ vimconn_imported[vim["type"]] = vim_conn
+ except (IOError, ImportError) as e:
+ if module_info and module_info[0]:
+ file.close(module_info[0])
+ raise NfvoException("Unknown vim type '{}'. Can not open file '{}.py'; {}: {}".format(
+ vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request)
+
+ thread_id = vim["datacenter_id"] + "." + vim['nfvo_tenant_id']
+ vim_persistent_info[thread_id] = {}
+ try:
+ #if not tenant:
+ # return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
+ myvim = vimconn_imported[ vim["type"] ].vimconnector(
+ uuid=vim['datacenter_id'], name=vim['datacenter_name'],
+ tenant_id=vim['vim_tenant_id'], tenant_name=vim['vim_tenant_name'],
+ url=vim['vim_url'], url_admin=vim['vim_url_admin'],
+ user=vim['user'], passwd=vim['passwd'],
+ config=extra, persistent_info=vim_persistent_info[thread_id]
+ )
+ except Exception as e:
+ raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), HTTP_Internal_Server_Error)
+ thread_name = get_non_used_vim_name(vim['datacenter_name'], vim['vim_tenant_id'], vim['vim_tenant_name'], vim['vim_tenant_id'])
+ new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, vim['datacenter_name'],
+ vim.get('datacenter_tenant_id'), db=db, db_lock=db_lock)
+ new_thread.start()
+ vim_threads["running"][thread_id] = new_thread
+ except db_base_Exception as e:
+ raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code)
+
+
+def stop_service():
+ for thread_id,thread in vim_threads["running"].items():
+ thread.insert_task(new_task("exit", None, store=False))
+ vim_threads["deleting"][thread_id] = thread
+ vim_threads["running"] = {}
+
+
def get_flavorlist(mydb, vnf_id, nfvo_tenant=None):
'''Obtain flavorList
return result, content:
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 )
#result, content = mydb.get_table(FROM='vms',SELECT=('vim_flavor_id',),WHERE=WHERE_dict )
flavors = mydb.get_rows(FROM='vms join flavors on vms.flavor_id=flavors.uuid',SELECT=('flavor_id',),WHERE=WHERE_dict )
flavorList.append(flavor['flavor_id'])
return flavorList
+
def get_imagelist(mydb, vnf_id, nfvo_tenant=None):
'''Obtain imageList
return result, content:
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=[]
imageList.append(image['image_id'])
return imageList
+
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):
'''Obtain a dictionary of VIM (datacenter) classes with some of the input parameters
- return dictionary with {datacenter_id: vim_class, ... }. vim_class contain:
+ 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'
raise exception upon error
'''
file.close(module_info[0])
raise NfvoException("Unknown vim type '{}'. Can not open file '{}.py'; {}: {}".format(
vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request)
-
+
try:
+ if 'nfvo_tenant_id' in vim:
+ thread_id = vim["datacenter_id"] + "." + vim['nfvo_tenant_id']
+ if thread_id not in vim_persistent_info:
+ vim_persistent_info[thread_id] = {}
+ persistent_info = vim_persistent_info[thread_id]
+ else:
+ persistent_info = {}
#if not tenant:
# return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
vim_dict[ vim['datacenter_id'] ] = vimconn_imported[ vim["type"] ].vimconnector(
uuid=vim['datacenter_id'], name=vim['datacenter_name'],
- tenant_id=vim.get('vim_tenant_id',vim_tenant), tenant_name=vim.get('vim_tenant_name',vim_tenant_name),
- url=vim['vim_url'], url_admin=vim['vim_url_admin'],
+ tenant_id=vim.get('vim_tenant_id',vim_tenant),
+ tenant_name=vim.get('vim_tenant_name',vim_tenant_name),
+ url=vim['vim_url'], url_admin=vim['vim_url_admin'],
user=vim.get('user',vim_user), passwd=vim.get('passwd',vim_passwd),
- config=extra
+ 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)
return vim_dict
except db_base_Exception as e:
raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code)
-
+
+
def rollback(mydb, vims, rollback_list):
undeleted_items=[]
- #delete things by reverse order
+ #delete things by reverse order
for i in range(len(rollback_list)-1, -1, -1):
item = rollback_list[i]
if item["where"]=="vim":
undeleted_items.append("{} {} from VIM {}".format(item['what'], item["uuid"], vim["name"]))
except db_base_Exception as e:
logger.error("Error in rollback. Not possible to delete %s '%s' from DB.datacenters Message: %s", item['what'], item["uuid"], str(e))
-
+
else: # where==mano
try:
if item["what"]=="image":
except db_base_Exception as e:
logger.error("Error in rollback. Not possible to delete %s '%s' from DB. Message: %s", item['what'], item["uuid"], str(e))
undeleted_items.append("{} '{}'".format(item['what'], item["uuid"]))
- if len(undeleted_items)==0:
+ if len(undeleted_items)==0:
return True," Rollback successful."
else:
return False," Rollback fails to delete: " + str(undeleted_items)
-
-def check_vnf_descriptor(vnf_descriptor):
+
+
+def check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1):
global global_config
- #create a dictionary with vnfc-name: vnfc:interface-list key:values pairs
+ #create a dictionary with vnfc-name: vnfc:interface-list key:values pairs
vnfc_interfaces={}
for vnfc in vnf_descriptor["vnf"]["VNFC"]:
- name_list = []
+ name_dict = {}
#dataplane interfaces
for numa in vnfc.get("numas",() ):
for interface in numa.get("interfaces",()):
- if interface["name"] in name_list:
- raise NfvoException("Error at vnf:VNFC[name:'{}']:numas:interfaces:name, interface name '{}' already used in this VNFC"\
- .format(vnfc["name"], interface["name"]),
- HTTP_Bad_Request)
- name_list.append( interface["name"] )
+ if interface["name"] in name_dict:
+ raise NfvoException(
+ "Error at vnf:VNFC[name:'{}']:numas:interfaces:name, interface name '{}' already used in this VNFC".format(
+ vnfc["name"], interface["name"]),
+ HTTP_Bad_Request)
+ name_dict[ interface["name"] ] = "underlay"
#bridge interfaces
for interface in vnfc.get("bridge-ifaces",() ):
- if interface["name"] in name_list:
- raise NfvoException("Error at vnf:VNFC[name:'{}']:bridge-ifaces:name, interface name '{}' already used in this VNFC"\
- .format(vnfc["name"], interface["name"]),
- HTTP_Bad_Request)
- name_list.append( interface["name"] )
- vnfc_interfaces[ vnfc["name"] ] = name_list
-
+ if interface["name"] in name_dict:
+ raise NfvoException(
+ "Error at vnf:VNFC[name:'{}']:bridge-ifaces:name, interface name '{}' already used in this VNFC".format(
+ vnfc["name"], interface["name"]),
+ HTTP_Bad_Request)
+ name_dict[ interface["name"] ] = "overlay"
+ vnfc_interfaces[ vnfc["name"] ] = name_dict
+ # check bood-data info
+ if "boot-data" in vnfc:
+ # check that user-data is incompatible with users and config-files
+ if (vnfc["boot-data"].get("users") or vnfc["boot-data"].get("config-files")) and vnfc["boot-data"].get("user-data"):
+ raise NfvoException(
+ "Error at vnf:VNFC:boot-data, fields 'users' and 'config-files' are not compatible with 'user-data'",
+ HTTP_Bad_Request)
+
#check if the info in external_connections matches with the one in the vnfcs
name_list=[]
for external_connection in vnf_descriptor["vnf"].get("external-connections",() ):
if external_connection["name"] in name_list:
- raise NfvoException("Error at vnf:external-connections:name, value '{}' already used as an external-connection"\
- .format(external_connection["name"]),
- HTTP_Bad_Request)
+ raise NfvoException(
+ "Error at vnf:external-connections:name, value '{}' already used as an external-connection".format(
+ external_connection["name"]),
+ HTTP_Bad_Request)
name_list.append(external_connection["name"])
if external_connection["VNFC"] not in vnfc_interfaces:
- raise NfvoException("Error at vnf:external-connections[name:'{}']:VNFC, value '{}' does not match any VNFC"\
- .format(external_connection["name"], external_connection["VNFC"]),
- HTTP_Bad_Request)
-
+ raise NfvoException(
+ "Error at vnf:external-connections[name:'{}']:VNFC, value '{}' does not match any VNFC".format(
+ external_connection["name"], external_connection["VNFC"]),
+ HTTP_Bad_Request)
+
if external_connection["local_iface_name"] not in vnfc_interfaces[ external_connection["VNFC"] ]:
- raise NfvoException("Error at vnf:external-connections[name:'{}']:local_iface_name, value '{}' does not match any interface of this VNFC"\
- .format(external_connection["name"], external_connection["local_iface_name"]),
- HTTP_Bad_Request )
-
+ raise NfvoException(
+ "Error at vnf:external-connections[name:'{}']:local_iface_name, value '{}' does not match any interface of this VNFC".format(
+ external_connection["name"],
+ external_connection["local_iface_name"]),
+ HTTP_Bad_Request )
+
#check if the info in internal_connections matches with the one in the vnfcs
name_list=[]
for internal_connection in vnf_descriptor["vnf"].get("internal-connections",() ):
if internal_connection["name"] in name_list:
- raise NfvoException("Error at vnf:internal-connections:name, value '%s' already used as an internal-connection"\
- .format(internal_connection["name"]),
- HTTP_Bad_Request)
+ raise NfvoException(
+ "Error at vnf:internal-connections:name, value '%s' already used as an internal-connection".format(
+ internal_connection["name"]),
+ HTTP_Bad_Request)
name_list.append(internal_connection["name"])
#We should check that internal-connections of type "ptp" have only 2 elements
- if len(internal_connection["elements"])>2 and internal_connection["type"] == "ptp":
- raise NfvoException("Error at vnf:internal-connections[name:'{}']:elements, size must be 2 for a type:'ptp'"\
- .format(internal_connection["name"]),
- HTTP_Bad_Request)
+
+ if len(internal_connection["elements"])>2 and (internal_connection.get("type") == "ptp" or internal_connection.get("type") == "e-line"):
+ raise NfvoException(
+ "Error at 'vnf:internal-connections[name:'{}']:elements', size must be 2 for a '{}' type. Consider change it to '{}' type".format(
+ internal_connection["name"],
+ 'ptp' if vnf_descriptor_version==1 else 'e-line',
+ 'data' if vnf_descriptor_version==1 else "e-lan"),
+ HTTP_Bad_Request)
for port in internal_connection["elements"]:
- if port["VNFC"] not in vnfc_interfaces:
- raise NfvoException("Error at vnf:internal-connections[name:'{}']:elements[]:VNFC, value '{}' does not match any VNFC"\
- .format(internal_connection["name"], port["VNFC"]),
- HTTP_Bad_Request)
- if port["local_iface_name"] not in vnfc_interfaces[ port["VNFC"] ]:
- raise NfvoException("Error at vnf:internal-connections[name:'{}']:elements[]:local_iface_name, value '{}' does not match any interface of this VNFC"\
- .format(internal_connection["name"], port["local_iface_name"]),
- HTTP_Bad_Request)
- return -HTTP_Bad_Request,
+ vnf = port["VNFC"]
+ iface = port["local_iface_name"]
+ if vnf not in vnfc_interfaces:
+ raise NfvoException(
+ "Error at vnf:internal-connections[name:'{}']:elements[]:VNFC, value '{}' does not match any VNFC".format(
+ internal_connection["name"], vnf),
+ HTTP_Bad_Request)
+ if iface not in vnfc_interfaces[ vnf ]:
+ raise NfvoException(
+ "Error at vnf:internal-connections[name:'{}']:elements[]:local_iface_name, value '{}' does not match any interface of this VNFC".format(
+ internal_connection["name"], iface),
+ HTTP_Bad_Request)
+ return -HTTP_Bad_Request,
+ if vnf_descriptor_version==1 and "type" not in internal_connection:
+ if vnfc_interfaces[vnf][iface] == "overlay":
+ internal_connection["type"] = "bridge"
+ else:
+ internal_connection["type"] = "data"
+ if vnf_descriptor_version==2 and "implementation" not in internal_connection:
+ if vnfc_interfaces[vnf][iface] == "overlay":
+ internal_connection["implementation"] = "overlay"
+ else:
+ internal_connection["implementation"] = "underlay"
+ if (internal_connection.get("type") == "data" or internal_connection.get("type") == "ptp" or \
+ internal_connection.get("implementation") == "underlay") and vnfc_interfaces[vnf][iface] == "overlay":
+ raise NfvoException(
+ "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format(
+ internal_connection["name"],
+ iface, 'bridge' if vnf_descriptor_version==1 else 'overlay',
+ 'data' if vnf_descriptor_version==1 else 'underlay'),
+ HTTP_Bad_Request)
+ if (internal_connection.get("type") == "bridge" or internal_connection.get("implementation") == "overlay") and \
+ vnfc_interfaces[vnf][iface] == "underlay":
+ raise NfvoException(
+ "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format(
+ internal_connection["name"], iface,
+ 'data' if vnf_descriptor_version==1 else 'underlay',
+ 'bridge' if vnf_descriptor_version==1 else 'overlay'),
+ HTTP_Bad_Request)
+
def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error = None):
#look if image exist
if return_on_error == None:
return_on_error = True
else:
- if image_dict['location'] is not None:
+ if image_dict['location']:
images = mydb.get_rows(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']})
else:
images = mydb.get_rows(FROM="images", WHERE={'universal_name':image_dict['universal_name'], 'checksum':image_dict['checksum']})
if len(images)>=1:
image_mano_id = images[0]['uuid']
else:
- #create image
+ #create image in MANO DB
temp_image_dict={'name':image_dict['name'], 'description':image_dict.get('description',None),
'location':image_dict['location'], 'metadata':image_dict.get('metadata',None),
'universal_name':image_dict['universal_name'] , 'checksum':image_dict['checksum']
}
+ #temp_image_dict['location'] = image_dict.get('new_location') if image_dict['location'] is None
image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True)
rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id})
#create image at every vim
if image_dict['location'] is not None:
image_vim_id = vim.get_image_id_from_path(image_dict['location'])
else:
- filter_dict={}
- filter_dict['name']=image_dict['universal_name']
- filter_dict['checksum']=image_dict['checksum']
+ filter_dict = {}
+ filter_dict['name'] = image_dict['universal_name']
+ if image_dict.get('checksum') != None:
+ filter_dict['checksum'] = image_dict['checksum']
#logger.debug('>>>>>>>> Filter dict: %s', str(filter_dict))
vim_images = vim.get_image_list(filter_dict)
+ #logger.debug('>>>>>>>> VIM images: %s', str(vim_images))
if len(vim_images) > 1:
- raise NfvoException("More than one candidate VIM image found for filter: " + str(filter_dict), HTTP_Conflict)
+ raise vimconn.vimconnException("More than one candidate VIM image found for filter: {}".format(str(filter_dict)), HTTP_Conflict)
elif len(vim_images) == 0:
- raise NfvoException("Image not found at VIM with filter: '%s'", str(filter_dict))
+ raise vimconn.vimconnNotFoundException("Image not found at VIM with filter: '{}'".format(str(filter_dict)))
else:
- image_vim_id = vim_images[0].id
+ #logger.debug('>>>>>>>> VIM image 0: %s', str(vim_images[0]))
+ image_vim_id = vim_images[0]['id']
except vimconn.vimconnNotFoundException as e:
- #Create the image in VIM
- try:
- image_vim_id = vim.new_image(image_dict)
- rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id})
- image_created="true"
+ #Create the image in VIM only if image_dict['location'] or image_dict['new_location'] is not None
+ try:
+ #image_dict['location']=image_dict.get('new_location') if image_dict['location'] is None
+ if image_dict['location']:
+ image_vim_id = vim.new_image(image_dict)
+ rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id})
+ image_created="true"
+ else:
+ #If we reach this point, then the image has image name, and optionally checksum, and could not be found
+ raise vimconn.vimconnException(str(e))
except vimconn.vimconnException as e:
if return_on_error:
- logger.error("Error creating image at VIM: %s", str(e))
+ logger.error("Error creating image at VIM '%s': %s", vim["name"], str(e))
raise
image_vim_id = None
- logger.warn("Error creating image at VIM: %s", str(e))
+ logger.warn("Error creating image at VIM '%s': %s", vim["name"], str(e))
continue
except vimconn.vimconnException as e:
if return_on_error:
raise
logger.warn("Error contacting VIM to know if the image exists at VIM: %s", str(e))
image_vim_id = None
- continue
+ continue
#if we reach here, the image has been created or existed
if len(image_db)==0:
#add new vim_id at datacenters_images
elif image_db[0]["vim_id"]!=image_vim_id:
#modify existing vim_id at datacenters_images
mydb.update_rows('datacenters_images', UPDATE={'vim_id':image_vim_id}, WHERE={'datacenter_id':vim_id, 'image_id':image_mano_id})
-
+
return image_vim_id if only_create_at_vim else image_mano_id
+
def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_vim=False, return_on_error = None):
temp_flavor_dict= {'disk':flavor_dict.get('disk',1),
'ram':flavor_dict.get('ram'),
image_dict['universal_name']=device.get('image name')
image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img"
image_dict['location']=device.get('image')
+ #image_dict['new_location']=vnfc.get('image location')
image_dict['checksum']=device.get('image checksum')
image_metadata_dict = device.get('image metadata', None)
image_metadata_str = None
- if image_metadata_dict != None:
+ if image_metadata_dict != None:
image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
image_dict['metadata']=image_metadata_str
image_id = create_or_use_image(mydb, vims, image_dict, rollback_list)
#print "Additional disk image id for VNFC %s: %s" % (flavor_dict['name']+str(dev_nb)+"-img", image_id)
dev_image_list.append(image_id)
- dev_nb += 1
+ dev_nb += 1
temp_flavor_dict['name'] = flavor_dict['name']
temp_flavor_dict['description'] = flavor_dict.get('description',None)
content = mydb.new_row('flavors', temp_flavor_dict, add_uuid=True)
# print "Error contacting VIM to know if the flavor %s existed previously." %flavor_vim_id
# continue
#elif res_vim==0:
-
+
#Create the flavor in VIM
#Translate images at devices from MANO id to VIM id
+ disk_list = []
if 'extended' in flavor_dict and flavor_dict['extended']!=None and "devices" in flavor_dict['extended']:
#make a copy of original devices
devices_original=[]
+
for device in flavor_dict["extended"].get("devices",[]):
dev={}
dev.update(device)
dev_nb=0
for index in range(0,len(devices_original)) :
device=devices_original[index]
- if "image" not in device or "image name" not in device:
+ 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)})
continue
image_dict={}
image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img")
image_dict['universal_name']=device.get('image name')
image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img"
image_dict['location']=device.get('image')
+ #image_dict['new_location']=device.get('image location')
image_dict['checksum']=device.get('image checksum')
image_metadata_dict = device.get('image metadata', None)
image_metadata_str = None
- if image_metadata_dict != None:
+ if image_metadata_dict != None:
image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
image_dict['metadata']=image_metadata_str
image_mano_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error=return_on_error )
image_dict["uuid"]=image_mano_id
image_vim_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=True, return_on_error=return_on_error)
+
+ #save disk information (image must be based on and size
+ disk_list.append({'image_id': image_vim_id, 'size': device.get('size', default_volume_size)})
+
flavor_dict["extended"]["devices"][index]['imageRef']=image_vim_id
dev_nb += 1
if len(flavor_db)>0:
#create flavor at vim
logger.debug("nfvo.create_or_use_flavor() adding flavor to VIM %s", vim["name"])
try:
- flavor_vim_id = vim.new_flavor(flavor_dict)
- rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id})
- flavor_created="true"
+ flavor_vim_id = None
+ flavor_vim_id=vim.get_flavor_id_from_data(flavor_dict)
+ flavor_create="false"
+ except vimconn.vimconnException as e:
+ pass
+ try:
+ if not flavor_vim_id:
+ flavor_vim_id = vim.new_flavor(flavor_dict)
+ rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id})
+ flavor_created="true"
except vimconn.vimconnException as e:
if return_on_error:
logger.error("Error creating flavor at VIM %s: %s.", vim["name"], str(e))
#if reach here the flavor has been create or exist
if len(flavor_db)==0:
#add new vim_id at datacenters_flavors
- mydb.new_row('datacenters_flavors', {'datacenter_id':vim_id, 'flavor_id':flavor_mano_id, 'vim_id': flavor_vim_id, 'created':flavor_created})
+ extended_devices_yaml = None
+ if len(disk_list) > 0:
+ extended_devices = dict()
+ extended_devices['disks'] = disk_list
+ extended_devices_yaml = yaml.safe_dump(extended_devices,default_flow_style=True,width=256)
+ mydb.new_row('datacenters_flavors',
+ {'datacenter_id':vim_id, 'flavor_id':flavor_mano_id, 'vim_id': flavor_vim_id,
+ 'created':flavor_created,'extended': extended_devices_yaml})
elif flavor_db[0]["vim_id"]!=flavor_vim_id:
#modify existing vim_id at datacenters_flavors
mydb.update_rows('datacenters_flavors', UPDATE={'vim_id':flavor_vim_id}, WHERE={'datacenter_id':vim_id, 'flavor_id':flavor_mano_id})
-
+
return flavor_vim_id if only_create_at_vim else flavor_mano_id
+
def new_vnf(mydb, tenant_id, vnf_descriptor):
global global_config
-
+
# Step 1. Check the VNF descriptor
- check_vnf_descriptor(vnf_descriptor)
+ check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1)
# Step 2. Check tenant exist
+ vims = {}
if tenant_id != "any":
- check_tenant(mydb, tenant_id)
+ check_tenant(mydb, tenant_id)
if "tenant_id" in vnf_descriptor["vnf"]:
if vnf_descriptor["vnf"]["tenant_id"] != tenant_id:
raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id),
else:
vnf_descriptor['vnf']['tenant_id'] = tenant_id
# Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
- vims = get_vim(mydb, tenant_id)
- else:
- vims={}
+ if global_config["auto_push_VNF_to_VIMs"]:
+ vims = get_vim(mydb, tenant_id)
# Step 4. Review the descriptor and add missing fields
#print vnf_descriptor
if "physical" in vnf_descriptor['vnf']:
del vnf_descriptor['vnf']['physical']
#print vnf_descriptor
- # Step 5. Check internal connections
- # TODO: to be moved to step 1????
- internal_connections=vnf_descriptor['vnf'].get('internal_connections',[])
- for ic in internal_connections:
- if len(ic['elements'])>2 and ic['type']=='ptp':
- raise NfvoException("Mismatch 'type':'ptp' with {} elements at 'vnf':'internal-conections'['name':'{}']. Change 'type' to 'data'".format(len(ic), ic['name']),
- HTTP_Bad_Request)
- elif len(ic['elements'])==2 and ic['type']=='data':
- raise NfvoException("Mismatch 'type':'data' with 2 elements at 'vnf':'internal-conections'['name':'{}']. Change 'type' to 'ptp'".format(ic['name']),
- HTTP_Bad_Request)
-
- # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
+
+ # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
logger.debug('BEGIN creation of VNF "%s"' % vnf_name)
logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC'])))
-
+
#For each VNFC, we add it to the VNFCDict and we create a flavor.
VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database
rollback_list = [] # It will contain the new images created in mano. It is used for rollback
VNFCitem={}
VNFCitem["name"] = vnfc['name']
VNFCitem["description"] = vnfc.get("description", 'VM %s of the VNF %s' %(vnfc['name'],vnf_name))
-
+
#print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"])
-
+
myflavorDict = {}
myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists
myflavorDict["description"] = VNFCitem["description"]
myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
myflavorDict["disk"] = vnfc.get("disk", 1)
myflavorDict["extended"] = {}
-
+
devices = vnfc.get("devices")
if devices != None:
myflavorDict["extended"]["devices"] = devices
-
+
# TODO:
# Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table
- # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
-
+ # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
+
# Previous code has been commented
#if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" :
# myflavorDict["flavor"]['extended']['processor_ranking'] = 200
# else:
# return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message
myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done
-
+
if 'numas' in vnfc and len(vnfc['numas'])>0:
myflavorDict['extended']['numas'] = vnfc['numas']
#print myflavorDict
-
+
# Step 6.2 New flavors are created in the VIM
flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list)
#print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id)
VNFCitem["flavor_id"] = flavor_id
VNFCDict[vnfc['name']] = VNFCitem
-
+
logger.debug("Creating new images in the VIM for each VNFC")
# Step 6.3 New images are created in the VIM
#For each VNFC, we must create the appropriate image.
- #This "for" loop might be integrated with the previous one
+ #This "for" loop might be integrated with the previous one
#In case this integration is made, the VNFCDict might become a VNFClist.
for vnfc in vnf_descriptor['vnf']['VNFC']:
#print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description'])
image_dict['universal_name']=vnfc.get('image name')
image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description'])
image_dict['location']=vnfc.get('VNFC image')
+ #image_dict['new_location']=vnfc.get('image location')
image_dict['checksum']=vnfc.get('image checksum')
image_metadata_dict = vnfc.get('image metadata', None)
image_metadata_str = None
- if image_metadata_dict is not None:
+ if image_metadata_dict is not None:
image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
image_dict['metadata']=image_metadata_str
#print "create_or_use_image", mydb, vims, image_dict, rollback_list
#print "Image id for VNFC %s: %s" % (vnfc['name'],image_id)
VNFCDict[vnfc['name']]["image_id"] = image_id
VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image')
+ if vnfc.get("boot-data"):
+ VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256)
+
-
# Step 7. Storing the VNF descriptor in the repository
if "descriptor" not in vnf_descriptor["vnf"]:
vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False)
-
+
# Step 8. Adding the VNF to the NFVO DB
vnf_id = mydb.new_vnf_as_a_whole(tenant_id,vnf_name,vnf_descriptor,VNFCDict)
return vnf_id
error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
#logger.error("start_scenario %s", error_text)
raise NfvoException(error_text, e.http_code)
-
+
+
def new_vnf_v02(mydb, tenant_id, vnf_descriptor):
global global_config
-
+
# Step 1. Check the VNF descriptor
- check_vnf_descriptor(vnf_descriptor)
+ check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=2)
# Step 2. Check tenant exist
+ vims = {}
if tenant_id != "any":
- check_tenant(mydb, tenant_id)
+ check_tenant(mydb, tenant_id)
if "tenant_id" in vnf_descriptor["vnf"]:
if vnf_descriptor["vnf"]["tenant_id"] != tenant_id:
raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id),
else:
vnf_descriptor['vnf']['tenant_id'] = tenant_id
# Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter
- vims = get_vim(mydb, tenant_id)
- else:
- vims={}
+ if global_config["auto_push_VNF_to_VIMs"]:
+ vims = get_vim(mydb, tenant_id)
# Step 4. Review the descriptor and add missing fields
#print vnf_descriptor
if "physical" in vnf_descriptor['vnf']:
del vnf_descriptor['vnf']['physical']
#print vnf_descriptor
- # Step 5. Check internal connections
- # TODO: to be moved to step 1????
- internal_connections=vnf_descriptor['vnf'].get('internal_connections',[])
- for ic in internal_connections:
- if len(ic['elements'])>2 and ic['type']=='e-line':
- raise NfvoException("Mismatch 'type':'e-line' with {} elements at 'vnf':'internal-conections'['name':'{}']. Change 'type' to 'e-lan'".format(len(ic), ic['name']),
- HTTP_Bad_Request)
-
- # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
+
+ # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM
logger.debug('BEGIN creation of VNF "%s"' % vnf_name)
logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC'])))
-
+
#For each VNFC, we add it to the VNFCDict and we create a flavor.
VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database
rollback_list = [] # It will contain the new images created in mano. It is used for rollback
VNFCitem={}
VNFCitem["name"] = vnfc['name']
VNFCitem["description"] = vnfc.get("description", 'VM %s of the VNF %s' %(vnfc['name'],vnf_name))
-
+
#print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"])
-
+
myflavorDict = {}
myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists
myflavorDict["description"] = VNFCitem["description"]
myflavorDict["vcpus"] = vnfc.get("vcpus", 0)
myflavorDict["disk"] = vnfc.get("disk", 1)
myflavorDict["extended"] = {}
-
+
devices = vnfc.get("devices")
if devices != None:
myflavorDict["extended"]["devices"] = devices
-
+
# TODO:
# Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table
- # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
-
+ # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host
+
# Previous code has been commented
#if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" :
# myflavorDict["flavor"]['extended']['processor_ranking'] = 200
# else:
# return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message
myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done
-
+
if 'numas' in vnfc and len(vnfc['numas'])>0:
myflavorDict['extended']['numas'] = vnfc['numas']
#print myflavorDict
-
+
# Step 6.2 New flavors are created in the VIM
flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list)
#print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id)
VNFCitem["flavor_id"] = flavor_id
VNFCDict[vnfc['name']] = VNFCitem
-
+
logger.debug("Creating new images in the VIM for each VNFC")
# Step 6.3 New images are created in the VIM
#For each VNFC, we must create the appropriate image.
- #This "for" loop might be integrated with the previous one
+ #This "for" loop might be integrated with the previous one
#In case this integration is made, the VNFCDict might become a VNFClist.
for vnfc in vnf_descriptor['vnf']['VNFC']:
#print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description'])
image_dict['universal_name']=vnfc.get('image name')
image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description'])
image_dict['location']=vnfc.get('VNFC image')
+ #image_dict['new_location']=vnfc.get('image location')
image_dict['checksum']=vnfc.get('image checksum')
image_metadata_dict = vnfc.get('image metadata', None)
image_metadata_str = None
- if image_metadata_dict is not None:
+ if image_metadata_dict is not None:
image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256)
image_dict['metadata']=image_metadata_str
#print "create_or_use_image", mydb, vims, image_dict, rollback_list
#print "Image id for VNFC %s: %s" % (vnfc['name'],image_id)
VNFCDict[vnfc['name']]["image_id"] = image_id
VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image')
+ if vnfc.get("boot-data"):
+ VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256)
-
# Step 7. Storing the VNF descriptor in the repository
if "descriptor" not in vnf_descriptor["vnf"]:
vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False)
-
+
# Step 8. Adding the VNF to the NFVO DB
vnf_id = mydb.new_vnf_as_a_whole2(tenant_id,vnf_name,vnf_descriptor,VNFCDict)
return vnf_id
#logger.error("start_scenario %s", error_text)
raise NfvoException(error_text, e.http_code)
+
def get_vnf_id(mydb, tenant_id, vnf_id):
#check valid tenant_id
- check_tenant(mydb, tenant_id)
+ check_tenant(mydb, tenant_id)
#obtain data
where_or = {}
if tenant_id != "any":
where_or["tenant_id"] = tenant_id
where_or["public"] = True
- vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
-
+ vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
+
vnf_id=vnf["uuid"]
filter_keys = ('uuid','name','description','public', "tenant_id", "created_at")
filtered_content = dict( (k,v) for k,v in vnf.iteritems() if k in filter_keys )
data={'vnf' : filtered_content}
#GET VM
content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id',
- SELECT=('vms.uuid as uuid','vms.name as name', 'vms.description as description'),
+ SELECT=('vms.uuid as uuid','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), HTTP_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"]
data['vnf']['VNFC'] = content
#TODO: GET all the information from a VNFC and include it in the output.
-
+
#GET NET
- content = mydb.get_rows(FROM='vnfs join nets on vnfs.uuid=nets.vnf_id',
+ content = mydb.get_rows(FROM='vnfs join nets on vnfs.uuid=nets.vnf_id',
SELECT=('nets.uuid as uuid','nets.name as name','nets.description as description', 'nets.type as type', 'nets.multipoint as multipoint'),
WHERE={'vnfs.uuid': vnf_id} )
data['vnf']['nets'] = content
net["ip_profile"] = ipprofiles[0]
elif len(ipprofiles)>1:
raise NfvoException("More than one ip-profile found with this criteria: net_id='{}'".format(net['uuid']), HTTP_Bad_Request)
-
-
+
+
#TODO: For each net, GET its elements and relevant info per element (VNFC, iface, ip_address) and include them in the output.
-
+
#GET External Interfaces
content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces on vms.uuid=interfaces.vm_id',\
SELECT=('interfaces.uuid as uuid','interfaces.external_name as external_name', 'vms.name as vm_name', 'interfaces.vm_id as vm_id', \
'interfaces.internal_name as internal_name', 'interfaces.type as type', 'interfaces.vpci as vpci','interfaces.bw as bw'),\
- WHERE={'vnfs.uuid': vnf_id},
+ WHERE={'vnfs.uuid': vnf_id},
WHERE_NOT={'interfaces.external_name': None} )
#print content
data['vnf']['external-connections'] = content
-
+
return data
if tenant_id != "any":
where_or["tenant_id"] = tenant_id
where_or["public"] = True
- vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
+ vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND")
vnf_id = vnf["uuid"]
-
+
# "Getting the list of flavors and tenants of the VNF"
- flavorList = get_flavorlist(mydb, vnf_id)
+ flavorList = get_flavorlist(mydb, vnf_id)
if len(flavorList)==0:
logger.warn("delete_vnf error. No flavors found for the VNF id '%s'", vnf_id)
-
+
imageList = get_imagelist(mydb, vnf_id)
if len(imageList)==0:
logger.warn( "delete_vnf error. No images found for the VNF id '%s'", vnf_id)
-
+
deleted = mydb.delete_row_by_id('vnfs', vnf_id)
if deleted == 0:
raise NfvoException("vnf '{}' not found".format(vnf_id), HTTP_Not_Found)
-
+
undeletedItems = []
for flavor in flavorList:
#check if flavor is used by other vnf
logger.error("delete_vnf_error. Not possible to get flavor details and delete '%s'. %s", flavor, str(e))
undeletedItems.append("flavor %s" % flavor)
-
+
for image in imageList:
try:
#check if image is used by other vnf
undeletedItems.append("image %s" % image)
return vnf_id + " " + vnf["name"]
- #if undeletedItems:
+ #if undeletedItems:
# return "delete_vnf. Undeleted: %s" %(undeletedItems)
+
def get_hosts_info(mydb, nfvo_tenant_id, datacenter_name=None):
result, vims = get_vim(mydb, nfvo_tenant_id, None, datacenter_name)
if result < 0:
topology = {'name':myvim['name'] , 'servers': servers}
return result, topology
+
def get_hosts(mydb, nfvo_tenant_id):
vims = get_vim(mydb, nfvo_tenant_id)
if len(vims) == 0:
server={'name':host['name'], 'vms':[]}
for vm in host['instances']:
#get internal name and model
- try:
+ try:
c = mydb.get_rows(SELECT=('name',), FROM='instance_vms as iv join vms on iv.vm_id=vms.uuid',\
WHERE={'vim_vm_id':vm['id']} )
if len(c) == 0:
logger.warn("nfvo.get_hosts virtual machine at VIM '{}' not found at tidnfvo".format(vm['id']))
continue
server['vms'].append( {'name':vm['name'] , 'model':c[0]['name']} )
-
+
except db_base_Exception as e:
logger.warn("nfvo.get_hosts virtual machine at VIM '{}' error {}".format(vm['id'], str(e)))
datacenter['Datacenters'][0]['servers'].append(server)
#return -400, "en construccion"
-
+
#print 'datacenters '+ json.dumps(datacenter, indent=4)
return datacenter
except vimconn.vimconnException as e:
raise NfvoException("Not possible to get_host_list from VIM: {}".format(str(e)), e.http_code)
+
def new_scenario(mydb, tenant_id, topo):
# result, vims = get_vim(mydb, tenant_id)
# return result, vims
#1: parse input
if tenant_id != "any":
- check_tenant(mydb, tenant_id)
+ check_tenant(mydb, tenant_id)
if "tenant_id" in topo:
if topo["tenant_id"] != tenant_id:
raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(topo["tenant_id"], tenant_id),
else:
tenant_id=None
-#1.1: get VNFs and external_networks (other_nets).
+#1.1: get VNFs and external_networks (other_nets).
vnfs={}
other_nets={} #external_networks, bridge_networks and data_networkds
nodes = topo['topology']['nodes']
if nodes[k]['type'] == 'VNF':
vnfs[k] = nodes[k]
vnfs[k]['ifaces'] = {}
- elif nodes[k]['type'] == 'other_network' or nodes[k]['type'] == 'external_network':
+ elif nodes[k]['type'] == 'other_network' or nodes[k]['type'] == 'external_network':
other_nets[k] = nodes[k]
other_nets[k]['external']=True
- elif nodes[k]['type'] == 'network':
+ elif nodes[k]['type'] == 'network':
other_nets[k] = nodes[k]
other_nets[k]['external']=False
-
+
#1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces
for name,vnf in vnfs.items():
where['name'] = vnf['VNF model']
if len(where) == 0:
raise NfvoException("Descriptor need a 'vnf_id' or 'VNF model' field at " + error_pos, HTTP_Bad_Request)
-
+
vnf_db = mydb.get_rows(SELECT=('uuid','name','description'),
FROM='vnfs',
- WHERE=where,
+ WHERE=where,
WHERE_OR=where_or,
WHERE_AND_OR="AND")
if len(vnf_db)==0:
vnf['uuid']=vnf_db[0]['uuid']
vnf['description']=vnf_db[0]['description']
#get external interfaces
- ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'),
- FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
+ ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'),
+ FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} )
for ext_iface in ext_ifaces:
vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']}
other_nets[k]["graph"] = conections[k]["graph"]
ifaces_list.append( (k, None) )
-
+
if con_type == "external_network":
other_nets[k]['external'] = True
if conections[k].get("model"):
other_nets[k]["model"] = conections[k]["model"]
else:
other_nets[k]["model"] = k
- if con_type == "dataplane_net" or con_type == "bridge_net":
+ if con_type == "dataplane_net" or con_type == "bridge_net":
other_nets[k]["model"] = con_type
-
+
conections_list_name.append(k)
conections_list.append(set(ifaces_list)) #from list to set to operate as a set (this conversion removes elements that are repeated in a list)
#print set(ifaces_list)
index += 1
#for k in conections_list:
# print k
-
+
#1.6 Delete non external nets
else: #external
#IF we do not want to check that external network exist at datacenter
pass
-#ELSE
+#ELSE
# error_text = ""
# WHERE_={}
# if 'net_id' in net:
# print "nfvo.new_scenario Error" +error_text+ " is not present at database"
# return -HTTP_Bad_Request, "unknown " +error_text+ " at " + error_pos
# elif r>1:
-# print "nfvo.new_scenario Error more than one external_network for " +error_text+ " is present at database"
-# return -HTTP_Bad_Request, "more than one external_network for " +error_text+ "at "+ error_pos + " Concrete with 'net_id'"
+# print "nfvo.new_scenario Error more than one external_network for " +error_text+ " is present at database"
+# return -HTTP_Bad_Request, "more than one external_network for " +error_text+ "at "+ error_pos + " Concrete with 'net_id'"
# other_nets[k].update(net_db[0])
-#ENDIF
+#ENDIF
net_list={}
net_nb=0 #Number of nets
for con in conections_list:
for net_key in other_nets.keys():
if con[index][0]==net_key:
if other_net_index>=0:
- error_text="There is some interface connected both to net '%s' and net '%s'" % (con[other_net_index][0], net_key)
+ error_text="There is some interface connected both to net '%s' and net '%s'" % (con[other_net_index][0], net_key)
#print "nfvo.new_scenario " + error_text
raise NfvoException(error_text, HTTP_Bad_Request)
else:
other_nets[net_target]["type"] = "data"
else:
other_nets[net_target]["type"] = "bridge"
-#ELSE
+#ELSE
# if other_nets[net_target]['external'] :
# type_='data' if len(con)>1 else 'ptp' #an external net is connected to a external port, so it is ptp if only one connection is done to this net
# if type_=='data' and other_nets[net_target]['type']=="ptp":
# error_text = "Error connecting %d nodes on a not multipoint net %s" % (len(con), net_target)
# print "nfvo.new_scenario " + error_text
# return -HTTP_Bad_Request, error_text
-#ENDIF
+#ENDIF
for iface in con:
vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target
else:
net_type_bridge=False
net_type_data=False
net_target = "__-__net"+str(net_nb)
- net_list[net_target] = {'name': conections_list_name[net_nb], #"net-"+str(net_nb),
+ net_list[net_target] = {'name': conections_list_name[net_nb], #"net-"+str(net_nb),
'description':"net-%s in scenario %s" %(net_nb,topo['name']),
- 'external':False}
+ 'external':False}
for iface in con:
vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target
iface_type = vnfs[ iface[0] ]['ifaces'][ iface[1] ]['type']
raise NfvoException(error_text, HTTP_Bad_Request)
#1.8: Connect to management net all not already connected interfaces of type 'mgmt'
- #1.8.1 obtain management net
+ #1.8.1 obtain management net
mgmt_net = mydb.get_rows(SELECT=('uuid','name','description','type','shared'),
FROM='datacenter_nets', WHERE={'name':'mgmt'} )
- #1.8.2 check all interfaces from all vnfs
+ #1.8.2 check all interfaces from all vnfs
if len(mgmt_net)>0:
add_mgmt_net = False
for vnf in vnfs.values():
'description':topo.get('description',topo['name']),
'public': topo.get('public', False)
})
-
+
return c
-def new_scenario_v02(mydb, tenant_id, scenario_dict):
+
+def new_scenario_v02(mydb, tenant_id, scenario_dict, version):
+ """ This creates a new scenario for version 0.2 and 0.3"""
scenario = scenario_dict["scenario"]
if tenant_id != "any":
- check_tenant(mydb, tenant_id)
+ check_tenant(mydb, tenant_id)
if "tenant_id" in scenario:
if scenario["tenant_id"] != tenant_id:
- print "nfvo.new_scenario_v02() tenant '%s' not found" % tenant_id
+ # print "nfvo.new_scenario_v02() tenant '%s' not found" % tenant_id
raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(
scenario["tenant_id"], tenant_id), HTTP_Unauthorized)
else:
tenant_id=None
-#1: Check that VNF are present at database table vnfs and update content into scenario dict
+ # 1: Check that VNF are present at database table vnfs and update content into scenario dict
for name,vnf in scenario["vnfs"].iteritems():
where={}
where_or={"tenant_id": tenant_id, 'public': "true"}
error_text = ""
error_pos = "'scenario':'vnfs':'" + name + "'"
if 'vnf_id' in vnf:
- error_text += " 'vnf_id' " + vnf['vnf_id']
+ error_text += " 'vnf_id' " + vnf['vnf_id']
where['uuid'] = vnf['vnf_id']
if 'vnf_name' in vnf:
- error_text += " 'vnf_name' " + vnf['vnf_name']
+ error_text += " 'vnf_name' " + vnf['vnf_name']
where['name'] = vnf['vnf_name']
if len(where) == 0:
raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, HTTP_Bad_Request)
- vnf_db = mydb.get_rows(SELECT=('uuid','name','description'),
+ vnf_db = mydb.get_rows(SELECT=('uuid', 'name', 'description'),
FROM='vnfs',
WHERE=where,
WHERE_OR=where_or,
WHERE_AND_OR="AND")
- if len(vnf_db)==0:
+ if len(vnf_db) == 0:
raise NfvoException("Unknown" + error_text + " at " + error_pos, HTTP_Not_Found)
- elif len(vnf_db)>1:
+ elif len(vnf_db) > 1:
raise NfvoException("More than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", HTTP_Conflict)
- vnf['uuid']=vnf_db[0]['uuid']
- vnf['description']=vnf_db[0]['description']
+ vnf['uuid'] = vnf_db[0]['uuid']
+ vnf['description'] = vnf_db[0]['description']
vnf['ifaces'] = {}
- #get external interfaces
- ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'),
- FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
- WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} )
+ # get external interfaces
+ ext_ifaces = mydb.get_rows(SELECT=('external_name as name', 'i.uuid as iface_uuid', 'i.type as type'),
+ FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
+ WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name': None} )
for ext_iface in ext_ifaces:
- vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']}
+ vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type': ext_iface['type']}
+ # TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly
-#2: Insert net_key at every vnf interface
- for net_name,net in scenario["networks"].iteritems():
- net_type_bridge=False
- net_type_data=False
+ # 2: Insert net_key and ip_address at every vnf interface
+ for net_name, net in scenario["networks"].items():
+ net_type_bridge = False
+ net_type_data = False
for iface_dict in net["interfaces"]:
- for vnf,iface in iface_dict.iteritems():
+ if version == "0.2":
+ temp_dict = iface_dict
+ ip_address = None
+ elif version == "0.3":
+ temp_dict = {iface_dict["vnf"] : iface_dict["vnf_interface"]}
+ ip_address = iface_dict.get('ip_address', None)
+ for vnf, iface in temp_dict.items():
if vnf not in scenario["vnfs"]:
- error_text = "Error at 'networks':'%s':'interfaces' VNF '%s' not match any VNF at 'vnfs'" % (net_name, vnf)
- #print "nfvo.new_scenario_v02 " + error_text
+ error_text = "Error at 'networks':'{}':'interfaces' VNF '{}' not match any VNF at 'vnfs'".format(
+ net_name, vnf)
+ # logger.debug("nfvo.new_scenario_v02 " + error_text)
raise NfvoException(error_text, HTTP_Not_Found)
if iface not in scenario["vnfs"][vnf]['ifaces']:
- error_text = "Error at 'networks':'%s':'interfaces':'%s' interface not match any VNF interface" % (net_name, iface)
- #print "nfvo.new_scenario_v02 " + error_text
+ error_text = "Error at 'networks':'{}':'interfaces':'{}' interface not match any VNF interface"\
+ .format(net_name, iface)
+ # logger.debug("nfvo.new_scenario_v02 " + error_text)
raise NfvoException(error_text, HTTP_Bad_Request)
if "net_key" in scenario["vnfs"][vnf]['ifaces'][iface]:
- error_text = "Error at 'networks':'%s':'interfaces':'%s' interface already connected at network '%s'" \
- % (net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key'])
- #print "nfvo.new_scenario_v02 " + error_text
+ error_text = "Error at 'networks':'{}':'interfaces':'{}' interface already connected at network"\
+ "'{}'".format(net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key'])
+ # logger.debug("nfvo.new_scenario_v02 " + error_text)
raise NfvoException(error_text, HTTP_Bad_Request)
scenario["vnfs"][vnf]['ifaces'][ iface ]['net_key'] = net_name
+ scenario["vnfs"][vnf]['ifaces'][iface]['ip_address'] = ip_address
iface_type = scenario["vnfs"][vnf]['ifaces'][iface]['type']
- if iface_type=='mgmt' or iface_type=='bridge':
+ if iface_type == 'mgmt' or iface_type == 'bridge':
net_type_bridge = True
else:
net_type_data = True
+
if net_type_bridge and net_type_data:
- error_text = "Error connection interfaces of bridge type and data type at 'networks':'%s':'interfaces'" % (net_name)
- #print "nfvo.new_scenario " + error_text
+ error_text = "Error connection interfaces of 'bridge' type and 'data' type at 'networks':'{}':'interfaces'"\
+ .format(net_name)
+ # logger.debug("nfvo.new_scenario " + error_text)
raise NfvoException(error_text, HTTP_Bad_Request)
elif net_type_bridge:
- type_='bridge'
+ type_ = 'bridge'
else:
- type_='data' if len(net["interfaces"])>2 else 'ptp'
+ type_ = 'data' if len(net["interfaces"]) > 2 else 'ptp'
+
+ if net.get("implementation"): # for v0.3
+ if type_ == "bridge" and net["implementation"] == "underlay":
+ error_text = "Error connecting interfaces of data type to a network declared as 'underlay' at "\
+ "'network':'{}'".format(net_name)
+ # logger.debug(error_text)
+ raise NfvoException(error_text, HTTP_Bad_Request)
+ elif type_ != "bridge" and net["implementation"] == "overlay":
+ error_text = "Error connecting interfaces of data type to a network declared as 'overlay' at "\
+ "'network':'{}'".format(net_name)
+ # logger.debug(error_text)
+ raise NfvoException(error_text, HTTP_Bad_Request)
+ net.pop("implementation")
+ if "type" in net and version == "0.3": # for v0.3
+ if type_ == "data" and net["type"] == "e-line":
+ error_text = "Error connecting more than 2 interfaces of data type to a network declared as type "\
+ "'e-line' at 'network':'{}'".format(net_name)
+ # logger.debug(error_text)
+ raise NfvoException(error_text, HTTP_Bad_Request)
+ elif type_ == "ptp" and net["type"] == "e-lan":
+ type_ = "data"
+
net['type'] = type_
net['name'] = net_name
net['external'] = net.get('external', False)
-#3: insert at database
+ # 3: insert at database
scenario["nets"] = scenario["networks"]
scenario['tenant_id'] = tenant_id
- scenario_id = mydb.new_scenario( scenario)
+ scenario_id = mydb.new_scenario(scenario)
return scenario_id
+
def edit_scenario(mydb, tenant_id, scenario_id, data):
data["uuid"] = scenario_id
data["tenant_id"] = tenant_id
c = mydb.edit_scenario( data )
return c
+
def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instance_scenario_description, datacenter=None,vim_tenant=None, startvms=True):
#print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter, vim_tenant=vim_tenant)
#print '================scenarioDict======================='
#print json.dumps(scenarioDict, indent=4)
#print 'BEGIN launching instance scenario "%s" based on "%s"' % (instance_scenario_name,scenarioDict['name'])
-
+
logger.debug("start_scenario Scenario %s: consisting of %d VNF(s)", scenarioDict['name'],len(scenarioDict['vnfs']))
#print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
-
+
auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id
auxNetDict['scenario'] = {}
-
+
logger.debug("start_scenario 1. Creating new nets (sce_nets) in the VIM")
for sce_net in scenarioDict['nets']:
#print "Net name: %s. Description: %s" % (sce_net["name"], sce_net["description"])
-
+
myNetName = "%s.%s" % (instance_scenario_name, sce_net['name'])
myNetName = myNetName[0:255] #limit length
myNetType = sce_net['type']
raise NfvoException(error_text, HTTP_Bad_Request)
logger.debug("Using existent VIM network for scenario %s. Network id %s", scenarioDict['name'],sce_net['vim_id'])
auxNetDict['scenario'][sce_net['uuid']] = sce_net['vim_id']
-
+
logger.debug("start_scenario 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']:
#print "Net name: %s. Description: %s" % (net["name"], net["description"])
-
+
myNetName = "%s.%s" % (instance_scenario_name,net['name'])
myNetName = myNetName[0:255] #limit length
myNetType = net['type']
auxNetDict[sce_vnf['uuid']][net['uuid']] = network_id
rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id})
net["created"] = True
-
+
#print "auxNetDict:"
#print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False)
-
+
logger.debug("start_scenario 3. Creating new vm instances in the VIM")
#myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
i = 0
i += 1
myVMDict = {}
#myVMDict['name'] = "%s-%s-%s" % (scenarioDict['name'],sce_vnf['name'], vm['name'])
- myVMDict['name'] = "%s.%s.%d" % (instance_scenario_name,sce_vnf['name'],i)
+ myVMDict['name'] = "{}.{}.{}".format(instance_scenario_name,sce_vnf['name'],chr(96+i))
#myVMDict['description'] = vm['description']
myVMDict['description'] = myVMDict['name'][0:99]
if not startvms:
myVMDict['start'] = "no"
myVMDict['name'] = myVMDict['name'][0:255] #limit name length
#print "VM name: %s. Description: %s" % (myVMDict['name'], myVMDict['name'])
-
+
#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, vims, image_dict, [], True)
+ image_id = create_or_use_image(mydb, vims, 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, vims, flavor_dict, [], True)
+ flavor_id = create_or_use_flavor(mydb, vims, flavor_dict, [], True)
vm['vim_flavor_id'] = flavor_id
-
-
+
+
myVMDict['imageRef'] = vm['vim_image_id']
myVMDict['flavorRef'] = vm['vim_flavor_id']
myVMDict['networks'] = []
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"]:
if net["name"]==iface["internal_name"]:
iface["vim_id"]=net["vim_id"]
break
-
+
logger.debug("start scenario Deployment done")
#print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)
#r,c = mydb.new_instance_scenario_as_a_whole(nfvo_tenant,scenarioDict['name'],scenarioDict)
instance_id = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_scenario_name, instance_scenario_description, scenarioDict)
return mydb.get_instance_scenario(instance_id)
-
+
except (db_base_Exception, vimconn.vimconnException) as e:
_, message = rollback(mydb, vims, rollbackList)
if isinstance(e, db_base_Exception):
#logger.error("start_scenario %s", error_text)
raise NfvoException(error_text, e.http_code)
-def unify_cloud_config(cloud_config):
+
+def unify_cloud_config(cloud_config_preserve, cloud_config):
+ ''' join the cloud config information into cloud_config_preserve.
+ In case of conflict cloud_config_preserve preserves
+ None is admited
+ '''
+ if not cloud_config_preserve and not cloud_config:
+ return None
+
+ new_cloud_config = {"key-pairs":[], "users":[]}
+ # key-pairs
+ if cloud_config_preserve:
+ for key in cloud_config_preserve.get("key-pairs", () ):
+ if key not in new_cloud_config["key-pairs"]:
+ new_cloud_config["key-pairs"].append(key)
+ if cloud_config:
+ for key in cloud_config.get("key-pairs", () ):
+ if key not in new_cloud_config["key-pairs"]:
+ new_cloud_config["key-pairs"].append(key)
+ if not new_cloud_config["key-pairs"]:
+ del new_cloud_config["key-pairs"]
+
+ # users
+ if cloud_config:
+ new_cloud_config["users"] += cloud_config.get("users", () )
+ if cloud_config_preserve:
+ new_cloud_config["users"] += cloud_config_preserve.get("users", () )
index_to_delete = []
- users = cloud_config.get("users", [])
+ users = new_cloud_config.get("users", [])
for index0 in range(0,len(users)):
if index0 in index_to_delete:
continue
if users[index0]["name"] == users[index1]["name"]:
index_to_delete.append(index1)
for key in users[index1].get("key-pairs",()):
- if "key-pairs" not in users[index0]:
+ if "key-pairs" not in users[index0]:
users[index0]["key-pairs"] = [key]
elif key not in users[index0]["key-pairs"]:
users[index0]["key-pairs"].append(key)
index_to_delete.sort(reverse=True)
for index in index_to_delete:
del users[index]
+ if not new_cloud_config["users"]:
+ del new_cloud_config["users"]
+
+ #boot-data-drive
+ if cloud_config and cloud_config.get("boot-data-drive") != None:
+ new_cloud_config["boot-data-drive"] = cloud_config["boot-data-drive"]
+ if cloud_config_preserve and cloud_config_preserve.get("boot-data-drive") != None:
+ new_cloud_config["boot-data-drive"] = cloud_config_preserve["boot-data-drive"]
+
+ # user-data
+ if cloud_config and cloud_config.get("user-data") != None:
+ new_cloud_config["user-data"] = cloud_config["user-data"]
+ if cloud_config_preserve and cloud_config_preserve.get("user-data") != None:
+ new_cloud_config["user-data"] = cloud_config_preserve["user-data"]
+
+ # config files
+ new_cloud_config["config-files"] = []
+ if cloud_config and cloud_config.get("config-files") != None:
+ new_cloud_config["config-files"] += cloud_config["config-files"]
+ if cloud_config_preserve:
+ for file in cloud_config_preserve.get("config-files", ()):
+ for index in range(0, len(new_cloud_config["config-files"])):
+ if new_cloud_config["config-files"][index]["dest"] == file["dest"]:
+ new_cloud_config["config-files"][index] = file
+ break
+ else:
+ new_cloud_config["config-files"].append(file)
+ if not new_cloud_config["config-files"]:
+ del new_cloud_config["config-files"]
+ return new_cloud_config
+
+
+def get_vim_thread(tenant_id, datacenter_id_name=None, datacenter_tenant_id=None):
+ datacenter_id = None
+ datacenter_name = None
+ thread = None
+ if datacenter_id_name:
+ if utils.check_valid_uuid(datacenter_id_name):
+ datacenter_id = datacenter_id_name
+ else:
+ datacenter_name = datacenter_id_name
+ if datacenter_id:
+ thread = vim_threads["running"].get(datacenter_id + "." + tenant_id)
+ else:
+ for k, v in vim_threads["running"].items():
+ datacenter_tenant = k.split(".")
+ if datacenter_tenant[0] == datacenter_id and datacenter_tenant[1] == tenant_id:
+ if thread:
+ raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
+ thread = v
+ elif not datacenter_id and datacenter_tenant[1] == tenant_id:
+ if thread.datacenter_name == datacenter_name:
+ if thread:
+ raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
+ thread = v
+ if not thread:
+ raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found)
+ return thread
+
def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter):
datacenter_id = None
datacenter_name = None
if datacenter_id_name:
- if utils.check_valid_uuid(datacenter_id_name):
+ if utils.check_valid_uuid(datacenter_id_name):
datacenter_id = datacenter_id_name
else:
datacenter_name = datacenter_id_name
raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
return vims.keys()[0], vims.values()[0]
-def new_scenario_v03(mydb, tenant_id, scenario_dict):
- scenario = scenario_dict["scenario"]
- if tenant_id != "any":
- check_tenant(mydb, tenant_id)
- if "tenant_id" in scenario:
- if scenario["tenant_id"] != tenant_id:
- logger("Tenant '%s' not found", tenant_id)
- raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(
- scenario["tenant_id"], tenant_id), HTTP_Unauthorized)
- else:
- tenant_id=None
-
-#1: Check that VNF are present at database table vnfs and update content into scenario dict
- for name,vnf in scenario["vnfs"].iteritems():
- where={}
- where_or={"tenant_id": tenant_id, 'public': "true"}
- error_text = ""
- error_pos = "'scenario':'vnfs':'" + name + "'"
- if 'vnf_id' in vnf:
- error_text += " 'vnf_id' " + vnf['vnf_id']
- where['uuid'] = vnf['vnf_id']
- if 'vnf_name' in vnf:
- error_text += " 'vnf_name' " + vnf['vnf_name']
- where['name'] = vnf['vnf_name']
- if len(where) == 0:
- raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, HTTP_Bad_Request)
- vnf_db = mydb.get_rows(SELECT=('uuid','name','description'),
- FROM='vnfs',
- WHERE=where,
- WHERE_OR=where_or,
- WHERE_AND_OR="AND")
- if len(vnf_db)==0:
- raise NfvoException("Unknown" + error_text + " at " + error_pos, HTTP_Not_Found)
- elif len(vnf_db)>1:
- raise NfvoException("More than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", HTTP_Conflict)
- vnf['uuid']=vnf_db[0]['uuid']
- vnf['description']=vnf_db[0]['description']
- vnf['ifaces'] = {}
- # get external interfaces
- ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'),
- FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id',
- WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} )
- for ext_iface in ext_ifaces:
- vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']}
-
- # TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly
-
-#2: Insert net_key and ip_address at every vnf interface
- for net_name,net in scenario["networks"].iteritems():
- net_type_bridge=False
- net_type_data=False
- for iface_dict in net["interfaces"]:
- logger.debug("Iface_dict %s", iface_dict)
- vnf = iface_dict["vnf"]
- iface = iface_dict["vnf_interface"]
- if vnf not in scenario["vnfs"]:
- error_text = "Error at 'networks':'%s':'interfaces' VNF '%s' not match any VNF at 'vnfs'" % (net_name, vnf)
- #logger.debug(error_text)
- raise NfvoException(error_text, HTTP_Not_Found)
- if iface not in scenario["vnfs"][vnf]['ifaces']:
- error_text = "Error at 'networks':'%s':'interfaces':'%s' interface not match any VNF interface" % (net_name, iface)
- #logger.debug(error_text)
- raise NfvoException(error_text, HTTP_Bad_Request)
- if "net_key" in scenario["vnfs"][vnf]['ifaces'][iface]:
- error_text = "Error at 'networks':'%s':'interfaces':'%s' interface already connected at network '%s'" \
- % (net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key'])
- #logger.debug(error_text)
- raise NfvoException(error_text, HTTP_Bad_Request)
- scenario["vnfs"][vnf]['ifaces'][ iface ]['net_key'] = net_name
- scenario["vnfs"][vnf]['ifaces'][ iface ]['ip_address'] = iface_dict.get('ip_address',None)
- iface_type = scenario["vnfs"][vnf]['ifaces'][iface]['type']
- if iface_type=='mgmt' or iface_type=='bridge':
- net_type_bridge = True
- else:
- net_type_data = True
- if net_type_bridge and net_type_data:
- error_text = "Error connection interfaces of bridge type and data type at 'networks':'%s':'interfaces'" % (net_name)
- #logger.debug(error_text)
- raise NfvoException(error_text, HTTP_Bad_Request)
- elif net_type_bridge:
- type_='bridge'
- else:
- type_='data' if len(net["interfaces"])>2 else 'ptp'
-
- if ("implementation" in net):
- if (type_ == "bridge" and net["implementation"] == "underlay"):
- error_text = "Error connecting interfaces of data type to a network declared as 'underlay' at 'network':'%s'" % (net_name)
- #logger.debug(error_text)
- raise NfvoException(error_text, HTTP_Bad_Request)
- elif (type_ <> "bridge" and net["implementation"] == "overlay"):
- error_text = "Error connecting interfaces of data type to a network declared as 'overlay' at 'network':'%s'" % (net_name)
- #logger.debug(error_text)
- raise NfvoException(error_text, HTTP_Bad_Request)
- net.pop("implementation")
- if ("type" in net):
- if (type_ == "data" and net["type"] == "e-line"):
- error_text = "Error connecting more than 2 interfaces of data type to a network declared as type 'e-line' at 'network':'%s'" % (net_name)
- #logger.debug(error_text)
- raise NfvoException(error_text, HTTP_Bad_Request)
- elif (type_ == "ptp" and net["type"] == "e-lan"):
- type_ = "data"
-
- net['type'] = type_
- net['name'] = net_name
- net['external'] = net.get('external', False)
-
-#3: insert at database
- scenario["nets"] = scenario["networks"]
- scenario['tenant_id'] = tenant_id
- scenario_id = mydb.new_scenario2(scenario)
- return scenario_id
def update(d, u):
'''Takes dict d and updates it with the values in dict u.'''
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...")
+ # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
+ # logger.debug("Creating instance...")
scenario = instance_dict["scenario"]
-
+
#find main datacenter
myvims = {}
+ myvim_threads = {}
datacenter2tenant = {}
datacenter = instance_dict.get("datacenter")
default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
myvims[default_datacenter_id] = vim
+ myvim_threads[default_datacenter_id] = get_vim_thread(tenant_id, default_datacenter_id)
datacenter2tenant[default_datacenter_id] = vim['config']['datacenter_tenant_id']
#myvim_tenant = myvim['tenant_id']
# default_datacenter_name = vim['name']
rollbackList=[]
-
+
#print "Checking that the scenario exists and getting the scenario dictionary"
scenarioDict = mydb.get_scenario(scenario, tenant_id, default_datacenter_id)
-
+
#logger.debug(">>>>>>> Dictionaries before merging")
#logger.debug(">>>>>>> InstanceDict:\n{}".format(yaml.safe_dump(instance_dict,default_flow_style=False, width=256)))
#logger.debug(">>>>>>> ScenarioDict:\n{}".format(yaml.safe_dump(scenarioDict,default_flow_style=False, width=256)))
-
+
scenarioDict['datacenter_id'] = default_datacenter_id
auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id
auxNetDict['scenario'] = {}
-
- logger.debug("Creating instance from scenario-dict:\n%s", yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) #TODO remove
+
+ logger.debug("Creating instance from scenario-dict:\n%s", yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) #TODO remove
instance_name = instance_dict["name"]
instance_description = instance_dict.get("description")
+ instance_tasks={}
try:
- #0 check correct parameters
+ # 0 check correct parameters
for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems():
- found=False
+ found = False
for scenario_net in scenarioDict['nets']:
if net_name == scenario_net["name"]:
found = True
#Add this datacenter to myvims
d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"])
myvims[d] = v
+ myvim_threads[d] = get_vim_thread(tenant_id, site["datacenter"])
datacenter2tenant[d] = v['config']['datacenter_tenant_id']
- site["datacenter"] = d #change name to id
+ site["datacenter"] = d #change name to id
else:
if site_without_datacenter_field:
raise NfvoException("Found more than one entries without datacenter field at instance:networks:{}:sites".format(net_name), HTTP_Bad_Request)
site_without_datacenter_field = True
- site["datacenter"] = default_datacenter_id #change name to id
-
+ 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 not found:
raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_instance_desc), HTTP_Bad_Request)
if "datacenter" in vnf_instance_desc:
- #Add this datacenter to myvims
+ # Add this datacenter to myvims
if vnf_instance_desc["datacenter"] not in myvims:
d, v = get_datacenter_by_name_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"])
myvims[d] = v
+ myvim_threads[d] = get_vim_thread(tenant_id, vnf_instance_desc["datacenter"])
datacenter2tenant[d] = v['config']['datacenter_tenant_id']
scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"]
+
#0.1 parse cloud-config parameters
- cloud_config = scenarioDict.get("cloud-config", {})
- if instance_dict.get("cloud-config"):
- cloud_config.update( instance_dict["cloud-config"])
- if not cloud_config:
- cloud_config = None
- else:
- scenarioDict["cloud-config"] = cloud_config
- unify_cloud_config(cloud_config)
+ cloud_config = unify_cloud_config(instance_dict.get("cloud-config"), scenarioDict.get("cloud-config"))
#0.2 merge instance information into scenario
#Ideally, the operation should be as simple as: update(scenarioDict,instance_dict)
#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"
+
+ # 1. Creating new nets (sce_nets) in the VIM"
for sce_net in scenarioDict['nets']:
sce_net["vim_id_sites"]={}
descriptor_net = instance_dict.get("networks",{}).get(sce_net["name"],{})
if site.get("datacenter"):
vim = myvims[ site["datacenter"] ]
datacenter_id = site["datacenter"]
+ myvim_thread = myvim_threads[ site["datacenter"] ]
else:
vim = myvims[ default_datacenter_id ]
datacenter_id = default_datacenter_id
+ myvim_thread = myvim_threads[default_datacenter_id]
net_type = sce_net['type']
lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True
if sce_net["external"]:
if not net_name:
- net_name = sce_net["name"]
+ net_name = sce_net["name"]
if "netmap-use" in site or "netmap-create" in site:
create_network = False
lookfor_network = False
if utils.check_valid_uuid(site["netmap-use"]):
filter_text = "scenario id '%s'" % site["netmap-use"]
lookfor_filter["id"] = site["netmap-use"]
- else:
+ else:
filter_text = "scenario name '%s'" % site["netmap-use"]
lookfor_filter["name"] = site["netmap-use"]
if "netmap-create" in site:
net_vim_name = net_name
if site["netmap-create"]:
net_vim_name = site["netmap-create"]
-
+
elif sce_net['vim_id'] != None:
#there is a netmap at datacenter_nets database #TODO REVISE!!!!
create_network = False
net_vim_name = net_name
create_network = True
lookfor_network = False
-
+
if lookfor_network:
vim_nets = vim.get_network_list(filter_dict=lookfor_filter)
if len(vim_nets) > 1:
create_network = False
if create_network:
#if network is not external
- network_id = vim.new_network(net_vim_name, net_type, sce_net.get('ip_profile',None))
- sce_net["vim_id_sites"][datacenter_id] = network_id
- auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = network_id
- rollbackList.append({'what':'network', 'where':'vim', 'vim_id':datacenter_id, 'uuid':network_id})
+ task = new_task("new-net", (net_vim_name, net_type, sce_net.get('ip_profile',None)))
+ task_id = myvim_thread.insert_task(task)
+ instance_tasks[task_id] = task
+ #network_id = vim.new_network(net_vim_name, net_type, sce_net.get('ip_profile',None))
+ sce_net["vim_id_sites"][datacenter_id] = task_id
+ auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = task_id
+ rollbackList.append({'what':'network', 'where':'vim', 'vim_id':datacenter_id, 'uuid':task_id})
sce_net["created"] = True
-
- #2. Creating new nets (vnf internal nets) in the VIM"
+
+ # 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"):
vim = myvims[ sce_vnf["datacenter"] ]
datacenter_id = sce_vnf["datacenter"]
+ myvim_thread = myvim_threads[ sce_vnf["datacenter"]]
else:
vim = myvims[ default_datacenter_id ]
datacenter_id = default_datacenter_id
+ myvim_thread = myvim_threads[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 = "%s.%s" %(instance_name, net["name"])
net_name = net_name[:255] #limit length
net_type = net['type']
- network_id = vim.new_network(net_name, net_type, net.get('ip_profile',None))
- net['vim_id'] = network_id
+ task = new_task("new-net", (net_name, net_type, net.get('ip_profile',None)))
+ task_id = myvim_thread.insert_task(task)
+ instance_tasks[task_id] = task
+ # network_id = vim.new_network(net_name, net_type, net.get('ip_profile',None))
+ net['vim_id'] = task_id
if sce_vnf['uuid'] not in auxNetDict:
auxNetDict[sce_vnf['uuid']] = {}
- auxNetDict[sce_vnf['uuid']][net['uuid']] = network_id
- rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id})
+ auxNetDict[sce_vnf['uuid']][net['uuid']] = task_id
+ rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':task_id})
net["created"] = True
-
+
#print "auxNetDict:"
#print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False)
-
- #3. Creating new vm instances in the VIM
+
+ # 3. Creating new vm instances in the VIM
#myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict)
for sce_vnf in scenarioDict['vnfs']:
if sce_vnf.get("datacenter"):
vim = myvims[ sce_vnf["datacenter"] ]
+ myvim_thread = myvim_threads[ sce_vnf["datacenter"] ]
datacenter_id = sce_vnf["datacenter"]
else:
vim = myvims[ default_datacenter_id ]
+ myvim_thread = myvim_threads[ default_datacenter_id ]
datacenter_id = default_datacenter_id
sce_vnf["datacenter_id"] = datacenter_id
i = 0
for vm in sce_vnf['vms']:
i += 1
myVMDict = {}
- myVMDict['name'] = "%s.%s.%d" % (instance_name,sce_vnf['name'],i)
+ myVMDict['name'] = "{}.{}.{}".format(instance_name,sce_vnf['name'],chr(96+i))
myVMDict['description'] = myVMDict['name'][0:99]
# if not startvms:
# myVMDict['start'] = "no"
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)
+ 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['networks'] = []
+ task_depends = {}
#TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
for iface in vm['interfaces']:
netDict = {}
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"]:
break
else:
netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ]
+ if is_task_id(netDict['net_id']):
+ task_depends[netDict['net_id']] = instance_tasks[netDict['net_id']]
#skip bridge ifaces not connected to any net
#if 'net_id' not in netDict or netDict['net_id']==None:
# continue
#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 ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
- vm_id = vim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None),
- myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks'], cloud_config = cloud_config)
+ if vm.get("boot_data"):
+ cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config)
+ else:
+ cloud_config_vm = cloud_config
+ task = new_task("new-vm", (myVMDict['name'], myVMDict['description'], myVMDict.get('start', None),
+ myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'],
+ cloud_config_vm, myVMDict['disks']), depends=task_depends)
+ vm_id = myvim_thread.insert_task(task)
+ instance_tasks[vm_id] = task
+
vm['vim_id'] = vm_id
rollbackList.append({'what':'vm','where':'vim','vim_id':datacenter_id,'uuid':vm_id})
#put interface uuid back to scenario[vnfs][vms[[interfaces]
logger.debug("create_instance Deployment done scenarioDict: %s",
yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) )
instance_id = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_name, instance_description, scenarioDict)
+ # Update database with those ended tasks
+ for task in instance_tasks.values():
+ if task["status"] == "ok":
+ if task["name"] == "new-vm":
+ mydb.update_rows("instance_vms", UPDATE={"vim_vm_id": task["result"]},
+ WHERE={"vim_vm_id": task["id"]})
+ elif task["name"] == "new-net":
+ mydb.update_rows("instance_nets", UPDATE={"vim_net_id": task["result"]},
+ WHERE={"vim_net_id": task["id"]})
return mydb.get_instance_scenario(instance_id)
except (NfvoException, vimconn.vimconnException,db_base_Exception) as e:
message = rollback(mydb, myvims, rollbackList)
error_text += " {} {}. {}".format(type(e).__name__, str(e), message)
#logger.error("create_instance: %s", error_text)
raise NfvoException(error_text, e.http_code)
-
+
+
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)
#2. delete from VIM
error_msg = ""
- myvims={}
+ myvims = {}
+ myvim_threads = {}
#2.1 deleting VMs
#vm_fail_list=[]
for sce_vnf in instanceDict['vnfs']:
datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
if datacenter_key not in myvims:
+ try:
+ myvim_thread = get_vim_thread(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:
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
try:
- myvim.delete_vminstance(vm['vim_vm_id'])
+ task=None
+ if is_task_id(vm['vim_vm_id']):
+ task_id = vm['vim_vm_id']
+ old_task = task_dict.get(task_id)
+ if not old_task:
+ error_msg += "\n VM was scheduled for create, but task {} is not found".format(task_id)
+ continue
+ with task_lock:
+ if old_task["status"] == "enqueued":
+ old_task["status"] = "deleted"
+ elif old_task["status"] == "error":
+ continue
+ elif old_task["status"] == "processing":
+ task = new_task("del-vm", task_id, depends={task_id: old_task})
+ else: #ok
+ task = new_task("del-vm", old_task["result"])
+ else:
+ task = new_task("del-vm", vm['vim_vm_id'], store=False)
+ if task:
+ myvim_thread.insert_task(task)
except vimconn.vimconnNotFoundException as e:
error_msg+="\n VM VIM_id={} not found at datacenter={}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
logger.warn("VM instance '%s'uuid '%s', VIM id '%s', from VNF_id '%s' not found",
error_msg+="\n VM VIM_id={} at datacenter={} Error: {} {}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"], e.http_code, str(e))
logger.error("Error %d deleting VM instance '%s'uuid '%s', VIM_id '%s', from VNF_id '%s': %s",
e.http_code, vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id'], str(e))
-
+
#2.2 deleting NETS
#net_fail_list=[]
for net in instanceDict['nets']:
continue #skip not created nets
datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
if datacenter_key not in myvims:
+ try:
+ myvim_thread = get_vim_thread(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=net["datacenter_id"],
datacenter_tenant_id=net["datacenter_tenant_id"])
if len(vims) == 0:
else:
myvims[datacenter_key] = vims.values()[0]
myvim = myvims[datacenter_key]
+ 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"])
continue
try:
- myvim.delete_network(net['vim_net_id'])
+ task = None
+ if is_task_id(net['vim_net_id']):
+ task_id = net['vim_net_id']
+ old_task = task_dict.get(task_id)
+ if not old_task:
+ error_msg += "\n NET was scheduled for create, but task {} is not found".format(task_id)
+ continue
+ with task_lock:
+ if old_task["status"] == "enqueued":
+ old_task["status"] = "deleted"
+ elif old_task["status"] == "error":
+ continue
+ elif old_task["status"] == "processing":
+ task = new_task("del-net", task_id, depends={task_id: old_task})
+ else: # ok
+ task = new_task("del-net", old_task["result"])
+ else:
+ task = new_task("del-net", net['vim_net_id'], store=False)
+ if task:
+ myvim_thread.insert_task(task)
except vimconn.vimconnNotFoundException as e:
- error_msg+="\n NET VIM_id={} not found at datacenter={}".format(net['vim_net_id'], net["datacenter_id"])
+ error_msg += "\n NET VIM_id={} not found at datacenter={}".format(net['vim_net_id'], net["datacenter_id"])
logger.warn("NET '%s', VIM_id '%s', from VNF_net_id '%s' not found",
- net['uuid'], net['vim_net_id'], str(net['vnf_net_id']))
+ net['uuid'], net['vim_net_id'], str(net['vnf_net_id']))
except vimconn.vimconnException as e:
- error_msg+="\n NET VIM_id={} at datacenter={} Error: {} {}".format(net['vim_net_id'], net["datacenter_id"], e.http_code, str(e))
+ error_msg += "\n NET VIM_id={} at datacenter={} Error: {} {}".format(net['vim_net_id'],
+ net["datacenter_id"],
+ e.http_code, str(e))
logger.error("Error %d deleting NET '%s', VIM_id '%s', from VNF_net_id '%s': %s",
- e.http_code, net['uuid'], net['vim_net_id'], str(net['vnf_net_id']), str(e))
- if len(error_msg)>0:
+ e.http_code, net['uuid'], net['vim_net_id'], str(net['vnf_net_id']), str(e))
+ if len(error_msg) > 0:
return 'instance ' + message + ' deleted but some elements could not be deleted, or already deleted (error: 404) from VIM: ' + error_msg
else:
return 'instance ' + message + ' deleted'
+
def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None):
'''Refreshes a scenario instance. It modifies instanceDict'''
'''Returns:
# Assumption: nfvo_tenant and instance_id were checked before entering into this function
#print "nfvo.refresh_instance begins"
#print json.dumps(instanceDict, indent=4)
-
+
#print "Getting the VIM URL and the VIM tenant_id"
myvims={}
# Returns appropriate output
#print "nfvo.refresh_instance finishes"
logger.debug("VMs updated in the database: %s; nets updated in the database %s; VMs not updated: %s; nets not updated: %s",
- str(vms_updated), str(nets_updated), str(vms_notupdated), str(nets_notupdated))
+ str(vms_updated), str(nets_updated), str(vms_notupdated), str(nets_notupdated))
instance_id = instanceDict['uuid']
if len(vms_notupdated)+len(nets_notupdated)>0:
error_msg = "VMs not updated: " + str(vms_notupdated) + "; nets not updated: " + str(nets_notupdated)
return len(vms_notupdated)+len(nets_notupdated), 'Scenario instance ' + instance_id + ' refreshed but some elements could not be updated in the database: ' + error_msg
-
+
return 0, 'Scenario instance ' + instance_id + ' refreshed.'
+
def instance_action(mydb,nfvo_tenant,instance_id, action_dict):
#print "Checking that the instance_id exists and getting the instance dictionary"
instanceDict = mydb.get_instance_scenario(instance_id, nfvo_tenant)
if len(vims) == 0:
raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), HTTP_Not_Found)
myvim = vims.values()[0]
-
+
input_vnfs = action_dict.pop("vnfs", [])
input_vms = action_dict.pop("vms", [])
vm_error+=1
else:
#print "console data", data
- try:
+ try:
console_thread = create_or_use_console_proxy_thread(data["server"], data["port"])
vm_result[ vm['uuid'] ] = {"vim_result": 200,
"description": "{protocol}//{ip}:{port}/{suffix}".format(
return vm_result
else:
return vm_result
-
+
+
def create_or_use_console_proxy_thread(console_server, console_port):
#look for a non-used port
console_thread_key = console_server + ":" + str(console_port)
if console_thread_key in global_config["console_thread"]:
#global_config["console_thread"][console_thread_key].start_timeout()
return global_config["console_thread"][console_thread_key]
-
+
for port in global_config["console_port_iterator"]():
#print "create_or_use_console_proxy_thread() port:", port
if port in global_config["console_ports"]:
raise NfvoException(str(e), HTTP_Bad_Request)
raise NfvoException("Not found any free 'http_console_ports'", HTTP_Conflict)
+
def check_tenant(mydb, tenant_id):
'''check that tenant exists at database'''
tenant = mydb.get_rows(FROM='nfvo_tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id})
raise NfvoException("tenant '{}' not found".format(tenant_id), HTTP_Not_Found)
return
+
def new_tenant(mydb, tenant_dict):
tenant_id = mydb.new_row("nfvo_tenants", tenant_dict, add_uuid=True)
return tenant_id
+
def delete_tenant(mydb, tenant):
#get nfvo_tenant info
-
+
tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant, 'tenant')
mydb.delete_row_by_id("nfvo_tenants", tenant_dict['uuid'])
return tenant_dict['uuid'] + " " + tenant_dict["name"]
+
def new_datacenter(mydb, datacenter_descriptor):
if "config" in datacenter_descriptor:
datacenter_descriptor["config"]=yaml.safe_dump(datacenter_descriptor["config"],default_flow_style=True,width=256)
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)
-
+
datacenter_id = mydb.new_row("datacenters", datacenter_descriptor, add_uuid=True)
return datacenter_id
+
def edit_datacenter(mydb, datacenter_id_name, datacenter_descriptor):
#obtain data, check that only one exist
datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id_name)
- #edit data
+ #edit data
datacenter_id = datacenter['uuid']
where={'uuid': datacenter['uuid']}
if "config" in datacenter_descriptor:
for k in new_config_dict:
if new_config_dict[k]==None:
to_delete.append(k)
-
+
config_dict = yaml.load(datacenter["config"])
config_dict.update(new_config_dict)
#delete null fields
mydb.update_rows('datacenters', datacenter_descriptor, where)
return datacenter_id
+
def delete_datacenter(mydb, datacenter):
#get nfvo_tenant info
datacenter_dict = mydb.get_table_by_uuid_name('datacenters', datacenter, 'datacenter')
mydb.delete_row_by_id("datacenters", datacenter_dict['uuid'])
return datacenter_dict['uuid'] + " " + datacenter_dict['name']
+
def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None, config=None):
#get datacenter info
- datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter)
- datacenter_name=myvim["name"]
-
- create_vim_tenant=True if vim_tenant_id==None and vim_tenant_name==None else False
+ datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter)
+ datacenter_name = myvim["name"]
- #get nfvo_tenant info
+ create_vim_tenant = True if not vim_tenant_id and not vim_tenant_name else False
+
+ # get nfvo_tenant info
tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', nfvo_tenant)
if vim_tenant_name==None:
vim_tenant_name=tenant_dict['name']
-
+
#check that this association does not exist before
tenants_datacenter_dict={"nfvo_tenant_id":tenant_dict['uuid'], "datacenter_id":datacenter_id }
tenants_datacenters = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
raise NfvoException("Not possible to create vim_tenant {} at VIM: {}".format(vim_tenant_id, str(e)), HTTP_Internal_Server_Error)
datacenter_tenants_dict = {}
datacenter_tenants_dict["created"]="true"
-
+
#fill datacenter_tenants table
if not vim_tenant_id_exist_atdb:
- datacenter_tenants_dict["vim_tenant_id"] = vim_tenant_id
+ datacenter_tenants_dict["vim_tenant_id"] = vim_tenant_id
datacenter_tenants_dict["vim_tenant_name"] = vim_tenant_name
- datacenter_tenants_dict["user"] = vim_username
- datacenter_tenants_dict["passwd"] = vim_password
- datacenter_tenants_dict["datacenter_id"] = datacenter_id
+ datacenter_tenants_dict["user"] = vim_username
+ datacenter_tenants_dict["passwd"] = vim_password
+ datacenter_tenants_dict["datacenter_id"] = datacenter_id
if config:
datacenter_tenants_dict["config"] = yaml.safe_dump(config, default_flow_style=True, width=256)
id_ = mydb.new_row('datacenter_tenants', datacenter_tenants_dict, add_uuid=True)
datacenter_tenants_dict["uuid"] = id_
-
+
#fill tenants_datacenters table
tenants_datacenter_dict["datacenter_tenant_id"]=datacenter_tenants_dict["uuid"]
mydb.new_row('tenants_datacenters', tenants_datacenter_dict)
+ # create thread
+ datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_dict['uuid'], datacenter_id) # reload data
+ thread_name = get_non_used_vim_name(datacenter_name, datacenter_id, tenant_dict['name'], tenant_dict['uuid'])
+ new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, datacenter_name, db=db, db_lock=db_lock)
+ new_thread.start()
+ thread_id = datacenter_id + "." + tenant_dict['uuid']
+ vim_threads["running"][thread_id] = new_thread
return datacenter_id
+
def deassociate_datacenter_to_tenant(mydb, tenant_id, datacenter, vim_tenant_id=None):
#get datacenter info
datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter)
mydb.delete_row_by_id('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id'])
if vim_tenant_dict['created']=='true':
#delete tenant at VIM if created by NFVO
- try:
+ try:
myvim.delete_tenant(vim_tenant_dict['vim_tenant_id'])
except vimconn.vimconnException as e:
warning = "Not possible to delete vim_tenant_id {} from VIM: {} ".format(vim_tenant_dict['vim_tenant_id'], str(e))
logger.warn(warning)
except db_base_Exception as e:
logger.error("Cannot delete datacenter_tenants " + str(e))
- pass #the error will be caused because dependencies, vim_tenant can not be deleted
-
+ pass # the error will be caused because dependencies, vim_tenant can not be deleted
+ thread_id = datacenter_id + "." + tenant_datacenter_item["nfvo_tenant_id"]
+ thread = vim_threads["running"][thread_id]
+ thread.insert_task(new_task("exit", None, store=False))
+ vim_threads["deleting"][thread_id] = thread
return "datacenter {} detached. {}".format(datacenter_id, warning)
+
def datacenter_action(mydb, tenant_id, datacenter, action_dict):
#DEPRECATED
- #get datacenter info
+ #get datacenter info
datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
if 'net-update' in action_dict:
elif 'net-edit' in action_dict:
net = action_dict['net-edit'].pop('net')
what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name'
- result = mydb.update_rows('datacenter_nets', action_dict['net-edit'],
+ result = mydb.update_rows('datacenter_nets', action_dict['net-edit'],
WHERE={'datacenter_id':datacenter_id, what: net})
return result
elif 'net-delete' in action_dict:
net = action_dict['net-deelte'].get('net')
what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name'
- result = mydb.delete_row(FROM='datacenter_nets',
+ result = mydb.delete_row(FROM='datacenter_nets',
WHERE={'datacenter_id':datacenter_id, what: net})
return result
else:
raise NfvoException("Unknown action " + str(action_dict), HTTP_Bad_Request)
+
def datacenter_edit_netmap(mydb, tenant_id, datacenter, netmap, action_dict):
#get datacenter info
datacenter_id, _ = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
what = 'uuid' if utils.check_valid_uuid(netmap) else 'name'
- result = mydb.update_rows('datacenter_nets', action_dict['netmap'],
+ result = mydb.update_rows('datacenter_nets', action_dict['netmap'],
WHERE={'datacenter_id':datacenter_id, what: netmap})
return result
+
def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None):
#get datacenter info
datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
filter_dict["name"] = action_dict['vim_name']
else:
filter_dict["shared"] = True
-
+
try:
vim_nets = myvim.get_network_list(filter_dict=filter_dict)
except vimconn.vimconnException as e:
raise
else:
net_nfvo["status"] = "FAIL: " + str(e)
- net_list.append(net_nfvo)
- return net_list
+ net_list.append(net_nfvo)
+ return net_list
+
def vim_action_get(mydb, tenant_id, datacenter, item, name):
#get datacenter info
content = myvim.get_network_list(filter_dict=filter_dict)
elif item=="tenants":
content = myvim.get_tenant_list(filter_dict=filter_dict)
+ elif item == "images":
+ content = myvim.get_image_list(filter_dict=filter_dict)
else:
raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
logger.debug("vim_action response %s", content) #update nets Change from VIM format to NFVO format
except vimconn.vimconnException as e:
print "vim_action Not possible to get_%s_list from VIM: %s " % (item, str(e))
raise NfvoException("Not possible to get_{}_list from VIM: {}".format(item, str(e)), e.http_code)
-
+
+
def vim_action_delete(mydb, tenant_id, datacenter, item, name):
#get datacenter info
if tenant_id == "any":
else: # it is a dict
item_id = items["id"]
item_name = str(items.get("name"))
-
+
try:
if item=="networks":
content = myvim.delete_network(item_id)
elif item=="tenants":
content = myvim.delete_tenant(item_id)
+ elif item == "images":
+ content = myvim.delete_image(item_id)
else:
- raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
+ raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
except vimconn.vimconnException as e:
#logger.error( "vim_action Not possible to delete_{} {}from VIM: {} ".format(item, name, str(e)))
raise NfvoException("Not possible to delete_{} {} from VIM: {}".format(item, name, str(e)), e.http_code)
return "{} {} {} deleted".format(item[:-1], item_id,item_name)
-
+
+
def vim_action_create(mydb, tenant_id, datacenter, item, descriptor):
#get datacenter info
logger.debug("vim_action_create descriptor %s", str(descriptor))
net_type = net.pop("type", "bridge")
net_public = net.pop("shared", False)
net_ipprofile = net.pop("ip_profile", None)
- content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, **net)
+ net_vlan = net.pop("vlan", None)
+ content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, vlan=net_vlan) #, **net)
elif item=="tenants":
tenant = descriptor["tenant"]
content = myvim.new_tenant(tenant["name"], tenant.get("description"))
else:
- raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
+ raise NfvoException(item + "?", HTTP_Method_Not_Allowed)
except vimconn.vimconnException as e:
raise NfvoException("Not possible to create {} at VIM: {}".format(item, str(e)), e.http_code)
return vim_action_get(mydb, tenant_id, datacenter, item, content)
-
-
projects / osm / RO.git / blobdiff